Class 03: Java Packages

Held: Wednesday, 1 September 2004

Summary: Today we explore the basics of packages (and the related import statement) in Java.

Related Pages:

• EBoard.
• First.java.
• Second.java.
• Handout on packages.

Notes:

• If you miss a class, even if it's because you lack the ability to set an alarm clock correctly, you should send me a note of explanation.
• Some of you asked about my legendary EBoards. I'll try to use them if you'd like, but the pictures we draw certainly aren't going there.
• We have a quiz!.
• If anyone is free from 11:00-11:50 today, the CSC152 students are starting to work with Java and would benefit from a few more helping hands in the room.
• Helpful handout: Packages in Java.

Overview:

• Quiz.
• The Import Statement.
• Why packages?
• Using packages in *nix systems.

Bigger Machines, Revisited

• Remember, we're trying to write a candy machine that can build the same kind of candy machine again and again.
• We want to tell it how to build that machine!

Extending Candy Machines

• One solution is to add another method to the candy machine interface, such as duplicateMe or refill.
• However, changing existing interfaces is dangerous (and not always possible).

Using Java Introspection

• We can take advantage of Java's introspection methods and classes.
• Pass the appropriate kind of machine (e.g., GumballMachine).
• Get the class of that machine with getClass.
• Get the constructor of that class with getConstructor.
• Call the constructor of that class.
• Moral: We need to learn Java well.

Factory

• Unfortunately, that solution is overly complicated and won't handle machines that have non-null constructors (like a doubled chicklet machine).
• Knowing Scheme, we might pass a function as a parameter to the constructor (e.g.,

  CandyMachine bigcm = new BiggerCandyMachine((lambda () (new ChickletMachine()));
  CandyMachine bigdcm = new BiggerCandyMachine((lambda () (new DoubledMachine(new ChickletMachine()))));
  public class BiggerCandyMachine {
    ...
    public BiggerCandyMachine(Function construct)
    {
      this.makebase = construct;
    }
    ...
    private CandyMachine newMachine() {
       return construct();
    } // newMachine
    ...
  }
  

• Unfortunately, that's not legal Java, but we can use a similar idea.
• As object-oriented programmers who have learned about patterns, we can recognize this as an instance of the Abstract Factory problem and build a CandyMachineFactory.
• Abstract factories are classes whose main job is to construct other classes.
• Moral: We need to learn design patterns.
• Side note: This was so obviously a factory problem that when Daren was talking about it with me, he said, So, what did you do with the factory problem?

Anonymous Inner Classes

• Factories are nice, but they don't completely solve the doubled chicklet machine problem (except by forcing us to create a DoubleChickletMachine class).
• Java comes to the rescue with the cool anonymous inner class technique.
• Such classes are anonymous: You can create them without naming them.
• Such classes are inner: You can create them within other classes (in the middle of code).
• Normal mechanism:

  new Constructor() {
    NewAndOverridenMethods
  } 
  

• For example,

  PrintWriter pen = new PrintWriter(System.out, true) {
    public void println(String whatever) {
      super.println("*** " + whatever + " ***");
    }
  };
  

• For our particular case, something like

    CandyMachineTester cmt = new CandyMachineTester(
                              new BiggerCandyMachine(
  			      new CandyMachineFactory() {
  			        public CandyMachine build()
  				{
  				  return new DoubledCandyMachine(
  				           new ChickletMachine());
  				}
  			      }));