Single inheritance in Java is a type of inheritance where a class (called the subclass or derived class) inherits from only one superclass (base class). This is the simplest form of inheritance, allowing the subclass to inherit fields (attributes) and methods (behaviors) from the superclass, facilitating code reuse and establishing a clear hierarchical relationship between classes.

Key Features of Single Inheritance:

1. Single Parent: A subclass can have only one direct superclass. This means it cannot inherit from multiple classes simultaneously, which helps avoid ambiguity.

2. Code Reusability: The subclass can use the methods and fields of the superclass without redefining them, promoting code reusability.

3. Method Overriding: The subclass can provide a specific implementation of a method that is already defined in the superclass. This is known as method overriding.

4. Simplicity: Single inheritance simplifies the class hierarchy, making it easier to understand and manage.

Example of Single Inheritance

Let’s illustrate single inheritance with an example involving an Animal superclass and a Dog subclass.

Step 1: Define the Superclass

// Superclass
class Animal {
    // Field
    String name;

    // Constructor
    Animal(String name) {
        this.name = name;
    }

    // Method
    void eat() {
        System.out.println(name + " is eating.");
    }
}

Step 2: Define the Subclass

// Subclass
class Dog extends Animal {
    // Additional field
    String breed;

    // Constructor
    Dog(String name, String breed) {
        super(name); // Call the constructor of the superclass
        this.breed = breed;
    }

    // Method specific to Dog
    void bark() {
        System.out.println(name + " barks.");
    }
}

Step 3: Use the Subclass in the Main Method

// Main class
public class Main {
    public static void main(String[] args) {
        // Create an instance of Dog
        Dog myDog = new Dog("Buddy", "Golden Retriever");
        
        // Access methods from the superclass
        myDog.eat(); // Output: Buddy is eating.
        
        // Access method from the subclass
        myDog.bark(); // Output: Buddy barks.
    }
}

Explanation of the Example:

1. Superclass Animal:

   • This class has a field (name) and a method (eat()) that can be inherited by subclasses.

2. Subclass Dog:

   • This class extends the Animal class, inheriting its properties and methods.
   • It also has its own field (breed) and a method (bark()).
   • The constructor of the Dog class uses super(name) to call the constructor of the Animal class, initializing the name field.

3. Main Class:

   • In the main method, we create an instance of Dog called myDog.
   • We can call the inherited method eat() from the Animal class and the method bark() defined in the Dog class.

Advantages of Single Inheritance:

1. Simplicity: The class structure is straightforward, making it easier to understand.

2. Code Reusability: Allows the subclass to reuse code from the superclass, reducing redundancy.

3. Easy Maintenance: Changes made to the superclass methods automatically reflect in the subclass, simplifying maintenance.

Limitations of Single Inheritance:

1. Limited Flexibility: A subclass can inherit from only one superclass, which may limit design options in some cases.

2. Lack of Multiple Inheritance: Java does not allow multiple inheritance with classes to prevent ambiguity (such as the diamond problem), although it allows multiple inheritance through interfaces.

Summary:

• Single inheritance in Java is a straightforward way to create a class hierarchy where one class inherits from another.
• It allows for code reusability, simpler maintenance, and clearer relationships between classes, making it an essential concept in object-oriented programming.