Inheritance

Inheritance is a core concept of object-oriented programming (OOP) that allows a new class (derived or child class) to inherit properties and methods from an existing class (base or parent class). This promotes code reusability, modularity, and flexibility in programming. Let’s break down the concept further and understand how it functions, using the example provided.

1. What is Inheritance?

• Inheritance enables a new class (derived class) to reuse and extend the functionality of an existing class (base class). The derived class inherits all non-private attributes and methods from the base class.
• This means that the derived class gains access to the methods and fields of the base class without having to rewrite the code.
• In Java, inheritance is achieved using the extends keyword.

Example:

class Index {
    protected int count;

    public Index() {
        count = 0;
    }

    public void increment() {
        count += 1;
    }

    public void display() {
        System.out.println("Count = " + count);
    }
}

class Index1 extends Index {   // Derived class
    public void decrement() {
        count -= 1;
    }
}

Here, Index1 is the derived class that extends the Index class, inheriting its properties and methods (count, increment(), and display()).

2. Why is Inheritance Important?

• Code Reusability: One of the primary advantages of inheritance is the ability to reuse existing, tested, and debugged code. Once the base class is implemented and debugged, it can be used in many derived classes without needing to modify the original code. For instance, in the example, the Index class has been written once but can now be extended by Index1 or any other class, saving time and effort.
• Extensibility: Inheritance allows the extension of existing functionality. In the example, the base class Index provides an increment() method, but not a decrement() method. By using inheritance, we can create a new class Index1 that adds this extra functionality (decrement()) without altering the base class. This preserves the original functionality and makes it easier to add or modify features in the future.
• Maintainability: If the base class Index ever needs to be updated or fixed, the change will automatically propagate to all derived classes. This improves maintainability, as you don’t need to update multiple classes individually.
• Flexibility: By extending base classes and adding new features, developers can quickly adapt code to new requirements without rewriting existing classes.

3. How Inheritance Works in Java

• Base Class (Parent Class): The base class contains all the common attributes and methods that derived classes can inherit. In this case, Index is the base class that contains:
  • An integer count (protected visibility)
  • A method to increment the count
  • A method to display the value of count

class Index {
    protected int count;

    public Index() {
        count = 0;
    }

    public void increment() {
        count += 1;
    }

    public void display() {
        System.out.println("Count = " + count);
    }
}

The protected keyword for the count variable allows it to be accessed by derived classes but not by any unrelated classes outside the inheritance hierarchy. This protects the variable while still enabling inheritance.

Derived Class (Child Class): The derived class, Index1, extends the Index class, meaning it inherits all its attributes and methods. The derived class can:

• Use the inherited methods increment() and display().
• Add new methods like decrement() to enhance functionality.

class Index1 extends Index {
    public void decrement() {
        count -= 1;
    }
}

• In this example, Index1 adds a new feature—the ability to decrement the counter. However, the Index1 class still inherits the ability to increment the counter and display the count value from the base class.

4. Constructor Behavior in Inheritance

• When a derived class is created, the constructor of the base class is called first, even if no constructor is explicitly defined in the derived class.
• In the example, the Index constructor initializes count to 0. When an Index1 object is created, this base class constructor is invoked first to initialize the inherited count variable.
• If the derived class has its own constructor, it can invoke the base class constructor using the super() keyword, but in this case, no explicit constructor is defined for Index1.

Example:

Index1 i = new Index1();  // Creates an object of the derived class

The Index constructor is called implicitly, initializing count to 0.

5. Access Levels and Inheritance

• Private Members: Private members of the base class cannot be accessed directly by the derived class.
• Protected Members: Protected members can be accessed by the derived class, as shown in the example where count is marked protected.
• Public Members: Public members are accessible everywhere, including derived classes and external classes.

If the count variable had been marked private, the derived class would not be able to access it, leading to a design that hides important data from derived classes. By marking it protected, it strikes a balance, ensuring access to child classes while keeping it hidden from external code.

6. The Flow of Control in Inheritance

When we create an object of the derived class (Index1), the flow of control is as follows:

1. Constructor of Base Class: First, the constructor of Index is called, initializing the count variable.
2. Constructor of Derived Class: The default constructor of Index1 is called (if no constructor is defined, Java automatically provides a no-argument constructor).
3. Method Calls: When methods are called, Java looks for the method in the derived class first. If not found, it checks the base class. In the example, calling i.increment() will execute the increment() method from the base class, because Index1 does not override this method.

