Inheritance

Welcome back! Now that you have a solid understanding of classes and objects in Java, it's time to build on that knowledge by exploring inheritance. Consider it a natural progression in our journey into object-oriented programming (OOP).

Inheritance allows you to create a new class based on an existing class. By using inheritance, you can reuse code, add new features, and make your programs easier to manage and understand. Let's dive in and see what it's all about.

In this lesson, you'll understand how to use inheritance in Java. We'll cover:

1. What Inheritance Is
2. How to Implement Inheritance in Java
3. Why Inheritance Is Beneficial

You'll also learn about chaining inheritance and how to manage multiple inheritance using interfaces.

Inheritance is a way to establish a relationship between a new class (derived class) and an existing class (base class). The derived class inherits properties and behaviors (methods) from the base class. To better understand this concept, we'll use an example involving a Person class as the base class and a Student class as the derived class. This example will help demonstrate how properties and methods are inherited from the base class and how additional features can be added to the derived class.

Let’s start by defining a Person class, which will act as the base class in our example:

// Define the base class Person with name and age attributes
class Person {
    private String name;
    private int age;

    // Constructor to initialize name and age
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Display method to show name and age
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

In this snippet, the Person class is defined with private attributes name and age. It also includes a constructor to initialize these attributes and a display method to print the details.

Now, let’s create a Student class that inherits from the Person class:

// Define the derived class Student, inheriting from Person
class Student extends Person {
    private String major;

    // Constructor to initialize name, age of the base class, and the major of the student
    public Student(String name, int age, String major) {
        super(name, age);
        this.major = major;
    }

    // Method to display major of the student
    public void displayMajor() {
        System.out.println("Major: " + major);
    }
}

In the Student class, we use the extends keyword to inherit from Person. The Student class reuses the name and age attributes from the Person class, and it adds a new attribute, major. The constructor uses the super keyword to call the base class constructor and initialize the inherited properties. The Student class also adds a displayMajor method to show the student’s major.

Finally, let’s see how we can use these classes in a Main method:

public class Main {
    public static void main(String[] args) {
        // Create a Student object and display its details
        Student student = new Student("Bob", 25, "Computer Science");
        student.display();  // Calls the display method from Person class
        student.displayMajor();  // Calls the displayMajor method from Student class
    }
}

In the Main class, we create an instance of Student and use it to call methods from both the Person class (inherited) and the Student class (specific to Student).

In this section, we’ll explore some important aspects and limitations of inheritance in Java that you should be aware of when designing your class hierarchies.

• Chaining Inheritance: In Java, you can create a chain of inheritance where a class inherits from another class, which in turn can be inherited by yet another class. This allows you to build complex class hierarchies where each class extends the functionality of the previous one.

• Single Inheritance with Classes: Java supports single inheritance, meaning a class can only inherit from one superclass. This is designed to keep the class hierarchy simple and avoid ambiguity that could arise from inheriting from multiple classes.

• Multiple Inheritance via Interfaces: Although Java doesn’t support multiple inheritance with classes, it allows a class to implement multiple interfaces. This approach provides the flexibility of multiple inheritance, enabling a class to inherit behavior from multiple sources.

• Final Keyword: The final keyword in Java can be used to prevent a class from being inherited. When a class is declared as final, it cannot be extended by any other class, ensuring that its behavior remains unaltered in subclasses.

Understanding these limitations and specifications of inheritance in Java helps you design effective and maintainable object-oriented systems.

Inheritance is powerful for several reasons:

1. Code Reusability: Instead of rewriting common functionalities, you can inherit them from a base class, making maintenance easier and reducing errors.
2. Extension: You can extend existing code by adding new features to a derived class without changing the existing base class.
3. Hierarchy: It helps in organizing code in a hierarchical manner, which reflects real-world relationships and improves code readability and structure.

Inheritance is a cornerstone of OOP, and understanding it will enable you to design more flexible and scalable applications. It's an essential concept for mastering OOP.

In the next unit, we'll also explore how the concept of inheritance enables (runtime) polymorphism, allowing objects of different classes to be treated as objects of a common base class.

Excited to start practicing? Let's move on and put this theory into action!