What is an Abstract Class?

Abstract class is a class that has no instances.
An abstract class is written with the expectation that its concrete subclasses will add to its structure and behaviour, typically by implementing its abstract operations

What is Polymorphism?

Polymorphism literally means taking more than one form.
Inheritance, Overloading and Overriding are used to achieve Polymorphism in java

The abiltiy to define more than one function with the same name is called Polymorphism.

In java,c++ there are two type of polymorphism: compile time polymorphism (overloading) and runtime polymorphism (overriding)

Polymorphism is briefly described as "one interface, many implementations."

When you override methods, JVM determines the proper methods to call at the program’s run time, not at the compile time.

Overriding occurs when a class method has the same name and signature as a method in parent class.

Overloading occurs when several methods have same names with

Overloading is determined at the compile time.

Different method signature and different number or type of parameters.

Same method signature but different number of parameters.

Same method signature and same number of parameters but of different type

class BookDetails{

String title;

setBook(String title){ }

}

class ScienceBook extends BookDetails{

setBook(String title){} //overriding

setBook(String title, String publisher,float price){ } //overloading

}

(Inheritance, Overloading and Overriding are used to achieve Polymorphism in java).

Polymorphism manifests itself in Java in the form of multiple methods having the same name.

In some cases, multiple methods have the same name, but different formal argument lists (overloaded methods).

In other cases, multiple methods have the same name, same return type, and same formal argument list (overridden methods).

Method overloading

Method overriding through inheritance

Method overriding through the Java interface

The overriding method cannot have a more restrictive access modifier than the method being overridden

(Ex: You can’t override a method marked public and make it protected).

You cannot override a method marked final

You cannot override a method marked static

Compile time polymorphism and the other is run time polymorphism.

Compile time polymorphism is method overloading.

Runtime time polymorphism is done using inheritance and interface.

• static polymorphism vs dynamic polymorphism

method overloading would be an example of static polymorphism
whereas overriding would be an example of dynamic polymorphism.

Dynamic, or late, binding occurs when a method is defined for several classes in a family, but the actual code for the method is not attached, or bound, until execution time.This gives support for overriding...

Static binding occurs when a method is defined with the same name but with different headers and implementations. The actual code for the method is attached, or bound, at compile time. Static binding is used to support overloaded methods in Java.

http://www.coderanch.com/t/379004/java/java/static-polymorphism-dynamic-polymorphism

What is Inheritance?

Inheritance is a relationship among classes, wherein one class shares the structure or behaviour defined in another class

Inheritance is the property which allows a Child class to inherit some properties from its parent class.

In Java this is achieved by using extends keyword.

Only properties with access modifier public and protected can be accessed in child class.

The two most common reasons to use inheritance are:

To promote code reuse

To use polymorphism

What is Encapsulation?

Encapsulation is the process of compartmentalising the elements of an abtraction that defines the structure and behaviour

Encapsulation is a process of binding or wrapping the data and the codes that operates on the data into a single entity

Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and abstraction.

Encapsulation is the technique of making the fields in a class private and providing access to the fields via public methods.
If a field is declared private, it cannot be accessed by anyone outside the class, thereby hiding the fields within the class.
For this reason, encapsulation is also referred to as data hiding.

The encapsulation is achieved by combining the methods and attribute into a class.

Encapsulation is a technique used for hiding the properties and behaviors of an object and allowing outside access only as appropriate.

What is abstraction?

Abstraction defines the essential characteristics of an object that distinguish it from all other kinds of objects

Abstraction is way of converting real world objects in terms of class.

Abstraction refers to the act of representing essential features without including the background details or explanations.

What are the core OOP’s concepts?

• ChatGPT

2. Interface

Definition: An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields. The methods in interfaces are abstract by default.

Purpose:

    Define Contracts: Interfaces define a contract that implementing classes must follow.

    Multiple Inheritance: Interfaces allow a class to implement multiple interfaces, overcoming the limitation of single inheritance in Java.

Example in Java:

// Interface

interface Drawable {

    void draw();

}

// Class implementing the interface

class Rectangle implements Drawable {

    @Override

    public void draw() {

        System.out.println("Drawing a rectangle");

    }

}

class Test {

    public static void main(String[] args) {

        Drawable myRectangle = new Rectangle();

        myRectangle.draw(); // Outputs: Drawing a rectangle

    }

}

In this example, Drawable is an interface with an abstract method draw(). The Rectangle class implements the Drawable interface and provides its own implementation of draw(). Interfaces define a contract that the Rectangle class adheres to.

1. Abstraction

Definition: Abstraction is the concept of hiding the complex implementation details and showing only the necessary features of an object. It focuses on what an object does rather than how it does it.

Purpose:

    Simplify Complex Systems: By focusing on essential characteristics, abstraction simplifies interaction with complex systems.

    Define Common Interface: Allows you to define a common interface for different implementations.

// Abstract class

abstract class Animal {

    // Abstract method (does not have a body)

    public abstract void makeSound();

    // Regular method

    public void sleep() {

        System.out.println("This animal sleeps");

    }

}

// Subclass providing specific implementation

class Dog extends Animal {

    @Override

    public void makeSound() {

        System.out.println("Bark");

    }

}

class Test {

    public static void main(String[] args) {

        Animal myDog = new Dog();

        myDog.makeSound(); // Outputs: Bark

        myDog.sleep();     // Outputs: This animal sleeps

    }

}

In this example, Animal is an abstract class with an abstract method makeSound(). The Dog class provides a specific implementation of makeSound(). Abstraction allows us to use the Animal class as a common interface without knowing the details of how makeSound() is implemented.

1. Encapsulation

Definition: Encapsulation is the concept of wrapping data (attributes) and methods (functions) that operate on the data into a single unit, usually a class. This means hiding the internal state of an object and requiring all interactions to be performed through an object’s methods.

Purpose:

    Protection: It protects an object’s internal state from unintended or harmful modifications.

    Controlled Access: By providing public methods (getters and setters), encapsulation allows controlled access to the internal data.

    Flexibility: Changes to the internal implementation of a class can be made with minimal impact on other parts of the code.

Example in Java:

public class Person {

    private String name; // private attribute

    // Constructor

    public Person(String name) {

        this.name = name;

    }

    // Public method to access private attribute

    public String getName() {

        return name;

    }

    // Public method to modify private attribute

    public void setName(String name) {

        this.name = name;

    }

}

2. Polymorphism

Definition: Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. The most common use of polymorphism is method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.

Purpose:

    Flexibility: Allows objects of different classes to be treated through a common interface.

    Method Overriding: Enables a subclass to provide a specific implementation of a method that is already defined in its superclass.

Example in Java:

class Animal {

    public void makeSound() {

        System.out.println("Some sound");

    }

}

