Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:50:28Z

Apurush: /* 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 ===

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.

=== Application 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>
<li> Factory Design Pattern Usage [http://www.developer.com/java/other/article.php/618421/Pattern-Summaries-Factory-Method.htm] </li>
<li> Examples of Factory Design Pattern [http://www.hiteshagrawal.com/java/factory-design-pattern-in-java] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:44:36Z

Apurush: /* External Links and References */

== 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>
<li> Factory Design Pattern Usage [http://www.developer.com/java/other/article.php/618421/Pattern-Summaries-Factory-Method.htm] </li>
<li> Examples of Factory Design Pattern [http://www.hiteshagrawal.com/java/factory-design-pattern-in-java] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:44:00Z

Apurush: /* External Links and References */

== 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>
<li> Factory Design Pattern Usage [http://www.developer.com/java/other/article.php/618421/Pattern-Summaries-Factory-Method.htm] </li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:43:43Z

Apurush: /* External Links and References */

== 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>
<li> Factory Design Pattern Usage [http://www.developer.com/java/other/article.php/618421/Pattern-Summaries-Factory-Method.htm
]</li>

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:24:56Z

Apurush: /* External Links and References */

== 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> 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:24:42Z

Apurush: /* External Links and References */

== 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> 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:16:09Z

Apurush: /* External Links and References */

== 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]</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:19Z

Apurush: /* Comparison with other Creational Patterns */

== 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]]

=== 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]

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:14:42Z

Apurush: /* External Links and References */

== 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> 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]

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T23:01:37Z

Apurush: /* External Links and References */

== 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 ==
<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:26:55Z

Apurush: /* Comparison with Abstract Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:25:18Z

Apurush: /* Comparison with Abstract Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:24:00Z

Apurush: /* Comparison with Abstract Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:23:42Z

Apurush: /* Comparison with Abstract Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T05:22:31Z

Apurush: /* Comparison with Abstract Factory Pattern */

File:Abstractfactory.gif

2009-11-18T04:58:46Z

Apurush:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:58:35Z

Apurush: /* Comparison with Abstract Factory Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:55:37Z

Apurush: /* Comparison with Prototype Pattern */

File:Prototype.jpg

2009-11-18T04:43:56Z

Apurush:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:43:40Z

Apurush: /* Comparison with Prototype Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:41:24Z

Apurush:

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T04:04:09Z

Apurush: /* Comparison with Builder Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:53:17Z

Apurush: /* Comparison with Singleton Pattern */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:43:45Z

Apurush: /* Comparison with other Creational Patterns */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:42:08Z

Apurush: /* Comparison with other Creational Patterns */

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:15:21Z

Apurush:

== Definition ==

== Overview ==

== Comparison with other Creational Patterns ==

== In depth Analysis ==

== External Links and References ==

CSC/ECE 517 Fall 2009/wiki3 16 AD

2009-11-18T03:13:41Z

Apurush:

== Definition ==

== Overview ==

== Comparison with other Creational Patterns ==

== In depth Analysis ==

CSC/ECE 517 Fall 2009/wiki1a 11 AS

2009-09-12T18:54:32Z

Apurush: /* <center> '''ruby vs Python''' </center> = */

= <center> '''Ruby vs Python''' </center> ==

== Definition of Ruby and Python ==

'''Ruby''' is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features.
It is an interpreted language that includes a powerful set of libraries. While it is often referred to as a scripting language, it is a pure objected-oriented language that has sufficient expressiveness for general-purpose applications.

'''Python''' is an interpreted, object-oriented, high-level programming language with dynamic semantics.

== Differences in their language features ==
1.The first thing to be noted in Ruby is that,everything is an object, whereas in Python we have the liberty to code without using objects.

2.In ruby, the programmer can use blocks to extend the language for application specific control statements where as in Python we are supposed to use only the control statements provided by the language.

3.Ruby protects class attributes.We can’t access attributes of objects from outside the class.
Python doesn’t protect our code from other programmers. If they want to shoot themselves in the foot they are allowed to do so.

4.In Ruby, there are no functions, but there are methods, blocks and lambdas. All of them seem to have subtle differences, and sometimes we need to not just call them, but use .call().
In Python, there are only functions. Lambdas are functions whose name is <lambda>. Methods are functions that are wrapped, we don’t have to pass self.

