Week 6 Notes and Questions

Abstract, Interface, Collections

Recap: last week we looked at subclassing, "extends", override/overload (what's the diff?) methods in "Object" toString, etc.
This week "abstract" classes (as appeared in one of the homework questions), "interfaces" and "collections"
Abstract classes:
- last week I mentioned "Tiger" as subclass of "Animal". Example of subclass.
- what if we declare a variable of type "Animal"? What would that be useful for? Ans:not much
- Java lets you define "abstract" class for this purpose, eg we have an idea what sort of fields/methods will apply to all "Animal"s, even if it doesn't make sense to create an object that is an Animal of unknown species.
- can anyone suggest some other candidates for abstract classes? (eg "tree", "car")
- What does an abstract class definition look like? Can be exactly the same as any other definition, with the exception that you have the "abstract" keyword ("abstract class Animal..."). So it can contain data and methods. Anyone suggest some you might have?
- Can an abstract class extend a non-abstract class? Ans: yes, e.g. they will all extend "Object" at least.
- An abstract class can contain abstract methods. This is a kind of placeholder method - just the prototype with no code behind it. E.g.
```
   abstract void feedAnimal(Food f);
  
```
  Any class which extends an abstract class must provide real implementations of the abstract methods. Unless..? - unless it's another abstract class itself.
- As you saw from homework, you can't instantiate objects of an abstract class.
- Use the keyword "extends", e.g.
```
class Tiger extends Animal {
```
- Same rules as for any subclassing - you can only extend from a single parent class (whether it's abstract or not).
Interfaces:
- Sometimes it is useful to define a set of functionality without deciding how that functionality will be implemented. An "abstract" method in an "abstract" class is an example of this. Examples? maybe "feed" method in "Animal" would be an abstract method.
- Java lets you define something called an "interface" which is like an asbtract class that has nothing but abstract methods. When would you want to do this? Best shown by example - interface in JFC "Comparable" has one method, namely:
```
public int compareTo(Object o)
```
  The "Comparable" interface contains no code, but the definition states what any implementation should do.
- How to declare an interface? Looks like a class definition but with word "Interface" instead, e.g.
```
public Interface Compare { ...
```
- How to use an interface? Use keyword "implements", e.g.
```
class Car implements Comparable { ... 
```
- An interface can extend another interface
- If you "implement" an interface, Java compiler will make sure you have implementations of the functions. Like abstract methods.
- Example for class "Car":
```
     public int compareTo(Object o) 
     {
       // Don't try this if it's not a Car!
       if (o instanceof Car) {
         Car otherCar = (Car)o;
         if (otherCar.tankSize > tankSize) {
            return -1;
         }
         if (otherCar.tankSize == tankSize) {
            return 0;
         }
         return 1;
       }

       // It wasn't a Car, so we'll just say the two
       // objects are equal.  
       return 0;
     }
  
```
- What's the value in interface? Why is it better than an abstract class that has just abstract methods? Because while you can only extend one class, you can implement as many interfaces as you want.
- Anyone think of other useful interfaces? E.g. "printable", "saveable", "drawable" - often they are "xxxxable"
What is so good about being able to have interfaces and abstract classes? It means that you can write code like this:
```
   void drawIt(Drawable d)
```
i.e. if we know the interface definition, we can write code that uses methods in that interface, and it will work with any class that subsequently comes along which implements that interface.

Collections:

In a program, how do we maintain a bunch of related info? E.g. if I want to manage an arbitrary number of "Animal"s?. Typically will use arrays, or perhaps some customized dynamic memory allocation (stack, linked list etc.)
Disadvantage with arrays? typically have predefined size
Disadvantage with customized mechanism? typically you have to write it yourself
Java does have arrays, but also the class library has lots of "Collection" types. And these rely on some of the concepts (subclasses, interfaces) that we've been looking at.
There is a whole load of classes in the library for this purpose, and they are a bit daunting, because they are arranged as a heirarchy of subclasses, interfaces etc. But some of the classes and interfaces available are:
- Stack, LinkedList, Vector, TreeSet, SortedSet, ArrayList, HashSet...
At the root of these is the "Collection" interface. What methods do you think that might have? Ans: includes "add", "isEmpty", "remove", "size".
E.g. a "LinkedList" implements "Collection" and so you can add, remove, check the size of it etc..
What do you think the "add" method will look like? Ans:
```
public boolean add(Object o)
```
So you can add any object at all.
Collection interface doesn't have a "Object getAt(int position)" method. Why? Because not all Collections guarantee an order. So how can you read things back out? Ans: Collection has an "iterator()" method which returns you an "Iterator"
What is an "Iterator"? It's an interface containing "boolean hasNext()", "Object next()" methods. So you can use it to iterate through the contents of any Collection.

Questions

Using the "Person" class (that we looked at in week 4), write a program that does:

      // ** a ** 
      for (int i=0; i<20; i++) {
         // Create a new person with random age
         int age = (int) (Math.random() * 70);
         Person p = new Person("Person number " + i, age);
      }
      // ** b **

How many "Person"s does this code create?
Where are they by the time you get to line "b"?
At line "a", create a "LinkedList" object called "myCollection". Inside the loop, add each new Person to myCollection.
Where are all the Person objects now by the time you get to line "b"?
At line "b", create a new Iterator to fetch each item out of myCollection and print them out. What order do they come out in?
Modify the "Person" class so that the definition now reads:
```
    class Person implements Comparable { ...
```
What happens when you try to compile it? What have you got to do to fix this?
Fix "Person" so it now compiles as a "Comparable" class. Now change your program so that "myCollection" is a "TreeSet". What difference does that make to the results?
Change the program so that instead of using a "TreeSet", you use a "Stack". What difference does that make to the results?
What is the problem with using "TreeSet" for this program? How would you fix this?
Implement the fix described in the previous answer

Back to index page