Abstract classes and interfaces

Last week we wrote area() in the Shape class and returned 0. But the area of a “generic shape” is meaningless; the only job of that method was to tell the subclasses “you will write this”. Abstract classes and interfaces put this intention into the language: the compiler does not compile a class that does not fulfill the contract. That is why the exam has many “find the compile error” questions on this topic, plus “sort this array” writing questions with Comparable.

Golden rules:

1. You cannot new an abstract class but you can use it as a type.
2. A class with an abstract method must be abstract. A concrete subclass must write all of them.
3. Interface methods are public. Do not forget to write public when you implement.
4. A single extends, many implements.
5. compareTo: negative, zero, positive. Arrays.sort uses this.

Abstract class

A class marked with the abstract keyword is an incomplete template. It can contain methods without a body (abstract). Like a normal class, it can also have fields, a constructor and methods with bodies.

abstract class Employee {
    private final String name;

    Employee(String name) {                 // an abstract class has a constructor too
        this.name = name;
        System.out.println("Employee(" + name + ")");
    }
    String getName() { return name; }

    abstract double earnings();             // no body, semicolon

    @Override
    public String toString() { return getName() + ": " + earnings(); }
}

class Salaried extends Employee {
    private final double monthly;
    Salaried(String n, double m) { super(n); monthly = m; }
    @Override double earnings() { return monthly; }
}

class Hourly extends Employee {
    private final double rate;
    private final int hours;
    Hourly(String n, double r, int h) { super(n); rate = r; hours = h; }
    @Override double earnings() {
        if (hours <= 40) return rate * hours;
        return rate * 40 + rate * 1.5 * (hours - 40);   // overtime
    }
}

Employee[] staff = { new Salaried("Ada", 3000), new Hourly("Bora", 100, 45) };
for (Employee e : staff) System.out.println(e);

Employee(Ada)
Employee(Bora)
Ada: 3000.0
Bora: 4750.0

If you had written new Employee("X"): Employee is abstract; cannot be instantiated. But an Employee[] array and an Employee e variable are fine; an abstract class is used as a common type for polymorphism.

Rules about abstract

Interface

An interface is a contract that says what a class “can do”. It is looser than the “is-a” relationship of inheritance: a “can-do” relationship. Classes that have nothing to do with each other (invoice, employee, rent) can implement the same Payable interface.

The hidden meanings of what you write in an interface:

interface Payable {
    double TAX = 0.2;
    double amount();
    default double afterTax() { return amount() * (1 - TAX); }
}

class Invoice implements Payable {
    private final int qty;
    private final double price;
    Invoice(int q, double p) { qty = q; price = p; }
    public double amount() { return qty * price; }   // public REQUIRED
}

Payable p = new Invoice(3, 50);
System.out.println(p.amount() + " " + p.afterTax());
System.out.println(Payable.TAX);

150.0 120.0
0.2

PITFALL · forgetting public. Even if you do not write public in the interface, the method is public. If you do not write it in the class, it becomes package-private and the access narrows: attempting to assign weaker access privileges; was public. This is the most common interface compile error.

Trying to change an interface constant is also an error: Payable.TAX = 0.3; → cannot assign a value to static final variable TAX.

Multiple interfaces

A class can extend only one class but can implement as many interfaces as it wants. The order of writing matters: first extends, then implements.

class Robot extends Machine implements Payable, Comparable<Robot> { ... }

If two interfaces bring a default method with the same signature, Java cannot know which one to pick and gives a compile error. Fix: the class overrides the method, and if it wants, calls one (or both) with InterfaceName.super.method().

interface Flyer   { default String move() { return "fly"; } }
interface Swimmer { default String move() { return "swim"; } }

class Duck implements Flyer, Swimmer {
    public String move() { return Flyer.super.move() + "+" + Swimmer.super.move(); }
}
System.out.println(new Duck().move());

fly+swim

If you write class Duck implements Flyer, Swimmer { } without an override: types Flyer and Swimmer are incompatible; class Duck inherits unrelated defaults for move() from types Flyer and Swimmer.

Abstract class or interface?

Practical rule: if the subclasses share common fields and code, use an abstract class. If there is only a shared capability, use an interface.

Comparable and compareTo

