Week 6

Inheritance, method overriding, class Object

Definition

Inheritance

Official Java documentation definition for Inheritance

Official Java documentation definition for Class Object

Inheritance is a fundamental concept in object-oriented programming where one class can inherit (or "take") properties and methods (behaviors) from another class. The class that shares its attributes and methods is called the parent class (also known as superclass, base class, or ancestor class). The class receiving these attributes and methods is called the child class (also known as subclass, derived class, or descendant class).

Using inheritance allows programmers to reuse code efficiently, avoid duplication, and build organized class structures.

In Java, every class created automatically inherits from a built-in class called java.lang.Object. This means the Object class acts as the ultimate ancestor (root class) for every class in Java, providing fundamental methods (like toString(), equals(), and hashCode()) which all Java objects inherently possess.

When a class is defined without explicitly inheriting from another class, Java automatically makes it a subclass of Object.

To create inheritance between classes, the new keyword extends is used :

class ChildClass extends ParentClass {
    // Child class will inherit methods and properties of ParentClass
}

• Here, ChildClass becomes the subclass (or child class), and ParentClass becomes the superclass (or parent class).
• The child class can directly access the non-private methods and attributes of the parent class.

In short, inheritance simplifies programming work by enabling developers to create specialized versions of general classes, while Java ensures all classes have a common starting point through java.lang.Object. Also if the class needs to inherit and implement interfaces at the same time, then the parent class must be specified first, followed by the interfaces to be implemented:

 
class ChildClass extends ParentClass implements ExampleInterface {…}

Now we can move on to an example (new comand super()) :

