Java Abstraction

Abstraction is one of the four fundamental concepts in object-oriented programming (OOP) in Java. It is the process of hiding complex implementation details and showing only the necessary information to the user. Abstraction allows you to focus on what an object does rather than how it does it.

In Java, abstraction is achieved through abstract classes and interfaces.

Abstract Class

In Java, an abstract class is a class that cannot be instantiated and may contain one or more abstract methods. An abstract method is a method that has no implementation and is declared using the abstract keyword. Any class that extends an abstract class must implement all its abstract methods.

abstract class Animal {
   public abstract void makeSound();
   public void eat() {
      System.out.println("Animal is eating.");
   }
}

Abstract classes are typically used when you want to create a base class that provides some common functionality for a group of related classes, but the base class itself is not complete enough to be instantiated. The abstract class provides a template for the subclasses to follow and provides a common interface that can be used to interact with them.

Here’s an example of an abstract class in Java:

abstract class Shape {
    protected int x;
    protected int y;
    
    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public abstract void draw();
    
    public void move(int deltaX, int deltaY) {
        x += deltaX;
        y += deltaY;
    }
}

In the above example, Shape is an abstract class that contains two instance variables x and y, a constructor that initializes these variables, one abstract method draw(), and one non-abstract method move(). The draw() method has no implementation and is declared using the abstract keyword. The move() method has an implementation and is not declared using the abstract keyword.

Any class that extends the Shape class must implement the draw() method. For example:

class Rectangle extends Shape {
    private int width;
    private int height;
    
    public Rectangle(int x, int y, int width, int height) {
        super(x, y);
        this.width = width;
        this.height = height;
    }
    
    public void draw() {
        System.out.println("Drawing a rectangle at (" + x + ", " + y + ") with width " + width + " and height " + height);
    }
}

In the above example, Rectangle is a class that extends the Shape class and implements the draw() method. The Rectangle class also has its own instance variables width and height and a constructor that initializes them.

Abstract Methods

Abstract methods are useful when you want to define a method in a base class that must be implemented in all the subclasses, but the implementation of the method may vary between the subclasses. By declaring the method as abstract, you ensure that all the subclasses provide their own implementation of the method.

Here’s an example of an abstract method in Java:

abstract class Animal {
    public abstract void makeSound();
}

In the above example, Animal is an abstract class that contains one abstract method makeSound(). Any class that extends the Animal class must provide its own implementation of the makeSound() method.

Abstract classes and methods are an important part of Java’s object-oriented programming model. They provide a way to define a common interface for a group of related classes and ensure that certain methods are implemented in all the subclasses. This helps to create more modular and extensible code.

Share on Facebook

Save