class Dog extends Animal {

    @Override

    public void makeSound() {

        System.out.println("Bark");

    }

}

class Cat extends Animal {

    @Override

    public void makeSound() {

        System.out.println("Meow");

    }

}

public class Test {

    public static void main(String[] args) {

        Animal myDog = new Dog();

        Animal myCat = new Cat();

        myDog.makeSound(); // Outputs: Bark

        myCat.makeSound(); // Outputs: Meow

    }

}

3. Inheritance

Definition: Inheritance is a mechanism where one class (subclass or derived class) inherits attributes and methods from another class (superclass or base class). This promotes code reusability and establishes a natural hierarchy between classes.

Purpose:

    Reusability: Allows a subclass to reuse code from the superclass, reducing redundancy.

    Hierarchy: Establishes a natural hierarchical relationship between classes.

    Extensibility: Facilitates the creation of new classes based on existing ones, adding or modifying functionality as needed.

Example in Java:

class Animal {

    public void eat() {

        System.out.println("This animal eats food");

    }

}

class Dog extends Animal {

    public void bark() {

        System.out.println("Dog barks");

    }

}

public class Test {

    public static void main(String[] args) {

        Dog myDog = new Dog();

        myDog.eat(); // Inherited method

        myDog.bark(); // Subclass-specific method

    }

}

Summary:

    Encapsulation: Bundles data and methods, restricting direct access to some of the object's components.

    Polymorphism: Allows objects to be treated as instances of their parent class, enabling method overriding and flexibility.

    Inheritance: Enables a new class to inherit attributes and methods from an existing class, fostering code reuse and hierarchy

• 
  
• 1. Encapsulation
• 
  
• Definition: Encapsulation is the concept of wrapping data (attributes) and methods (functions) that operate on the data into a single unit, usually a class. This means hiding the internal state of an object and requiring all interactions to be performed through an object’s methods.
• 
  
• Purpose:
• 
  
•     Protection: It protects an object’s internal state from unintended or harmful modifications.
•     Controlled Access: By providing public methods (getters and setters), encapsulation allows controlled access to the internal data.
•     Flexibility: Changes to the internal implementation of a class can be made with minimal impact on other parts of the code.
• Example in Java:
• 
  
• public class Person {
•     private String name; // private attribute
• 
  
•     // Constructor
•     public Person(String name) {
•         this.name = name;
•     }
• 
  
•     // Public method to access private attribute
•     public String getName() {
•         return name;
•     }
• 
  
•     // Public method to modify private attribute
•     public void setName(String name) {
•         this.name = name;
•     }
• }
• 
  
• 
  
• 2. Polymorphism
• 
  
• Definition: Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. The most common use of polymorphism is method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.
• 
  
• Purpose:
• 
  
•     Flexibility: Allows objects of different classes to be treated through a common interface.
•     Method Overriding: Enables a subclass to provide a specific implementation of a method that is already defined in its superclass.
• 
  
• Example in Java:
• 
  
• class Animal {
•     public void makeSound() {
•         System.out.println("Some sound");
•     }
• }
• 
  
• class Dog extends Animal {
•     @Override
•     public void makeSound() {
•         System.out.println("Bark");
•     }
• }
• 
  
• class Cat extends Animal {
•     @Override
•     public void makeSound() {
•         System.out.println("Meow");
•     }
• }
• 
  
• public class Test {
•     public static void main(String[] args) {
•         Animal myDog = new Dog();
•         Animal myCat = new Cat();
• 
  
•         myDog.makeSound(); // Outputs: Bark
•         myCat.makeSound(); // Outputs: Meow
•     }
• }
• 
  
• 
  
• 3. Inheritance
• 
  
• Definition: Inheritance is a mechanism where one class (subclass or derived class) inherits attributes and methods from another class (superclass or base class). This promotes code reusability and establishes a natural hierarchy between classes.
• 
  
• Purpose:
• 
  
•     Reusability: Allows a subclass to reuse code from the superclass, reducing redundancy.
•     Hierarchy: Establishes a natural hierarchical relationship between classes.
•     Extensibility: Facilitates the creation of new classes based on existing ones, adding or modifying functionality as needed.
• 
  
• Example in Java:
• 
  
• class Animal {
•     public void eat() {
•         System.out.println("This animal eats food");
•     }
• }
• 
  
• class Dog extends Animal {
•     public void bark() {
•         System.out.println("Dog barks");
•     }
• }
• 
  
• public class Test {
•     public static void main(String[] args) {
•         Dog myDog = new Dog();
•         myDog.eat(); // Inherited method
•         myDog.bark(); // Subclass-specific method
•     }
• }
• 
  
• Summary:
• 
  
•     Encapsulation: Bundles data and methods, restricting direct access to some of the object's components.
•     Polymorphism: Allows objects to be treated as instances of their parent class, enabling method overriding and flexibility.
•     Inheritance: Enables a new class to inherit attributes and methods from an existing class, fostering code reuse and hierarchy

1. Abstraction
2. Encapsulation
3. Inheritance
4. Polymorphism

Polymorphism, Inheritance and Encapsulation

Inheritance is the process by which one object acquires the properties of another object. Inheritance allows well-tested procedures to be reused and enables changes to

make once and have effect in all relevant places

Explain the Polymorphism principle. Explain the different forms of Polymorphism.

Polymorphism in simple terms means one name many forms.

Polymorphism exists in three distinct forms in Java:

• Method overloading

• Method overriding through inheritance

• Method overriding through the Java interface

method overloading is the primary way polymorphism is implemented in Java

overloaded methods:

appear in the same class or a subclass

have the same name but,

have different parameter lists, and,

can have different return types

an example of an overloaded method is print() in the java.io.PrintStream class

public void print(boolean b)

public void print(char c)

public void print(char[] s)

public void print(float f)

public void print(double d)

public void print(int i)

public void print(long l)

public void print(Object obj)

public void print(String s)

Overriding methods

appear in subclasses

have the same name as a superclass method

have the same parameter list as a superclass method

have the same return type as as a superclass method

the access modifier for the overriding method may not be more restrictive than the access modifier of the superclass method



Explain Encapsulation, Polymorphism and Inheritance.
http://www.youtube.com/watch?v=QzX7REqciPY

• Inheritance - comes under Relationship -> Generalization/Specilization -> enables code resuability. But also enables maintanence nightmare of managing classes.

Polymorphism - comes unders Behaviour->Compile time/Runtime -> enables the varying behaviour of the operations depending upon the type of the object(runtime entity).

http://www.linkedin.com/groups/what-is-difference-between-dynamic-70526.S.217712129?view=&srchtype=discussedNews&gid=70526&item=217712129&type=member&trk=eml-anet_dig-b_pd-ttl-cn&ut=23CVDF6gnvwlE1