In this example, we model a banking system with a base class for bank accounts and one derived class for different types of accounts.

 
class BankAccount {
    protected String accountNumber;
    protected double balance;
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
    //Getters
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    //Setters
    public void setAccountNumber(String accountNumber) {
        this.accountNumber = accountNumber;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public double calculateMonthlyInterest() {
        // Default implementation (for non-interest accounts)
        return 0.0;
    }
}

---

class SavingsAccount extends BankAccount {
    private double annualInterestRate; 
    public SavingsAccount(String accountNumber, double balance, double annualInterestRate) {
        super(accountNumber, balance);
        this.annualInterestRate = annualInterestRate;
    }
}

We created a class BankAccount that held basic information about an account, such as an account number and balance. It also provided methods like showBalance() to display the current balance and calculateMonthlyInterest() which, in the base class, returned 0.0 because not every account was designed to earn interest.

Next, we created a SavingsAccount class that extended BankAccount. This meant that SavingsAccount automatically inherited all public and protected fields and methods from BankAccount. For example, it could use the showBalance() method without needing to rewrite it. This is one of the key benefits of inheritance: code reuse, which helped avoid duplication and kept the code cleaner.

The constructor of the SavingsAccount class accepted three parameters: the account number, balance, and an additional field called annualInterestRate. Inside its constructor, it explicitly called the parent’s constructor using super(…) and the parameters that we want to inherite (accountNumber, balance). This call was essential because it initialized the inherited fields in a consistent way, using the logic already defined in the BankAccount class. After calling super(), the constructor then set the annualInterestRate specific to the SavingsAccount.

If a constructor was not specified in a child class, Java would have automatically generated a default constructor that called the parent's no-argument constructor. However, in this case, since BankAccount did not have a no-argument constructor (the constructor we have requires an account number and balance), it was necessary to explicitly define a constructor in SavingsAccount to call the appropriate BankAccount constructor. For example, if BankAccount had had a no-argument constructor, one could have omitted the constructor in SavingsAccount and relied on the default one, but that was not possible here.

In situations when the superclass have multiple constructors, there is the flexibility to choose which one to call in the child class by passing the appropriate arguments in the super() call. This allowed the parent part of the object to be initialized using different initialization strategies based on the needs.

The IDE could be used to generate suitable constructors automatically. For IntelliJ, one could use the Generate option from the Code menu or Alt + Insrert button combination.

It's worth noting that the generated subclass inherits all the properties of the superclass, but only those fields and methods that do not have a private delimiter can be used directly from the subclass. In order to access the private fields of the superclass, either the necessary get methods must be added to the superclass, or the program must be arranged so that no private fields need to be accessed from the subclass.

Definition

Method overriding (new command @Override )

Method overriding is an essential concept in object-oriented programming, where a subclass provides a specific implementation of a method that is already defined in its superclass (like public double calculateMonthlyInterest()). In other words, the subclass modifies or customizes the behavior of the inherited method to meet its own requirements. Method overriding helps programmers achieve flexibility, as different subclasses can implement methods differently while sharing the same method name and parameters. It is considered one form of polymorphism—an important principle in object-oriented programming—allowing methods to perform different functions depending on the object that invokes them. Through method overriding, classes can maintain a consistent interface while offering distinct behaviors.

For example:

 
class SavingsAccount extends BankAccount {
    private double annualInterestRate; 
    public SavingsAccount(String accountNumber, double balance, double annualInterestRate) {
        super(accountNumber, balance);
        this.annualInterestRate = annualInterestRate;
    }
    @Override
    public double calculateMonthlyInterest() {
        // Calculate interest based on the current balance and annual rate divided by 12
        return getBalance() * (annualInterestRate / 12);
    }
}

In this updated example, the SavingsAccount class provided its own version of the calculateMonthlyInterest() method, thereby overriding the one defined in the BankAccount superclass. Originally, the BankAccount class’s implementation of calculateMonthlyInterest() simply returned 0.0 because it served as a generic placeholder for accounts that did not earn interest. However, the SavingsAccount class needed a more specific calculation for interest accumulation.

To cover all superclass methods they must be neither static nor private. It is a good idea to add an @Override annotation in front of the overridden methods (intellij adds it automatically). The annotation has no effect on the behavior of the program - it is merely a hint to the compiler that the programmer intended the method to be overridden. If the compiler discovers that there is no method with the same signature(name and parameter) in the superclass, it will refuse to compile the code.

Definition

Dynamic Binding

What happens if we call a method on an object, but that method is defined only in a parent class — or also in both the parent and the child class?

This is where dynamic binding comes in.

Dynamic binding means that Java decides at runtime which version of a method to run — based on the actual class of the object, not just the type of the variable.

If the method is overridden in the child class, that version is used. If it's not overridden, Java searches up the inheritance chain until it finds the method.

 
class Animal {
    public String speak() {
        return "Some generic animal sound";
    }
}
class Cat extends Animal {
    // No speak() method here
}
class Kitten extends Cat {
    // Also no speak() method here
}
public class Main {
    public static void main(String[] args) {
        Kitten myPet = new Kitten();
        System.out.println(myPet.speak()); // Output: Some generic animal sound
    }
}

*Note that a subclass commonly overrides a method, but sometimes the parent version of the method is still needed. In such cases, the parent method can be called using super.methodName().

Definition

Abstract class

Official Java documentation definition

An abstract class in Java serves as a blueprintfor other classes. It provides a foundation by defining common properties and behaviors that related classes share, yet it cannot be instantiated on its own. Essentially, an abstract class can include implemented methods and state (fields), as well as declare abstract methods—methods without an implementation—that its subclasses must complete. This makes it ideal when there is a strong “is-a” relationship among classes. For example, consider a generic BankAccount class that contains shared attributes like account number and balance along with methods for depositing funds, then specific account types such as SavingsAccount or CheckingAccount can extend this abstract class to add their unique behavior.

In contrast, an interface defines a contract by listing method signatures that implementing classes must provide. Interfaces typically do not contain any state or complex behavior, though they may include default methods with implementations in modern Java. They are used to specify common capabilities that can be adopted by any class, even if those classes do not share a common ancestry. For instance, an interface called Controllable might declare methods such as turnOn() and turnOff() that various electronic devices (like televisions, radios, or computers) would implement.

In terms of design and usage, abstract classes are best suited for situations where a group of classes share significant commonalities in both behavior and state—like different types of bank accounts that all inherit from a BankAccount. On the other hand, interfaces are appropriate when ensuring that diverse classes implement a specific set of methods, regardless of their position in the class hierarchy.

 
//End resault example:

import java.time.LocalDate;
public class EmployeeTest {
    public static void main(String[] args) {
        // Create a full-time employee with a hire date 5 years ago, a base salary, and a bonus percentage.
        FullTimeEmployee fullTime = new FullTimeEmployee("Alice", LocalDate.now().minusYears(5), 60000, 0.02);

        // Create a part-time employee with a hire date 2 years ago, an hourly rate, and a fixed number of hours worked in a month.
        PartTimeEmployee partTime = new PartTimeEmployee("Bob", LocalDate.now().minusYears(2), 0, 10, 80);

        // Print employee details using the overridden toString() method.
        System.out.println(fullTime);
        System.out.println(partTime);
    }
}

Please leave your feedback on the materials