7. Encapsulation and Data Hiding in Inheritance

• Inheritance allows derived classes to access base class members, but good OOP design maintains encapsulation and data hiding principles.
• In the example, marking count as protected ensures that it is hidden from external classes while still allowing Index1 to manipulate it. However, marking it public would break encapsulation, exposing count to external modifications.

Encapsulation is essential for safeguarding the internal state of objects and ensuring that only trusted methods can modify important fields like count.

8. Extending Functionality Without Modifying the Base Class

• The true power of inheritance lies in its ability to extend a class without modifying the original code. In the example, we could continue to extend the Index class into multiple other classes (e.g., Index2, Index3) with additional features, while the base Index class remains untouched.
• This avoids redundant code, enhances flexibility, and adheres to the open/closed principle, which states that software entities should be open for extension but closed for modification.

Conclusion

Inheritance in Java is a powerful mechanism that promotes code reuse, modularity, and extensibility. It allows developers to build on existing classes without altering their core functionality, as seen in the example where Index1 adds new functionality to Index. By properly managing access levels and encapsulation, inheritance can be used to create robust, maintainable, and flexible code.

USES OF INHERITANCE

Inheritance is one of the foundational concepts in Object-Oriented Programming (OOP), which plays a significant role in software design. In Java, inheritance allows one class (the derived class or child class) to inherit properties and methods from another class (the base class or parent class). This enables the reuse of existing code, reduces redundancy, and promotes cleaner, more maintainable code. Let’s explore inheritance in greater detail, focusing on its uses, how it works, and the broader implications in programming.

Key Features of Inheritance:

1. Code Reusability: One of the primary advantages of inheritance is that you can use the existing, tested code from a base class without having to rewrite it. The derived class automatically gains access to the base class’s fields and methods.
2. Extensibility: Inheritance allows you to extend the functionality of an existing class by adding new features or refining the current behavior in a derived class without altering the original base class.
3. Method Overriding: Inheritance allows a derived class to provide a specific implementation for methods that are already defined in its base class. This is called method overriding and is useful for modifying the behavior of inherited methods.
4. Inheritance Chain: You can create a chain of inheritance, where a class is derived from another derived class, leading to multiple levels of inheritance. For example, class C can inherit from class B, which itself inherits from class A.
5. Single Inheritance in Java: In Java, a class can only inherit from one other class, which is known as single inheritance. However, a class can implement multiple interfaces, allowing for multiple inheritance of behavior.

Uses of Inheritance in Java:

Use Existing Functionality: The derived class can use methods and fields of the base class directly, without the need to redefine them. This is useful in scenarios where classes share common behaviors but differ in certain specific implementation.

Example:

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

class Dog extends Animal {
    // No need to redefine eat()
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Uses inherited method
    }
}

In this example, Dog inherits the eat() method from Animal, reusing the functionality without redefining it.

Override Existing Functionality: The derived class can override methods of the base class to modify or extend the behavior. This is done by redefining the method in the derived class.

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound();  // Outputs: Dog barks
    }
}

In this case, the Dog class overrides the sound() method of Animal to provide a more specific implementation.

Provide New Functionality: The derived class can introduce new methods and fields that are not present in the base class. This adds specialized functionality unique to the derived class while maintaining the inherited behaviors.

Example:

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

class Bird extends Animal {
    void fly() {
        System.out.println("Bird is flying");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.eat();  // Inherited method
        bird.fly();  // New method specific to Bird
    }
}

Here, the Bird class inherits the eat() method but introduces the new method fly().

Combination of Existing and New Functionality: The derived class can combine both inherited and new functionalities. For example, it can override a method from the base class but still call the base class method using super to combine behaviors.

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        super.sound();  // Calls the base class method
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound();  // Outputs: Animal makes sound
                      //          Cat meows
    }
}

In this example, the Cat class overrides sound() but still calls the sound() method of the base class Animal using super, combining the old functionality with new behavior.

Multiple Levels of Inheritance (Inheritance Chain)

In Java, inheritance can span multiple levels, meaning that a class can inherit from another derived class. This creates an inheritance chain, allowing each class to build on the functionality of its predecessors.