• Class versus object

A class is a template for objects. A class defines object properties including a valid range of values, and a default value. A class also describes object behavior. An object is a member or an "instance" of a class. An object has a state in which all of its properties have values that you either explicitly define or that are defined by default settings.

https://www.ncl.ucar.edu/Document/HLUs/User_Guide/classes/classoview.shtml#:~:text=A%20class%20defines%20object%20properties,are%20defined%20by%20default%20settings.

• Let's see some real life example of class and object in java to understand the difference well:

Class: Human Object: Man, Woman

Class: Fruit Object: Apple, Banana, Mango, Guava wtc.

Class: Mobile phone Object: iPhone, Samsung, Moto

Class: Food Object: Pizza, Burger, Samosa

https://www.javatpoint.com/difference-between-object-and-class

What is an Object?

Object is an instance of a class

What is a Class?

Class is a template for a set of objects that share a common structure and a common behaviour.

Decorator (Wrapper) Pattern

• Introducing the Decorator Design Pattern

http://www.youtube.com/watch?v=Xk8durvtiys&feature=channel&list=UL
wrapper classes
using wrapper classes to avoid changing code continuously

• Overview of the Decorator Design Pattern

http://www.youtube.com/watch?v=MI_qyfeRk8c&feature=autoplay&list=ULXk8durvtiys&playnext=1

• Coding the Decorator Design Pattern

http://www.youtube.com/watch?v=HkOdDMePE4Q&feature=autoplay&list=ULMI_qyfeRk8c&playnext=2

• Executing the Decorator Design Pattern

http://www.youtube.com/watch?v=Ra-33SFHq6M&feature=autoplay&list=ULHkOdDMePE4Q&playnext=3

• JAVA: Decorator Design Pattern

http://www.youtube.com/watch?v=9FQVs85fZd8&list=UUUvwlMMaeppKPdtAK8PxO8Q&index=2&feature=plcp
also known as wrapper pattern
extends class functionality by delegation
alternative to extending class functionality by inheritance(subclassing)

• Decorator Pattern

http://www.youtube.com/watch?v=T9kqwyhQP24&feature=related
Structural Design Pattern
attach additional responsibility dynamically
alternative to subclassing  through composite and delegation
object level pattern

• Java Design Pattern Decorator with Eclipse

http://www.youtube.com/watch?v=k_uTRC7DO68&feature=related

• Decorator sablonu belirli nesnelerin davranislarini yeni türetilmis siniflar olusturmadan degistirmemizi saglar. 

Siniflarin varsayilan kodlarini degistirmeden  ek
davranislar kazanmasini saglamak için kullanilir.

Bu sekilde her zaman degisen ihtiyaçlarimiza cevap
verebilecek olan siniflari tasarlayabiliriz.


Örnegin; bir GUI bilesenine kenarliklar(border) eklemek
istiyoruz yada kaydirma çubugu (scrollbars) eklemek
istiyoruz.
Bu nesneden iki yeni nesne türeterek bu islemi
yapabiliriz. Bu sekilde yaparsak her nesne için kenarlik
çizdirmek için kenarlik çizimide yapabilen yeni nesneler
türetmemiz gereklidir. Hepsinde yapilan islem kenarlik
çizmedir, buna ragmen tüm kenarliga ihtiyaci olan
bilesenler için yeni siniflar türetmemiz gerekir.
Bu gibi durumlarda Decorator kullanilir


http://members.comu.edu.tr/msahin/courses/ust_duzey_files/patterns/decorator.pdf

• Decorating Servlet Request Objects

how to apply the Decorator pattern to servlet request objects
how to use the pattern in servlets and lists popular servlet-related projects that use it
http://www.oracle.com/technetwork/articles/entarch/decorators-099517.html

what's the difference between abstract and concrete class?

Concrete class - Provides implementation for all its methods & also for methods from extended abstract classes or implemented interfaces
Abstract class - Does not provide implementation for one or more of its methods
Interface - Does not provide implementation for any of its methods

Read more: http://wiki.answers.com/Q/Difference_between_concrete_class_and_abstract_class_and_interface#ixzz1y2HulwzD


The default class is a concrete class. The class keyword is used to define classes (e.g. in Java).
And usually they are simply referred to as classes (without the adjective concrete). (adjective concrete).
Abstract classes usually have partial or no implementation. On the other hand, concrete classes always have full implementation of its behavior.
Unlike concrete classes, abstract classes cannot be instantiated.
Therefore abstract classes have to be extended in order to make them useful.
Abstract classes may contain abstract methods, but concrete classes can’t.
When an abstract class is extended, all methods (both abstract and concrete) are inherited.
The inherited class can implement any or all the methods.
If all the abstract methods are not implemented, then that class also becomes an abstract class.

Read more: http://www.differencebetween.com/difference-between-abstract-class-and-vs-concrete-class/#ixzz1y2IGPCHk

Java Programming Tutorial - 58 - Abstract and Concrete Classes
http://www.youtube.com/watch?v=TyPNvt6Zg8c

Strategy (Policy) Pattern

1. Strategy Class can be an interface or an abstract class
2. There are a set of classes which extend abstract class or implement interface
3. Switching between these classes changes the behaviour of application
4. Using a class which extends or implements strategy class with conditional logic,conditional logic represents the behaviour of  application
5. This pattern helps add or remove specific behaviour to application without having recode or retest all part of application
6. algorithms can be changed at runtime or design time

JAVA: Strategy Design Pattern
http://www.youtube.com/watch?v=x3saJPT4SaE&list=PL028D1E25AAF87B8E&index=2&feature=plpp_video


Introducing the Strategy Design Pattern
http://www.youtube.com/watch?v=9n3gF39-trE

Overview of the Strategy Design Pattern
http://www.youtube.com/watch?v=F1841_llRSw&feature=channel&list=UL

Coding the Strategy Design Pattern
http://www.youtube.com/watch?v=vYByr2u8gqk&feature=autoplay&list=ULF1841_llRSw&playnext=1


Executing the Strategy Design Pattern
http://www.youtube.com/watch?v=mmiWFcjMTLw&feature=autoplay&list=ULvYByr2u8gqk&playnext=2
verbs are objects now


The strategy pattern is a behavioral design pattern that allows you to decide which course of action a program should take, based on a specific context during runtime. You encapsulate two different algorithms inside two classes, and decide at runtime which strategy you want to go with.
http://net.tutsplus.com/articles/general/a-beginners-guide-to-design-patterns/

Iterator Pattern

Intent

Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation


We use iterators quite frequently in everyday life. For example, remote control of TV. We just pick up the TV remote control and start pressing Up and Down or Forward and Back keys to iterate through the channels.


Motivation
Need to traverse different data structures so that algorithms can be defined that are capable of interfacing with each transparently.



