Classwork

Annoymous Inner class

• Creates a new class inherited from the given class/interface and its object is created.
• If in static context, behaves like static member class. If in non-static context, behaves like non-static member class.
• Along with Outer class members, it can also access (effectively) final local variables of the enclosing method.

// (named) local class
class EmpnoComparator implements Comparator<Employee> {
    public int compare(Employee e1, Employee e2) {
        return e1.getEmpno() - e2.getEmpno();
    }
}
Arrays.sort(arr, new EmpnoComparator()); // anonymous obj of local class

// Anonymous inner class
Comparator<Employee> cmp = new Comparator<Employee>() {
    public int compare(Employee e1, Employee e2) {
        return e1.getEmpno() - e2.getEmpno();
    }
};
Arrays.sort(arr, cmp);

// Anonymous object of Anonymous inner class.
Arrays.sort(arr, new Comparator<Employee>() {
    public int compare(Employee e1, Employee e2) {
        return e1.getEmpno() - e2.getEmpno();
    }
});

Java 8 Interfaces

Before Java 8

• Interfaces are used to design specification/standards. It contains only declarations – public abstract.

interface Geometry {
    /*public static final*/ double PI = 3.14;
    /*public abstract*/ int calcRectArea(int length, int breadth);
    /*public abstract*/ int calcRectPeri(int length, int breadth);
}
// By default fields of interface is public static final
// and methods are public abstract

• As interfaces doesn't contain method implementations, multiple interface inheritance is supported (no ambiguity error).
• Interfaces are immutable. One should not modify interface once published.

Java 8 added many new features in interfaces in order to support functional programming in Java. Many of these features also contradicts earlier Java/OOP concepts.

Default methods

• Java 8 allows default methods in interfaces. If method is not overridden, its default implementation in interface is considered.
• This allows adding new functionalities into existing interfaces without breaking old implementations e.g. Collection, Comparator, …

interface Emp {
    double getSal();
    default double calcIncentives() {
        return 0.0;
    }
}

class Manager implements Emp {
    // ...
    // calcIncentives() is overridden
    double calcIncentives() {
        return getSal() * 0.2;
    }
}

class Clerk implements Emp {
    // ...
    // calcIncentives() is not overridden -- so method of interface is considered
}

new Manager().calcIncentives(); // return sal * 0.2
new Clerk().calcIncentives(); // return 0.0

• However default methods will lead to ambiguity errors as well, if same default method is available from multiple interfaces. Error: Duplicate method while declaring class.
• Superclass same method get higher priority. But super-interfaces same method will lead to error.
  • Super-class wins! Super-interfaces clash!!