Exercises: Interfaces and Polymorphism

Exercises

As a new Java coder, it might take you some time to recognize the usefulness of interfaces. At first glance, these tools do not seem to provide much benefit over extending a base class, adding instance methods to a class, or overriding a method like toString.

To help overcome this, let’s consider a common occurrence—sorting an ArrayList of objects.

If the list contains String or numerical entries, then sorting the list is trivial :

Collections.sort(arrayListName);

However, if the elements are custom objects (like Cat), then sorting the list becomes more complicated. This is because the objects may contain multiple fields, any of which could be used as a sorting option. For Cat objects, this could include name, age, or mass.

Getting Started

Work on these exercises in the IntelliJ java-web-dev-projects. You will find the starter code in the exercises package of the interfaces directory. Go ahead and open the folder and take a quick look at the class files.

You will practice implementing interfaces by playing around with a small ice cream store. It consists of a refrigerated display Case, which contains a collection of ice cream Flavor objects and a selection of Cone objects.

1. Sorting Flavors by Name

To display a menu for your customers, you need to sort the ice cream flavors alphabetically by their name field. Fortunately, the Comparator interface helps you solve the sorting-objects-by-field problem.

Create a Sorting Class

1. Create an new class called FlavorComparator and have it implement the Comparator interface:

   public class FlavorComparator implements Comparator<Flavor>

2. Notice that IntelliJ flags a couple of errors that you need to fix:

   1. Import java.util.Comparator. This removes the flag on Comparator.
   2. Hover over the line again and select implement methods. Choose the compare option.
   3. This adds an @Override method that compares two Flavor objects and always returns 0.

3. Always returning 0 results in no sorting, so replace line 8 with:

return o1.getName().compareTo(o2.getName());

This returns an integer (negative, positive, or zero) depending on whether Flavor object o1 or o2 comes first, alphabetically.

public class FlavorComparator implements Comparator<Flavor> {
   @Override
   public int compare(Flavor flavor1, Flavor flavor2) {
      return flavor1.getName().compareTo(flavor2.getName());
   }
}

Sorting the flavors ArrayList

In Main, we declare menu that contains everything in the Case as well as specific flavors and cones collections.

 6
 7
 8
 9
10
11

public static void main(String[] args){
   Case menu = new Case();
   ArrayList<Flavor> flavors = menu.getFlavors();
   ArrayList<Cone> cones = menu.getCones();

}

1. To sort the flavors list, first create a new FlavorComparator object.

   6 7 8 9 10 11

   public static void main(String[] args){ Case menu = new Case(); ArrayList<Flavor> flavors = menu.getFlavors(); ArrayList<Cone> cones = menu.getCones(); Comparator comparator = new FlavorComparator(); }

2. Next, call the sort method on flavors and pass the comparator object as the argument.

   6 7 8 9 10 11 12 13

   public static void main(String[] args){ Case menu = new Case(); ArrayList<Flavor> flavors = menu.getFlavors(); ArrayList<Cone> cones = menu.getCones(); Comparator comparator = new FlavorComparator(); flavors.sort(comparator); }

3. Next, add some code to iterate over the flavors list and print out the flavors before and after sorting.

   6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   public static void main(String[] args){ Case menu = new Case(); ArrayList<Flavor> flavors = menu.getFlavors(); ArrayList<Cone> cones = menu.getCones(); Comparator comparator = new FlavorComparator(); System.out.println("Before:"); System.out.println(); for (Flavor flavor : flavors) { System.out.println(flavor.getName()); } flavors.sort(comparator); System.out.println(); System.out.println("After:"); System.out.println(); for (Flavor flavor : flavors) { System.out.println(flavor.getName()); } }

4. Running the application, shows the list before and after the sort.

   Before:
   
   Vanilla
   Chocolate
   Red Velvet
   Rocky Road
   Strawberry Sorbet
   
   After:
   
   Chocolate
   Red Velvet
   Rocky Road
   Strawberry Sorbet
   Vanilla

Note that Main does NOT have to implement the Comparator interface. This only needs to happen in the class that actually uses the compare method.

flavors.sort(new FlavorComparator());

Sorting Cones by Cost

Now let’s sort our cones list by cost, from least expensive to most expensive.

1. Create the new class ConeComparator.

2. Follow the example above to implement the Comparator interface and evaluate Cone objects by cost.

3. In Main, sort the cones list, then print the elements to the screen to verify the results.

   Before:           After:
   
   Waffle: $1.25        Bowl: $0.05
   Sugar: $0.75         Wafer: $0.50
   Wafer: $0.50         Sugar: $0.75
   Bowl: $0.05          Waffle: $1.25
   Check your solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class ConeComparator implements Comparator<Cone> {
   @Override
   public int compare(Cone cone1, Cone cone2) {
      if (cone1.getCost() - cone2.getCost() < 0){
         return -1;
      } else if (cone1.getCost() - cone2.getCost() > 0) {
         return 1;
      } else {
         return 0;
      }
   }
}

Troubleshooting

Did you get this error?

This happens because according to the interface, compare MUST return an integer value, but the cost fields are double type.

To fix this, use an if/else if/else block to evaluate o1.getCost() - o2.getCost(). Return a positive integer, negative integer, or 0 depending on the result.

Bonus Exercises

1. Modify FlavorComparator to sort Flavor objects by the number of allergens, from highest to lowest.

2. Create a Topping class that extends Ingredient. Add toppings to the Case constructor, then choose how to sort a toppings array in Main.

Next Steps

In these exercises, you practiced implementing existing interfaces. In the studio activity, you will design and implement your own.