Reference:
http://kapilnevatia.blogspot.com/2011/12/iterator-pattern.html

dependency vs association

Dependency is normally created when you receive a reference to a class as part of a particular operation / method.
Dependency indicates that you may invoke one of the APIs of the received class reference and any modification to that class may break your class as well.
Dependency is represented by a dashed arrow starting from the dependent class to its dependency.
Multiplicity normally doesn’t make sense on a Dependency.

http://nirajrules.wordpress.com/2011/07/15/association-vs-dependency-vs-aggregation-vs-composition/

One class depends on another if the latter is a parameter variable or local variable of a method of the former.
This is different from an association, where an attribute of the former is an instance of the latter.

http://en.wikipedia.org/wiki/Class_diagram#Analysis_stereotypes

Dependency

Dependency is a weaker form of relationship which indicates that one class depends on another because it uses it at some point of time

One class depends on another if the latter is a parameter variable or local variable of a method of the former.

This is different from an association, where an attribute of the former is an instance of the latter.

http://en.wikipedia.org/wiki/Class_diagram#Analysis_stereotypes

• Dependency relationships

a dependency is displayed in the diagram editor as a dashed line with an open arrow that points from the client model element to the supplier model element.

a dependency relationship is a relationship in which changes to one model element (the supplier) impact another model element (the client). You can use dependency relationships in class diagrams, component diagrams, deployment diagrams, and use case diagrams.


Example
In an e-commerce application, a Cart class depends on a Product class because the Cart class uses the Product class as a parameter for an add operation. In a class diagram, a dependency relationship points from the Cart class to the Product class. The Cart class is, therefore, the client model element, and the Product class is the supplier model element. This relationship indicates that a change to the Product class might require a change to the Cart class

http://publib.boulder.ibm.com/infocenter/rsdvhelp/v6r0m1/index.jsp?topic=%2Fcom.ibm.xtools.modeler.doc%2Ftopics%2Fcdepend.html

bi-directional association

For instance, a flight class is associated with a plane class bi-directionally

Realization

In java when one class implements and interface it is called realization, the class realizes the interface.

In UML modeling, a realization relationship is a relationship between two model elements, in which one model element (the client) realizes (implements or executes) the behavior that the other model element (the supplier) specifies

a realization is displayed in the diagram editor as a dashed line with an unfilled arrowhead that points from the client (realizes the behavior) to the supplier (specifies the behavior).
http://publib.boulder.ibm.com/infocenter/rsmhelp/v7r0m0/index.jsp?topic=/com.ibm.xtools.modeler.doc/topics/creal.html

Generalization

The generalization relationship is also known as the inheritance or "is a" relationship.
When one class inherits or extends another class, it is called Generalization.

composition vs aggregation

• composition vs aggregation

Composition is more restrictive.
When there is a composition between two objects, the composed object cannot exist without the other object.

This restriction is not there in aggregation.

A Library contains students and books.
Relationship between library and student is aggregation.
Relationship between library and book is composition.
A student can exist without a library and therefore it is aggregation
A book cannot exist without a library and therefore its a composition.

http://javapapers.com/oops/association-aggregation-composition-abstraction-generalization-realization-dependency/

• composition vs aggregation

composition is stronger than aggregation relation
in composition a part only belongs to a whole
if you destroy a building you destroy a room as well

in aggregation relation this is different because if you destroy a band musician can continue to exist

• What is the difference between aggregation and composition?

Aggregation 
Aggregation is an association in which one class
belongs to a collection. This is a part of a whole
relationship where a part can exist without a whole.
For example a line item is a whole and product is a
part. If a line item is deleted then corresponding
product need not be deleted. So aggregation has a
weaker relationship.

Composition
Composition is an association in which one class belongs to a
collection. This is a part of a whole relationship where a part
cannot exist without a whole. If a whole is deleted then all parts are
deleted. For example An order is a whole and line items are parts.
If an order is deleted then all corresponding line items for that
order should be deleted. So composition has a stronger
relationship.

Composition

Composition is a stronger variant of the "owns a" or association relationship
composition is more specific than aggregation.
It is represented with a solid diamond shape.
Composition has a strong life cycle dependency between instances of the container class and instances of the contained class(es)
If the container is destroyed, normally every instance that it contains is destroyed as well

Aggregation

Aggregation is a variant of the "has a" or association relationship;
aggregation is more specific than association.
It is an association that represents a part-whole relationship which means that one object contains another object.
Aggregation can occur when a class is a collection or container of other classes,
but where the contained classes do not have a strong life cycle dependency on the container--essentially

Stereotypes

stereotypes are used to show how this element of a class is specialized

4.03_Stereotypes
http://www.youtube.com/watch?v=g7O6R8loCss&feature=relmfu

Visibility

• Visibility

To specify the visibility of a class member (i.e., any attribute or method)

All the Visibility of a Class Members Are:

+         Public 

-         Private 

#         Protected 

~         Package

/         Derived

underline Static

4.02_Attributes & Operations
http://www.youtube.com/watch?v=Brjle3R_iXA&feature=relmfu

reflexive (recursive) association

a class can be associated with itself

Association

When two objects are associated, one object will be having a variable that points to the other object

 Association is a relationship type between classes
"has a " relationship
manager has an employee or an employee has a manager
manager manages an employee or an employee works for a manager


There are four different types of association

1.  bi-directional
2.  uni-directional
3.  Aggregation (includes Composition aggregation) 
4.  Reflexive( Recursive)

4.04_Associations & Multiplicity
http://www.youtube.com/watch?v=eDO-okP-kaU&feature=relmfu
http://en.wikipedia.org/wiki/Class_diagram#Analysis_stereotypes

object oriented software system

• object oriented software system

usecase view(requirements of system)
design view
process view
implementation view
deployment view

UML

• UML,unified modelling language

visualizing,constructing and documenting all parts of system

UML Views of the World

• UML Views of the World

1. Use Case Model
2. Static Models
3. Interaction Models

• Use Case Model

1. use case diagram
2. use cases

• Use Case Diagram

initial system model
provides a graphical representation of services the system will provide
inception phase

actor:person,system etc
use case:a function of value for the actor
communication:link between actor and use case

• Use Cases

represent function as experienced by the actor
eloboration phase

• Static Models: show the structure of the system

1. Class
2. Object
3. Package
4. Component
5. Deployment

• Class Diagram

shows relationship between classes
elaboration phase

• Object Diagram

used to give an example of how a system will look like under specific circumstances

• Package Diagram

depicts the dependencies between the packages that make up a model.

• Component Diagram

depicts how components are wired together to form larger components and or software systems.

• Deployment Diagram

models the physical deployment of artifacts on nodes.

• Interaction Models :shows the interaction of the system