5.The one line nameless mini-functions that can be created in Python are called Lambdas where as its Ruby counterpart is called as Blocks. Not only the name is different but also Blocks have some terrific advantage over lambdas. One of the most notable advantage is that Ruby blocks are more powerful, in that the interaction between the blocks and its contents is quite easy where as its almost impossible for the interaction between lambdas and its contents in Python. The other advantage is that Ruby blocks have access to the variables in the scope in which they were defined. This allows blocks to be used in a more expressive manner.

code snippet for computing the largest of two numbers using python lambdas
>>>bigger = lambda a, b : a > b
>>>print bigger(1,2)
False
>>>print bigger(2,1)
True

code snippet for computing the square of each number in the array using ruby blocks
array = [1, 2, 3, 4]
array.iterate! do |n|
n ** 2
end
puts array.inspect
# => [1, 4, 9, 16]

6.Python has a much greater range of libraries available to it, and most of those libraries are more mature and better documented than their Ruby counterparts.

7.As far as readability is concerned, Python is considered to be easily readable whereas Ruby’s code is considered to be on the downside for readability.

== Differences in Programming Environment ==

Both Ruby and Python run on almost all the user friendly platforms like Windows9x/2000/NT, Unix, Mac-OS, MS-DOS. The difference in their programming environments is very subtle.

Python has a Virtual Machine which optimizes certain functions like hash functions and sorting algorithms.

