Inheritance In Object-Oriented Programming Java (With Examples)

If you're just getting started with object-oriented programming in Java, then you're probably wondering what exactly inheritance is and how you can use it in your code. This article will explain everything you need to know about inheritance in Java, including a few examples to show you how it works.

Inheritance

Inheritance is a fundamental principle of object-oriented programming. It is a mechanism by which one class can be derived from another. The class that is derived is called the child class, and the class from which it is derived is called the parent class.

Inheritance allows child classes to inherit the attributes and methods of the parent class. This means that the child class can access all the public methods and attributes of the parent class. It also means that the child class can override any of the methods of the parent class if it needs to.

Inheritance is a powerful tool, but it should be used with care. If not used carefully, it can lead to problems such as fragility (a child class breaking when the parent class changes) and tight coupling (child classes being too dependent on the implementation details of the parent class).

Syntax of inheritance

Inheritance is a powerful tool in object-oriented programming that allows you to reuse code and extend the functionality of existing classes. In Java, inheritance is declared using the extends keyword. For example, if you have a class called Vehicle, you could create a subclass called Car that inherits from Vehicle.

The syntax for declaring a subclass is:

class Car extends Vehicle {

//code goes here

}

In the above example, Car is the subclass and Vehicle is the superclass. When a subclass inherits from a superclass, it automatically has access to all of the public methods and fields of the superclass. You can then add new methods and fields to the subclass as needed.

Inheritance Example

Inheritance is one of the key features of object-oriented programming (OOP). It allows you to create a new class that is derived from an existing class. The existing class is called the superclass, and the new class is called the subclass.

Inheritance enables you to reuse the code in the superclass, and it also allows you to add new code to the subclass. For example, you could create a subclass of the java.util.Vector class that contains a method for sorting the elements in the vector.

The Java language supports single inheritance, which means that a subclass can have only one superclass. However, a superclass can have multiple subclasses.

Types Of Inheritance

There are five types of inheritance in object-oriented programming Java: 

• Single inheritance
• Multiple inheritance
• Multilevel inheritance
• Hierarchical inheritance
• Hybrid inheritance 

Need of Inheritance

While developing any software, we always come across the requirement of creating a new class that has some similar characteristics to another class. For instance, consider a situation where we need to develop a class Vehicle that represents all types of vehicles like cars, bikes, trucks, etc. Now, each type of vehicle has some common attributes like color, weight, and structure. However, each type also has some unique attributes. For example, a car has attributes like the number of doors and seats whereas a bike has attributes like the number of gears.

In such cases, the inheritance comes to the rescue. Inheritance is a mechanism in Java that allows us to create a new class by reusing the functionality of an existing class. The existing class is known as the parent class or superclass and the new class is known as the child class or subclass.

There are different types of inheritance in Java that are explained in detail in this article along with examples.

Method Overloading in Inheritance

When it comes to inheritance in Java, one of the key concepts to understand is method overloading. This is when a subclass inherits a method from a superclass, but the subclass redefines the method to have a different signature. This can be useful in a number of situations, such as when you want to override the behavior of a method without changing its original behavior.

One common use case for method overloading is overriding the toString() method. This method is used to convert an object into a String representation. By default, the toString() method will return the object's class name and memory address. However, you can override this behavior by defining your own toString() method in a subclass. For example, you could create a Person class with a toString() method that returns the person's name and age.

Another use case for method overloading is creating overloaded constructors. A constructor is a special type of method that is used to create an instance of a class. By default, every class has a no-args constructor that takes no arguments and initializes the object with default values. However, you can create overloaded constructors that take different numbers and types of arguments. This can be useful

Example of Method Overloading

In the Java programming language, method overloading is a technique that allows you to create multiple methods with the same name, but with different parameter lists. This is useful when you want to provide different functionality depending on the type or number of parameters passed to the method.

For example, consider a class that represents a two-dimensional point. Such a class might have two overloaded methods named distanceFromOrigin. The first method could take no parameters and return the distance of the point from the origin (0,0). The seconddistanceFromOrigin method could take another Point as a parameter and return the distance between the two points.

Overloaded methods are distinguished by their signatures. A signature is made up of the method name and the number and types of its parameters. Two overloaded methods can have the same name, but they must have different signatures.

Here is an example of a simple class with overloaded methods:

public class Point {
// no-argument constructor
public Point() { }

// constructor that takes x- and y-coordinates as arguments
public Point(int x, int y) { }

// compute the distance from this point too (0)