This article explains how Java’s inheritance has an “is-a” relationship between superclasses and subclasses, allowing subclasses to inherit and customize superclass functionality. By using polymorphism, subclasses can define unique behaviors, allowing code reuse and flexibility in object-oriented programming.
Alexander S. Ricciardi
June 10, 2024
In Java, the relationship between super-classes (parent class) and subclasses (child class or derived class) in inheritance is a is-a relationship implying that the subclass is a specialized version of the superclass inheriting the functionality (restrictions can be applied) of a class that it is derived from (CSU Global, n.d). In other words, if class B inherits from class A, then class B "is a" type of class A. This relationship allows class B to use all the functionalities (restrictions can be applied) provided by class A, while also adding its own specific functionalities or/and by overriding some or all of the functionalities of class A. The ability of the child class to override functionality is a form of polymorphism.
“The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class” (The Java™ Tutorials, n.d.)This is especially beneficial when dealing with multiple objects from different subclasses that share a common superclass type.
For example: dogs, cats, and owls are animals:
Superclass
public class Animal {
public void makeSound() {
System.out.println("Makes a Sound");
}
}
Subclass of Animals
public class Domesticated extends Animal {
public void friendly() {
System.out.println("This animal is friendly.");
}
}
Subclass of Animals
public class Undomesticated extends Animal {
public void notFriendly() {
System.out.println("This animal is not friendly.");
}}Subclass of Domesticated
public class Undomesticated extends Animal {
public void notFriendly() {
System.out.println("This animal is not friendly.");
}
}
Subclass of Domesticated
public class Cat extends Domesticated {
@Override
public void makeSound() {
System.out.println("Meow");
}
}
Subclass of Undomesticated
public class Owl extends Undomesticated {
@Override
public void makeSound() {
System.out.println("Hoots");
}
}
Main class to output the result
public class inheritanceExample {
public static void main(String[] args) {
Dog myDog = new Dog();
Cat myCat = new Cat();
Owl redOwl = new Owl();
System.out.println("MY Dog:");
myDog.makeSound(); // Outputs: Bark
myDog.friendly(); // Outputs: This animal is friendly.
System.out.println();
System.out.println("My Cat:");
myCat.makeSound(); // Outputs: Meow
myCat.friendly(); // Outputs: This animal is friendly.
System.out.println();
System.out.println("Red Owl:");
redOwl.makeSound(); // Outputs: Hoot
redOwl.notFriendly(); // Outputs: This animal is not friendly.
}
}Note:The makeSound() methods in the Dog and Cat classes override the makeSound() method in the Animal class.
Additionally, the Dog class is a subclass of the Domesticated class which is a subclass of the Animal class.
Child of
In Java, a subclass can only have one superclass, for example, the Dog class cannot have a superclass Domesticated and a superclass Animal, the following is not allowed.
In other words, a subclass can have one parent class, one grandparent class, one great-grandparent class, … and they are not allowed to have multiple parents, grandparents, or great-grandparents.
In conclusion, Java's inheritance allows subclasses to utilize and extend the functionality of superclasses, embodying the "is-a" relationship and facilitating polymorphism. This enhances code reusability, flexibility, and consistency by enabling specific behaviors in subclasses while maintaining shared characteristics across a common superclass.
References:
CUS Global (n.d.). Module 1: Working with inheritance [Interactive lecture]. In Colorado State University Global, CSC372: Programming II, Computer Science Department. Canvas. Retrieved June 8, 2024, from https://csuglobal.instructure.com/courses/94948/pages/module-1-overview?module_item_id=4868813
The Java™ Tutorials (n.d.). Learning the Java language: Interfaces and inheritance. Oracle. Retrieved June 8, 2024, fromhttps://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html
Comments