To Lecture Notes

IT 313 -- Feb 27, 2020

Review Exercise

1. Look up the Iterator and Iterable interface in the Java 11 Class Library. What are these interfaces' required methods? You want your LibraryManager class to implement the Iterator interface so that its Transaction objects can be processed in a for loop. If manager is a LibraryManager object that implements Iterator, we can do something like this:
   

   for (LibraryItem item : manager) {
       System.out.println(t);
   }
   

   Ans: The required method of the Iterable interface is iterator. Since the TransactionManager interface contains the ArrayList collection named col, we can use the iterator of the arraylist as our TransactionManager class; we define our Transaction iterator method like this:
   

   @Override
   public Iterable<Transaction> iterator( ) {
       return col.iterator( );
   }
   

   The required methods of the Iterator interface are hasNext and next. Instead of using the for loop above, which uses the iterator behind the scenes (implicit iteration), we can use the iterator methods explicitly like this:
   

   Iterable<LibraryItem> itr = manager.iterator( );
   while itr.hasNext( ) {
       LibraryItem item = itr.next( );
       // Do something with item.
   }

Software Design Patterns

• Software Patterns Summary
• We will discuss these software design patterns:
  Factory  Singleton  Observer  Iterator  Strategy  State

Factory Pattern

• The user of a class designed using the Factory Pattern does not use a constructor to create objects, she uses the getInstance method instead.
• Why use the Factory Pattern? For example, the Java class library Calendar class uses the getInstance method because, before creating a Calendar object, the computer Locale is checked for the country and language before creating the Calendar object. The month names or day of week names are language and possibly country dependent.
• To force the class to use getInstance instead of the constructor, make the constructor private.
  

  public class FactoryObject {
  
      private FactoryObject( ) {
          // Constructor implementation.
      }
      
      public FactoryObject getInstance( ) {
          return new FactoryObject( );
      }
  }
  

• See the factory module in the Patterns1 Example.
• One of the possible uses for the Factory pattern is to allow a class getInstance method to return one of several base or derived class objects:
  

  public Person getInstance(String className) {
      switch(className) {
          case "Person":    return new Person( );   break;
          case "Employee":  return new Employee( ); break;
          case "Executive": return new Person( );   break;
      }
  }
  

• See the employeefactory module in the Patterns1 Example.
• The constructors in the Person, Employee, and Executive classes are made inaccessible to the main method by giving them package accessibility, also called default accessibility.
• You give a method package accessibility by not specifying any accessibility, which means do not use either public or private in the method header.
• Package accessibility means that a method is accessible anywhere in the package, but not outside of the package.
• See the PackageAccessibility Example.
• The fields in the returned object for the employeefactory module are set with setters.
• The PersonFactory.getInstance method returns an object of the class specified by the input argument.
• Another reason to use a Factory pattern instead of an ordinary constructor is to allow object reusability. When a client no longer needs an object, it is returned to the object pool. Then when a different client needs an object, the class first checks the object pool and only creates a new object if none is available.
• See the Reusable Example in the patterns1 example file.

Singleton Pattern

• A singleton is a class that is only allowed to create one instance of an object.
• Use a singleton class for a class that has at most one object from that class.
• Uses for a singleton class: caches, device drivers, thread pools, loggers, registry setting managers, window managers.
• Two styles for implementing a singleton class:
  
  1. Lazy Initialization: wait until the object is needed before instantiating it.
     

     public class Singleton {
         public Singleton theInstance;
         // ... other Singleton instance 
         //     variables.
         
         private Singleton( ) { }
         
         public getInstance( ) {
             if (theInstance == null) {
                 theInstance = new Singleton( );
             }
             return theInstance;
         }
         
         // ... other Singleton methods.
     }
     

  2. Eager Instantiation: preinstantiate the single instance immediately for use later.
     

     public class Singleton {
         private static final Singleton 
             THE_INSTANCE = new Singleton( );
         // ... other Singleton
         //     instance variables.
     
         private Singleton( ) { }
     
         public static Singleton getInstance() {
             return THE_INSTANCE;
         }
     
         // ... other Singleton methods.
     }
     

  3. Static Class. Don't instantiate an object at all. Create a class with only static methods.
• See the Logger Example in the patterns1 example file.
• The Singleton Pattern is probably the most controversial pattern in the Gang of Four list of patterns.
• Here are some references:
  
  • Why Singletons are Controversial, Google Article.
  • J.B. Rainsberger, Use Your Singletons Wisely, IBM Article.
  • J.B. Rainsberger, Use your Singletons Wisely: Ten Years Later

Observer Pattern

• The Observer Pattern is facilitated by these two items: the Observable class and the Observer interface.
• The Observable class and the Observer interface are now depreciated in the Java Class Library. This is because they are not considered to be "industrial strength."
• See the MessageBoard1 Example in the observer examples file.
• The MessageBoard object is the observable.
• Here is a UML diagram showing the relationship between the MessageBoard and Student classes with the Observable class and the Observer interface.
• The Student objects are the observers.
• The MessageBoard object
  
  1. must extend the Observable class to qualify as an observable.
  2. contains a posted message that may be useful to the observers.
  3. may add one or more observers (Student objects) with the addObserver method.
  4. may delete observers with the deleteObservers method.
  5. calls the setChange method to show that the message has been changed.
  6. calls the notifyObservers method whenever the message is changed to notify all the observers. Calling notifyObservers automatically calls its clearChange after all observers have been notified.
  7. the notifyObservers method automatically calls the update method of each registered observer.
• A Student object
  
  1. must implement the Observer interface to qualify as observer.
  2. supplies the required update method (which will be automatically called by notifyObservers in Item 7 of the MessageBoard object).
  3. in addition, each observer can go back to the observable to obtain additional information.
• Look at the MessageBoard2 Example in the observer example file.
• Look at the Casino Example in the observer example file.
• The Casino Example has a SlotMachine simulator with three reels. Each reel contains these 20 symbols:
  

  7  $  ?  +  apple  bar  bell  cash
  cent  cherries  diamond  grapes  
  heart  horseshoe  lemon  orange
  plum  pound  watermelon  win
  

• Here is a stock photo that shows some of these symbols:
  
• When a slot machine is played, each of the three reals shows one symbol. A jackpot is obtained if three 7s are obtained.
• The probability that a jackpot occurs in one play is 1/8000.
• The probability that a jackpot occurs at least once in 10,000 tries is:
       1 - (1 - 1/8000)^10,000 = 0.714.
• In the casino example, a slot machine is an observable.
• The casino manager is an observer that records, for each jackpot, the ID number of the machine and the time at which the jackpot occurred.