Java Abstraction

What is Abstraction?

Abstraction is one of the four fundamental principles of Object-Oriented Programming (OOP). It means hiding the implementation details from the user and showing only the functionality. In simple terms, it's about "what it does" rather than "how it does it."

Think about driving a car: You know how to use the steering wheel, brake, and accelerator to drive, but you don't need to understand how the engine, transmission, or fuel injection system works internally. That's abstraction – you interact with the car through a simple interface without worrying about complex internal mechanisms!

• Hide Complexity: Users don't need to know internal implementation details
• Show Functionality: Users only see what the object can do
• Reduce Complexity: Makes large systems easier to understand and use

How to Achieve Abstraction in Java?

In Java, abstraction can be achieved in two ways:

• Abstract Classes (0-100% abstraction): Classes that cannot be instantiated and may contain both abstract and concrete methods
• Interfaces (100% abstraction): Pure abstraction where all methods are abstract (before Java 8)

What is an Abstract Class?

An abstract class is a class that is declared using the abstract keyword. It serves as a blueprint for other classes and cannot be instantiated (you can't create objects of an abstract class).

• Cannot Create Objects: You cannot instantiate an abstract class directly
• Can Have Abstract Methods: Methods without implementation (no body)
• Can Have Concrete Methods: Regular methods with implementation
• Can Have Constructors: Used when creating child class objects
• Can Have Variables: Instance variables, static variables, constants

Abstract Method Rules

• No Method Body: Abstract methods have no implementation, only declaration
• Must Be Overridden: Child classes must provide implementation for all abstract methods
• Use abstract Keyword: Declared with the abstract keyword
• End with Semicolon: No curly braces, just a semicolon at the end

Simple Abstract Class Example

Let's create a basic example with an abstract Animal class and concrete child classes.

// Abstract class
abstract class Animal {
    // Abstract method (no body)
    abstract void sound();
    
    // Concrete method (with body)
    void sleep() {
        System.out.println("This animal is sleeping...");
    }
}

// Child class 1
class Dog extends Animal {
    // Must provide implementation for abstract method
    void sound() {
        System.out.println("Dog barks: Woof! Woof!");
    }
}

// Child class 2
class Cat extends Animal {
    // Must provide implementation for abstract method
    void sound() {
        System.out.println("Cat meows: Meow! Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        // Animal a = new Animal();  // Error! Cannot instantiate abstract class
        
        Animal myDog = new Dog();
        myDog.sound();  // Calls Dog's implementation
        myDog.sleep();  // Calls inherited concrete method
        
        System.out.println();
        
        Animal myCat = new Cat();
        myCat.sound();  // Calls Cat's implementation
        myCat.sleep();  // Calls inherited concrete method
    }
}

Dog barks: Woof! Woof!
This animal is sleeping...

Cat meows: Meow! Meow!
This animal is sleeping...

Explanation:

• Animal is an abstract class with one abstract method sound()
• sleep() is a concrete method that child classes inherit directly
• Both Dog and Cat must provide implementation for the abstract sound() method
• We cannot create an object of Animal, but can use it as a reference type

Practical Example: Shape Calculator

A real-world example showing how abstract classes define a contract that child classes must follow.

// Abstract class
abstract class Shape {
    String color;
    
    // Constructor
    Shape(String color) {
        this.color = color;
    }
    
    // Abstract method - each shape calculates area differently
    abstract double calculateArea();
    
    // Concrete method - common for all shapes
    void displayColor() {
        System.out.println("Color: " + color);
    }
}

// Circle class
class Circle extends Shape {
    double radius;
    
    Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    double calculateArea() {
        return 3.14159 * radius * radius;
    }
}

// Rectangle class
class Rectangle extends Shape {
    double length;
    double width;
    
    Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }
    
    @Override
    double calculateArea() {
        return length * width;
    }
}

// Triangle class
class Triangle extends Shape {
    double base;
    double height;
    
    Triangle(String color, double base, double height) {
        super(color);
        this.base = base;
        this.height = height;
    }
    
    @Override
    double calculateArea() {
        return 0.5 * base * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5);
        circle.displayColor();
        System.out.println("Circle Area: " + circle.calculateArea());
        
        System.out.println();
        
        Shape rectangle = new Rectangle("Blue", 4, 6);
        rectangle.displayColor();
        System.out.println("Rectangle Area: " + rectangle.calculateArea());
        
        System.out.println();
        
        Shape triangle = new Triangle("Green", 8, 5);
        triangle.displayColor();
        System.out.println("Triangle Area: " + triangle.calculateArea());
    }
}

Color: Red
Circle Area: 78.53975

Color: Blue
Rectangle Area: 24.0

Color: Green
Triangle Area: 20.0

Explanation:

• Shape is abstract because every shape calculates area differently
• Each child class (Circle, Rectangle, Triangle) must implement calculateArea()
• The abstract class defines what each shape must do, not how
• Common functionality like displayColor() is inherited by all shapes

Bank Account Example

A banking system where different account types have different interest calculation methods.

// Abstract class
abstract class BankAccount {
    String accountNumber;
    String accountHolder;
    double balance;
    
    BankAccount(String accountNumber, String accountHolder, double balance) {
        this.accountNumber = accountNumber;
        this.accountHolder = accountHolder;
        this.balance = balance;
    }
    
    // Abstract method - each account type calculates interest differently
    abstract double calculateInterest();
    
    // Concrete method - common for all accounts
    void displayAccountInfo() {
        System.out.println("Account Number: " + accountNumber);
        System.out.println("Account Holder: " + accountHolder);
        System.out.println("Balance: $" + balance);
    }
    