Example of Multi-Level Inheritance:

class A {
    void displayA() {
        System.out.println("Class A");
    }
}

class B extends A {
    void displayB() {
        System.out.println("Class B");
    }
}

class C extends B {
    void displayC() {
        System.out.println("Class C");
    }
}

public class Main {
    public static void main(String[] args) {
        C obj = new C();
        obj.displayA();  // Inherited from A
        obj.displayB();  // Inherited from B
        obj.displayC();  // Defined in C
    }
}

In this example, class C inherits from class B, which in turn inherits from class A. The object of class C can access methods from both B and A, illustrating multi-level inheritance.

Why Java Doesn’t Support Multiple Inheritance

Java does not allow a class to inherit from more than one class directly (i.e., multiple inheritance) to avoid the Diamond Problem. The Diamond Problem occurs when two parent classes have a method with the same signature, and the child class doesn’t know which one to inherit.

Example of the Diamond Problem (conceptual):

class A {
    void print() {
        System.out.println("From A");
    }
}

class B {
    void print() {
        System.out.println("From B");
    }
}

class C extends A, B {  // Not allowed in Java
    // Which print() method would C inherit?
}

To resolve this, Java allows multiple inheritance through interfaces, where a class can implement multiple interfaces and define the behavior it wants.

Advantages of Inheritance:

1. Code Reusability: Inheritance enables you to reuse code across multiple classes. Instead of duplicating code, you create a base class with shared functionality and derive other classes from it.
2. Extensibility: A well-designed base class allows easy extension. Derived classes can introduce new behaviors without altering the base class, making programs easier to maintain and extend.
3. Maintainability: By localizing changes to a base class, you reduce the risk of errors in the derived classes, as they rely on tested, inherited functionality.
4. Polymorphism: Inheritance allows for polymorphism, where objects of a derived class can be treated as objects of the base class. This enables dynamic method dispatch, where the method to be invoked is determined at runtime based on the actual object type.

Conclusion

Inheritance in Java is a powerful mechanism that encourages code reuse, enhances maintainability, and supports polymorphism. By enabling a class to inherit fields and methods from another class, Java provides a structured way to extend functionality, override behavior, and create complex class hierarchies. Understanding the nuances of inheritance helps in designing flexible and robust systems, allowing developers to focus on extending existing code rather than reinventing solutions.

This structured approach simplifies both large-scale software development and smaller projects by promoting modular, reusable, and maintainable code.

Constructors in Inheritance

In Java, constructors in an inheritance chain are treated differently from other methods. When an object of a derived class is created, the constructor of the base class is automatically called before the derived class’s constructor, ensuring that the base part of the object is fully initialized before the derived part is constructed. This guarantees that the base class’s fields and behavior are set up before the derived class begins its construction.

Here are the key points regarding constructors in inheritance:

1. Order of Constructor Calls:
   • When an object of a derived class is instantiated, the constructor of the base class is invoked first, followed by the constructor of the derived class. This ensures that any base class initialization occurs before the derived class initialization.
2. Calling the Base Class Constructor:
   • If the base class constructor needs specific arguments to be passed, the derived class constructor must explicitly call the base class constructor using the super() keyword.
   • If the derived class does not explicitly call the base class constructor using super(), the default constructor (i.e., the zero-argument constructor) of the base class is called automatically.

Example: Demonstrating Constructor Behavior in Inheritance

Here’s an example that demonstrates the order of constructor calls and how constructors in the inheritance chain work:

// Demonstrates calls to constructors in Inheritance chain
package constructorsininheritanceproject;

class A {
    public A() {
        System.out.println("A's 0-arg Constructor");
    }

    public A(int xx) {
        System.out.println("A's 1-arg Constructor");
    }
}

class B extends A {
    public B() {
        System.out.println("B's 0-arg Constructor");
    }

    public B(int x) {
        super(x);  // Explicitly calls A's 1-arg constructor
        System.out.println("B's 1-arg Constructor");
    }
}

public class ConstructorsIninheritanceProject {
    public static void main(String[] args) {
        B y = new B();      // Calls B's 0-arg constructor
        B z = new B(10);    // Calls B's 1-arg constructor
    }
}

Output:

A's 0-arg Constructor
B's 0-arg Constructor
A's 1-arg Constructor
B's 1-arg Constructor

