Introduction
Single inheritance is a fundamental concept in Java’s Object-Oriented Programming (OOP). It allows a class (subclass or derived class) to inherit fields and methods from another class (superclass or base class). This enables code reusability and helps to create a hierarchical classification.
Table of Contents
- What is Single Inheritance?
- Benefits of Single Inheritance
- Implementing Single Inheritance in Java
- The
super
Keyword - Method Overriding
- Real-World Analogy
- Example: Single Inheritance
- Conclusion
1. What is Single Inheritance?
Single inheritance is when a class inherits from only one superclass. This means a subclass can have only one direct superclass. Single inheritance helps to derive new classes that share common properties and behaviors of the existing class.
2. Benefits of Single Inheritance
- Code Reusability: Allows a subclass to reuse the fields and methods of the superclass, reducing code redundancy.
- Simplicity: Simplifies the class hierarchy by maintaining a clear and straightforward inheritance path.
- Easy Maintenance: Changes in the superclass can be easily propagated to subclasses, making maintenance easier.
3. Implementing Single Inheritance in Java
In Java, single inheritance is implemented using the extends
keyword.
Syntax:
class Superclass { // fields and methods } class Subclass extends Superclass { // additional fields and methods }
4. The super Keyword
The super
keyword in Java is used to refer to the immediate superclass of a subclass. It can be used to:
- Call the superclass’s constructor.
- Access superclass methods.
- Access superclass fields.
Example: Using super
Keyword
public class Animal { String name; // Constructor public Animal(String name) { this.name = name; } public void display() { System.out.println("Animal: " + name); } } public class Dog extends Animal { String breed; // Constructor public Dog(String name, String breed) { super(name); // Call to superclass constructor this.breed = breed; } public void display() { super.display(); // Call to superclass method System.out.println("Breed: " + breed); } } public class Main { public static void main(String[] args) { Dog myDog = new Dog("Buddy", "Golden Retriever"); myDog.display(); } }
Output:
Animal: Buddy Breed: Golden Retriever
5.() Method Overriding
Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The overridden method in the subclass must have the same signature as the method in the superclass.
Example: Method Overriding
public class Animal { public void sound() { System.out.println("This animal makes a sound."); } } public class Dog extends Animal { @Override public void sound() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Animal myDog = new Dog(); myDog.sound(); // Calls the overridden method in Dog class } }
Output:
The dog barks.
6. Real-World Analogy
Think of a simple inheritance relationship like that between vehicles and cars. A vehicle is a general class with common properties like speed and capacity. A car is a specific type of vehicle that inherits these properties but can also have additional features like air conditioning and a sunroof.
7. Example: Single Inheritance
Let’s create a more detailed example of single inheritance in Java.
Example: Single Inheritance
// Superclass public class Employee { String name; int employeeId; // Constructor public Employee(String name, int employeeId) { this.name = name; this.employeeId = employeeId; } // Method to display employee details public void displayDetails() { System.out.println("Name: " + name + ", Employee ID: " + employeeId); } } // Subclass public class Manager extends Employee { String department; // Constructor public Manager(String name, int employeeId, String department) { super(name, employeeId); // Call to superclass constructor this.department = department; } // Method to display manager details public void displayDetails() { super.displayDetails(); // Call to superclass method System.out.println("Department: " + department); } } public class Main { public static void main(String[] args) { // Creating an object of the Manager class Manager manager = new Manager("Alice", 101, "HR"); // Displaying manager details manager.displayDetails(); } }
Output:
Name: Alice, Employee ID: 101 Department: HR
In this example, the Manager
class inherits from the Employee
class, demonstrating single inheritance. The Manager
class adds its own field (department
) and overrides the displayDetails
method to include department information.
8. Conclusion
Single inheritance in Java allows a class to inherit properties and behaviors from a single superclass. This promotes code reusability and helps in organizing classes in a hierarchical manner. By understanding and implementing single inheritance, you can create more modular, maintainable, and efficient Java applications. The super
keyword and method overriding are essential aspects of inheritance that enable subclasses to extend and customize the behavior of their superclasses.