Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:41:02Z

Beacon: /* Applicants of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

The essence of a pattern is a reusable solution for a recurring problem.The type of object needed depends on the contents of the external data or event. It defines an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Creator class is written without knowing what actual ConcreteProduct class will be instantiated. The ConcreteProduct class which is instantiated is determined solely by which ConcreteCreator subclass is instantiated and used by the application.

[[Image:facuml.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates
 Classes delegate responsibility to one of several helper subclasses, and you want to localize the knowledge of which helper subclasses is the delegate.

Sometimes, you need to create an object to represent external data or process an external event. The type of object needed depends on the contents of the external data or event. You don’t want the source of the data or event nor object’s clients to need to be aware of the actual type of object created. You accomplish that by encapsulating the decision of the class of object to create in its own class.This is when factory method design can be put in to to best use.

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li> Factory Design Pattern [http://en.wikipedia.org/wiki/Factory_method_pattern] </li>
<li> Abstract Factory Method[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<li> Factory v/s Abstract Factory Pattern[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>
<li> Builder Design Pattern v/s Factory Design Pattern[http://stackoverflow.com/questions/757743/what-is-the-difference-between-builder-design-pattern-and-factory-design-pattern]</li>
<li> Abstract Factory Method [http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf]</li>
<li> UML Diagram of Builder Pattern [http://en.wikipedia.org/wiki/Builder_pattern]</li>
<li> UML Diagram of Prototype Design Pattern [http://www.apwebco.com/gofpatterns/creational/Prototype.html] </li>
<li> UML Diagram of Abstract Factory Design Pattern [http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:40:46Z

Beacon: /* Applicants of Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:26:20Z

Beacon: /* Factory Patterns Insight */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

The essence of a pattern is a reusable solution for a recurring problem.The type of object needed depends on the contents of the external data or event. It defines an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Creator class is written without knowing what actual ConcreteProduct class will be instantiated. The ConcreteProduct class which is instantiated is determined solely by which ConcreteCreator subclass is instantiated and used by the application.

