UNIT 3 Array in C#

 Inheritance

Inheritance can be defined as the process where
one class acquires the properties (methods and fields) of another(parent). It is an
important part of OOP. The class which inherits
the properties of other is known as subclass (derived class, child class) and
the class whose properties are inherited is known as superclass (base class,
parent class).
extends is the keyword used to inherit the
properties of a class. Following is the syntax of extends keyword.

Syntax
class Super {
   .....
....
}
class Sub extends Super {
   .....
   .....
}

Types of Inheritance
Java supports the following four types of inheritance:
○       Single Inheritance

○       Multi-level Inheritance

○       Hierarchical Inheritance

○       Hybrid Inheritance
Single Inheritance
In single inheritance, a sub-class is derived from only one super class. It inherits the properties and
behavior of a single-parent class. Sometimes it is also known as simple inheritance.

Example:
class Employee {
    void display() {
        System.out.println("I am an Employee");
    }
}
class Executive extends Employee {
    void show() {
        System.out.println("I am an Executive");
    }
}
public class Main {
    public static void main(String[] args) {
        Executive e = new Executive();
        e.display(); // from Employee
        e.show();    // from Executive
    }
}
Multi-level Inheritance
In multi-level inheritance, a class is derived from a class which is
also derived from another class is called multi-level inheritance. In simple
words, we can say that a class that has more than one parent class is called
multi-level inheritance.
Example:
class Student {          // Super class
 void studentInfo() {
        System.out.println("This is Student class");
    }
}
class Marks extends Student {   // Intermediate subclass
    void marksInfo() {
        System.out.println("This is Marks class");
    }
}
class Sports extends Marks {    // Derived class
    void sportsInfo() {
        System.out.println("This is Sports class");
    }
}
public class Main {
    public static void main(String[] args) {
        Sports s = new Sports();
        s.studentInfo();  // from Student class
        s.marksInfo();    // from Marks class
        s.sportsInfo();   // from Sports class
    }
}


Hierarchical Inheritance
If a number of classes arederived from a single base class, it is called hierarchical inheritance.

// Superclass
class Student {
    void display() {
        System.out.println("I am a Student");
    }
}

// Subclass 1
class Science extends Student {
    void show() {
        System.out.println("I am a Science Student");
    }
}

// Subclass 2
class Commerce extends Student {
    void show() {
        System.out.println("I am a Commerce Student");
    }
}

// Subclass 3
class Arts extends Student {
    void show() {
        System.out.println("I am an Arts Student");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Science s = new Science();
        Commerce c = new Commerce();
        Arts a = new Arts();

        s.display();
        s.show();

        c.display();
        c.show();

        a.display();
        a.show();
    }
}

Hybrid Inheritance
Hybrid means consist of more than one. Hybrid inheritance is the combination of two or more types of
inheritance.
Example:
class GrandFather {
    void showGrandFather() {
        System.out.println("I am GrandFather.");
    }
}

// Father inherits GrandFather (Single Inheritance)
class Father extends GrandFather {
    void showFather() {
        System.out.println("I am Father.");
    }
}

// Hierarchical Inheritance: Father → Son and Father → Daughter
class Son extends Father {
    void showSon() {
        System.out.println("I am Son.");
    }
}

class Daughter extends Father {
    void showDaughter() {
        System.out.println("I am Daughter.");
    }
}

// Hybrid Inheritance is demonstrated by combination of above relations

public class FamilyInheritance {
    public static void main(String[] args) {

        System.out.println("--- Son's Family ---");
        Son s = new Son();
        s.showGrandFather(); // Inherited from GrandFather
        s.showFather();      // Inherited from Father
        s.showSon();         // Own method

        System.out.println("\n--- Daughter's Family ---");
        Daughter d = new Daughter();
        d.showGrandFather(); // Inherited from GrandFather
        d.showFather();      // Inherited from Father
        d.showDaughter();    // Own method
    }
}