Interfaces and Abstract Classes

12. Interfaces and Abstract Classes

Interfaces and abstract classes are essential concepts in Java's object-oriented programming (OOP) paradigm. They provide a way to define contracts and abstract behavior that can be shared among classes. In this Core Java tutorial, we'll explore interfaces and abstract classes in detail, along with comprehensive explanations and examples.

Interfaces:

An interface is a blueprint for a class that defines a set of methods (and possibly constants) that any class implementing the interface must provide. Java interfaces are used to achieve multiple inheritance of behavior because a class can implement multiple interfaces.

interface MyInterface {
    // Constant (implicitly public, static, and final)
    int MY_CONSTANT = 42;

    // Abstract method (implicitly public and abstract)
    void myMethod();

    // Default method (introduced in Java 8)
    default void defaultMethod() {
        // Method implementation
    }

    // Static method (introduced in Java 8)
    static void staticMethod() {
        // Method implementation
    }
}

• 'interface': Keyword used to declare an interface.
• 'MY_CONSTANT': Constant field, implicitly 'public', 'static', and 'final' .
• 'myMethod()': Abstract method, implicitly 'public' and 'abstract'.
• 'defaultMethod()': Default method with an implementation (introduced in Java 8).
• 'staticMethod()': Static method with an implementation (introduced in Java 8).

Implementing an Interface:

class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        // Method implementation
    }
}

In this example, 'MyClass'implements the 'MyInterface' interface and provides an implementation for the 'myMethod' method.

Abstract Classes:

An abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It can contain both abstract (unimplemented) and concrete (implemented) methods. Abstract classes allow you to define a common base class with shared behavior.

abstract class MyAbstractClass {
    // Concrete method
    void concreteMethod() {
        // Method implementation
    }

    // Abstract method (no method body)
    abstract void abstractMethod();
}

• 'abstract': Keyword used to declare an abstract class.
• 'concreteMethod()': A concrete method with an implementation.
• 'abstractMethod()': An abstract method with no method body.

Extending an Abstract Class:

A class extends an abstract class using the 'extends' keyword and provides implementations for any abstract methods.

class MySubclass extends MyAbstractClass {
    @Override
    void abstractMethod() {
        // Method implementation
    }
}

In this example, 'MySubclass'extends the 'MyAbstractClass' abstract class and provides an implementation for the 'abstractMethod' method.

When to Use Interfaces vs. Abstract Classes:

• Interfaces: Use interfaces when you want to define a contract that multiple classes can implement, especially if they don't share a common base class. Interfaces are well-suited for defining roles, such as 'Comparable', 'Serializable', or custom behaviors.

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        // Implementation
    }
}

class Rectangle implements Drawable {
    @Override
    public void draw() {
        // Implementation
    }
}

• Abstract Classes: Use abstract classes when you want to provide a common base with shared behavior and some methods that should be implemented by subclasses. Abstract classes are useful for modeling hierarchies where some methods have a default implementation.

abstract class Shape {
    abstract double area();

    double perimeter() {
        return 0.0;
    }
}

class Circle extends Shape {
    double radius;

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length;
    double width;

    @Override
    double area() {
        return length * width;
    }
}