Interface

A class's public methods == its interface
Defines how other classes can interact with it (a protocol)
input (parameters), output (return values), invariants, side-effects, behaviors
Basically: all the stuff we need to document in javadoc

`interface`

In Java: interface
Defines particular behavior(s) (incl. all details) that different classes can then implement
Basically: guarantees the implementing classes have these methods

Example: Challenge

Suppose: RPG game
Different things worth XP: puzzles, treasure, dead monsters, quests, etc.
These may even be in different class hierarchies
But all are a kind of challenge that can grant experience points
In Challenge.java:

public interface Challenge {
  public int getXP();
}

Implementing Challenge interface

public class Treasure implements Challenge {
  ...
}

public class Monster implements Challenge, Destructable, ... {
  ...
}

Compiler will force each of these classes to implement a public int getXP() method.

Challenge variables

Can then put any Challenging-implementing object into a Challenge variable:
```
Challenge first = new Monster();
Challenge reward = new Treasure();
```

Can only call Challenge methods on this objects... but that's often all we care about right now! (abstraction)

ArrayList<Challenge> done = ArrayList<Challenge>();
done.add(first);
done.add(reward);
done.add(new Monster());
...
int score = 0;
for (Challenge c : done) {
  score += c.getXP();
}

Comparable

Important in Java.

Already written for you in java.lang.Comparable:

public interface Comparable<T> {
  public int compareTo(T obj);
}

Note the generics: only comparable to something of same type.
Many many implementing classes, including Integer and String (see API)
Should produce "natural ordering" (ascending values)

Circle: Implementing Comparable

public class Circle implements Comparable<Circle> {
  private int radius;
  
  public Circle(int radius) {
    this.radius = radius;
  }
  
  public int compareTo(Circle c) {
    //sort by increasing size
    if (this.radius < c.radius) {
      return -1;
    }else if (this.radius > c.radius) {
      return 1;
    }else {
      return 0;
    }
  }
  
  //...
  
  public String toString() {
    return "Circle(" + this.radius + ")";
  }
}

Could have implemented this compareTo method in one line:

return this.radius - c.radius;

Using the compareTo method

Circle big = new Circle(50);
Circle mid = new Circle(20);
Circle small = new Circle(5);

if (small.compareTo(big) < 0) {
  System.out.println("Small circle comes before big circle");
}
if (mid.compareTo(big) == 0) {
  System.out.println("mid and big are the same size");  
}

Circle[] circles = {mid, small, big};
java.util.Arrays.sort(circles);
System.out.println(java.util.Arrays.toString(circles));
//prints: [Circle(5), Circle(20), Circle(50)]

Used by many methods in java.util.Arrays and java.util.Collections to do sorting.

Longer interfaces possible

public interface Collection<E> {
  public void add(E item);
  public E get();
  public E remove();
  public int size();
}

Implemented by Stack

public class Stack<E> implements Collection<E> {

  //...existing Stack implementation here...

  public void add(E item) {
    this.push(item);
  }

  public E get() {
    return this.peek();
  }
  
  public E remove() {
    return this.pop();
  }

  //size method already exists
}

Using it

Collection<String> c = new Stack<String>();
Collection<String> other = new Queue<String>():
c.add("Alice");
c.add("Bob");
c.remove();
System.out.println(c.get());
System.out.println(c.size());

//NO: c.push("Carol")
//NO: c.peek()

Summary of Interfaces

Declared like a class, but methods have no bodies (end in semi-colon).
- Don't have to declare the interface if it already exists (Comparable)
Classes then implement the interface (and maybe more than one)
Can put instances of those classes into interface variables and collections
Can then process those based only on their interface methods

Inheritance

One class can extend another
Inherits all of super class's non-private variables and methods
Can then add additional behavior or override existing behavior
Once a method is overridden, the behavior of that method depends on the specific type of the object at runtime. This is polymorphism.

Example

public class Animal {
  public void speak() {
    System.out.println("The animal vocalizes.");
  }
}

public class Dog extends Animal {
  public void speak() { 
    System.out.println("Woof! Woof!");
  }
  
  public void fetch(Ball b) {
    //????
  }
}

public class SmallDog extends Dog {
  public void speak() { 
    System.out.println("Yip! Yip! Yip!");
  }
}

public class Cat extends Animal {
  public void speak() {  
    System.out.println("Meow.");
  }
}

public class Fish extends Animal {
}

public class Ball { 
}

Class hierarchy: super/parent class vs sub/child class relationship

Inheritance and Overriding

Animal a = new Animal();
Dog dog = new Dog();
SmallDog pom = new SmallDog();
Cat cat = new Cat();
Fish fish = new Fish();

Who can speak()?
- Overriding: Where is it happening here? What does each animal say?
Who can fetch?

Basically, starts at most specific class and works up until it finds a definition to execute.

Polymorphism

Like with interfaces, can put subclass instances in superclass variables
Behavior depends on most specific implementation though

Animal beast = new Fish();
beast.speak();  //prints? 
Dog dog = new SmallDog();
dog.speak();  //prints?

Animal[] zoo = {new Dog(), new SmallDog(), new Cat(), new Fish()};
for (Animal a : zoo) {
  a.speak();
}

Animal rex = new Dog();
//NO: rex.fetch(new Ball());

Casting

Review of primitives: necessary only when losing precision or size

double three = 3;  
double four = 4.0;
int two = (int) (four / 2.0);

With objects: unnecessary when assigning subclass instance to superclass variables (as seen earlier)

