1.2.5 Abstraction Explained

Abstraction is a fundamental concept in Object-Oriented Programming (OOP) that focuses on hiding the complex reality while exposing only the essential features. It allows developers to manage complexity by breaking down a system into smaller, more manageable parts.

Key Concepts

1. Abstract Classes

An abstract class is a class that cannot be instantiated and may contain abstract methods. Abstract classes serve as a base for other classes to extend and implement the abstract methods. They provide a common interface for related classes.

2. Abstract Methods

An abstract method is a method declared in an abstract class without an implementation. Subclasses of the abstract class must provide an implementation for these methods. Abstract methods define a contract that subclasses must fulfill.

3. Interfaces

Interfaces are similar to abstract classes but can only contain abstract methods and constants. They define a contract for classes to implement, ensuring that all implementing classes adhere to a specific structure.

Examples and Analogies

Abstract Class Example

Consider an abstract class Shape that defines a common method area() without providing an implementation. Subclasses like Circle and Rectangle extend Shape and implement the area() method.

        abstract class Shape {
            abstract double area();
        }
        
        class Circle extends Shape {
            double radius;
            
            public Circle(double radius) {
                this.radius = radius;
            }
            
            @Override
            double area() {
                return Math.PI * radius * radius;
            }
        }
        
        class Rectangle extends Shape {
            double length, width;
            
            public Rectangle(double length, double width) {
                this.length = length;
                this.width = width;
            }
            
            @Override
            double area() {
                return length * width;
            }
        }
        
        public class Main {
            public static void main(String[] args) {
                Shape myCircle = new Circle(5);
                Shape myRectangle = new Rectangle(4, 6);
                
                System.out.println("Area of the circle: " + myCircle.area()); // Output: Area of the circle: 78.53981633974483
                System.out.println("Area of the rectangle: " + myRectangle.area()); // Output: Area of the rectangle: 24.0
            }
        }
    

Interface Example

Consider an interface Drawable that defines a method draw(). Classes like Circle and Rectangle implement this interface and provide their own implementation of the draw() method.

        interface Drawable {
            void draw();
        }
        
        class Circle implements Drawable {
            @Override
            public void draw() {
                System.out.println("Drawing a circle.");
            }
        }
        
        class Rectangle implements Drawable {
            @Override
            public void draw() {
                System.out.println("Drawing a rectangle.");
            }
        }
        
        public class Main {
            public static void main(String[] args) {
                Drawable myCircle = new Circle();
                Drawable myRectangle = new Rectangle();
                
                myCircle.draw(); // Output: Drawing a circle.
                myRectangle.draw(); // Output: Drawing a rectangle.
            }
        }
    

Analogies

Think of abstraction as creating a blueprint for a house. The blueprint outlines the structure and essential features (like rooms and doors) without detailing every single nail and brick. Builders use this blueprint to construct different houses, each implementing the blueprint in their own way.

Similarly, in software development, abstraction allows developers to define a common structure (like an abstract class or interface) that multiple classes can implement, each providing their own specific details.

By mastering abstraction, you can design flexible and maintainable Java SE 11 applications that are easier to extend and modify.