Class 05: Polymorphism (3)

Held: Monday, 6 September 2004

Summary: We conclude our polymorphism example with further study of factories.

Related Pages:

• EBoard.
• Sample Code.

Assignments

• Read Fowler, Chapter 3, 5, and 6.

Notes:

• Are there questions on the homework for Friday?
• I spent the weekend sick, so today's class is less well prepared than I would like.
• You'll notice some .txt files in the code directories. These files allow you to preview the code in your Web browser.

Overview:

• Factories, Revisited.
• Anonymous Inner Classes.
• Factories, Re-Revisited.

Factories, Revisited

• The key idea of factories: When you need to construct many copies of the same object, but can operate polymorphically with different kinds of objects, use a Factory that knows how to build the object.
• The factory is an interface that specifies which construct methods are available.
  • See CandyMachineFactory.java for a sample interface.
• Individual factories are made for different situations.
  • See ChickletMachineFactory.java for a specific implementation.

Anonymous Inner Classes

• Factories work well with Java's anonymous inner classes.
• Such classes are anonymous: They have no names.
• Such classes are inner: They are built within other classes.
• Such classes are similar to lambda abstractions.
• Normal form

  new INTERFACE() {
    IMPLEMENTATIONS_OF_METHODS;
  }
  

• For example, here is a factory that creates doubled doubled gumball machines

  new CandyMachineFactory() {
    public CandyMachine newMachine() {
      return new DoubleCandyMachine(
        new DoubleCandyMachine(
          new GumballMachine()));
    }
  }
  

• You can see this factory in action in NewMain.java.

Factories, Re-Revisited

• The Factory pattern is one of the first patterns presented in the Design Patterns text.
• The basic idea of design patterns is that you find common structural solutions to common structural problems.
  • I hope that when you next encounter a factory problem you say to yourself "boy, that looks like a factory problem".
• The abstract factory discussion in DP focuses on factories that build a variety of related objects (e.g., the windows and scrollbars for differentGUI systems).
• There are a number of issues that a fully-specified design pattern covers, including:
  • Intent
  • Aliases
  • Motivation
  • Applicability
  • Structure
  • Participants
  • Collaborations
  • Consequences
  • Implementation
  • Examples
  • Known Uses
  • Related Patterns
• We'll revisit these in detail the future. For now, let's just look at a few issues.
• Applicability: Use the Abstract Factory pattern when
  • A system should be independent of how a group of objects a created, composed, and represented.
  • A system should be configured with one of multiple families of products.
  • A family of product objects is designed to be used together, and you need to enforce this constraint
• Consequences:
  • It isolates concrete classes
  • It makes exchanging product families easy
  • It promotes consistency among products.
  • However, supporting new kinds of products is difficult.