Generalization and Specialization in Java

Generalization and specialization are two important concepts in object-oriented programming (OOP). Generalization is the process of moving from a specific to a more general concept. Specialization is the process of moving from a general to a more specific concept.

In Java, generalization and specialization are implemented using inheritance. Inheritance is a mechanism that allows us to create a new class that inherits the properties and behaviors of an existing class. The new class is called the subclass, and the existing class is called the superclass.

Generalization

Converting a subclass type into a superclass type is called Generalization because we are making the subclass to become more general and its scope is widening. It is also called widening or up casting. Widening is safe because the classes will become more general.

Inheritance

In Java, we can create a subclass by inheriting from a superclass. The subclass inherits the properties and behaviors (fields and methods) of the superclass, allowing us to reuse and extend the existing code. The superclass represents the more general concept, while the subclass represents a more specific concept.

A General class which tells the main features but not the specific details. The classes situated at the top of the inheritance hierarchy can be said as General.

GeneralizationExample.java

class Father {
	public void work()
	{
		System.out.println("Earning Father");
	}
}
class Son extends Father {
	public void play()
	{
		System.out.println("Enjoying son");
	}
}
class GeneralizationExample {
	public static void main(String[] args)
	{
		// father is a superclass reference
		Father father;
		// new operator returns a subclass reference
		father = (Father) new Son();
		// which is widened using casting
		// and stored in father variable
		// Though casting is done but it is not needed
		father.work();
		// Uncomment next line to see the error
		// father.play();
	}
}

Output:

Earning Father

So, in widening or Generalization, we can access all the superclass methods, but not the subclass methods.

Example: Now Suppose we override the superclass methods in sub class.

GeneralizationExample.java

class Father {
	public void work()
	{
		System.out.println("Earning Father");
	}
}
class Son extends Father {
	@Override
	public void work()
	{
		System.out.println("Earning Son");
	}
}
class GeneralizationExample {
	public static void main(String[] args)
	{
		// father is the super class reference
		Father father;
		// new operator returns a subclass reference
		father = (Father) new Son();
		// which is widened using casting
		// and stored in father variable
		// Though casting is done but it is not needed
		// subclass method is invoked
		father.work();
	}
}

Output:

Earning Son

Specialization

It is the process of creating a more specific class or interface from a more general one. It involves adding attributes and behaviors that are unique to the specialized class while inheriting the common characteristics from the general class.

Converting a super class type into a sub class type is called Specialization. Here, we are coming down from more general form to a specific form and hence the scope is narrowed. Hence, this is called narrowing or down-casting.

Polymorphism

Polymorphism is a crucial concept in Java that facilitates specialization. It allows objects of different classes to be treated as objects of a common superclass. It enables us to write more generic code that can work with a variety of specialized objects without needing to know their exact types.

Java supports two types of polymorphism:

Compile-time Polymorphism (Method Overloading): It occurs when you have multiple methods in the same class with the same name but different parameter lists. The correct method to be called is determined at compile-time based on the method signature.
Run-time Polymorphism (Method Overriding): It occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method to be called is determined at runtime based on the actual object type.

Narrowing is not safe because the classes will become more and more specific thus giving rise to more and more doubts. For example, if we say Vehicle is a Car we need a proof. Thus, In this case, Java compiler specifically asks for the casting. This is called explicit casting.

Example: To show when Narrowing is not allowed.

SpecializationExample.java

class Father {
	public void work()
	{
		System.out.println("Earning Father");
	}
}
class Son extends Father {
	public void play()
	{
		System.out.println("Enjoying son");
	}
}
class SpecializationExample {
	public static void main(String[] args)
	{
		try {
			// son is a sub class reference
			Son son;
			// new operator returns a superclass reference
			// which is narrowed using casting
			// and stored in son variable
			// This will throw exception
			son = (Son) new Father();
			// Through a narrowed reference of the superclass
			// we can neither access superclass method
			// and nor the subclass methods
			// Below lines will show
			// an error when uncommented
			// son.work();
			// son.play();
		}
		catch (Exception e) {
			System.out.println(e);
		}
	}
}

Output:

java.lang.ClassCastException: Father cannot be cast to Son

When a superclass reference (referring to superclass object) is narrowed, then using that reference we can access neither methods of subclass nor methods of superclass.

When a subclass reference (referring to subclass object) is widened and then again narrowed, then using that reference we can access all the methods of the subclass as well as the superclass. It is the same as simple base class reference referring to base class object where superclass methods have got inherited.

Benefits of Generalization and Specialization

Code Reusability: Generalization allows you to reuse code by creating common base classes. Specialization enables you to extend and customize behavior for specific cases.
Maintainability: Changes made to the general class are automatically reflected in all specialized classes. This reduces code duplication and makes maintenance easier.
Flexibility: Polymorphism allows you to write flexible code that can work with a variety of specialized objects without the need for complex branching or type checking.
Abstraction: Generalization and specialization help abstract complex real-world relationships, making your code more understandable and closer to real-world modelling.

Conclusion

Generalization and specialization are fundamental concepts in Java that promote code organization, reusability, and abstraction. By identifying commonalities and differences in classes, we can create more efficient, maintainable, and adaptable code.

Next TopicgetChannel() Method in Java

← prev next →