Java Programming Inheritance And Method Overriding Complete Guide

Top 10 Questions and Answers on Java Programming: Inheritance and Method Overriding

1. What is Inheritance in Java?

Example:

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    // Inherits the eat() method from Animal
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // Output: This animal eats food.
    }
}

2. What is Method Overriding in Java?

Answer:
Method overriding in Java occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method in the subclass must have the same name, return type, and parameters as the method in the superclass. Method overriding is a fundamental concept for runtime polymorphism.

Example:

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        myAnimal.makeSound(); // Output: Animal makes a sound
        myDog.makeSound();     // Output: Dog barks
    }
}

3. Can a Private Method in a Superclass be Overridden by a Subclass?

Answer:
No, a private method in a superclass cannot be overridden by a subclass. Since private methods are not accessible outside the class where they are defined, they cannot be seen by subclasses and, hence, cannot be overridden. A subclass can define a method with the same signature as a private method in a superclass, but it does not constitute method overriding.

Example:

class SuperClass {
    private void display() {
        System.out.println("SuperClass method");
    }
}

class SubClass extends SuperClass {
    // This is not overriding but a new method in SubClass
    void display() {
        System.out.println("SubClass method");
    }
}

4. What is the Benefit of Using Inheritance in Java?

Answer:
The primary benefits of using inheritance in Java are:

• Code Reusability: Inherited fields and methods reduce the need to write duplicate code, making development faster.
• Hierarchy Management: Inheritance helps in defining a clear hierarchical structure between classes, which is useful for categorization and logical grouping.
• Maintainability: Changes made to a method in a superclass are automatically reflected in all subclasses, which simplifies maintenance and updates.

5. What is the Use of super Keyword in Java?

Answer:
The super keyword in Java is used to refer to the immediate parent class of the current class. It can be used to:

• Access the non-static data members of the superclass.
• Access the methods of the superclass (useful when the subclass and superclass have methods with the same name).
• Call the constructor of the superclass (using super()).

Example:

class SuperClass {
    String name;

    SuperClass(String name) {
        this.name = name;
    }

    void display() {
        System.out.println("Name from SuperClass: " + name);
    }
}

class SubClass extends SuperClass {
    String name;

    SubClass(String name) {
        super(name); // Calls the constructor of SuperClass
        this.name = name;
    }

    void display() {
        super.display(); // Calls the display() method of SuperClass
        System.out.println("Name from SubClass: " + this.name);
    }
}

public class TestSuper {
    public static void main(String[] args) {
        SubClass myObj = new SubClass("Java");
        myObj.display();
        // Output:
        // Name from SuperClass: Java
        // Name from SubClass: Java
    }
}

6. Can a Subclass Override a Static Method in Java?

Answer:
Static methods cannot be overridden in Java. However, they can be hidden by a subclass, meaning that the subclass can provide a method with the same name and signature that seems to override it. This is called method hiding, not overriding.

Example:

class SuperClass {
    static void staticMethod() {
        System.out.println("Static method from SuperClass");
    }
}

class SubClass extends SuperClass {
    static void staticMethod() {
        System.out.println("Static method from SubClass");
    }
}

public class TestStaticMethod {
    public static void main(String[] args) {
        SuperClass.staticMethod(); // Output: Static method from SuperClass
        SubClass.staticMethod();   // Output: Static method from SubClass
    }
}

7. What is the Difference Between Overloading and Overriding in Java?

Answer:
Overloading and overriding are two mechanisms in Java for reusing methods, but they serve different purposes.

• Overloading (Compile-time Polymorphism): It occurs when two or more methods in the same class have the same name but different parameters (different type, number, or both). The method to be invoked is determined at compile time based on the method signature.

• Overriding (Runtime Polymorphism): It occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method to be invoked is determined at runtime, depending on the object being referred to.

Example of Overloading:

class MathOperations {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

Example of Overriding:

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

8. What are the Rules for Method Overriding in Java?

Answer:
The rules for method overriding in Java are as follows:

• Signature: The method in the subclass must have the same name, return type, and parameters as the method in the superclass.
• Access Level: The method in the subclass must have the same or a broader access level than the method in the superclass. For example, a private method cannot be overridden as it is not accessible.
• Exception Handling: The method in the subclass cannot throw a new or broader checked exception than the method in the superclass. It can throw fewer, narrower, or no exceptions.
• Final Methods: Methods marked with the final keyword cannot be overridden.
• Abstract Methods: Abstract methods must be overridden in the subclass.

Example:

class SuperClass {
    void display() throws IOException {
        System.out.println("SuperClass method");
    }
}

class SubClass extends SuperClass {
    @Override
    void display() throws FileNotFoundException { // Okay, since it's narrower
        System.out.println("SubClass method");
    }
}

9. Can a Subclass Override a Constructor?

Answer:
No, constructors cannot be overridden in Java. Constructors are not inherited, and each class must define its own constructors. However, a subclass can invoke the constructor of its superclass using the super() call.

Example:

class SuperClass {
    SuperClass() {
        System.out.println("SuperClass Constructor");
    }
}

class SubClass extends SuperClass {
    SubClass() {
        super(); // Calls the constructor of SuperClass
        System.out.println("SubClass Constructor");
    }
}

public class TestConstructor {
    public static void main(String[] args) {
        SubClass myObj = new SubClass();
        // Output:
        // SuperClass Constructor
        // SubClass Constructor
    }
}

10. What is a Concrete Method in Java?

Answer:
A concrete method in Java is a method that has an implementation or a body. Unlike abstract methods, which do not have an implementation and must be overridden by subclasses, concrete methods contain the actual code that defines the behavior of a method.

Example:

class Animal {
    void eat() { // This is a concrete method
        System.out.println("Animal eats food");
    }

    void breathe(); // This is an abstract method (compiler error, needs abstract class)
}

In Java, a class can have both abstract and concrete methods. If a class has at least one abstract method, it must be declared as an abstract class.

Example: