Inheritance and polymorphism in Java

Inheritance and polymorphism are two important concepts in Java programming that enable the creation of more efficient and scalable code. Understanding these concepts is essential for any Java developer to write high-quality and reusable code. In this article, we’ll explore what inheritance and polymorphism are and how they can be used in Java programming.

Inheritance in Java

Inheritance is a fundamental concept in object-oriented programming (OOP) that enables a class to inherit properties and behaviors from another class. The class that inherits from another class is called a subclass, and the class that is inherited from is called a superclass. A subclass can access all the public and protected members of its superclass and can also override its methods.

In Java, inheritance is implemented using the “extends” keyword. For example, the following code snippet shows how to create a subclass “ChildClass” that extends a superclass “ParentClass.”

public class ParentClass {
    public void printMessage() {
        System.out.println("Hello, World!");
    }
}

public class ChildClass extends ParentClass {
    // override the printMessage() method
    public void printMessage() {
        System.out.println("Hello, Java!");
    }
}

In the above example, the “ChildClass” inherits the “printMessage()” method from its superclass “ParentClass.” The subclass overrides the method to print a different message.

Polymorphism in Java

Polymorphism is another key concept in OOP that allows objects of different classes to be treated as if they were the same type. Polymorphism allows for greater flexibility in programming by enabling a method to be applied to objects of different classes that share a common interface or superclass.

In Java, polymorphism is implemented using method overriding and method overloading. Method overriding is the process of defining a method in a subclass that has the same signature as a method in its superclass. When an object of the subclass calls the method, the method in the subclass is called instead of the method in the superclass.

public class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

public class Circle extends Shape {
    // override the draw() method
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Square extends Shape {
    // override the draw() method
    public void draw() {
        System.out.println("Drawing a square");
    }
}

In the above example, the “Circle” and “Square” classes inherit the “draw()” method from the “Shape” class. The subclasses override the method to draw a circle and square, respectively.

Method overloading is the process of defining multiple methods with the same name but different parameters in a class. When a method is called, Java determines which method to call based on the number and type of arguments passed to the method.

public class Math {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

In the above example, the “Math” class defines two “add()” methods with different parameter types. When the “add()” method is called, Java determines which method to call based on the type of arguments passed to the method.

Conclusion

Inheritance and polymorphism are powerful concepts in Java programming that enable the creation of efficient and scalable code. Inheritance allows for code reuse and enables subclasses to access properties and behaviors of their superclass. Polymorphism enables objects of different classes to be treated as if they were the same type and allows for greater flexibility in programming. By understanding and using these concepts effectively, Java developers can write high-quality and reusable code