Inheritance : MCQs & PYQs with Explanation

Option D

In Java, the final keyword is used to restrict modification and ensure immutability where needed. A method declared as final cannot be overridden in subclasses, which helps in maintaining consistent behavior.

class Parent {
    final void show() {
        System.out.println("This is a final method");
    }
}
class Child extends Parent {
    void show() {}  // Compile-Time Error.
}

A class declared as final cannot be inherited, which is useful for creating immutable classes or preventing extension.

final class MyClass {
    int value = 100;
}

class NewClass extends MyClass { }  //Compile-Time Error.

If a variable is declared final, its value cannot be changed, regardless of whether it is inside a final method.

final int p = 33;
final void modifyValue() {
    p = 20; //Compile-Time Error.
}

The finalize() method in Java is a special method of the Object class that is called by the garbage collector before an object is removed from memory. It can be used to perform cleanup tasks, such as closing file streams, releasing network connections, or freeing other system resources held by the object.

class MyClass {
    protected void finalize()throws Throwable {
        System.out.println("Object is being Garbage Collected");
    }
}

Option B

In Java, constructors are special methods used to initialize objects when they are created. When dealing with inheritance, constructors follow a specific order to ensure that the parent class is properly initialized before the child class. 
If a class A is a superclass, B is a subclass of A, and C is a subclass of B, then creating an object of class C triggers constructor calls in a Top-Down order, starting from the highest superclass down to the actual subclass.
This happens because the subclass constructor implicitly calls the constructor of its parent class using the super().

class A {
    A() {
        System.out.println("Constructor of Class A.");
    }
}
class B extends A {
    B() {
        System.out.println("Constructor of Class B.");
    }
}
class C extends B {
    C() {
        System.out.println("Constructor of Class C.");
    }
}
public class Main {
    public static void main(String args[]) {
        C obj = new C();
    }
}
OUTPUT
Constructor of Class A.
Constructor of Class B.
Constructor of Class C.

Option B

In Java, a Base Class (Parent Class or Super Class) is a class whose properties and methods are inherited by other classes. It serves as a foundation from which new classes (derived classes or subclasses) can extend functionality. This helps in reusing common code, reducing duplication, and implementing object-oriented feature like inheritance.
Syntax:
    class BaseClass
    {
        ……………..;
        ……………..;
    }
    class DerivedClass extends BaseClass
    {
        ……………..;
        ……………..;
    }

Option B

To inherit a class, Java provides the extends keyword, which indicates that the subclass will acquire all non-private (private members are never inherited) fields and methods of the superclass.

Option D

When a class inherits another class using the extends keyword, it can reuse or modify the methods of the parent class. This concept is called inheritance.
Java also supports Method Overriding, which allows a subclass to provide its own implementation of a method defined in the parent class. 
When a method is overridden, the version of the method that belongs to the actual object (not the reference type) is called at runtime, this is known as Runtime Polymorphism.
In the given code, the Vehicle class has a method move() that prints "Vehicle is moving". The Car class extends Vehicle and overrides the move() method to print "Car is moving".
In the main method, a reference of type Vehicle is used to create an object of type Car: Vehicle v = new Car();. When v.move() is called, Java checks the actual object type at runtime, sees that it is a Car, and executes the overridden move() method in the Car class. Therefore, the program prints "Car is moving".