But can do this:

Animal beast = new Dog();
Dog rover = (Dog) beast;
SmallDog rex = (SmallDog) beast;  //NO: causes ClassCastException

You can check if an object is really an instance of a class using instanceof operator

if (beast instanceof Dog) {
  Dog rex = (Dog) beast;  //safe, because I checked first
  rex.fetch(new Ball());
}

Top of the Hierarchy: `Object`

If you don't extend another class, you still extend class Object
Thus, every object inherits these methods (among others):
- toString()
- equals()
You'll often want to override the default behavior of some of these for your class
- Also hashCode(), which we'll come back to

toString()

Because every object has toString(), you can do things like this:

Dog dog = new Dog();
String str = "Hello, " + dog;  //calls toString()
System.out.println(dog);       //calls toString()

Actually safer not to call toString() explicitly, as here:

Dog canine = null;
String str = "Hello, " + canine;
System.out.println(canine);   //canine.toString() would crash with NPE here

Default behavior: class@hashCode (memory address): Dog@6629a046
Override to return something useful (as we did earlier for UsernameA05, Circle, etc.)

Default equals method

Default equals behavior: same as == (which compares references)

//assuming earlier Circle definition

Circle one = new Circle(10);
Circle two = new Circle(10);
Circle tu = two;
System.out.println(one == two);      //false
System.out.println(tu == two);       //true
System.out.println(one.equals(two)); //false
System.out.println(tu.equals(two));  //true

Custom equals method

public class Circle implements Comparable<Circle> {
  //... earlier definition...
  
  public boolean equals(Object obj) {  //note the Object
    if (obj instanceof Circle) {  //also catches null
      Circle circle = (Circle) obj;
      return this.radius == circle.radius;
    }
    return false;
  }
}

Circle one = new Circle(10);
Circle two = new Circle(10);
Circle tu = two;
System.out.println(one.equals(two)); //true
System.out.println(tu.equals(two));  //true

Failure to override

Easy to do something like this:

  public String toSting() {
    //...
  }

  public boolean equals(Circle e) {
    //...
  }

Signatures are wrong here; doesn't actually override

@Override annotation

  @Override
  public String toString() {
    //...
  }

  @Override public boolean equals(Circle e) {
    //...
  }

Now won't compile if not really overriding (like second example here.
So use this whenever you mean to override a method
Other @annotations exist (not the same as javadoc @tags!): @SuppressWarnings, @Deprecated, etc.

`super` keyword: Methods

Sometimes you want to refer to original method that you're overriding:

public class SmallDog extends Dog {
  public void speak() { 
    super.speak();
    System.out.println("Yip! Yip! Yip!");
  }
}

super is like this, but refers to immediate superclass.
Very handy when you want to just add (extend) the behavior of an existing superclass method

`super` keyword: Constructors

public class Rectangle {
  
  private int width;
  private int height;
  
  public Rectangle(int width, int height) {
    this.width = width;
    this.height = height;
  }
  
  //...
}

public class Square extends Rectangle {

  public Square(int side) {
    super(side, side);  //actually required
  }
}

`protected`

In previous example, Square class set Rectangle's width and height... but then had no access to them.

If you can't implement subclass behavior without access to superclass's internals, you can make superclass details protected:

public class Rectangle {
  
  protected int width;
  protected int height;
  
  public Rectangle(int width, int height) {
    this.width = width;
    this.height = height;
  }
  
  //...
}

Now, any subclass or other class in same package can access width and height of an Rectangle
Square will inherit them now, so can use this.width or this.height as if defined them itself

Abstract classes

Occasionally, you want to provide some methods, but leave others unimplemented for subclasses to implement.

public abstract class Animal {
  
  public void locomote() {
    //..implementation here...
  }  
  public void respire() {
    //...implementation here...
  }

  public abstract void speak(); 
}

All subclasses of Animal must implement a speak() method. (Only a problem for Fish at the moment.)
So all our earlier polymorphism examples still work
But can't create any Animal instances: new Animal();
Generally prefer interfaces to abstract classes unless you want to provide quite a bit of implementation at this level.

06b: Java: Interfaces and Inheritance

ICS211, Fall 2012
Dr. Zach

Status check

Interface

`interface`

Example: Challenge

Implementing Challenge interface

Challenge variables

Comparable

Circle: Implementing Comparable

Using the compareTo method

Longer interfaces possible

Implemented by Stack

Using it

Summary of Interfaces

Inheritance

Example

Inheritance and Overriding

Polymorphism

Casting

Top of the Hierarchy: `Object`

toString()

Default equals method

Custom equals method

Failure to override

@Override annotation

`super` keyword: Methods

`super` keyword: Constructors

`protected`

Abstract classes

For next time

06b: Java: Interfaces and Inheritance

ICS211, Fall 2012Dr. Zach

Status check

Interface

interface

Example: Challenge

Implementing Challenge interface

Challenge variables

Comparable

Circle: Implementing Comparable

Using the compareTo method

Longer interfaces possible

Implemented by Stack

Using it

Summary of Interfaces

Inheritance

Example

Inheritance and Overriding

Polymorphism

Casting

Top of the Hierarchy: Object

toString()

Default equals method

Custom equals method

Failure to override

@Override annotation

super keyword: Methods

super keyword: Constructors

protected

Abstract classes

For next time

ICS211, Fall 2012
Dr. Zach

`interface`

Top of the Hierarchy: `Object`

`super` keyword: Methods

`super` keyword: Constructors

`protected`