[[Image:facuml.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates
 Classes delegate responsibility to one of several helper subclasses, and you want to localize the knowledge of which helper subclasses is the delegate.

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li> Factory Design Pattern [http://en.wikipedia.org/wiki/Factory_method_pattern] </li>
<li> Abstract Factory Method[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<li> Factory v/s Abstract Factory Pattern[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>
<li> Builder Design Pattern v/s Factory Design Pattern[http://stackoverflow.com/questions/757743/what-is-the-difference-between-builder-design-pattern-and-factory-design-pattern]</li>
<li> Abstract Factory Method [http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf]</li>
<li> UML Diagram of Builder Pattern [http://en.wikipedia.org/wiki/Builder_pattern]</li>
<li> UML Diagram of Prototype Design Pattern [http://www.apwebco.com/gofpatterns/creational/Prototype.html] </li>
<li> UML Diagram of Abstract Factory Design Pattern [http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:20:37Z

Beacon: /* Applicants of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Creator class is written without knowing what actual ConcreteProduct class will be instantiated. The ConcreteProduct class which is instantiated is determined solely by which ConcreteCreator subclass is instantiated and used by the application.

[[Image:facuml.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates
 Classes delegate responsibility to one of several helper subclasses, and you want to localize the knowledge of which helper subclasses is the delegate.

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li> Abstract Factory Method[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<li> Factory v/s Abstract Factory Pattern[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>
<li> Builder Design Pattern v/s Factory Design Pattern[http://stackoverflow.com/questions/757743/what-is-the-difference-between-builder-design-pattern-and-factory-design-pattern]</li>
<li> Abstract Factory Method [http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf]</li>
<li>UML Diagram of Builder Pattern [http://en.wikipedia.org/wiki/Builder_pattern]</li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:17:30Z

Beacon: /* Factory Patterns Insight */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Creator class is written without knowing what actual ConcreteProduct class will be instantiated. The ConcreteProduct class which is instantiated is determined solely by which ConcreteCreator subclass is instantiated and used by the application.

[[Image:facuml.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li> Abstract Factory Method[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<li> Factory v/s Abstract Factory Pattern[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>
<li> Builder Design Pattern v/s Factory Design Pattern[http://stackoverflow.com/questions/757743/what-is-the-difference-between-builder-design-pattern-and-factory-design-pattern]</li>
<li> Abstract Factory Method [http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf]</li>
<li>UML Diagram of Builder Pattern [http://en.wikipedia.org/wiki/Builder_pattern]</li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:15:46Z

Beacon: /* Factory Patterns Insight */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:facuml.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li> Abstract Factory Method[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<li> Factory v/s Abstract Factory Pattern[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>
<li> Builder Design Pattern v/s Factory Design Pattern[http://stackoverflow.com/questions/757743/what-is-the-difference-between-builder-design-pattern-and-factory-design-pattern]</li>
<li> Abstract Factory Method [http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf]

File:Facuml.jpg

2009-11-18T23:15:11Z

Beacon:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:14:32Z

Beacon: /* Factory Patterns Insight */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac1.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li>[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<le>[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:09:00Z

Beacon: /* Applicants of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:

 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li>[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<le>[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:07:45Z

Beacon: /* Applicants of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

Use the Factory Method pattern in any of the following situations:
 A class can't anticipate the class of objects it must create
 A class wants its subclasses to specify the objects it creates

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==
<ol>
<li>[http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html] </li>
<le>[http://www.coderanch.com/t/99780/OO-Patterns-UML-Refactoring/Factory-Vs-Abstract-Factory-Pattern] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:49:48Z

Beacon: /* Examples of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:49:03Z

Beacon: /* Examples of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:47:59Z

Beacon: /* Examples of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

Dog class

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

public class FactoryClient {
public static void main(String args[]) {
MammalsFactory mf = new MammalsFactory();
System.out.println(mf.getMammalObject("Dog").doWalking());
}
}

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:47:01Z

Beacon: /* Examples of Factory Pattern */

== Definition ==

Factory Method is a creational pattern. This pattern helps to model an interface for creating an object which at creation time can let its subclasses decide which class to instantiate.It is called as Factory Pattern as it is responsible for "Manufacturing" an Object. It helps instantiate the appropriate Subclass by creating the right Object from a group of related classes. The Factory Pattern encourages loose coupling by eliminating the need to bind application-specific classes into the code.It Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

== Overview ==

This topic deals with the Factory method design pattern.It explains Factory design pattern and compares with other creational pattern to highlight the uniqueness and distinguishing features of the pattern.It also gives examples of where factory design pattern is used and scenarios wherein its more suitable than other creational patterns.

== In Depth Analysis ==

=== Factory Patterns Insight ===

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.It means that Factory is written without knowing what actual sub class will be instantiated. The subclass which is instantiated is determined solely by which subclass is instantiated and used by the application.

Factory method framework can be shown in the figure below.In the below figure the createDocument() method is a factory method.
[[Image:fac.jpg]]

Benefits
Code is made more flexible and reusable by the elimination of instantiation of application-specific classes,Code deals only with the interface of the Factory class and can work with any sub class that supports this interface

=== Applicants of Factory Pattern ===

=== Examples of Factory Pattern ===

Factory design pattern can be explained by the following example. This example involves factory class called Mammals and it involves calling objects cat and dog with out actually creating an object for cat and dog class.

public class MammalsFactory {
public static Mammals getMammalObject(String name) {
if (name.equalsIgnoreCase("Cat")){
return new Cat();
} else {
return new Dog();
}
}
}

Here we will be passing an argument to the getMammalObject function based on the argument passed we return the Mammals object of the class.

Abstract class is created so that dog ans cat can implement this class

public abstract class Mammals {
public abstract String doWalking();
}

The cat and dog class can be created to implement the abstract class as follows

public class Cat extends Mammals {
public String doWalking() {
return "Cats has been Informed to perform Walk Operation";
}
}

public class Dog extends Mammals {
public String doWalking() {
return "Dogs has been Informed to perform Walk Operation";
}
}

Now without creating object for dog and cat but we are instantiating the object for Mammals Factory class.

== Comparison with other Creational Patterns ==

=== Comparison with Builder Pattern ===
In Factory pattern, the factory is in charge of creating various subtypes of an object depending on the needs.

Where as in Builder pattern, the composition of the objects might differ within the same subclass.

An example of a Factory method CarCreate might return a Audi or a Toyota where as in the same scenario if we are using a Builder pattern, it allows us to create objects with finer granularity like specifying different engine specifications (a 4 cylinder engine or a 6 cylinder engine)for the objects.
As seen from the above example the Factory pattern is a simpler version of the Builder Pattern.

UML diagram of Builder Pattern

[[Image:Builder2.png]]
Source: [http://en.wikipedia.org/wiki/Builder_pattern]

=== Comparison with Prototype Pattern ===
The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.
The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.

[[Image:prototype.jpg]]

=== Comparison with Abstract Factory Pattern ===
Abstract pattern is one level of abstraction higher than the factory pattern.
A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common methods, but each of them performs a task differently and is optimized for different kinds of data.

There are several similar variations on the factory pattern:
1. The base class is abstract and the pattern must return a complete working class.
2. The base class contains default methods and is only sub-classed for cases where the default methods are insufficient.
3. Parameters are passed to the factory telling it which of several class types to return. In this case the classes may share
the same method names but may do something quite different.

[[Image:abstractfactory.gif]]

== External Links and References ==

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:41:13Z

Beacon: /* Examples of Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:38:24Z

Beacon: /* Examples of Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:07:28Z

Beacon: /* Definition */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:07:04Z

Beacon: /* Factory Patterns Insight */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:04:13Z

Beacon: /* Factory Patterns Insight */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:56:23Z

Beacon: /* Factory Patterns Insight */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:53:32Z

Beacon: /* Factory Patterns Insight */

File:Fac.jpg

2009-11-18T04:50:43Z

Beacon:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:50:24Z

Beacon: /* Factory Patterns Insight */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:40:02Z

Beacon: /* In Depth Analysis */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:38:46Z

Beacon: /* In depth Analysis */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:32:54Z

Beacon:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:25:23Z

Beacon: /* Definition */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:11:28Z

Beacon: /* Comparison with other Creational Patterns */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:10:32Z

Beacon: /* Comparison with Builder Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:09:32Z

Beacon: /* Comparison with Builder Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:08:03Z

Beacon: /* Comparison with Builder Pattern */

File:Builder2.png

2009-11-18T04:07:00Z

Beacon:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:37:46Z

Beacon: /* Overview */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:29:41Z

Beacon: /* Definition */

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-14T23:10:49Z

Beacon: /* '''Reflection''' */

'''Reflection Oriented Programming'''
 
This wiki throws light on what '''Reflection Oriented programming''' is all about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs. It further highlights the importance and the limitations of reflection oriented programming languages.
 

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity, we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior. A system which exhibits such reflective behavior is called as reflection oriented system.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. Reflection allows program entities to discover things about themselves through introspection.

In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation, but in reflection the program (object) needs to have information about its structures. This is done by storing it in the form of [http://en.wikipedia.org/wiki/Metadata metadata].

There are two types of reflection based on its dynamic nature. Few programs support reflection during compilation. They are called as compile time or static reflection. Run time reflections are those which are carried on during run time and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 1.class # print the class of 1
>> Fixnum

puts 123456789012345.class
>> Bignum

The above code dynamically finds out the class. Thus reflection is done in ruby code to carry out operations during run time with [http://en.wikipedia.org/wiki/Metaprogramming meta programming] enabled.

=== '''Reflection Oriented Program as paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented] and [http://en.wikipedia.org/wiki/Procedural_programming procedure oriented model]. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets. Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length), intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based upon the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories:
*Atomic
*Compound
Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called meta information(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the meta information. It changes as the state changes and its designed to hold the meta information of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during run time.

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of meta information. The current state of meta information is reflected by the instances of reflectives or objects of reflectives.

Reflectives can be broadly classified in to two categories.
* Simple reflective and
* Control reflective.

Simple reflective contains the computational concepts whereas control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. It is called as the value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html here].

=== '''Illustration''' ===

Below is an illustration of the concept for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def hello (name)
puts "hello, #{name}"
end
end
p = Person.new
p.send(:hello, "Sam")

== List of Reflection Oriented Programming Languages ==

The list of reflection oriented programming languages includes programming languages which can support and implement reflection i.e. dynamically typed languages like Smalltalk,etc., scripting languages like PERL, etc.

The following is a comprehensive list of the reflection oriented programming languages:
* [http://en.wikipedia.org/wiki/APL_(programming_language) APL]
* [http://en.wikipedia.org/wiki/Befunge Befunge]
* [http://en.wikipedia.org/wiki/Curl_(programming_language) Curl]
* [http://www.engin.umd.umich.edu/CIS/course.des/cis400//delphi/delphi.html Delphi]
* [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel]
* [http://iolanguage.com/ Io]
* [http://en.wikipedia.org/wiki/Java_(programming_language) JAVA](java.lang.reflect)
* [http://en.wikipedia.org/wiki/Java_(programming_language) Lisp]
* [http://el.media.mit.edu/Logo-foundation/logo/programming.html Logo]
* [http://en.wikipedia.org/wiki/.NET_Framework .NET Framework]
** [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]
** [http://en.wikipedia.org/wiki/Visual_Basic_.NET VB .NET]
* [http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html Objective-C]
* [http://en.wikipedia.org/wiki/Perl Perl]
* [http://www.php.net/ PHP]
* [http://www.python.org/ Python]
* [http://www.ruby-lang.org/en/ Ruby]
* [http://www.smalltalk.org/main/ Smalltalk]
* [http://www.tcl.tk/ Tcl]

== Examples of Reflection Oriented Languages ==

=== '''Example in JAVA''' ===
In JAVA, reflection is implemented by using the Java package, [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html java.lang.reflect]:

<pre>
/*
In the following example in JAVA, identification of an array using reflection is demonstrated.
*/

import java.lang.reflect.*;

public class FindIfArray {
public static void main(String str[]){
int[] arr = {1,9,8,7};
String strg="Hello";
Class cl_arr= arr.getClass();
Class cl_strg= strg.getClass();
if(cl_arr.isArray())
System.out.println(" arr is an array ");
else
System.out.println(" arr is not an array ");

if(cl_strg.isArray())
System.out.println(" strg is an array ");
else
System.out.println(" strg is not an array ");
}
}
</pre>

The output of this above program will be as follows:

<pre>
C:\Reflection\javac FindIfArray.java

C:\Reflection\java FindIfArray
arr is an array
strg is not an array

</pre>

=== '''Example in C#''' ===
To implement reflection in C#, the namespace [http://msdn.microsoft.com/en-us/library/system.reflection.aspx System.Reflection] is used.

The System.Reflection namespace contains classes and interfaces that provide a managed view of loaded types, methods, and fields, with the ability to dynamically create and invoke types[http://www.codersource.net/published/view/291/reflection_in.aspx 7].

<pre>
using System;
using System.Reflection;

public class MyClass
{
public virtual int AddNumb(int numb1,int numb2)
{
int result = numb1 + numb2;
return result;
}

}

class MyMainClass
{
public static int Main()
{
Console.WriteLine ("\nReflection.MethodInfo");
// Create MyClass object

MyClass myClassObj = new MyClass();
// Get the Type information.

Type myTypeObj = myClassObj.GetType();
// Get Method Information.

MethodInfo myMethodInfo = myTypeObj.GetMethod("AddNumb");

object[] mParam = new object[] {5, 10};

// Get and display the Invoke method.
Console.Write("\nFirst method - " + myTypeObj.FullName + " returns " + myMethodInfo.Invoke(myClassObj, mParam) + "\n");

return 0;
}
}
</pre>

In this code:
* Firstly, we obtain the type information and <code>myTypeObj</code> will have the information about <code>MyClass</code>
* Secondly,
by using the <code>MethodInfo myMethodInfo = myTypeObj.GetMethod("AddNumb"); </code>,we can get the method's information.
* Thirdly, the following code will invoke the <code>AddNumb</code> method:
<pre>
myMethodInfo.Invoke(myClassObj, mParam);
//In this example, we will use the typeof keyword to obtain the
//System.Type object for a type.

Public class MyClass2
{
int answer;
public MyClass2()
{
answer = 0;
}

public int AddNumb(intnumb1, intnumb2)
{
answer = numb1 + numb2;
return answer;
}
}
</pre>

Hence, in this way we can use reflection to obtain details of an object, method, and create objects and invoke methods at runtime.

== Importance of Reflection Oriented Programming Languages==

Reflection is a advanced feature which helps applications work better in the following ways[http://java.sun.com/docs/books/tutorial/reflect/index.html 6]:

*'''Dynamic nature'''
It can be used for modifying or observing a program execution at run time.

*'''Features can be extended'''
An application can use external, user-defined classes by generating instances of extensibility objects using their fully-qualified names.

*'''Class Browsers and Visual Development Environments'''
A class browser must be capable of enumeration of the class members. Visual Development Environments are at an advantage from making use of type information available in reflection to help the developer in writing code correctly.

*'''Debuggers and Test Tools'''
Debuggers must be able to inspect the private members on the classes. Test harnesses can make use of reflection to systematically call a discoverable set of API's defined on a class, to insure a high level of code coverage in a test suite.

*'''Adaptability to environment & elimination of hard-coding'''
Consider an application which makes use of two different classes X and Y interchangeably to do similar operations. Without reflection-oriented programming, the application might be hard-coded to call method names of class X and class Y.
However, by making use of the reflection-oriented programming paradigm, the application can be designed and written to utilize reflection in order to invoke methods in classes X and Y without hard-coding method names.

*'''Reflection can be used in [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming].'''
Aspect-oriented programming is all about enabling the programmer to concisely address functionality that may crosscut the actual implementation of their application [http://people.csail.mit.edu/gregs/cacm-sidebar.pdf 9].

== Limitations of Reflection Oriented Programming Languages ==

There are certain limitations which hinder the usage of the reflection oriented programming languages with the major drawback being performance issues[http://java.sun.com/docs/books/tutorial/reflect/index.html 6].

*'''Performance Overhead'''
Operations involving reflections have slower performance than the non-reflective counterparts.

Consider the following java code[http://www.ibm.com/developerworks/library/j-dyn0603/ 9]:
<pre>
public int accessSame(int loops) {
m_value = 0;
for (int index = 0; index < loops; index++) {
m_value = (m_value + ADDITIVE_VALUE) *
MULTIPLIER_VALUE;
}
return m_value;
}

public int accessReference(int loops) {
TimingClass timing = new TimingClass();
for (int index = 0; index < loops; index++) {
timing.m_value = (timing.m_value + ADDITIVE_VALUE) *
MULTIPLIER_VALUE;
}
return timing.m_value;
}

public int accessReflection(int loops) throws Exception {
TimingClass timing = new TimingClass();
try {
Field field = TimingClass.class.
getDeclaredField("m_value");
for (int index = 0; index < loops; index++) {
int value = (field.getInt(timing) +
ADDITIVE_VALUE) * MULTIPLIER_VALUE;
field.setInt(timing, value);
}
return timing.m_value;
} catch (Exception ex) {
System.out.println("Error using reflection");
throw ex;
}
}
</pre>

In order to study the performance issues, the program above is called repeatedly with a large loop count.

An average field access time is calculated, and during this, the first call has not been included. Hence, the initialization factor has not been considered as a factor in the results.
In this performance test, a loop count of 10 million for each call has been considered and this execution has been performed on a 1GHz Pentium III system.

In the Figure 1[http://www.ibm.com/developerworks/library/j-dyn0603/ 9]:
the timing results for three different Linux JVM's(with default settings for each JVM) have been displayed.

[[Image:field-accesses.jpg|frame|center|Figure 1|[http://www.ibm.com/developerworks/library/j-dyn0603/ 9]]]

The X-axis, i.e. the logarithmic scale, displays the full range of times.
The following observations can be made from the performance test and the above figure:
<ol>

<li>In the first 2 cases, the execution time using reflection is 1000 times greater than accessing directly.</li>

<li>The IBM's JVM has worked considerably better when compared to the Sun JVM's but the reflection method has taken more than 700 times as long as the other methods. </li>

<li>We can observe that there were no notable differences in the times between the other two methods on the other JVM, though the IBM JVM ran these almost 2 times faster as the Sun JVM's.</li>

<li>Probably, this difference shows the specialized optimizations used by the Sun Hot Spot JVMs, which tend to do poorly in certain simple benchmarks.</li>

</ol>
*'''Security Restrictions'''
Reflections require a run time permission which may not be present when running under a security manager.

*'''Exposure of Internals'''
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private methods and fields, the use of reflection can result in unexpected side-effects, which may cause the code to become dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=Conclusion=

Reflection is a wide-ranging topic that has been studied independently in various areas of science in general, as well as the field of computer science particularly. Even in the sub-area of programming languages, it has been applied to a variety of paradigms, especially the logic, functional and object oriented ones[8].

With a few exceptions, performance problems of reflection oriented programming languages are rarely addressed and never solved completely in the research of reflection. The best way to overcome this performance problem of reflection is to use less amount of reflection oriented coding in the programming languages.

But to make reflection oriented languages accepted by a wider community we have to prove that the implementation of reflection can take place in a way which does not affect performance too much.

=References=
<ol>
<li> Conference on Object Oriented Programming Systems Languages and Applications : [http://portal.acm.org/citation.cfm?id=62083.62111 Reflection in an object-oriented concurrent language]</li>
<li>Jonathan M. Sobel Daniel P. Friedman : [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html An Introduction to Reflection-Oriented Programming]</li>
<li>.NET Framework Class Library : [http://msdn.microsoft.com/en-us/library/system.reflection.aspx System.Reflection Namespace]</li>
<li>Package [http://java.sun.com/j2se/1.3/docs/api/java/lang/reflect/package-summary.html : java.lang.reflect] </li>
<li>[http://wapedia.mobi/en/Reflection_(computer_science) Reflection]</li>
<li>[http://java.sun.com/docs/books/tutorial/reflect/index.html Trail: The Reflection API]</li>
<li>[http://www.codersource.net/published/view/291/reflection_in.aspx Reflection in C#] </li>
<li>Reflection in logic, functional and object-oriented programming: a Short Comparative Study (1995) by François-Nicola Demers , Jacques Malenfant </li>
<li>[http://www.ibm.com/developerworks/library/j-dyn0603/ Java Programming Dynamics Part 2: Introducing reflection]</li>
<li>[http://people.csail.mit.edu/gregs/cacm-sidebar.pdf Aspect-Oriented Programming using Reflection and Metaobject Protocols]: Gregory T. Sullivan, Artifcial Intelligence Laboratory, Massachusetts Institute of Technology</li>

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:56:52Z

Beacon: /* '''Examples and Scenerios''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives. Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. Its called as value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found here [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]

=== '''Example''' ===

Below is an example for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def hello (name)
puts "hello, #{name}"
end
end
p = Person.new
p.send(:hello, "Sam")

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:54:04Z

Beacon: /* '''Examples and Scenerios''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives. Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. Its called as value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found here [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]

=== '''Examples and Scenerios''' ===

Below is an example for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def hello (name)
puts "hello, #{name}"
end
end
p = Person.new
p.send(:hello, "Sam")

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:53:35Z

Beacon: /* '''Examples and Scenerios''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives. Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. Its called as value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found here [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]

=== '''Examples and Scenerios''' ===

Below is an example for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def greet (name)
puts "hello, #{name}"
end
end
p = Person.new
p.send(:greet, "Sam")

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:53:25Z

Beacon: /* '''Examples and Scenerios''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives. Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. Its called as value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found here [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]

=== '''Examples and Scenerios''' ===

Below is an example for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def greet (name)
puts "hello, #{name}"
end
end

p = Person.new
p.send(:greet, "Sam")

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:53:07Z

Beacon: /* '''Examples and Scenerios''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives. Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

There is a subcategory of simple reflectives that is designed to contain the meanings of the expressed values. Its called as value reflectives. The common notation for expressing relative is <reflective>.Numerous examples of reflectives can be found here [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]

=== '''Examples and Scenerios''' ===

Below is an example for reflection in ruby. Here the class person has a function defined which is used to display the name. An object is created to the class Person and we use obj.send to send the object to the function. This shows the dynamic behavior in ruby

class Person
def greet (name)
puts "hello, #{name}"
end
end

p = Person.new
p.send(:greet, "Sam")

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:31:28Z

Beacon:

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:31:10Z

Beacon:

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:29:21Z

Beacon: /* '''Reflectives''' */

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:29:09Z

Beacon: /* '''Reflectives''' */

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:25:01Z

Beacon: /* '''Reflectives''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called metainformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

=== '''Reflectives''' ===

A reflective does the job of describing the behavior of metainformation. The current state of meta information is reflected by the instances of reflectives or objects of reflectives.Reflectives can be broadly classified in to two catgories. Simple reflective and Control reflective.Simple reflective contains the computational concepts whereas Control reflectives contains concept related to flow and control.

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T02:08:24Z

Beacon:

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T01:05:01Z

Beacon: /* '''Concepts''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called meta nformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and its designed to hold the metainformation of the current state.On encountering data it derives the information of the state, processes it and triggers the state change. These operations are performed during runtime

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T01:03:40Z

Beacon: /* '''Concepts''' */

'''Reflection Oriented Programming'''

----

== Definition ==

Reflection is a process of reasoning about and acting up on by itself [http://portal.acm.org/citation.cfm?id=62083.62111]. Throwing more clarity we can presume reflection as a computer code which can be dynamically modified in the process of execution. The dynamic modification depends on the code features and its run time behavior.A system which exhibits such reflective behavior is called as reflection oriented system.

== Overview ==

This Article throws light up on what Reflection Oriented programme is about. It deals with the need for such dynamic aspect and how it is useful in satisfying the practical needs.Further it highlights the research work that is carried out in this area and scope for future improvements.

== Reflection oriented programming – Insights ==

=== '''Reflection''' ===

Reflection is the process of converting a programmatically expressed value into a component of interpreter state [http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/rop.html]. In the case of usual programs the information about itself (i.e the program) is lost as soon as it finishes compilation ,but in Reflection the program (object) needs to have information about its structures. This is done by storing it in the form of metadata[http://en.wikipedia.org/wiki/Metadata].

There are two types of reflection based on its dynamic nature.Few programs support reflection during compilation. They are called as compile time or static reflection. Runtime reflections are those which are carried on during runtime and its the usual form of reflections.

Example of Reflections:

A simple ruby code does enough to understand the concept behind reflections

puts 12.kind_of?

The above code dynamically finds out what kind is 12 ? It returns the value integer. Thus reflection is done in ruby code to carry out operations during runtime with metaprogramming[http://en.wikipedia.org/wiki/Metaprogramming] enabled.

=== '''Reflection Oriented Program as Paradigm''' ===

Reflection oriented paradigm is a new paradigm used as an extension to the object oriented paradigm. It adds various features meeting the need of various applications and its very flexible. Its a dynamic run time paradigm unlike object oriented and procedure oriented model. In this paradigm objects can be varied and modified according to the needs during the run time rather than creating static set of codes with a predetermined set of operations.

The dynamic decision in this paradigm is decided based up on the data being processed and the manipulation performed on those data sets.Here is where the knowledge about its own structure plays a crucial role. On considering an example wherein a program needs to change dynamically on various sets of data (find an instance of that data or length) ,intercepting the interpreters becomes important. In these cases the program should consist of codes just to identify the data and to decide the operations to be performed on them.

=== '''Concepts''' ===

The concept of reflection oriented programming is based up on the extension of object oriented program to dynamically shape the program based on its data. All the computations can be divided in to two categories.ATOMIC and COMPOUND.Atomic refers to when the computation is completed in a single logical step whereas compound refers to the computation that requires the completion of sub computation

To make the concept work as described earlier a new entity called meta nformation(information about information) is introduced.It takes into account of the details contained in the meta level.It acts as a storage wherein it contains the metainformation. It changes as the state changes and designed to hold the metainformation of the current state.On encountering data it derives the information of the state and process it and trigger the state change. These operations are performed during runtime

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T00:54:46Z

Beacon: /* '''Concepts''' */

CSC/ECE 517 Fall 2009/wiki2 8 RP

2009-10-08T00:53:00Z

Beacon: /* '''Concepts''' */