Inheritance in Java

Explanation

This Java code demonstrates various forms of inheritance: class inheritance and interface inheritance, along with interface implementation. It defines a hierarchy of classes (A4, B4, C4) and interfaces (X, Y) to illustrate how properties (variables) and behaviors (methods) are passed down or enforced across this hierarchy.

1. Interface Definitions:

   • interface X declares a single abstract method called methodX(). Any class implementing X must provide a concrete definition for methodX().
   • interface Y extends X declares its own abstract method methodY() and also inherits methodX() from interface X. This means any class implementing Y must provide implementations for both methodX() and methodY().

2. Class Hierarchy:

   • class A4 is the base class, containing an integer variable a.
   • class B4 extends A4 implements Y is a crucial class. It extends A4, meaning it inherits the variable a. Additionally, it implements Y, which compels it to provide concrete implementations for methodX() (inherited from X via Y) and methodY() (declared in Y). It also introduces its own integer variable b.
   • class C4 extends B4 is the most derived class. It extends B4, inheriting everything from B4 (which includes everything from A4 and the method implementations for Y). It adds its own integer variable c.

3. Main Program (InterfaceProgram1):

   • The main method creates an object c1 of the C4 class.
   • It then proceeds to access and assign values to c1.a, c1.b, and c1.c. This is possible because c1 (an object of C4) inherits a from A4 (via B4) and b from B4, in addition to having its own c.
   • Next, it calls c1.methodX() and c1.methodY(). These methods are executed using the implementations provided in the B4 class, which C4 inherited.
   • Finally, the program prints the values of a, b, and c associated with the c1 object, demonstrating that all inherited and self-declared members are accessible and functional.

In essence, the code showcases how a single object (c1 of type C4) can possess properties and behaviors defined across multiple parent classes and interfaces through the power of inheritance and interface implementation.

Algorithm

The program follows these steps:

1. Define Interfaces: Declare interface X with methodX() and interface Y extending X with methodY().
2. Define Base Class: Create class A4 with an integer a.
3. Define Intermediate Class: Create class B4 that extends A4 and implements Y.
   • Declare an integer b in B4.
   • Provide concrete implementations for methodX() and methodY() within B4.
4. Define Derived Class: Create class C4 that extends B4.
   • Declare an integer c in C4.
5. Instantiate Object: In the main method, create an object c1 of type C4.
6. Assign Values: Assign integer values to the inherited variables c1.a, c1.b, and the local variable c1.c.
7. Invoke Methods: Call the inherited methods c1.methodX() and c1.methodY().
8. Print Values: Display the current values of c1.a, c1.b, and c1.c to the console.