    // Concrete method
    void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: $" + amount);
    }
}

class SavingsAccount extends BankAccount {
    SavingsAccount(String accountNumber, String accountHolder, double balance) {
        super(accountNumber, accountHolder, balance);
    }
    
    @Override
    double calculateInterest() {
        return balance * 0.04;  // 4% interest
    }
}

class CurrentAccount extends BankAccount {
    CurrentAccount(String accountNumber, String accountHolder, double balance) {
        super(accountNumber, accountHolder, balance);
    }
    
    @Override
    double calculateInterest() {
        return balance * 0.01;  // 1% interest
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount savings = new SavingsAccount("SA001", "John Doe", 10000);
        savings.displayAccountInfo();
        System.out.println("Interest: $" + savings.calculateInterest());
        
        System.out.println("\n" + "=".repeat(40) + "\n");
        
        BankAccount current = new CurrentAccount("CA001", "Jane Smith", 15000);
        current.displayAccountInfo();
        current.deposit(5000);
        System.out.println("Updated Balance: $" + current.balance);
        System.out.println("Interest: $" + current.calculateInterest());
    }
}

Account Number: SA001
Account Holder: John Doe
Balance: $10000.0
Interest: $400.0

========================================

Account Number: CA001
Account Holder: Jane Smith
Balance: $15000.0
Deposited: $5000.0
Updated Balance: $20000.0
Interest: $200.0

Explanation:

• BankAccount is abstract because interest calculation varies by account type
• Common functionality (display info, deposit) is in the abstract class
• Each account type implements its own interest calculation logic
• This design makes the system extensible – easy to add new account types

Vehicle Example with Multiple Abstract Methods

An example showing abstract classes with multiple abstract methods that child classes must implement.

abstract class Vehicle {
    String brand;
    
    Vehicle(String brand) {
        this.brand = brand;
    }
    
    // Abstract methods
    abstract void start();
    abstract void stop();
    abstract int getMaxSpeed();
    
    // Concrete method
    void displayBrand() {
        System.out.println("Brand: " + brand);
    }
}

class Car extends Vehicle {
    Car(String brand) {
        super(brand);
    }
    
    @Override
    void start() {
        System.out.println("Car is starting with ignition key");
    }
    
    @Override
    void stop() {
        System.out.println("Car stopped with foot brake");
    }
    
    @Override
    int getMaxSpeed() {
        return 200;
    }
}

class Motorcycle extends Vehicle {
    Motorcycle(String brand) {
        super(brand);
    }
    
    @Override
    void start() {
        System.out.println("Motorcycle is starting with kick/button");
    }
    
    @Override
    void stop() {
        System.out.println("Motorcycle stopped with hand brake");
    }
    
    @Override
    int getMaxSpeed() {
        return 180;
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car("Toyota");
        car.displayBrand();
        car.start();
        System.out.println("Max Speed: " + car.getMaxSpeed() + " km/h");
        car.stop();
        
        System.out.println("\n" + "-".repeat(40) + "\n");
        
        Vehicle bike = new Motorcycle("Honda");
        bike.displayBrand();
        bike.start();
        System.out.println("Max Speed: " + bike.getMaxSpeed() + " km/h");
        bike.stop();
    }
}

Brand: Toyota
Car is starting with ignition key
Max Speed: 200 km/h
Car stopped with foot brake

----------------------------------------

Brand: Honda
Motorcycle is starting with kick/button
Max Speed: 180 km/h
Motorcycle stopped with hand brake

Explanation:

• Vehicle has three abstract methods that all child classes must implement
• Each vehicle type (Car, Motorcycle) has its own way of starting and stopping
• Abstract class ensures all vehicles have consistent interface
• Child classes must implement all abstract methods, otherwise compilation error occurs

Key Characteristics of Abstract Classes

Why Use Abstract Classes?

• Enforce Rules: Force child classes to implement specific methods
• Code Reusability: Share common code among multiple child classes
• Provide Template: Create a blueprint that all child classes must follow
• Achieve Abstraction: Hide implementation details, show only functionality
• Partial Implementation: Provide some common functionality, leave specific details to children
• Consistency: Ensure all child classes have the same interface

Important Rules for Abstract Classes

• abstract Keyword Required: Both abstract classes and abstract methods must use the abstract keyword
• Cannot Be Final: Abstract classes cannot be declared final (final means can't be extended)
• Cannot Be Static: Abstract methods cannot be static
• Cannot Be Private: Abstract methods cannot be private (child classes must access them)
• Can Have Constructors: Abstract classes can have constructors for initialization
• Can Extend Another Class: Abstract classes can extend other classes (abstract or concrete)

Abstract Class vs Concrete Class

• Concrete Class: Regular class that can be instantiated, all methods have implementation
• Abstract Class: Cannot be instantiated, may contain abstract methods without implementation
• Purpose: Concrete classes create objects, abstract classes serve as blueprints
• Flexibility: Abstract classes provide framework, concrete classes provide complete functionality

Benefits of Abstraction

• Security: Hides sensitive implementation details from users
• Simplicity: Users only need to know what to do, not how it's done
• Maintainability: Implementation changes don't affect users
• Flexibility: Different implementations can be swapped easily
• Code Organization: Clear separation between interface and implementation
• Reduced Complexity: Large systems become easier to understand

Key Points to Remember

• Abstraction = Hiding implementation, showing functionality
• Abstract classes cannot be instantiated directly
• Use abstract keyword for both abstract classes and methods
• Abstract methods have no body, end with semicolon
• Child classes must implement all abstract methods
• Abstract classes can have both abstract and concrete methods
• Abstract classes can have constructors, variables, and static members