Abstraction

Abstract Classes

Abstract classes cannot be instantiated and may contain abstract methods.

Basic Abstract Class

public abstract class Shape {
    String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // Abstract method - no implementation
    public abstract double area();
    public abstract double perimeter();
    
    // Concrete method - has implementation
    public String getColor() {
        return color;
    }
}

// Shape s = new Shape("red");  // COMPILE ERROR!

Concrete Subclass

public class Circle extends Shape {
    double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Rectangle extends Shape {
    double width, height;
    
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
    
    @Override
    public double perimeter() {
        return 2 * (width + height);
    }
}

Abstract Class Features

public abstract class Example {
    // Can have constructors
    public Example() { }
    
    // Can have instance variables
    private int count;
    
    // Can have concrete methods
    public void increment() { count++; }
    
    // Can have abstract methods
    public abstract void doSomething();
    
    // Can have static methods
    public static void utility() { }
    
    // Can have final methods
    public final void fixed() { }
}

When to Use Abstract Class

// USE abstract class when:
// 1. Shared state (fields) among subclasses
// 2. Common implementation of some methods
// 3. Constructor chaining needed
// 4. Non-public members needed

// Example:
public abstract class Vehicle {
    protected int speed;  // Shared state
    protected double fuel;
    
    // Common implementation
    public void start() {
        System.out.println("Vehicle starting");
    }
    
    // Abstract - each vehicle different
    public abstract void drive();
}

Abstract Methods

Abstract methods have no implementation and must be overridden.

Declaration

public abstract class Animal {
    // Abstract method - no body
    public abstract void makeSound();
    
    // Abstract method with parameters
    public abstract void eat(String food);
}

// Subclass MUST implement all abstract methods
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    @Override
    public void eat(String food) {
        System.out.println("Dog eats " + food);
    }
}

Partial Implementation

public abstract class Database {
    // Abstract methods
    public abstract void connect();
    public abstract void disconnect();
    public abstract void query(String sql);
    
    // Concrete methods
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    public boolean isConnected() {
        return true;
    }
}

// Subclass only needs to implement abstract methods
public class MySQLDatabase extends Database {
    @Override
    public void connect() { }
    
    @Override
    public void disconnect() { }
    
    @Override
    public void query(String sql) { }
    
    // log() and isConnected() inherited as-is
}

Abstract Method Rules

public abstract class Example {
    // Valid abstract methods
    public abstract void method1();
    protected abstract void method2();
    abstract void method3();  // Package-private
    
    // INVALID:
    // private abstract void method();  // Can't be private
    // static abstract void method();    // Can't be static
    // final abstract void method();     // Can't be final
}

Abstract Class vs Interface

When to Use Abstract Class

// USE abstract class when:
// 1. Shared state among subclasses
// 2. Need constructors
// 3. Need non-public members
// 4. Have some common implementation

public abstract class Employee {
    protected String name;
    protected double salary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    
    public abstract double calculateBonus();
    
    public void printInfo() {
        System.out.println(name + ": " + salary);
    }
}

When to Use Interface

// USE interface when:
// 1. No shared state
// 2. Multiple inheritance needed
// 3. Define contract for unrelated classes
// 4. Type checking

public interface Serializable { }
public interface Comparable<T> { }
public interface Runnable { }

// Class can implement multiple interfaces
public class Employee implements Serializable, Comparable<Employee> {
    // Must implement Comparable's compareTo method
}

Multiple Interfaces

// Abstract class: only one parent
public class Dog extends Animal { }  // Only Animal

// Interface: multiple
public class Dog extends Animal implements Pet, Serializable {
    // Can have multiple interfaces
}

Design Guidelines

// 1. Use interface for capability
public interface Flyable {
    void fly();
}

// 2. Use abstract class for partial implementation
public abstract class Bird implements Flyable {
    String name;
    public abstract void fly();
}

// 3. Use interface for type checking
public void process(Flyable f) {
    f.fly();
}