• Purpose:
  • Initialize the attributes of an instance of a class
    
• Comparison to Other Methods:
  • Difference -
    No return type (because they do not return anything)
    
  • Similarity -
    Can throw exceptions
    
• Calling:
  • Indirectly (i.e., the new operator calls the constructor)
    

• A Weakness of Constructors:
  • Because they do not return anything, we are limited in what we can do with them
• An Alternative/Supplement to Constructors:
  • Factory Methods (i.e., static methods that construct and return objects)

• An Abstract Class:
  • SecurityQuotation
• Two Concrete Specializations:
  • StockQuotation
  • FutureQuotation

• Add Functionality:
  • Provide the ability to construct an instance of the concrete specializations from a String representation (e.g., lines read from a file)
• Consider Alternative Designs:
  • There are several ways to add this functionality and it is a useful exercise to consider their advantages and disadvantages

• General Approach:
  • Avoid code duplication
  • Put as much functionality in the base class as possible
• Specifics:
  • Use constructors

The constructor in SecurityQuotation is straightforward.

The constructor in StockQuotation is elegant.

The constructor in FutureQuotation is awful!

It has to do unnecessary work and it has to know what work was done in the base class.

• General Approach:
  • Avoid code duplication
  • Put as much functionality in the base class as possible
• Specifics:
  • Use a fromString() method that sets the attributes of an empty object from a String representation

The SecurityQuotation class now needs a default constructor (because the derived classes will), but it can be protected.

The code that was in the constructor can now be moved to the fromString() method (which can also be protected), and this method can return the StringTokenizer it used in case a derived class needs to use it.

The StockQuotation class now needs a public default constructor (because someone that wants to create a StockQuotation from a String will first need to construct an empty object and then call its fromString()).

The fromString() method is now elegant because it can use the same StringTokenizer that the fromString() method in the SecurityQuotation class used.

The FutureQuotation class also needs a public default constructor.

The fromString() method is now elegant because it can use the same StringTokenizer that the fromString() method in the SecurityQuotation class used.

• Advantages:
  • The fromString() methods are both elegant
  • These classes can be further specialized if needed
• Disadvantages:
  • Someone that wants to create an object from a String first has to use the default constructor and then call the fromString() method

• General Approach:
  • Improve on design 2
• Specifics:
  • Add a factory method

The default constructor in the StockQuotation class is now protected.

The fromString() method remains the same (though it could be made protected if desired) and a static factory method is added.

The default constructor in the FutureQuotation class is now protected.

The fromString() method remains the same (though it could be made protected if desired) and a static factory method is added.