Low Budget Productions, LLC - PowerPoint PPT Presentation

About This Presentation
Title:

Low Budget Productions, LLC

Description:

Gamma, Helm, Johnson and Vlissides. Martin Fowler. Wikipedia. A host of internet writers ... Design system to evolve while maximizing code reuse and eliminating ... – PowerPoint PPT presentation

Number of Views:48
Avg rating:3.0/5.0
Slides: 15
Provided by: patricia161
Category:
Tags: llc | budget | helm | low | productions

less

Transcript and Presenter's Notes

Title: Low Budget Productions, LLC


1
Low Budget Productions, LLC
Low Budget Productions, LLC
  • Presents
  • The Factory Method Pattern

2
  • Co-Executive Producers
  • Trisha Rogers
  • Gamma, Helm, Johnson and Vlissides
  • Martin Fowler
  • Wikipedia
  • A host of internet writers
  • Creative Consultant
  • Mark Shacklette

3
Act I Scene 1 Design for Change
  • Open for extension but closed for modification
  • Design system to evolve while maximizing code
    reuse and eliminating changes to existing classes
    and client classes
  • Factory Method Pattern Take the code that is
    likely to change over time and put it in its own
    class
  • Create objects without specifying the exact class
    of the object that will be created
  • Commit to the interface not the implementation
  • Factory Method Pattern defers instantiation to
    subclasses

4
Act I Scene 2 Design pattern space
  • Purpose A creational pattern, concerned with the
    process of object creation
  • Scope Class scope
  • Factory Method Pattern applies primarily to
    classes and their subclasses
  • These relationships are established through
    inheritance and so are static - fixed at compile
    time. Factory Method Pattern deals with the
    dilemma of not knowing what the client will want
    until run-time.

5
Act I Scene 3 Factory Method Purpose
  • Problems
  • What if it is the nature of the application to
    have classes that change on a regular basis (new
    products, e.g.) and code re-writing will have to
    be done frequently?
  • What if the classes are abstract and they do not
    know how the subclasses will be implemented?
  • Solution
  • Factory Method Pattern can defer instantiation
    to subclasses, encapsulating the knowledge of
    which subclass to create and move this knowledge
    to a separate class.
  • 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 a Factory Pattern since 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 promotes loose
    coupling by eliminating the need to bind
    application-specific classes into the code.

6
Act I Scene 3 Factory Method Purpose
  • Variation on the theme Parameterized factory
    methods
  • Problem What if there is ambiguity in the
    meaning of the constructor parameters? Only one
    constructor is allowed per class, and while
    overloading will solve the problem of passing
    different types of parameters, it will not solve
    problem of the same type with different meanings.
  • Solution Create a factory class that will
    privatize the constructor and pull all the logic
    into one class. Provide different static methods
    to return the appropriate object depending on the
    meaning. Example to follow.
  • Problem You want a simple concrete creator class
    to handle object creation depending on a passed
    parameter?
  • Solution Create a factory class that will
    privatize the constructor and pull all the logic
    into one class. Write a switch statement to
    handle various parameters. If there is an
    addition of a sub-class, fix code in the factory
    class only. The interface does not change.
    Example to follow.

7
Act I Scene 4 Where to use it
  • Three basic situations
  • Frameworks
  • High level software written for an industry
  • Abstract classes used to define and maintain
    relationships between objects
  • A company in the industry will purchase the
    framework and implement the subclasses to its own
    specifications
  • So if there arent many/any subclasses in the
    framework, how does the framework developer
    create objects?
  • Encapsulates the knowledge of which subclass to
    create and moves this knowledge out of the
    framework
  • Parallel hierarchies
  • Application class cannot anticipate the subclass
    to be instantiated at run-time it knows when,
    not what kind.
  • Little Factories with logic in one place

8
Act I Scene 5 UML per GoF
9
Act II Scene 1 Old Approach
10
Act II Scene 2 Factory Method
11
Act II Scene 2 Factory Method
  • Scenario
  • A bank has multiple types of accounts. These are
    subclasses of the class Account. There is a
    saving account class and a checking account
    class. The client uses a factory method class as
    an interface.
  • When a new type of account is added an IRA
    account no changes need to be made to the
    abstract account class, the savings account class
    or the checking account class.
  • More importantly, no changes need to be made to
    the client class.
  • Only changes in the factory class need to be made
    to add the new product IRA account.
  • See the example in Eclipse.

12
Act II Scene 3 Disambiguation Example
  • How to use a factory method pattern to solve
    problem of multiple meanings for parameters
  • Make the constructor private
  • Add one or more factory methods that are static
    and accessible from the public class. Example is
    from Wikipedia.
  • class Complex
  • private Complex(double a, double b) //...
  • public static Complex fromCartesian(double real,
    double imag)
  • return new Complex(real, imag)
  • public static Complex fromPolar(double modulus,
    double angle)
  • return new Complex(modulus cos(angle),
    modulus sin(angle))
  • Complex c Complex.fromPolar(1, pi) // Same as
    fromCartesian(-1, 0)

13
Act III Scene 1 Limitations
  • The first limitation is that refactoring an
    existing class to use factories breaks existing
    clients. For example, if class Complex was a
    standard class, it might have numerous clients
    with code like
  • Complex c new Complex(-1, 0)
  • Once we realize that two different factories are
    needed, we change the class (to the code shown
    earlier). But since the constructor is now
    private, the existing client code no longer
    compiles.
  • The second limitation is that, since the pattern
    relies on using a private constructor, the class
    cannot be extended. Any subclass must invoke the
    inherited constructor, but this cannot be done if
    that constructor is private.
  • The third limitation is that, if we do extend the
    class (e.g., by making the constructor protected
    -- this is risky but possible), the subclass must
    provide its own re-implementation of all factory
    methods with exactly the same signatures. For
    example, if class StrangeComplex extends Complex,
    then unless StrangeComplex provides its own
    version of all factory methods, the call
    StrangeComplex.fromPolar(1, pi) will yield an
    instance of Complex (the superclass) rather than
    the expected instance of the subclass.

14
Coda
  • Never, ever follow student presenter Will Rodgers
    (the state pattern with the Pepsi machine guy) in
    any presentations. Ever.
Write a Comment
User Comments (0)
About PowerShow.com