1. Sequence
2. Communication
3. Activity
4. State Machine

• Sequence Diagram

kind of interaction diagram that shows how processes operate with one another and in what order
represents sequence of events
show messages passing between objects

• Communication(Collaboration) diagram

relationships between classes

• Activity Diagram

flowchart with object notation
represents task activity

• State Machine Diagram

shows how activities change the state of an object




Reference:
http://en.wikipedia.org/wiki/Deployment_diagram

RUP

• RUP presents Software Architecture 4+1 views

logical view
implementation view
use-case view
process view
deployment view

• RUP ,rational unified process (software development process)

inception
elaboration
construction
transition



Reference:
http://www.jkang.com/0602-574/ooad/sld001.htm

uml interview questions-1

• Define UML?

Unified Modeling Language, a standard language for designing and documenting a system in an object-oriented manner
It has nine diagrams which can be used in design document to express design of software architecture.

• Can you explain use case diagrams?

Use case diagram answers what system does from the user point of view.
Use case answer ‘What will the system do?


Scenario: A scenario is a sequence of events which happen when a user interacts with the system.
Actor: Actor is the who of the system, in other words the end user.
Use Case: Use case is task or the goal performed by the end user

• Can you explain class diagrams?

Class is basically a prototype which helps us create objects.

• Multiplicity?

Multiplicity can be termed as classes having multiple associations or one class can be linked to instances of many other classes.

• Can you explain object diagrams in UML?

Classes come to live only when objects are created from them. Object diagram gives a pictorial representation of class diagram at any point of time.

• Can you explain sequence diagrams?

Sequence diagram shows interaction between objects over a specific period time

http://www.codeproject.com/Articles/28445/UML-Interview-Questions-Part-1#Canyouexplainusecasediagrams

• What are the different views that are considered when building an object-oriented software system?

Normally there are 5 views.

Use Case view - This view exposes the requirements of a system.
Design View - Capturing the vocabulary.
Process View - modeling the distribution of the systems processes and threads.
Implementation view - addressing the physical implementation of the system.
Deployment view - focus on the modeling the components required for deploying the system

• What are the different views that are commonly used when developing Software in Java?

A) 1) Use Case View - Describes the system from the User's point of view, Describes the various functionalities expected from the system to be developed and how user is going to interact with those features.
2) Class Diagram - Shows graphically the relationships between classes and packages.
3) Sequence Diagram - Shows the sequence of method calls and interactions between classes.
4) Component Diagram - Shows the components within the system and the interaction between components.

http://www.javajotter.net/uml/interview_questions/umlinterviewquestions.php

• What are diagrams? 

Diagrams are graphical representation of a set of elements

• How are the diagrams divided? 

The nine diagrams are divided into static diagrams and dynamic diagrams.

Static Diagrams (Also called Structural Diagram):
Class diagram, Object diagram, Component Diagram, Deployment diagram.

Dynamic Diagrams (Also called Behavioral Diagrams):
Use Case Diagram, Sequence Diagram, Collaboration Diagram, Activity diagram, Statechart diagram.

• What are the major three types of modeling used? 

Major three types of modeling are structural, behavioral, and architectural.

• the different kinds of modeling diagrams used?

Use case diagram
Class Diagram
Object Diagram
Sequence Diagram
statechart Diagram
Collaboration Diagram
Activity Diagram
Component diagram
Deployment Diagram

• What is SDLC? 

SDLC is Software Development Life Cycle.
SDLC of a system included processes that are Use case driven, Architecture centric and Iterative and Incremental.
This Life cycle is divided into phases.
Phase is a time span between two milestones.
The milestones are Inception, Elaboration, Construction, and Transition.
Process Workflows that evolve through these phase are Business Modeling, Requirement gathering, Analysis and Design, Implementation, Testing, Deployment.
Supporting Workflows are Configuration and change management, Project management

• What are Relationships? 

There are different kinds of relationships:
Dependencies
Generalization
Association


Dependencies are relations ships between two entities that that a change in specification of one thing may affect another thing
Most commonly it is used to show that one class uses another class as an argument in the signature of the operation

Generalization is relationships specified in the class subclass scenario, it is shown when one entity inherits from other.

Associations are structural relationships that are: a room has walls, Person works for a company
Aggregation is a type of association where there is a has a relation ship,
That is a room has walls, if there are two classes room and walls then the relation ship is called a association and further defined as an aggregation.



http://www.techinterviews.com/uml-interview-questions-and-answers

• What is Association?

Association is a relationship between two classes.

In this relationship the object of one instance perform an action on behalf of the other class.

The typical behaviour can be invoking the method of other class and using the member of the other class.

public class MyMainClass{

public void init(){

new OtherClass.init();

}

}

• What is Aggregation?

Aggregation has a relationship between two classes.

In this relationship the object of one class is a member of the other class.

Aggregation always insists for a direction.

