CBSE Class 12 Informatics Practices Concept Of Inheritance Worksheet

Inheritance: It is the capability of one class to derive properties from another class.

Need for Inheritance:

1. It ensures closeness with real-world models.

2. Reusability

3. Transitive nature of inheritance

Subclass & Super Class: The class being inherited is called super class or base class and the inheriting class is called sub class or inherited class. Thus subclass derives some features (data members and methods) from its super class.

Forms of Inheritance

• Single Inheritance: A Subclass inherits from only one base class.

• Multiple Inheritance: A subclass inherits from multiple base classes (not supported by Java).

• Hierarchical Inheritance: Many subclasses inherit from a single base class.

• Multilevel Inheritance: A subclass inherits from a class that itself inherits from another class.

This shows transitive nature of inheritance.

• Hybrid Inheritance: Here a sub class inherits from multiple base classes and all of its base classes inherit from a single base class.

Defining Derived class:

Class _{extends {}

: // members of sub class}

Function Overloading: A function name having several definitions in the same scope that are differentiable by the number or types of their arguments (i.e. same name but different signature), is said to be an overloaded function. Functions with same name and same signature but different return type are not allowed. Functions with same name and signature are treated as re-declaration of first.

Need for Function Overloading: To cope with the changing behavior in different situations.

Declaration and Definition:

double a =0.0, b = 5.4, c = 8.9;

int d = 0, e = 5, f = 8;

a = sum(b,c);

d = sum(e,f);

System.out.println(a + "," + d);

int sum( int a, int b){                                 //func 1

return (a+b); }

double sum( double x, double y){             //func 2

return (x+y); }

Example of Inheritance and constructors

package a;

class person {

int j = 4;

private int i = 5;

protected String name;

public String address;

person (String name, String address) {

this.name = name ;

this.address = address ; }

}

class student extends person { //can’t access i

int rolno ; int j = 1;

student (String name, String address, int rolno){

super(name, address);

this. rolno = rolno ; }

public void display () {System.out.println(j + “, ” + super.j);} }

// j of class person is hidden

class employee extends person{

String dept;

employee (String name, String address, String dept) {

super(name, address);

this.dept = dept; }}

class professor extends employee{

String inst;

professor(String name, String address, String dept, String inst) {

super(name, address, dept);

this. institute = inst; }}

class p { }             // can’t access i,

package b;

class q { }

Sample Questions:

1. What is inheritance? Discuss its various forms.

2. Define base class and derived class. How are these related?

3. How does the visibility mode control the access of members in the derived class? Explain with examples.

Concept of Inheritance

Inheritance refers to the mechanism by which one class can acquire the attributes and behaviors of another class.

Need for Inheritance:

• It allows programs to closely mimic actual real-world scenarios.
• It supports the reuse of existing code.
• It exhibits a transitive nature, allowing multi-level hierarchies.

Subclass and Superclass:

The class whose features are being passed down is referred to as the superclass or base class. Conversely, the class that receives these features is known as the subclass or derived class. Consequently, a subclass acquires specific variables and methods from its parent class.

Forms of Inheritance:

• Single Inheritance: A single child class derives directly from a single parent class.
• Multiple Inheritance: A single child class attempts to derive from more than one parent class (which Java does not support directly).
• Hierarchical Inheritance: Several different child classes extend from one parent class.
• Multilevel Inheritance: A child class extends a parent class that itself extends another class, demonstrating transitive behavior.
• Hybrid Inheritance: This is a combination of two or more types of inheritance, such as where a subclass inherits from multiple parent classes that share a common ancestor.

Defining a Derived Class:

class <sub class name> extends <super class name> { 
    // members of sub class
}

Function Overloading:

Function overloading occurs when multiple methods within the same scope share an identical name but possess different parameter lists (either in count or data types). This is referred to as having unique signatures. Note that changing only the return type while keeping the same parameters is not permitted, as the system will view this as an invalid duplicate declaration.

Need for Function Overloading:

This is useful for handling varied behaviors depending on different situations and input types.

Declaration and Definition Example:

double a = 0.0, b = 5.4, c = 8.9; 
int d = 0, e = 5, f = 8; 
a = sum(b, c); 
d = sum(e, f); 
System.out.println(a + "," + d); 

int sum(int a, int b) { // func 1 
    return (a + b); 
} 

double sum(double x, double y) { // func 2 
    return (x + y); 
}

Example of Inheritance and Constructors:

package a; 

class person { 
    int j = 4; 
    private int i = 5; 
    protected String name; 
    public String address; 

    person(String name, String address) { 
        this.name = name; 
        this.address = address; 
    } 
} 

class student extends person { // can't access i 
    int rolno; 
    int j = 1; 

    student(String name, String address, int rolno) { 
        super(name, address); 
        this.rolno = rolno; 
    } 

    public void display() { 
        System.out.println(j + ", " + super.j); 
    } 
} // j of class person is hidden 

class employee extends person { 
    String dept; 

    employee(String name, String address, String dept) { 
        super(name, address); 
        this.dept = dept; 
    } 
} 

class professor extends employee { 
    String inst; 

    professor(String name, String address, String dept, String inst) { 
        super(name, address, dept); 
        this.inst = inst; 
    } 
} 

class p { } // can't access i 

package b; 

class q { }

Question 1. What is inheritance? Discuss its various forms.
Answer: Inheritance is a fundamental mechanism in object-oriented programming that permits a class to acquire the properties and methods of another class. This fosters code reuse and establishes a hierarchical relationship.
The primary types of inheritance include:
- Single Inheritance: A single derived class inherits directly from a single base class.
- Multiple Inheritance: A derived class extends more than one base class. This is not supported in Java.
- Hierarchical Inheritance: Multiple derived classes inherit from a single base class.
- Multilevel Inheritance: A subclass inherits from another subclass, creating a chain where a class extends a class that already extends a parent class.
- Hybrid Inheritance: A combination of two or more types of inheritance within a single program structure.
In simple words: Inheritance lets a new class copy and use the code from an existing class. It comes in different types depending on how classes are linked together.

Exam Tip: When discussing inheritance forms, clearly state that Java does not support multiple inheritance with classes, as this is a highly tested concept in exams.

Question 2. Define base class and derived class. How are these related?
Answer: A base class, often called a superclass, is the existing class whose features and methods are inherited. A derived class, or subclass, is the new class that inherits those features from the base class.
These two classes are related through a parent-child relationship (known as an "is-a" relationship). The derived class extends the functionality of the base class by acquiring its attributes and methods, while also having the option to add its own specific features.
In simple words: A base class is like a parent, and a derived class is like a child. The child class automatically gets everything the parent class has.

Exam Tip: Always use terms like "superclass" and "subclass" or "parent" and "child" to demonstrate a clear understanding of the hierarchy.

Question 3. How does the visibility mode control the access of members in the derived class? Explain with examples.
Answer: Visibility modes, or access specifiers, determine how the members of a superclass are accessed within a subclass:
1. Private Members: Members declared as private (such as private int i) are not accessible by any subclass.
2. Default (Package-Private) Members: Members with no modifier are accessible only within subclasses that belong to the same package.
3. Protected Members: Members declared with the protected keyword are accessible by subclasses, regardless of whether they reside in the same or a different package.
4. Public Members: Public members are fully accessible by any subclass in any package.

For instance, in the provided code, class student extends person. The private variable i in person cannot be accessed inside student. However, the variable j (default access) and address (public access) are fully accessible. If a subclass has a member with the same name as a superclass member (like variable j), the superclass variable becomes hidden. The subclass can still access it using the super keyword, as seen in super.j.
In simple words: Access modifiers decide which parts of a parent class are visible to its child class. Private parts stay completely hidden, while public and protected parts are shared.

Exam Tip: Be prepared to show how the super keyword is used to access hidden parent variables, as this is a common practical question.