4. Interfaces and Inner Classes

Interfaces

• • Interface is a way of describing what classes should do, without specifying how they should do it

  • A class can implement one or more interfaces

  • All methods of an interface are automatically public, so not required to specify access modifier

  • Interfaces can also define constants, fields are always public static final

  • Interfaces never have instance fields

  • Interfaces could have method definition from Java8 as default definition

  • Some interfaces define just constants and no methods

  • You can declare Interface variables, refer to object of class that implements interface

public interface Comparable {

int compareTo(Object other);

}

// Any class that implements Comparable interface is required to have compareTo() method with same signature

class Employee implements Comparable {

public int compareTo(Object other) {

Employee e = (Employee) other;

if (salary < other.salary) return -1;

if (salary > other.salary) return 1;

return 0;

}

}

If (e instanceof Comparable) {...}

java.lang.Comparable

• int compareTo(Object otherObject) - compares this object with otherObject and returns -ive, zero, +ive integer

java.util.Arrays

• static void sort(Object[] a) - sort the elements in the array a, using tunes mergesort, all element if array must belong to object of class that implements Comparable interface

A class implements the interface by 2 steps

• • Declare the class implements the interface

  • Supply definition of all methods in the interface along with access modfier (e.g. public)

  • Class must implement compareTo() method to avail itself if the sorting service

  • But why can's Employee implement compareTo() without implementing Comparable interface?

  • The reason for interfaces is that Java language is strongly types

  • When making a method call, the compiler needs to able to check that the method actually exist

  • If object variable is type Comparable, then existence of the method is assured

Interfaces and Abstract Classes

• • Why can't Comparable simply be an abstract class

  • A generic property can't be expressed using the class inheritance, since multiple class inheritance is not supported

Object Cloning

• • A clone of an object is a new object that has the same state as the original but a different identity

  • If you class implements Cloneable, the clone method in the Object class will make an exact copy of your class's object

  • The clone method is a protected method of Object, which means that your code cannot simply call it.

  • Only the Employee class can clone Employee objects

  • The default cloning operation is "shallow"

  • If the subobjects that is shared between the original and the shallow clone is immutable, then the sharing is safe

  • Even if the default (shallow copy) is adequate, you still need to implement the Cloneable interface, redefine clone to be public, call super.clone(), and catch the CloneNotSupportedException

Employee copy = (Employee) original.clone);

class Person implements Cloneable {

public Object clone() {

try {

return super.clone();

}

catch(CloneNotSupportedException e) { return null;}

}

}

Inner Classes

• • Inner classes are technically somewhat complex, they are defined inside other classes

  • Their methods can access the fields of the surrounding class