Explanation of the Output:

• When B y = new B() is executed:
  • The 0-arg constructor of the base class A is called first (A's 0-arg Constructor).
  • Then, the 0-arg constructor of the derived class B is called (B's 0-arg Constructor).
• When B z = new B(10) is executed:
  • The 1-arg constructor of the base class A is explicitly called using super(x) (A's 1-arg Constructor).
  • Then, the 1-arg constructor of the derived class B is called (B's 1-arg Constructor).

Default Behavior with Zero-Argument Constructor

If the derived class does not explicitly call the base class constructor, the default behavior is to call the zero-argument constructor of the base class. This happens automatically unless another constructor is specified with super().

For example:

public B(int x) {
    // Even though we don't call super(), A's 0-arg constructor will be invoked automatically
    System.out.println("B's Constructor with value " + x);
}

In this case, if super(x) is not specified, the 0-arg constructor of A will be invoked by default.

Why the Base Class Constructor is Called First

The base class constructor is called first to ensure that the derived class has a properly initialized foundation to build upon. This is crucial because the derived class may rely on fields and methods that are inherited from the base class, which need to be initialized before the derived class begins its own initialization.

Consider the following example:

// Order of construction of object in Inheritance chain
package orderofconstructionproject;

class Base1 {
    protected int i;

    public Base1() {
        i = 4;
    }
}

class Der extends Base1 {
    private int j;

    public Der() {
        j = i * 4;  // Relies on Base1's initialization of 'i'
    }

    public void display() {
        System.out.println("i = " + i);
        System.out.println("j = " + j);
    }
}

public class OrderOfConstructionProject {
    public static void main(String[] args) {
        Der d = new Der();
        d.display();
    }
}

Output:

i = 4
j = 16

Explanation:

• Base Class Initialization: The constructor of the base class Base1 initializes the variable i with the value 4.
• Derived Class Initialization: When the constructor of the derived class Der is called, it calculates j = i * 4, where i was already initialized by the base class constructor.
• If the base class constructor had not been called first, the variable i would not have been initialized, and the calculation j = i * 4 would have resulted in an error or incorrect value.

This shows why the construction order must proceed from the base class to the derived class: to ensure that all inherited fields are properly initialized before the derived class starts using them.

Summary of Constructor Behavior in Inheritance

1. Base Class Constructor First: When an object of a derived class is created, the base class constructor is always called first, ensuring that the inherited fields and methods are initialized before the derived class adds its own behavior.
2. Zero-Argument Constructor: If no explicit call to a base class constructor is made using super(), Java automatically calls the zero-argument constructor of the base class.
3. Explicit Call to Base Constructor: If the base class does not have a zero-argument constructor or if the derived class needs to pass arguments to the base class constructor, the derived class constructor must explicitly call super() with the required arguments.
4. Super Keyword: The super() keyword is used to invoke the base class constructor from the derived class constructor, especially when passing arguments.
5. Order of Initialization: The order of construction in inheritance ensures that the base class is fully initialized before the derived class, ensuring correct object state and avoiding issues with uninitialized fields.

Understanding this behavior is crucial in designing class hierarchies where proper initialization and inheritance are key to creating robust, error-free programs.

The final Keyword

In Java, the final keyword can be used to prevent both class inheritance and method overriding, providing a way to control and restrict the extensibility of a class or its behavior. Let’s break down the two scenarios described:

1. Preventing Inheritance Using final Class

When we declare a class as final, it cannot be extended (inherited). This is useful when you want to ensure that a class’s implementation remains intact and cannot be altered by subclassing.

Here’s an example demonstrating how using final prevents inheritance:

// Demonstrates prevention of Inheritance
package preventinheritanceproject;

final class Base1 {
    // Class body
}

class Derived extends Base1 {  // This will cause a compilation error
    public void fun() {
        System.out.println("Too much noise, too little substance");
    }
}

public class PreventInheritanceProject {
    public static void main(String[] args) {
        Derived d = new Derived();  // This will not compile
        d.fun();
    }
}

Compilation Error:

The program fails to compile with the following error:

Cannot inherit from final 'Base1'

This error occurs because the class Base1 is marked as final, which means it cannot be extended by any other class. If you attempt to inherit from a final class, the compiler will prevent it.

2. Preventing Method Overriding Using final Methods

Sometimes, you may want to allow class inheritance but prevent certain methods from being overridden in the derived class. This can be done by marking the method with the final keyword.

Here’s an example that demonstrates how using final prevents method overriding:

// Demonstrates prevention of overriding
class Base1 {
    final public void fun() {  // This method cannot be overridden
        System.out.println("In the final method");
    }
}

class Derived extends Base1 {
    // This method will cause a compilation error
    public void fun() {
        System.out.println("Illegal");
    }
}

public class PreventOverrideProject {
    public static void main(String[] args) {
        Derived d = new Derived();  // This will not compile
        d.fun();
    }
}

Compilation Error:

The attempt to override the fun() method in the Derived class causes a compilation error:

Cannot override the final method from Base1

The method fun() in the Base1 class is marked as final, meaning that any attempt to override it in a subclass will result in a compilation error. This ensures that the behavior of the fun() method remains unchanged and cannot be altered by subclasses.

Key Points About final Keyword

1. final Classes:
   • When a class is marked final, it cannot be extended by any other class.
   • Example: public final class Base1 { }
   • Use case: This is typically used to create classes that should not be modified by inheritance, such as utility classes (e.g., java.lang.String).
2. final Methods:
   • When a method is marked final, it cannot be overridden by any subclass.
   • Example: public final void fun() { }
   • Use case: Prevents modification of core logic in subclasses, ensuring the integrity of certain methods.
3. final Fields:
   • Fields marked with final cannot be reassigned after they have been initialized.
   • Example: final int x = 10;
   • This is often used to create constants or variables that should only be assigned once, either at the time of declaration or in the constructor.

Real-World Example: Why Use final?

• Immutable Classes: The String class in Java is a real-world example of a final class. It is designed to be immutable, meaning once a String object is created, it cannot be modified. Marking the class as final prevents other classes from extending it and changing its behavior.
• Security: In some cases, you might want to prevent subclasses from overriding security-sensitive methods. By marking these methods as final, you ensure that the original behavior is preserved.

Incremental Development

Inheritance in Java enables a concept known as incremental development, which refers to the process of building upon existing code without modifying the original code base. This approach offers several advantages when designing complex programs and systems, particularly when it comes to improving code reuse, maintainability, and reducing the likelihood of introducing bugs.

Here’s how inheritance supports incremental development:

1. Introducing New Features Without Altering Existing Code

When you inherit from a base class, you can add new features in the form of additional data members (fields) and member functions (methods). This allows you to expand the functionality of a class without altering the original code that might already be in use. As a result, existing code remains unchanged and functional, which reduces the risk of introducing new bugs.

• Example: Imagine you have a class called Vehicle that provides basic functionality like start() and stop(). You can create a new class Car that inherits from Vehicle and adds new methods like openTrunk() without changing the Vehicle class. Existing systems using Vehicle won’t be affected, while the Car class can have additional functionality.

class Vehicle {
    public void start() {
        System.out.println("Vehicle started");
    }
    public void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {
    public void openTrunk() {
        System.out.println("Trunk opened");
    }
}

2. Reusing Existing Code

By inheriting from an existing, tested, and functional class, you can reuse its code in a new class. This minimizes code duplication, which not only saves time and effort but also makes your new code shorter, cleaner, and easier to read. Additionally, since the original class (base class) is already functional and bug-free, it reduces the risk of introducing new bugs in your project.

Another important aspect is that you don’t need the source code of the base class. As long as you have the compiled bytecode, you can extend and reuse the base class. This is common in libraries or frameworks where you extend pre-existing classes without modifying their code.

• Example: When you create a new class ElectricCar that inherits from Car, it reuses methods like start(), stop(), and openTrunk() but can add its own specific functionality such as chargeBattery(). Thus, inheritance reduces code repetition and promotes code reuse across the hierarchy.

class ElectricCar extends Car {
    public void chargeBattery() {
        System.out.println("Battery charging");
    }
}

3. Redefining (Overriding) Existing Behavior

If the base class provides functionality that isn’t quite right for the new subclass, inheritance allows you to redefine or override the behavior of existing methods. This is particularly useful in scenarios where you want to maintain the interface of the base class but modify the implementation for specialized cases.

• Example: The start() method for an ElectricCar might work differently than for a Vehicle. You can override the start() method in ElectricCar while still keeping the general contract (method signature) the same, making it seamless for users of the ElectricCar class.

class ElectricCar extends Car {
    @Override
    public void start() {
        System.out.println("Electric car started silently");
    }
}

4. Evolutionary and Organic Growth of Programs

Programs evolve over time as new requirements emerge and existing ones change. Inheritance supports this evolutionary growth by enabling you to build new classes and add new features progressively, without having to rewrite or restructure large parts of the existing codebase. This gradual process allows you to experiment and expand the functionality in manageable steps, reducing the risk of introducing major bugs or regressions.

Instead of attempting to create the entire program from scratch (which is unrealistic in complex systems), the program “grows” through the addition of new classes and features as needed. This organic development ensures that the system remains flexible and adaptable, while still leveraging the power of inheritance to maintain order in the hierarchy.

5. Refining Class Hierarchies

Over time, as your system grows, you might realize that certain classes share more in common than originally thought. Inheritance allows you to refactor your classes into more sensible hierarchies. For example, you may combine functionality or extract common traits into base classes, ensuring a cleaner, more maintainable design.

After the initial development phases, you might revisit your class hierarchy to collapse redundant or overlapping features into a streamlined structure. Inheritance simplifies this process since functionality is already encapsulated in classes and can be reorganized without rewriting entire components.

Other Code Reuse Mechanisms

Java facilitates code reuse at two levels: source code level and bytecode level. These levels allow for flexibility in how developers can reuse existing code depending on whether they have access to the original source code or not. Here’s how each works:

1. Source Code Level Reuse

At the source code level, reuse is only possible if the source code is available. This type of reuse is implemented using generic functions and generic classes in Java. Generics allow developers to write generalized code that can work with any data type, and the compiler creates specific implementations based on the types provided at runtime.

• Generics: Generics let you write methods or classes that operate on objects of various types while providing type safety at compile time. This feature avoids code duplication and promotes code reuse for different data types without the need to manually write code for each type.

Example:

public class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

Box<Integer> intBox = new Box<>();
Box<String> strBox = new Box<>();

Since the source code has to be available for the compiler to generate specific implementations, this is known as source code level reuse. If the source code isn’t accessible, then creating specialized functions or classes isn’t possible with generics.

2. Bytecode Level Reuse

Bytecode level reuse doesn’t require access to the source code, allowing developers to reuse precompiled classes or libraries without needing their original source code. There are two primary mechanisms for bytecode level reuse in Java: containership and inheritance.

a. Containership (Composition)

Containership, also known as composition, refers to one class containing objects of another class. It is used when there is a “has-a” relationship between classes, meaning one class is composed of the other class as part of its structure.

• Example: In the case of Employee and Address classes, an employee “has an” address, so the Employee class would contain an instance of the Address class.

class Address {
    String street, city, country;
    // Constructor and other methods
}

class Employee {
    String name;
    Address address;  // Employee "has an" Address
    // Constructor and other methods
}

Containership allows code reuse without modifying or having the source code of the contained class, as it works with precompiled bytecode.

b. Inheritance

Inheritance represents an “is-a” relationship between classes. It allows a new class to inherit the properties and behavior of an existing class, making it possible to reuse code by extending existing functionality.

• Example: In the case of Window and Button classes, a button “is a” type of window, so the Button class can inherit from the Window class.

class Window {
    // Window properties and methods
}

class Button extends Window {
    // Additional Button properties and methods
}

Inheritance enables code reuse at the bytecode level, as the subclass can extend a precompiled base class without needing access to the source code of the base class.

When to Use Containership vs. Inheritance

• Containership (Composition) should be used when there is a “has-a” relationship between classes. This is more flexible and promotes loose coupling, as it allows the contained class to evolve independently of the containing class.
• Inheritance should be used when there is an “is-a” relationship, where the subclass represents a specialized form of the base class. Inheritance tightly couples the subclass to the base class, and changes to the base class can impact the subclass.

Summary

• Source code level reuse (with generics) requires the source code to create specific implementations of generalized classes or functions.
• Bytecode level reuse (with containership or inheritance) does not require the source code, as it allows for reusing existing compiled classes by either composing objects or extending classes.

By supporting both levels of reuse, Java makes it easier for developers to build robust, modular, and maintainable systems, regardless of whether they have access to the source code or just the bytecode.