Add multiple OOP-based implementations for average calculation.

- Implemented average calculation using basic multi-level class inheritance.
  > DemoA → DemoB → DemoC → DemoD
  > Variables x and y initialized in parent classes
  > calcAverage() in DemoC computes and prints the average

- Created an abstract class-based version.
  > Abstract class DemoBase holds variable x
  > Inherited through DemoB and DemoC, where calcAverage() is defined
  > DemoD extends DemoC and invokes the inherited logic

- Developed an interface-based implementation.
  > Defined AverageCalculator interface with method calcAverage()
  > DemoA implements the interface with a default message
  > Extended by DemoB and DemoC; DemoD overrides calcAverage() to compute average

- All examples demonstrate key OOP concepts: inheritance, abstraction, and polymorphism.

- Implement average calculation using:
  1. Basic multi-level class inheritance
  2. Abstract class as a base with derived classes
  3. Interface-based implementation with method overriding

- Demonstrates polymorphism and inheritance in different OOP styles.

Signed-off-by: Someshdiwan <Someshdiwan369@gmail.com>

Author: Someshdiwan

Section12Inheritance/src/Demo.java

@@ -0,0 +1,29 @@
+class DemoA
+{
+    int x = 5;
+}
+class DemoB extends DemoA
+{
+    int y = 7;
+}
+class DemoC extends DemoB
+{
+    double average = 0.0;
+    void calcAverage()
+    {
+        average = (x + y) / 2.0;
+        System.out.println(average);
+    }
+}
+class DemoD extends DemoC
+{
+    // Additional functionality can be added in DemoD if needed
+}
+class DemoE
+{
+    public static void main(String[] args)
+    {
+        DemoD objD = new DemoD();
+        objD.calcAverage();
+    }
+}

Section13AbstractClasses/src/Demo.java

@@ -0,0 +1,29 @@
+abstract class DemoBase
+{
+    int x = 5;
+}
+class DemoB extends DemoBase
+{
+    int y = 7;
+}
+class DemoC extends DemoB
+{
+    double average = 0.0;
+    void calcAverage()
+    {
+        average = (x + y) / 2.0;
+        System.out.println("Average: " + average);
+    }
+}
+class DemoD extends DemoC
+{
+
+}
+class Demo
+{
+    public static void main(String[] args)
+    {
+        DemoD objD = new DemoD();
+        objD.calcAverage();
+    }
+}

Section14Interfaces/src/Demo.java

@@ -0,0 +1,51 @@
+interface AverageCalculator
+{
+    void calcAverage();
+}
+
+class DemoA implements AverageCalculator
+{
+    int x = 5; //initialize the value of x is 5.
+
+    @Override
+    public void calcAverage() //Method for calculating Average.
+    {
+        System.out.println("Calculating average in DemoA");
+    }
+}
+
+class DemoB extends DemoA
+{
+    int y = 7;
+}
+
+class DemoC extends DemoB
+{
+
+}
+class DemoD extends DemoC implements AverageCalculator
+{
+    double average = 0.0;
+    @Override
+    public void calcAverage()
+    {
+        average = (x + y) / 2.0;
+        System.out.println("Average: " + average);
+    }
+}
+
+class Demo
+{
+    public static void main(String[] args)
+    {
+        DemoD objD = new DemoD();
+        objD.calcAverage();
+    }
+}
+/*
+AverageCalculator interface with a method calcAverage().
+DemoA implements it and gives a basic print message.
+DemoB and DemoC extend the hierarchy (inherit x and y).
+DemoD extends DemoC and overrides calcAverage() to calculate the average of x and y.
+In main(), an object of DemoD is created and calcAverage() is called.
+*/