java.lang.Comparable<T> is an interface with a single method: int compareTo(T other). When a class implements it, it has defined a “natural order” for its objects. Arrays.sort and Collections.sort use this order.

The meaning of the value compareTo returns:

class Student implements Comparable<Student> {
    String name; double gpa;
    Student(String n, double g) { name = n; gpa = g; }

    @Override
    public int compareTo(Student o) { return Double.compare(gpa, o.gpa); }

    @Override
    public String toString() { return name + "(" + gpa + ")"; }
}

Student[] st = { new Student("Ece", 3.1), new Student("Ali", 3.8), new Student("Can", 2.5) };
Arrays.sort(st);
System.out.println(Arrays.toString(st));
System.out.println(st[0].compareTo(st[2]));
System.out.println("apple".compareTo("banana"));
System.out.println("b".compareTo("a"));
System.out.println(Integer.valueOf(5).compareTo(5));

[Can(2.5), Ece(3.1), Ali(3.8)]
-1
-1
1
0

TIP · reverse order. To sort from largest to smallest, swap the arguments: Double.compare(o.gpa, gpa). To sort by name, use String’s own compareTo: name.compareTo(o.name).

Ready-made classes such as String, Integer and Double are already Comparable. That is why you can sort a String[] array alphabetically directly with Arrays.sort. If your own class is not Comparable and you call Arrays.sort, you do not get a compile error, but a ClassCastException is thrown at run time.

Interface type and instanceof

An interface is also a type: Payable p = new Invoice(...) is valid, p instanceof Payable works. With a variable of an interface type you can call only the methods defined in the interface (last week’s static type rule applies exactly).

Object o = new Invoice(1, 1);
System.out.println(o instanceof Payable);
System.out.println(o instanceof Comparable);

true
false

Common mistakes

abstract class Shape { abstract double area(); }
// in main:
Shape s = new Shape();

abstract class Shape { abstract double area(); }
class Circle extends Shape {
    double r;
}

interface Payable { double amount(); }
class Bill implements Payable {
    double amount() { return 10; }
}

class Shape {
    abstract double area();
}

abstract class Employee {
    private final String name;
    Employee(String name) { this.name = name; }
    String getName() { return name; }
    abstract double earnings();
    public String toString() { return getName() + ": " + earnings(); }
}
class Hourly extends Employee {
    private double rate; private int hours;
    Hourly(String n, double r, int h) { super(n); rate = r; hours = h; }
    double earnings() {
        if (hours <= 40) return rate * hours;
        return rate * 40 + rate * 1.5 * (hours - 40);
    }
}
// in main:
System.out.println(new Hourly("Bora", 100, 45));

interface Payable {
    double TAX = 0.2;
    double amount();
    default double afterTax() { return amount() * (1 - TAX); }
}
class Invoice implements Payable {
    private int qty; private double price;
    Invoice(int q, double p) { qty = q; price = p; }
    public double amount() { return qty * price; }
}
// in main:
Payable p = new Invoice(3, 50);
System.out.println(p.amount() + " " + p.afterTax());

interface Flyer   { default String move() { return "fly"; } }
interface Swimmer { default String move() { return "swim"; } }
class Duck implements Flyer, Swimmer { }

class Student implements Comparable<Student> {
    String name; double gpa;
    Student(String n, double g) { name = n; gpa = g; }
    public int compareTo(Student o) { return Double.compare(gpa, o.gpa); }
    public String toString() { return name + "(" + gpa + ")"; }
}
// in main:
Student[] st = { new Student("Ece", 3.1), new Student("Ali", 3.8), new Student("Can", 2.5) };
Arrays.sort(st);
System.out.println(Arrays.toString(st));

System.out.println("apple".compareTo("banana"));
System.out.println("b".compareTo("a"));
System.out.println(Integer.valueOf(5).compareTo(5));

abstract class Base {
    Base() { System.out.println("Base " + id()); }
    abstract String id();
}
class Impl extends Base {
    Impl() { super(); System.out.println("Impl"); }
    String id() { return "impl-id"; }
}

public class Money implements Comparable<Money> {
    private final int cents;

    @Override
    public int compareTo(Money other) {
        return Integer.compare(cents, other.cents);
    }

    @Override
    public String toString() { return cents + "c"; }
}