Inner Class

• A class defined inside another class
• Can be defined outside or inside method
• Useful for small helper classes

Inner class at the class level

• Inner class defined directly in the class

  public class Outer
  {
     private class Inner { ... }
     void someMethod() 
     {
        Inner fred = new Inner();
        ...
     }
  }

• This inner class can be accessed by any method in the class
• Used when the inner class is closed associated with the outer class
• Can be public or private or ...
• A public inner class can be accessed by other classes
  • new outer.inner()
  • new Ellipse2D.Double()

Inner class in a method

• Inner class defined inside a method

  public class Outer
  {
     void someMethod()
     {
        class Inner { ... }
        Inner fred = new Inner();
        ...
     }
   
  }

• Class is only visible inside the method
  • Like a local variable.
• Use when the inner class in never needed outside the local context

 

Inner class example

Creating a Comparator as an inner class

• Want to sort an array of strings by length
• Want to use Arrays.sort
• But that sorts strings by dictionary order (why?)
• Use Comparator instead
• Need a class that implements Comparator

Inner class example (cont.)

• We will never want to reuse this class
• Tuck it away out of sight inside the method that uses it

  public static void main(String[] args)
  {
     String[] names = { "Fred", "Wilma", "Barney" };
     class LengthComparator implements Comparator
     {
        public int compare(Object o1, Object o2)
        {
           return ((String) o1).length() - ((String) o2).length();
        }
     }
     Arrays.sort(names, new LengthComparator());
  }

• Note the return statement

Anonymous Objects

• Look at this statement

  Arrays.sort(names, new LengthComparator());

• The red code creates an anonymous object
  • It has no name
• Could have given it a name

  Comparator fred = new LengthComparator();
  Arrays.sort(names, fred);

• But no point
  • only used this one time

Anonymous Inner Classes

• Can make classes anonymous too

  Arrays.sort(names, new Comparator() 
     {
        public int compare(Object o1, Object o2)
        {
           return ((String) o1).length() - ((String) o2).length();
        }
     });

• We never use the class again so it doesn't even need a name
• We won't use anonymous inner classes in this class
  • But you'll see it a lot in CS151
  • Used heavily in graphics programming

8/29 Lecture 2 Question 1

Let's make Item an inner class of ArrayListAddressBook (from the lab):

public class ArrayListAddressBook 
{
   private class Item 
   {
      String name;
      String key;
      String value;
   }
   ...
}

Which of the following is true?

1. All methods of the ArrayListAddressBook class can construct and access Item objects
2. Any code outside the ArrayListAddressBook class refers to the inner class as ArrayListAddressBook.Item
3. The Item class is poorly designed because the instance variables of Item should have been declared as private
4. The Item class should have been added to the AddressBook interface instead of the ArrayListAddressBook class

Mock Objects

• Problem: How can you test your code when it is part of a multi-class project
  • You need to start testing before all the code is complete
• Example: Want to write and test user interface for AddressBook
  • ArrayListAddressBook is not ready yet
• There is a simple solution because AddressBook is an interface
• Write your own class that implements the AddressBook interface
  • Code a simplified version of the methods you need right now to test your code
  • Provide stubs for the others

  public class MockAddressBook implements AddressBook
  {
     public void load(String sourceName) {}
     public void save() {}
     public void get(String name, String key) { return "Fred"; }
     public void put(String name, String key, String value) {}
     public void remove(String name, String key) {}
  }

Mock Objects

• Great for team work. You can make progress while someone else writes the real address book
• While testing, use a variable of the interface type
  • Assign an instance of your mock object to it.

    AddressBook book = new MockAddressBook()

• When the real AddressBook is read to be integrated with your code
  • Assign an instance of the ArrayListAdressBook to the AddressBook variable

    AddressBook book = new ArrayListAddressBook()

• Done correctly, you will only need to make the one change.
• You will do this in one of the labs

8/29 Lecture 2 Question 2

Why is it necessary that the real class and the mock address book class implement the same interface?

1. In order to make use of already-written methods in Java classes such as Arrays and Collections
2. In order to minimize the amount of code that needs to be updated when the mock class is replaced with the real class
3. In order to allow two programmers to work independently on each class
4. In order to reuse the address book class in other projects

Another interface example

Worked Example 9.1

• Sequence interface
• www.wiley.com/college/horstmann
• First digits of random numbers are not evenly distibuted