Ruby as such does not have any virtual machine but it acts as an interpreter. There is a project going on for building a virtual machine for Ruby- the YARV [http://www.atdot.net/yarv/].

== What Ruby has and Python does not have? ==
Ruby has continuations, where as Python does not have it. One notable use of continuations in Ruby is for breakpoints in debuggers.
Continuation is an abstract representation of the control state, of the things to come. Practically continuation support in a language means we can “save” our state at a point and return to it later. This is called a first-class continuation.

In ruby, the callcc method is used (it’s Kernel#callcc) to create a Continuation class. Look at this small sample:

def loop
cont=nil
for i in 1..4
puts i
callcc {|continuation| cont=continuation} if i==2
end
return cont
end
c = loop
c.call

In irb this will print 1,2,3,4 then 3,4 again, then exit. As a script file run by the main ruby interpreter, this will loop forerver as it captures the control state of the program when and where it was called and this includes returning the continuation and then calling it again.

== What Python has and Ruby does not have? ==

1.It’s worth mentioning that Python has some big features like list comprehensions that Ruby doesn’t.

[foo(x) for x in alist if bar(x) != 'frotz']

This is definitely shorter than:

foo = []
for x in alist:
if bar(x) != 'frotz':
foo.append(x)

2.Python uses whitespace indentation, rather than curly braces or keywords, to delimit statement blocks (a feature also known as the off-side rule). An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.

== Advantages over statically typed languages ==

1.Java has static typing. We declare the type of each variable, and then, during compilation, we get an error message if we use a variable of the wrong type. Ruby, on the other hand, has dynamic typing: We don't declare types for variables or functions, and no type-check occurs until runtime, when we get an error if we call a method that doesn't exist. Even then, Ruby doesn't care about an object's class, just whether it has a method of the name used in the method call. For this reason, the dynamic approach has earned the name duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

'''Duck Typing'''

class ADuck
def quack()
puts "quack A";
end
end
class BDuck
def quack()
puts "quack B";
end
end
# quack_it doesn't care about the type of the argument duck, as long
# as it has a method called quack. Classes A and B have no
# inheritance relationship.
def quack_it(duck)
duck.quack
end
a = ADuck.new
b = BDuck.new
quack_it(a)
quack_it(b)

2.In Ruby, variables do not need to be declared and are free to change type from statement to statement. So the following code, where the variable x changes from a FixNum (an integer that fits within a native machine word) to a String to an Array, is a perfectly legal sequence of Ruby code:

x = 10
x += 4
x = "My String"
x = [1, "My String", Hash.new ]

3.Ruby's dynamic typing means you don't repeat yourself: In Java have we had to suffer through verbose code along the lines of

XMLPersistence xmlPersistence = (XMLPersistence)persistenceManager.getPersistence();
Ruby eliminates the need for the type declaration and casting (as well as parentheses and semicolon): a typical Ruby equivalent would be
xmlPersistence = persistence_manager.persistence.

4.In Java, we often iterate over a collection's Iterator, running the logic on each element. But the iteration is just an implementation detail: in general, we are just trying to apply the same logic to each element of a collection.
In Ruby, we pass a code block to a method that does just that, iterating behind the scenes.
For example,
[1, 2, 3, 4, 5].each{|n| print n*n, " "}
prints the string 1 4 9 16 25; an iterator takes each element of the list and passes it into the code block as the variable n.

== Projects better suited for Ruby ==

The most prominent application of Ruby is in web development using Ruby on Rails.
Ruby on Rails is an open source web framework. Rails was created by David Heinemeier Hansson in 2003. Since then many applications have been created using Ruby on Rails and presently this has been used in various applications like twitter [http://www.twitter.com] e-commerce[http://www.shopify.com/], live video streaming [http://www.hulu.com/], group chat application [http://campfirenow.com/?source=rails].

== Projects better suited for Python ==

Python has two web development frameworks: Django and TurboGears. Apart from web development, Python also provides platform for applications like Database Access, Desktop Graphical User Interface(GUI) development, Software development, Game and 3D graphics development.
One of the best examples of open source Python language is the "Zone Application server" [http://c2.com/cgi/wiki?ZopeApplicationServer].

== References ==

[1] "Ruby v/s Python" http://www.c2.com/cgi/wiki?PythonVsRuby 
[2] "Lambda the ultimate" http://lambda-the-ultimate.org/node/1480 
[3] "Ruby" http://en.wikipedia.org/wiki/Ruby_(programming_language) 
[4] "Python" http://en.wikipedia.org/wiki/Python_(programming_language) 
[5] "Ruby, Python, Power" http://blog.ianbicking.org/ruby-python-power.html

CSC/ECE 517 Fall 2009/wiki1a 11 AS

2009-09-12T18:54:13Z

Apurush: /* <center> '''Ruby vs Python''' </center> */

= <center> '''ruby vs Python''' </center> ==

== Definition of Ruby and Python ==

'''Ruby''' is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features.
It is an interpreted language that includes a powerful set of libraries. While it is often referred to as a scripting language, it is a pure objected-oriented language that has sufficient expressiveness for general-purpose applications.

'''Python''' is an interpreted, object-oriented, high-level programming language with dynamic semantics.

== Differences in their language features ==
1.The first thing to be noted in Ruby is that,everything is an object, whereas in Python we have the liberty to code without using objects.

2.In ruby, the programmer can use blocks to extend the language for application specific control statements where as in Python we are supposed to use only the control statements provided by the language.

3.Ruby protects class attributes.We can’t access attributes of objects from outside the class.
Python doesn’t protect our code from other programmers. If they want to shoot themselves in the foot they are allowed to do so.

4.In Ruby, there are no functions, but there are methods, blocks and lambdas. All of them seem to have subtle differences, and sometimes we need to not just call them, but use .call().
In Python, there are only functions. Lambdas are functions whose name is <lambda>. Methods are functions that are wrapped, we don’t have to pass self.

5.The one line nameless mini-functions that can be created in Python are called Lambdas where as its Ruby counterpart is called as Blocks. Not only the name is different but also Blocks have some terrific advantage over lambdas. One of the most notable advantage is that Ruby blocks are more powerful, in that the interaction between the blocks and its contents is quite easy where as its almost impossible for the interaction between lambdas and its contents in Python. The other advantage is that Ruby blocks have access to the variables in the scope in which they were defined. This allows blocks to be used in a more expressive manner.

code snippet for computing the largest of two numbers using python lambdas
>>>bigger = lambda a, b : a > b
>>>print bigger(1,2)
False
>>>print bigger(2,1)
True

code snippet for computing the square of each number in the array using ruby blocks
array = [1, 2, 3, 4]
array.iterate! do |n|
n ** 2
end
puts array.inspect
# => [1, 4, 9, 16]

6.Python has a much greater range of libraries available to it, and most of those libraries are more mature and better documented than their Ruby counterparts.

7.As far as readability is concerned, Python is considered to be easily readable whereas Ruby’s code is considered to be on the downside for readability.

== Differences in Programming Environment ==

Both Ruby and Python run on almost all the user friendly platforms like Windows9x/2000/NT, Unix, Mac-OS, MS-DOS. The difference in their programming environments is very subtle.

Python has a Virtual Machine which optimizes certain functions like hash functions and sorting algorithms.

Ruby as such does not have any virtual machine but it acts as an interpreter. There is a project going on for building a virtual machine for Ruby- the YARV [http://www.atdot.net/yarv/].

== What Ruby has and Python does not have? ==
Ruby has continuations, where as Python does not have it. One notable use of continuations in Ruby is for breakpoints in debuggers.
Continuation is an abstract representation of the control state, of the things to come. Practically continuation support in a language means we can “save” our state at a point and return to it later. This is called a first-class continuation.

In ruby, the callcc method is used (it’s Kernel#callcc) to create a Continuation class. Look at this small sample:

def loop
cont=nil
for i in 1..4
puts i
callcc {|continuation| cont=continuation} if i==2
end
return cont
end
c = loop
c.call

In irb this will print 1,2,3,4 then 3,4 again, then exit. As a script file run by the main ruby interpreter, this will loop forerver as it captures the control state of the program when and where it was called and this includes returning the continuation and then calling it again.

== What Python has and Ruby does not have? ==

1.It’s worth mentioning that Python has some big features like list comprehensions that Ruby doesn’t.

[foo(x) for x in alist if bar(x) != 'frotz']

This is definitely shorter than:

foo = []
for x in alist:
if bar(x) != 'frotz':
foo.append(x)

2.Python uses whitespace indentation, rather than curly braces or keywords, to delimit statement blocks (a feature also known as the off-side rule). An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.

== Advantages over statically typed languages ==

1.Java has static typing. We declare the type of each variable, and then, during compilation, we get an error message if we use a variable of the wrong type. Ruby, on the other hand, has dynamic typing: We don't declare types for variables or functions, and no type-check occurs until runtime, when we get an error if we call a method that doesn't exist. Even then, Ruby doesn't care about an object's class, just whether it has a method of the name used in the method call. For this reason, the dynamic approach has earned the name duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

'''Duck Typing'''

class ADuck
def quack()
puts "quack A";
end
end
class BDuck
def quack()
puts "quack B";
end
end
# quack_it doesn't care about the type of the argument duck, as long
# as it has a method called quack. Classes A and B have no
# inheritance relationship.
def quack_it(duck)
duck.quack
end
a = ADuck.new
b = BDuck.new
quack_it(a)
quack_it(b)

2.In Ruby, variables do not need to be declared and are free to change type from statement to statement. So the following code, where the variable x changes from a FixNum (an integer that fits within a native machine word) to a String to an Array, is a perfectly legal sequence of Ruby code:

x = 10
x += 4
x = "My String"
x = [1, "My String", Hash.new ]

3.Ruby's dynamic typing means you don't repeat yourself: In Java have we had to suffer through verbose code along the lines of

XMLPersistence xmlPersistence = (XMLPersistence)persistenceManager.getPersistence();
Ruby eliminates the need for the type declaration and casting (as well as parentheses and semicolon): a typical Ruby equivalent would be
xmlPersistence = persistence_manager.persistence.

4.In Java, we often iterate over a collection's Iterator, running the logic on each element. But the iteration is just an implementation detail: in general, we are just trying to apply the same logic to each element of a collection.
In Ruby, we pass a code block to a method that does just that, iterating behind the scenes.
For example,
[1, 2, 3, 4, 5].each{|n| print n*n, " "}
prints the string 1 4 9 16 25; an iterator takes each element of the list and passes it into the code block as the variable n.

== Projects better suited for Ruby ==

The most prominent application of Ruby is in web development using Ruby on Rails.
Ruby on Rails is an open source web framework. Rails was created by David Heinemeier Hansson in 2003. Since then many applications have been created using Ruby on Rails and presently this has been used in various applications like twitter [http://www.twitter.com] e-commerce[http://www.shopify.com/], live video streaming [http://www.hulu.com/], group chat application [http://campfirenow.com/?source=rails].

== Projects better suited for Python ==

Python has two web development frameworks: Django and TurboGears. Apart from web development, Python also provides platform for applications like Database Access, Desktop Graphical User Interface(GUI) development, Software development, Game and 3D graphics development.
One of the best examples of open source Python language is the "Zone Application server" [http://c2.com/cgi/wiki?ZopeApplicationServer].

== References ==

[1] "Ruby v/s Python" http://www.c2.com/cgi/wiki?PythonVsRuby 
[2] "Lambda the ultimate" http://lambda-the-ultimate.org/node/1480 
[3] "Ruby" http://en.wikipedia.org/wiki/Ruby_(programming_language) 
[4] "Python" http://en.wikipedia.org/wiki/Python_(programming_language) 
[5] "Ruby, Python, Power" http://blog.ianbicking.org/ruby-python-power.html

CSC/ECE 517 Fall 2009/wiki1a 11 AS

2009-09-11T17:51:32Z

Apurush: /* <center> '''Ruby vs Python''' </center> */

== <center> '''Ruby vs Python''' </center> ==

== Definition of Ruby and Python ==

'''Ruby''' is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features.
It is an interpreted language that includes a powerful set of libraries. While it is often referred to as a scripting language, it is a pure objected-oriented language that has sufficient expressiveness for general-purpose applications.

'''Python''' is an interpreted, object-oriented, high-level programming language with dynamic semantics.

== Differences in their language features ==
1.The first thing to be noted in Ruby is that,everything is an object, whereas in Python we have the liberty to code without using objects.

2.In ruby, the programmer can use blocks to extend the language for application specific control statements where as in Python we are supposed to use only the control statements provided by the language.

3.Ruby protects class attributes.We can’t access attributes of objects from outside the class.
Python doesn’t protect our code from other programmers. If they want to shoot themselves in the foot they are allowed to do so.

4.In Ruby, there are no functions, but there are methods, blocks and lambdas. All of them seem to have subtle differences, and sometimes we need to not just call them, but use .call().
In Python, there are only functions. Lambdas are functions whose name is <lambda>. Methods are functions that are wrapped, we don’t have to pass self.

5.The one line nameless mini-functions that can be created in Python are called Lambdas where as its Ruby counterpart is called as Blocks. Not only the name is different but also Blocks have some terrific advantage over lambdas. One of the most notable advantage is that Ruby blocks are more powerful, in that the interaction between the blocks and its contents is quite easy where as its almost impossible for the interaction between lambdas and its contents in Python. The other advantage is that Ruby blocks have access to the variables in the scope in which they were defined. This allows blocks to be used in a more expressive manner.

code snippet for computing the largest of two numbers using python lambdas
>>>bigger = lambda a, b : a > b
>>>print bigger(1,2)
False
>>>print bigger(2,1)
True

code snippet for computing the square of each number in the array using ruby blocks
array = [1, 2, 3, 4]
array.iterate! do |n|
n ** 2
end
puts array.inspect
# => [1, 4, 9, 16]

6.Python has a much greater range of libraries available to it, and most of those libraries are more mature and better documented than their Ruby counterparts.

7.As far as readability is concerned, Python is considered to be easily readable whereas Ruby’s code is considered to be on the downside for readability.

== Differences in Programming Environment ==

Both Ruby and Python run on almost all the user friendly platforms like Windows9x/2000/NT, Unix, Mac-OS, MS-DOS. The difference in their programming environments is very subtle.

Python has a Virtual Machine which optimizes certain functions like hash functions and sorting algorithms.

Ruby as such does not have any virtual machine but it acts as an interpreter. There is a project going on for building a virtual machine for Ruby- the YARV [http://www.atdot.net/yarv/]

== What Ruby has and Python does not have? ==
Ruby has continuations, where as Python does not have it. One notable use of continuations in Ruby is for breakpoints in debuggers.
Continuation is an abstract representation of the control state, of the things to come. Practically continuation support in a language means we can “save” our state at a point and return to it later. This is called a first-class continuation.

In ruby, the callcc method is used (it’s Kernel#callcc) to create a Continuation class. Look at this small sample:

def loop
cont=nil
for i in 1..4
puts i
callcc {|continuation| cont=continuation} if i==2
end
return cont
end
c = loop
c.call

In irb this will print 1,2,3,4 then 3,4 again, then exit. As a script file run by the main ruby interpreter, this will loop forerver as it captures the control state of the program when and where it was called and this includes returning the continuation and then calling it again.

== What Python has and Ruby does not have? ==

1.It’s worth mentioning that Python has some big features like list comprehensions that Ruby doesn’t.

[foo(x) for x in alist if bar(x) != 'frotz']

This is definitely shorter than:

foo = []
for x in alist:
if bar(x) != 'frotz':
foo.append(x)

2.Python uses whitespace indentation, rather than curly braces or keywords, to delimit statement blocks (a feature also known as the off-side rule). An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.

== Advantages over statically typed languages ==

1.Java has static typing. We declare the type of each variable, and then, during compilation, we get an error message if we use a variable of the wrong type. Ruby, on the other hand, has dynamic typing: We don't declare types for variables or functions, and no type-check occurs until runtime, when we get an error if we call a method that doesn't exist. Even then, Ruby doesn't care about an object's class, just whether it has a method of the name used in the method call. For this reason, the dynamic approach has earned the name duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

'''Duck Typing'''

class ADuck
def quack()
puts "quack A";
end
end
class BDuck
def quack()
puts "quack B";
end
end
# quack_it doesn't care about the type of the argument duck, as long
# as it has a method called quack. Classes A and B have no
# inheritance relationship.
def quack_it(duck)
duck.quack
end
a = ADuck.new
b = BDuck.new
quack_it(a)
quack_it(b)

2.In Ruby, variables do not need to be declared and are free to change type from statement to statement. So the following code, where the variable x changes from a FixNum (an integer that fits within a native machine word) to a String to an Array, is a perfectly legal sequence of Ruby code:

x = 10
x += 4
x = "My String"
x = [1, "My String", Hash.new ]

3.Ruby's dynamic typing means you don't repeat yourself: In Java have we had to suffer through verbose code along the lines of

XMLPersistence xmlPersistence = (XMLPersistence)persistenceManager.getPersistence();
Ruby eliminates the need for the type declaration and casting (as well as parentheses and semicolon): a typical Ruby equivalent would be
xmlPersistence = persistence_manager.persistence.

4.In Java, we often iterate over a collection's Iterator, running the logic on each element. But the iteration is just an implementation detail: in general, we are just trying to apply the same logic to each element of a collection.
In Ruby, we pass a code block to a method that does just that, iterating behind the scenes.
For example,
[1, 2, 3, 4, 5].each{|n| print n*n, " "}
prints the string 1 4 9 16 25; an iterator takes each element of the list and passes it into the code block as the variable n.

== Projects better suited for Ruby ==

The most prominent application of Ruby is in web development using Ruby on Rails.
Ruby on Rails is an open source web framework. Rails was created by David Heinemeier Hansson in 2003. Since then many applications have been created using Ruby on Rails and presently this has been used in various applications like twitter [http://www.twitter.com] e-commerce[http://www.shopify.com/], live video streaming [http://www.hulu.com/], group chat application [http://campfirenow.com/?source=rails].

== Projects better suited for Python ==

Python has two web development frameworks: Django and TurboGears. Apart from web development, Python also provides platform for applications like Database Access, Desktop Graphical User Interface(GUI) development, Software development, Game and 3D graphics development.
One of the best examples of open source Python language is the "Zone Application server" [http://c2.com/cgi/wiki?ZopeApplicationServer].

== References ==

[1] "Ruby v/s Python" http://www.c2.com/cgi/wiki?PythonVsRuby 
[2] "Lambda the ultimate" http://lambda-the-ultimate.org/node/1480 
[3] "Ruby" http://en.wikipedia.org/wiki/Ruby_(programming_language) 
[4] "Python" http://en.wikipedia.org/wiki/Python_(programming_language) 
[5] "Ruby, Python, Power" http://blog.ianbicking.org/ruby-python-power.html