Java Inheritance : Essential OCA Java 8 Tips & Tricks

In this article, we’ll delve into the key aspects of Java inheritance, offering essential tips and tricks for those preparing for the OCA Java 8 certification exam. Whether you’re new to inheritance or looking to solidify your understanding, this guide has you covered.

Why Use Inheritance?

Inheritance is one of the pillars of object-oriented programming (OOP). It enables a new class, known as a subclass, to inherit properties and behaviors (fields and methods) from an existing class, referred to as the superclass. This concept promotes code reuse and establishes a natural hierarchy among classes, making it easier to manage and extend complex applications. Java Inheritance

• Code Reuse: By inheriting from a superclass, subclasses can reuse code, reducing redundancy and maintenance effort.
• Polymorphism: Inheritance supports polymorphism, allowing a single method to perform different behaviors based on the object’s actual type.
• Natural Hierarchy: It helps in creating a natural class hierarchy, making it easier to manage and understand the code structure.

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

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // Inherited method
        myDog.bark(); // Subclass method
    }
}

In this article, we won’t be discussing inheritance in detail. If you are not familiar with the concept, please take some time to familiarize yourself with it before returning to this article for some common tips on the OCA Java 8 exam!

I strongly encourage you to read this article.

Essential Tricks for Exam Success in Java Inheritance

In this section, we will cover some amazing tricks frequently employed by exam creators. These tricks include the constructor execution order when dealing with an inheritance hierarchy, the usage of the this keyword and this() method, as well as super and super(). We will finish this section with tricks related to the initialization of final fields in a constructor.

Java Inheritance And Constructor Execution Order

This is one of the simplest tricks when dealing with inheritance questions, but most people find it a little bit confusing. This is why I wrote a separate section to tackle it independently.

Let’s start with a simple example to illustrate the idea:

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

class B extends A {
    B() {
        System.out.println("in B Constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        B b = new B();  // Creating an object of type B
    }
}

Creating an object of type B (invoking the B constructor) will result in the invocation of the A constructor.

Output:

in A Constructor 
in B Constructor

But Why?

Even though there is no explicit call to the A constructor from the B constructor, it gets called automatically. This is because the Java compiler implicitly inserts a super() call as the first line of the B constructor.

To further illustrate this behavior, consider the following equivalent code snippets:

class A extends X {
    // No constructor defined; the default no-arg constructor is used.
}

class A extends X {
    A() {
        System.out.println("in A Constructor");
    }
}

class A extends X {
    A() {
        super();  // Explicitly calling the superclass constructor
        System.out.println("in A Constructor");
    }
}
// Assuming X has a no-arg constructor; otherwise, a compilation error will be thrown.

Top Compilation Errors Related to Java Inheritance

In Java inheritance, it’s crucial to understand how constructors are handled, especially when dealing with parent-child class relationships. In this example, a compilation failure occurs due to the way the Java compiler manages constructor calls. Specifically, the compiler implicitly adds a call to the default constructor of the parent class using the super() method. However, if the parent class has a constructor that takes parameters and does not define a no-argument constructor, the compiler refrains from adding a default constructor. As a result, a compilation error arises. To resolve this issue, we must either explicitly call the parent constructor using super(int) or define a no-argument constructor in the parent class.

Code Example:

class Parent {
    Parent(int value) {
        System.out.println("Parent Constructor with value: " + value);
    }
    // Uncommenting the following will resolve the compilation error
    // Parent() {
    //     System.out.println("Default Parent Constructor");
    // }
}

class Child extends Parent {
    Child() {
        // Compilation Error: cannot find symbol - method super() 
        // must call Parent constructor explicitly since no default constructor is available
        super(10);  // Explicitly calling Parent constructor with an argument
        System.out.println("Child Constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();  // Creating an instance of Child
    }
}

Output:

Parent Constructor with value: 10
Child Constructor

In this code example, the Child constructor explicitly calls the Parent constructor with an integer argument to avoid the compilation error that would arise if it relied on an implicit default constructor. This highlights the importance of constructor management in Java inheritance, ensuring that all required constructors are properly defined and invoked.

Ambiguity with the this Keyword Java Inheritance

In Java, the this keyword is essential for resolving ambiguity between class fields and method parameters when they share the same name. This often happens in constructors or methods where you want to initialize a class variable with the value passed in as a parameter. Without using this, the compiler wouldn’t know whether you’re referring to the class field or the parameter.

public class Person {
    private String name;

    // Constructor with parameter 'name'
    public Person(String name) {
        // Ambiguity: name refers to the parameter, not the field
        name = name; // This won't work as expected!
    }
}

In the above case, without this, the assignment name = name; doesn’t initialize the class variable. Instead, it just assigns the parameter to itself. To resolve this, we use this to explicitly refer to the class field:

public class Person {
    private String name;

    // Constructor with parameter 'name'
    public Person(String name) {
        this.name = name; // This correctly assigns the parameter to the class field
    }
}

Using this.name makes it clear that you’re referring to the class-level variable, avoiding ambiguity.

Using this() for Constructor Chaining Java Inheritance

In Java, the this() keyword is used to call another constructor from the same class. This is particularly useful when you have multiple constructors and want to avoid code duplication by reusing one constructor inside another. Using this() helps in chaining constructors, ensuring that common initialization logic is executed consistently.

For example:

public class Person {
    private String name;
    private int age;

    // Constructor with only 'name' parameter
    public Person(String name) {
        this.name = name;
        this.age = 0; // Default age
    }

    // Constructor with both 'name' and 'age' parameters
    public Person(String name, int age) {
        this(name); // Call the other constructor to avoid repetition
        this.age = age;
    }
}

In the above example, the constructor with both name and age calls the constructor that takes only name using this(name); This avoids repeating the same initialization statement.

Conclusion

In this article, we’ve explored the essential aspects of Java inheritance, highlighting its significance in object-oriented programming and providing key strategies for success in the OCA Java 8 certification exam.