Java Abstract Class

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

In Java, an abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It can contain both abstract methods (methods without a body) and concrete methods (methods with an implementation). Abstract classes are used to provide a common base class for other classes to extend and share common code.

Key Points:

• Cannot be Instantiated: Abstract classes cannot be instantiated directly.
• Abstract Methods: Can contain methods without implementation.
• Concrete Methods: Can also contain methods with implementation.
• Constructors: Can have constructors, which can be called by subclasses.
• Common Base Class: Used to share common code among related classes.

Table of Contents

1. Defining an Abstract Class
2. Abstract Methods
3. Implementing Abstract Methods
4. Constructors in Abstract Classes
5. Real-World Example
6. Conclusion

1. Defining an Abstract Class

An abstract class is defined using the abstract keyword. It can contain both abstract and concrete methods.

Example:

public abstract class Animal { // Abstract method public abstract void makeSound(); // Concrete method public void eat() { System.out.println("Eating..."); } } 

Explanation:

• abstract class Animal: Declares an abstract class named Animal.
• public abstract void makeSound(): An abstract method that must be implemented by subclasses.
• public void eat(): A concrete method with an implementation.

2. Abstract() Methods

Abstract methods are methods that do not have an implementation. Subclasses must provide an implementation for these methods.

Example:

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

Explanation:

• public abstract void makeSound(): Declares an abstract method that subclasses must implement.

3. Implementing Abstract() Methods

Subclasses of an abstract class must implement all abstract methods from the abstract class.

Example:

public class Dog extends Animal { @Override public void makeSound() { System.out.println("Bark"); } } public class AbstractClassExample { public static void main(String[] args) { Dog dog = new Dog(); dog.makeSound(); // Outputs: Bark dog.eat(); // Outputs: Eating... } } 

Explanation:

• Dog: A subclass of Animal that provides an implementation for the makeSound() method.
• AbstractClassExample: A class with a main method to test the Dog class.

4. Constructors in Abstract Classes

Abstract classes can have constructors, which can be called by subclasses to initialize common fields.

Example:

public abstract class Animal { private String name; public Animal(String name) { this.name = name; } public String getName() { return name; } public abstract void makeSound(); public void eat() { System.out.println("Eating..."); } } public class Dog extends Animal { public Dog(String name) { super(name); } @Override public void makeSound() { System.out.println("Bark"); } } public class ConstructorExample { public static void main(String[] args) { Dog dog = new Dog("Buddy"); System.out.println("Dog's name: " + dog.getName()); // Outputs: Dog's name: Buddy dog.makeSound(); // Outputs: Bark dog.eat(); // Outputs: Eating... } } 

Explanation:

• Animal(String name): A constructor in the abstract class Animal to initialize the name field.
• Dog(String name): A constructor in the Dog class that calls the superclass constructor using super(name).

5. Real-World Example

Let's create a real-world example with multiple abstract classes and concrete classes that extend them.

Example:

public abstract class Vehicle { private String model; public Vehicle(String model) { this.model = model; } public String getModel() { return model; } public abstract void start(); public void stop() { System.out.println("Vehicle stopped."); } } public class Car extends Vehicle { public Car(String model) { super(model); } @Override public void start() { System.out.println("Car " + getModel() + " started."); } } public class Motorcycle extends Vehicle { public Motorcycle(String model) { super(model); } @Override public void start() { System.out.println("Motorcycle " + getModel() + " started."); } } public class RealWorldExample { public static void main(String[] args) { Car car = new Car("Toyota"); Motorcycle motorcycle = new Motorcycle("Harley Davidson"); car.start(); // Outputs: Car Toyota started. car.stop(); // Outputs: Vehicle stopped. motorcycle.start(); // Outputs: Motorcycle Harley Davidson started. motorcycle.stop(); // Outputs: Vehicle stopped. } } 

Explanation:

• Vehicle: An abstract class with an abstract method start() and a concrete method stop().
• Car: A subclass of Vehicle that provides an implementation for the start() method.
• Motorcycle: Another subclass of Vehicle that provides an implementation for the start() method.
• RealWorldExample: A class with a main method to test the Car and Motorcycle classes.

6. Conclusion

Abstract classes in Java provide a way to define common behavior that can be shared among related classes while allowing for customization through abstract methods. By using abstract classes, you can achieve a higher level of code reuse and organization. Understanding how to define and use abstract classes and methods can help you design more flexible and maintainable Java applications.