Interfaces and Abstract Classes

February 7, 2025

Interface

An interface is an abstraction of behavior.

Abstract methods: Before Java 8, interfaces could only have abstract methods.
Default methods: Provide method bodies, available since Java 8.
Static methods: Provide method bodies, available since Java 8, can be called via Interface.method().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public interface MyInterface {
    // Abstract method
    void abstractMethod();

    // Default method
    default void defaultMethod() {
        System.out.println("This is the default method of the interface");
        privateHelperMethod();  // Call private helper method (Note: private methods are a Java 9 feature, shown here for example only)
    }

    // Static method
    static void staticMethod() {
        System.out.println("This is the static method of the interface");
    }

    // Private helper method (Java 9 feature, but included for completeness)
    private void privateHelperMethod() {
        System.out.println("This is the private helper method of the interface");
    }
}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implementing the abstract method of the interface");
    }

    // Can choose to override the default method
    @Override
    public void defaultMethod() {
        System.out.println("Overriding the default method of the interface");
        MyInterface.super.defaultMethod();  // Call the default method of the interface
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();

        // Call the implemented abstract method
        myClass.abstractMethod();

        // Call the default method
        myClass.defaultMethod();  // Note that the overridden version is called here

        // Call the static method of the interface
        MyInterface.staticMethod();
    }
}

Abstract Class

Abstract classes typically serve as base classes, such as Person, Animal. Because the body of certain methods may differ among various subclasses, these methods are placed as abstract methods in the abstract class.

An abstract class can inherit from another class and can implement multiple interfaces.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public interface Sing {
    public void sing();
}
public interface Dance {
    public void dance();
}

public abstract class Animal implements Dance, Sing{
    @Override
    public void dance(){
        System.out.println("Animal dance");
    }
    @Override
    public void sing(){
        System.out.println("Animal sing");
    }
    abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("cat eat");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("Dog eats");
    }
}

Sing and Dance both represent capabilities, so they are interfaces implemented by the Animal abstract class.
The Animal class provides the abstract method eat().
The Cat and Dog classes then provide different method bodies for the eat() method.

Autoboxing & Unboxing

Autoboxing: Automatically converts primitive types to their corresponding wrapper class objects, actually calling methods like Integer.valueOf(), Double.valueOf(), etc.

1
2
int num = 10;
Integer boxedNum = num;  // Autoboxing (int → Integer)

Unboxing: Automatically converts wrapper class objects to primitive types. Actually calls methods like intValue(), doubleValue(), etc.
Performance issues: Autoboxing/unboxing creates temporary objects, and frequent use in loops can lead to performance degradation.
When comparing wrapper class objects, == compares memory addresses, not values!

1
2
3
4
5
6
7
Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true (JVM caches small integer objects)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // false (outside cache range, new objects created)