it's includes Simple Factory pattern, Factory Method pattern, and Abstract Factory pattern.

1. Text
Factory Patterns

2. Contents
Basics (Review)
(Simple) Factory Pattern
Factory Method Pattern
Abstract Factory Pattern
Factory Method vs Abstract
Factory Pattern

3. Basics (Review)

4. B1: Interface, Abstract Class, and
Concrete Class
An interface is an empty shell, there are only the signatures
(name / params / return type) of the methods.
Abstract classes look a lot like interfaces, but they have
something more : you can define a behavior for them.
When you use new you are certainly instantiating a
concrete class, so that’s definitely an implementation, not
an interface.

5. B2: Class Diagram

6. Association is reference based relationship between two
classes.
Dependency is often confused as Association. Dependency
is normally created when you receive a reference to a class
as part of a particular operation / method.

7. An extends relationship (also called an inheritance or an is-a
relationship) implies that a specialized (child) class is based on a
general (parent) class.
An implements relationship exists between two classes when one of
them must implement, or realize, the behavior specified by the other.

8. Aggregation is same as association and is often seen as redundant
relationship. A common perception is that aggregation represents one-
to-many / many-to-many / part-whole relationships
Composition relates to instance creational responsibility. When class B
is composed by class A, class A instance owns the creation or controls
lifetime of instance of class B.

9. Simple Factory Pattern

10. creates objects without exposing the instantiation logic to
the client.
refers to the newly created object through a common
interface.

12. # Not using Simple Factory!
class PizzaStore!
def order_pizza(pizza_type)!
pizza = case pizza_type.downcase!
when "cheese"!
CheesePizza.new!
when "clam"!
ClamPizza.new!
when "veggie"!
VeggiePizza.new!
else!
raise "Unknown"!
end!
pizza.prepare!
pizza.bake!
pizza.cut!
pizza.box!
pizza!
end!
end!
!
class Pizza!
# more codes!
end!
!
class CheesePizza < Pizza!
# more codes!
end!
!
class ClamPizza < Pizza!
# more codes!
end!
!
class VeggiePizza < Pizza!
# more codes!
end
# Using Simple Factory!
class PizzaStore!
attr_accessor :factory!
!
def initialize(factory)!
@factory = factory!
end!
!
def order_pizza(pizza_type)!
pizza = factory.create_pizza(pizza_type)!
pizza.prepare!
pizza.bake!
pizza.cut!
pizza.box!
pizza!
end!
end!
!
class SimplePizzaFactory!
def create_pizza(pizza_type)!
case pizza_type.downcase!
when "cheese"!
CheesePizza.new!
when "clam"!
ClamPizza.new!
when "veggie"!
VeggiePizza.new!
else!
raise "Unknown"!
end!
end!
end!
def self.create_pizza(pizza_type)!
const_get("#{pizza_type.capitalize}Pizza").new!
end

13. Factory Method Pattern

14. Defines an interface for creating objects, but let subclasses
to decide which class to instantiate.
Refers to the newly created object through a common
interface.

17. class PizzaStore!
def order_pizza(pizza_type)!
pizza = create_pizza(pizza_type)!
pizza.prepare!
pizza.bake!
pizza.cut!
pizza.box!
pizza!
end!
!
def create_pizza(pizza_type)!
raise "need to implement"!
end!
end!
!
class NYPizzaStore < PizzaStore!
def create_pizza(pizza_type)!
const_get("NYStyle#{pizza_type.capitalize}Pizza")!
end!
end!
!
class ChicagoPizzaStore < PizzaStore!
def create_pizza(pizza_type)!
const_get("ChicagoStyle#{pizza_type.capitalize}Pizza")!
end!
end!
!
class NYStyleCheesePizza < Pizza!
def prepare!
"prepare for cheese pizza of NY style"!
end!
end

18. Abstract Factory Pattern

19. Abstract Factory offers the interface for creating a family of
related objects, without explicitly specifying their classes.

22. class PizzaStore!
attr_accessor :ingredient_factory!
!
def order_pizza(pizza_type)!
pizza = create_pizza(pizza_type)!
pizza.prepare!
pizza.bake!
pizza.cut!
pizza.box!
pizza!
end!
!
def create_pizza(pizza_type)!
raise "need to implement"!
end!
end!
!
class NYPizzaStore < PizzaStore!
def initialize!
@ingredient_factory = NYPizzaIngredientFactory.new!
end!
!
def create_pizza(pizza_type)!
# CheesePizza.new(ingredient_factory)!
self.class.const_get("#{pizza_type.capitalize}
Pizza").new(ingredient_factory)!
end!
end!

23. class Pizza!
attr_accessor :ingredient_factory, :name, :dough,!
:sauce, :cheese, :veggie, :pepperoni, :clam!
!
def initialize(ingredient_factory)!
@ingredient_factory = ingredient_factory;!
end!
def prepare!
raise "need to implement"!
end!
# more methods: bake, cut, box!
end!
!
class CheesePizza < Pizza !
def prepare!
puts "Preparing #{name}"!
@dough = ingredient_factory.create_dough!
@sauce = ingredient_factory.create_sauce!
@cheese = ingredient_factory.create_cheese!
end!
end!
!
class NYPizzaIngredientFactory < PizzaIngredientFactory!
def create_dough; ThinCrustDough.new end!
def create_sauce; MarinaraSauce.new end!
def create_cheese; ReggianoCheese.new end!
def create_veggies!
[ Garlic.new, Mushroom.new ]!
end!
def create_pepperoni; SlicedPepperoni.new end!
def create_clam; FreshClams.new end!
end

24. Factory Method vs. Abstract Factory
The methods of an Abstract Factory are implemented as factory
methods.
Both Abstract Factory and Factory Method create objects, but
Factory Method do it through inheritance, and Abstract do it
through object composition.
Abstract Factory is used whenever you have families of products
you need to create and you want to make sure your clients create
products that belong together.
Factory Method is used to decouple your client code from the
concrete classes you need to instantiate, or if you don’t know
ahead of time all the concrete classes you are going to need.

25. References
http://www.oodesign.com
http://stackoverflow.com/questions/1913098/what-is-the-
difference-between-an-interface-and-abstract-class
http://nirajrules.wordpress.com/2011/07/15/association-vs-
dependency-vs-aggregation-vs-composition/
http://www.amazon.com/Head-First-Design-Patterns-
Freeman/dp/0596007124
Code: https://github.com/kuyseng/design-patterns-in-ruby/
tree/first_head_factory