public class MyMainClass{

OtherClass otherClassObj = new OtherClass();

http://www.java-questions.com/oops_interview_questions.html

http://www.tutorialspoint.com/java/java_encapsulation.htm
http://www.interview-questions-java.com/
http://www.janeg.ca/scjp/overload/poly.html

8 Core Beliefs of Extraordinary Bosses

8 Core Beliefs of Extraordinary Bosses

1. Business is an ecosystem, not a battlefield.

2. A company is a community, not a machine.

3. Management is service, not control.
They push decision making downward, allowing teams form their own rules and intervening only in emergencies.

4. My employees are my peers, not my children
Average bosses see employees as inferior, immature beings who simply can't be trusted if not overseen by a patriarchal management.
Employees take their cues from this attitude, expend energy on looking busy and covering their behinds.

5. Motivation comes from vision, not from fear.
Average bosses see fear--of getting fired, of ridicule, of loss of privilege--as a crucial way to motivate people.
As a result, employees and managers alike become paralyzed and unable to make risky decisions.

6. Change equals growth, not pain.

7. Technology offers empowerment, not automation
trengthen management control and increase predictability

8. Work should be fun, not mere toil

http://www.inc.com/geoffrey-james/8-core-beliefs-of-extraordinary-bosses.html

5 Toxic Beliefs That Ruin Careers

5 Toxic Beliefs That Ruin Careers

1. My self-worth is based on what others think of me.

2. My past equals my future.
When some people experience a series of setbacks, they assume that their goals are not achievable.
Over time, they become dispirited and discouraged, and avoid situations where failure is a risk.
Because any significant effort entails risk, such people are then unable to make significant achievements

3. My destiny is controlled by the supernatural.
Some people believe that their status in life–or even their potential as a human being–is determined by luck, fate, or divine intervention.
This all-too-common (and ultimately silly) belief robs such people of initiative, making them passive as they wait for their "luck" to change.

4. My emotions accurately reflect objective reality.

5. My goal is to be perfect or do something perfectly.
Because perfection is unattainable, the people who seek it are simply setting themselves up for disappointment.
Perfectionists blame the world (and everything in it) rather than doing what's necessary to accomplish extraordinary results.
That's why "successful perfectionist" is an oxymoron


http://www.inc.com/geoffrey-james/5-toxic-beliefs-that-ruin-careers.html?utm_source=twitterfeed&utm_medium=twitter&utm_campaign=Feed%3A+inc%2Fheadlines+%28Inc.com+Headlines%29

Bouncing Back from Job Loss: The 7 Habits of Highly Effective Job Hunters

Bouncing Back from Job Loss: The 7 Habits of Highly Effective Job Hunters

if you look at job loss, like any setback from an enlarged perspective, you realize that success in life is measured far less by our opportunities than by how we respond to life’s setbacks and challenges.

The challenge people in that situation face is how they handle not only the loss of their job, but the many emotions that can arise. These range from a sense of humiliation, failure and vulnerability, to anxiety, resentment and self-pity. Sure, losing your job can be a blow to your back pocket, but it’s often an even bigger blow to your ego and self worth.

When it comes to a successful job hunt, attitude is everything.  A proactive and positive mindset will differentiate you from the masses, making all the difference in how “lucky” you get in an unlucky economy

1. Stay future-focused

2. Don’t let your job status define you.
Who you are is not what you do. Never was. Never will be.
People who interpret losing their job as a sign of personal inadequacy or failure are less likely to ‘get back on the horse’ in their job hunt than those who interpret it as an unfortunate circumstance that provided a valuable opportunity to grow in self-awareness, re-evaluate priorities and build resilience.

3. Prioritize self-care.
mental and emotional resilience requires physical resilience
(After all, you now have no excuse that you don’t have time for exercise.)
Studies have found that exercise builds resilience, leaving you more immune to stress.
just do something that lifts your spirits

4. Surround yourself with positive people
Emotions are contagious.
The people around you impact how you see yourself, your situation and what you do to improve it
Surround yourself with people who lift you up, and avoid those who don’t.
Let them know that while you may not have chosen your circumstances, you are confident that with time and effort, you will all pull through together, and be all the stronger and wiser for it.

5. Tap your network

6. Treat finding a job as a job.
Sure you have more time on your hands than you had before, but you will be amazed at how little you can do in a day if you aren’t intentional about what you want to get done
Then prioritize, structure your day and treat finding a job as a job.


7. Extend kindness.
extending kindness toward others makes us feel good.
scientists have found that acts of kindness produce some of the same “feel good” chemicals in the brain as anti-depressants
In addition, when we give our time to help others, it helps us stop dwelling on our own problems, and makes us realize how much we have to be thankful for.

http://www.forbes.com/sites/womensmedia/2012/06/12/bouncing-back-from-job-loss-the-7-habits-of-highly-effective-job-hunters/

class diagram

In software engineering, a class diagram in the Unified Modeling Language (UML) is a type of static structure diagram that describes the structure of a system by showing the system's classes, their attributes, operations (or methods), and the relationships among the classes.

A relationship is a general term covering the specific types of logical connections found on class and object diagrams. 

UML shows the following relationships:

• Instance level relationships
• Class level relationships
• General relationship

1) Instance Level Relationships

a. Association

b. Aggregation

c. Composition

2) Class Level Relationships

a. Generalization

b. Realization

3) General Relationships

a. Dependency

b. Multiplicity

New dimensions in UML2.0

• New dimensions in UML2.0

The major difference is the enhancement and additional features added to the diagrams in UML2.0

Sequence diagram is a time dependent view of the interaction between objects to accomplish a behavioral goal of the system. The time sequence is similar to the earlier version of sequence diagram.

Communication diagram is a new name added in UML2.0. A Communication diagram is a structural view of the messaging between objects, taken from the Collaboration diagram concept of UML 1.4 and earlier versions. This can be defined as a modified version of collaboration diagram.

Interaction Overview diagram is also a new addition in UML2.0. An Interaction Overview diagram describes a high-level view of a group of interactions combined into a logic sequence, including flow-control logic to navigate between the interactions.

Timing diagram is also added in UML2.0. It is an optional diagram designed to specify the time constraints on messages sent and received in the course of an interaction.

if we analyze the new diagrams then it is clear that all the diagrams are created based upon the interaction diagrams described in the earlier versions

http://www.tutorialspoint.com/uml/uml_2_overview.htm

• some of the new notations added to the class diagram from UML 1.x.

Instances
When modeling a system's structure it is sometimes useful to show example instances of the classes.
To model this, UML 2 provides the instance specification element, which shows interesting information using example (or real) instances in the system.

However, merely showing some instances without their relationship is not very useful; therefore, UML 2 allows for the modeling of the relationships/associations at the instance level as well

http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell/#N1031B

JavaServer Pages Standard Tag Library

JavaServer Pages Standard Tag Library (JSTL) encapsulates as simple tags the core functionality common to many Web applications. JSTL has support for common, structural tasks such as iteration and conditionals, tags for manipulating XML documents, internationalization tags, and SQL tags. It also provides a framework for integrating existing custom tags with JSTL tags. 


JSTL 1.2 is part of the Java EE 5 platform


http://www.oracle.com/technetwork/java/index-jsp-135995.html

Denormalization

Denormalization

Denormalization on the contrary is the process of adding redundant data to speed up complex queries involving multiple table JOINS. Data is included in one table from another in order to eliminate the second table which reduces the number of JOINS in a query and thus achieves performance.

Only one valid reason exists for denormalizing a relational design - to enhance performance. The sacrifice to performance is that you increase redundancy in a database.

References:
http://www.indiabix.com/technical/dbms-basics/7
http://www.techpreparation.com/mysql-interview-questions-answers1.htm
http://www.dotnetfunda.com/interview/exclusive/showcatquestion.aspx?category=38


In computing, denormalization is the process of attempting to optimise the read performance of a database by adding redundant data or by grouping data.[1][2] In some cases, denormalisation helps cover up the inefficiencies inherent in relational database software. A relational normalised database imposes a heavy access load over physical storage of data even if it is well tuned for high performance.

http://en.wikipedia.org/wiki/Denormalization



Denormalization means allowing redundancy in a table. The main benefit of denormalization is improved performance with simplified data retrieval and manipulation. This is done by reduction in the number of joins needed for data 

string literal vs string object

when you use new String("...") you get a new string object.

In this example both string literals refer the same object:

String a = "abc";
String b = "abc";
System.out.println(a == b);  // True

Here two different objects are created and they have different references:

String c = new String("abc");
String d = new String("abc");
System.out.println(c == d);  // False
In general you should use the string literal notation when possible. It is easier to read and it gives the compiler a chance to optimize your code.

Reference:
http://stackoverflow.com/questions/3297867/difference-between-string-object-and-string-literal

•    the String class creates a pool of Strings

    when you create a String by using the new operator or by using the + and += operators (the string is computed at runtime) you are implicitly telling the compiler to create a new String object
    when you create a String by assigning a string literal the compiler searches the existing string pool for an exact match. If it finds one, a new string is NOT created. Instead the variable is assigned a reference to the existing pooled string.
 
    http://www.janeg.ca/scjp/oper/string.html



public class compareStrings {


public static void main(String[] args) {

/*
* string literal example
* when you create a String by assigning a string literal the compiler searches the existing string pool for an exact match.
* If it finds one, a new string is NOT created. Instead the variable is assigned a reference to the existing pooled string
*/
String str1="abc";
String str2="abc";



if (str1==str2)
{
System.out.println("str1=str2");
}
else
{
System.out.println("str1 not str2");
}



//to actually compare the contents of String objects use the String method equals()
if (str1.equals(str2)) {
System.out.println("str1=str2");
} else {
System.out.println("str1 not str2");
}



}

}




output:

str1=str2
str1=str2




public class compareStrings {


public static void main(String[] args) {




/*
* Here two different string objects are created and they have different references
* when you use new String("...") you get a new string object
* when you create a String by using the new operator or by using the + and += operators (the string is computed at runtime)
* you are implicitly telling the compiler to create a new String object
*/

String str1=new String("abc");
String str2=new String("abc");


if (str1==str2)
{
System.out.println("str1=str2");
}
else
{
System.out.println("str1 not str2");
}



//to actually compare the contents of String objects use the String method equals()
if (str1.equals(str2)) {
System.out.println("str1=str2");
} else {
System.out.println("str1 not str2");
}



}

}


output:

str1 not str2
str1=str2

• Comparison of Objects with equals 

 
    == relational operator is used to compare primitive data types
 
int a = 5;
int b = 5;

if (a == b)
System.out.println("equal");
else
System.out.println("not equal");

Output is "equal".



"==" operator works only with primitive data types, does not work if we use wrapper classes of primitive data types

Integer a = new Integer(5);
Integer b = new Integer(5);

if (a == b)
System.out.println("equal");
else
System.out.println("not equal");

Output is "not equal".

"==" operator is not applicable for objects because it compares  references of objects not contents of objects
comparison of contents of objects there is "equals" method in each object

wrapper class example

Integer a = new Integer(5);
Integer b = new Integer(5);

if (a.equals(b))
System.out.println("equal");
else
System.out.println("not equal");

Output is "equal".


This "equals" work fine for wrapper classes but does not run correctly for custom classes because it compares two object references by default just like "==" operator.
To change behaviour of "equals" we will have to override it in our classes

http://javainnovations.blogspot.com/2008/05/comparison-of-objects-with-equals.html

• equals method is overriden in all wrapper classes and String class as well. 

the StringBuffer class doesnt overrides it.


http://www.coderanch.com/t/241896/java-programmer-SCJP/certification/equals-Wrapper-Classes

public class TestWrapper {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

Integer i=new Integer("1");
Integer j=new Integer("1");
String s=new String("1");
String s1="1";
StringBuffer sb=new StringBuffer("1");
StringBuffer sb1=new StringBuffer("1");
 
System.out.println(i==j);         //false
System.out.println(i.equals(j));   //true  
System.out.println(s==s1);          //false
System.out.println(s.equals(s1));   //true
System.out.println(sb==sb1);        //false
System.out.println(sb.equals(sb1)); //false
System.out.println(sb==sb);          //true
System.out.println(sb.equals(sb));   //true
System.out.println(sb1==sb1);        //true
System.out.println(sb1.equals(sb1)); //true


}

}

• String and wrapper classes have override the equals method in Object class

Primitive values in Java are not objects.
In order to manipulate these values as objects, the java.lang package provides a wrapper class for each of the primitive data types
All wrapper classes are final.
The objects of all wrapper classes that can be instantiated are immutable,


Wrapper Comparison, Equality, and Hashcode

Each wrapper class (except Boolean) defines the following method:
int compareTo(WrapperType obj2)


Each wrapper class (except Boolean) also implements the Comparable interface, which defines the following method:
int compareTo(Object obj2)
This method is equivalent to the compareTo(WrapperType) method when the current object and the object denoted by the argument obj2 have the same WrapperType.




Each wrapper class overrides the equals() method from the Object class.
The overriding method compares two wrapper objects for object value equality.
boolean equals(Object obj2)


Each wrapper class overrides the hashCode() method in the Object class.
The overriding method returns a hash value based on the primitive value in the wrapper object.
int hashCode()

http://etutorials.org/cert/java+certification/Chapter+10.+Fundamental+Classes/10.3+The+Wrapper+Classes/

Prepare Yourself Mentally and Emotionally for Your Job Search

 it’s important not to neglect the mental and emotional preparation that is also necessary

Rehearse
anticipate some of the questions the interviewer will ask, or that you think he or she will ask
Relaxation Exercises
They help you get your attention focused, centered, and calm. Deep breathing is one such exercise; meditation takes it a bit further along the preparedness scale
Remember – It’s Not Personal
So before your interview, go over how you will respond if the answer is no.
Have some steps planned out and some practical things you can do in the face of rejection.
This may make you more relaxed anyway, and you won’t appear desperate to the interviewer.
Visualization
Get a good mental picture of what your position will look like.

Reference:
http://jobstar.info/prepare-yourself-mentally-and-emotionally-for-your-job-search/?goback=.gde_1698247_member_120807357

perl interview questions

• Explain the difference between 'my' and 'local' variable scope declarations?

Both of them are used to declare local variables.
The variables declared with 'my' can live only within the block and cannot gets its visibility inherited fucntions called within that block, but one defined as 'local' canlive within the block and have its visibility in the functions called within that block.




'my' creates a new variable, 'local' temporarily amends the value of a variable

There is a subtle difference.

In the example below, $::a refers to $a in the 'global' namespace.

$a = 3.14159;
{
local $a = 3;
print "In block, $a = $a ";
print "In block, $::a = $::a ";
}
print "Outside block, $a = $a ";
print "Outside block, $::a = $::a ";

# This outputs
In block, $a = 3
In block, $::a = 3
Outside block, $a = 3.14159
Outside block, $::a = 3.14159
[download]
ie, 'local' temporarily changes the value of the variable, but only within the scope it exists in.

so how does that differ from 'my'? 'my' creates a variable that does not appear in the symbol table, and does not exist outside of the scope that it appears in. So using similar code:

$a = 3.14159;
{
my $a = 3;
print "In block, $a = $a ";
print "In block, $::a = $::a ";
}
print "Outside block, $a = $a ";
print "Outside block, $::a = $::a ";

# This outputs
In block, $a = 3
In block, $::a = 3.14159
Outside block, $a = 3.14159
Outside block, $::a = 3.14159
[download]
ie, 'my' has no effect on the global $a, even inside the block.

http://www.coolinterview.com/interview/6205/

• what is meant by a 'pack' in perl?

Pack Converts a list into a binary representation. Takes an array or list of values and packs it into a binary structure

http://discuss.itacumens.com/index.php?topic=37847.0

• What are scalar data and scalar variables?

Scalar means a single thing, like a number or string

http://www.toppersarena.com/index.php?option=com_content&view=article&id=217:perl-interview-questions-and-answers&catid=36:blog-section&Itemid=49

• What is a hash?

conventions remain the same - any combination of letters, numbers and the underscore characte
%special_events
A hash is also called an associative array, or an array where each value is associated with a corresponding key
%contactInfo = ('name', 'Bob', 'phone', '111-111-1111');
http://www.techinterviews.com/perl-interview-questions-and-answers
http://www.onesmartclick.com/interviews/perl-programming-interview-questions-answers.html




What does the command ‘use strict’ do and why should you use it?

#!/usr/local/bin/perl -w
use strict;

This will help you (really, it will force you) to write better, cleaner code.
Adding the -w switch to the perl interpreter will cause it to spit out warnings on uninitialized variables
'use strict' turns on the 'strict' pragma which will make you declare your variables with the my keyword
'use strict' also tosses up errors if your code contains any barewords that can't be interpreted in their current context.

http://perl.about.com/b/2006/09/21/why-you-should-use-strict.htm

• "Use strict" is one of the pragma used for checking the variable scope and syntax

Eg: You can write a program like this:

$x=100
print $x

But if you use strict pragma, then you have to be very
specific while using variables

use strict;
my $x=100; ##look at the usage of scope like my,local,our
print $x;

http://www.allinterview.com/showanswers/16873.html

• Explain the difference between use and require.

The use statement works at compile time, require at run time. So if you have a module that does a lot in a begin block and you don't really need it in all cases, then it's clever to "require" it there where you want to use it but don't "use" it. So you don't have to wait for all that initializations of that module in case you don't need it.

The differences are many and often subtle:
use only expects a bareword, require can take a bareword or an expression
use is evaluated at compile-time, require at run-time
use implicitly calls the import method of the module being loaded, require does not
use excepts arguments in addition to the bareword (to be passed to import), require does not
use does not behave like a function (i.e can't be called with parens, can't be used in an expression, etc), whereas require does
So they behave differently but achieve the same goal. Then there's a list of cultural differences in addition to the technical differences, but they're not so hard and fast.

http://www.perlmonks.org/?node_id=412860

• What purpose does each of the following serve: -w, strict, - T ?

-w enables the warnings mode in perl-T is enables the Taint mode it performs some checks howyour program is using the data passed to itTurn on strict mode to make Perl check for common mistakes.

http://www.scribd.com/doc/1184228/Perl-Interview


-w:Enables warnings.Turning on warnings will make Perl yelp and complain at a huge variety of things that are almost always sources of bugs in your programs.

-t:Perl offers a mechanism called taint that marks any variable that the user can possibly control as being insecure. This includes user input, file input and environment variables.

Strict: It makes you declare all your variables (``strict vars''), and it makes it harder for Perl to mistake your intentions when you are using subs (``strict subs'').

• Difference between for & foreach ?

For and foreach both are for looping the code but if you want to use array in place of scalar for loop, you have to use foreach keyword

• What is a subroutine?

subroutine is a reusable piece of code.

• Why we use Perl?

1.Perl is a powerful free interpreter.

2.Perl is portable, flexible and easy to learn.

-For shell scripting

-For CGI 

-Tons of scripts are available.

-Easy development

-Enormous big support script archive like CPAN

-No one starts to write a Perl scripts from scratch, you choose one from an archive and modify that.

-It is a "mature" scripting language.

-You may find Perl interpreter on every mission critical environment

-Easy to learn

• what's hash?

Hash in basically used to comment the script line.

A hash is and unordered set of key/value pairs that you access using strings (keys) as subscripts, to look up the scalar value corresponding to a given key.

• Name all the prefix dereferencer in perl?

The symbol that starts all scalar variables is called a prefix dereferencer. The different types of dereferencer are.

(i) $-Scalar variables

(ii) %-Hash variables

(iii) @-arrays

(iv) &-subroutines

(v) Type globs-*myvar stands for @myvar, %myvar.

• What's the difference between grep and map in Perl?

grep returns those elements of the original list that match the expression, while map returns the result of the expression applied to each element of the original list.
http://perlknowledge.blogspot.com/2010/12/perl-basic-interview-question-and.html

how to perl on linux

@variables

A variable is defined by the ($) symbol (scalar)
the (@) symbol (arrays)
the (%) symbol (hashes)


Scalar variables are simple variables containing only one element--a string, a number, or a reference

Strings may contain any symbol, letter, or number.
Numbers may contain exponents, integers, or decimal values.
The bottom line here with scalar variables is that they contain only one single piece of data


Arrays contain a list of scalar data (single elements).

Hashes are complex lists with both a key and a value part for each element of the list.

Reference:
http://www.tizag.com/perlT/perlvariables.php



$a=1;
($a,$b)=(7,8);

$nummer1 =3;
$string1="estamboel";

print "$string1 $nummer1 \n";

print "$string1 + $nummer1 \n";

Reference:

http://www.youtube.com/watch?v=y25VxNiGc2M&feature=autoplay&list=PLE7511681ABEA8635&playnext=2





@syntax

File names, variables, and arrays are all case sensitive

'#' sign. Any words, spaces, or marks after a pound symbol will be ignored

use the backslash (\) character to escape any type of character that might interfere with our code



@strings

There is no limit to the size of the string, any amount of characters
string can be used with single or double quotations

@numbers

Numbers exist as real numbers, float, integers, exponents, octal, and hexidecimal numbers

@arrays

sequential number arrays
Rather than typing out each element when counting to 100 for example
@100 = (1 .. 100);

finding the length of an array
set the array to a scalar variable, then just print the new variable
@nums = (1 .. 20);
$nums = @nums;


adding and removing elements

push() - adds an element to the end of an array.
unshift() - adds an element to the beginning of an array.
pop() - removes the last element of an array.
shift() - removes the first element of an array.

Function Definition
push(@array, Element) Adds to the end of an array
pop(@array) Removes the last element of the array
unshift(@array, Element) Adds to the beginning of an array
shift(@array) Removes the first element of an array
delete $array[index] Removes an element by index number