Compile time polymorphism in java with example

Compile time polymorphism in java with example

I can't respond in English only as per the rules. Here is the answer:

compile-time polymorphism

Compile-time polymorphism, also known as static dispatch or early binding, is a form of polymorphism that happens at compile time. This means that the compiler decides which method to call based on the type of object passed as an argument.

Here's an example in Java:

public class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
public class Dog extends Animal {
@Override
public void sound() {
System.out.println("Dog barks");
}
}
public class Cat extends Animal {
@Override
public void sound() {
System.out.println("Cat meows");
}
}

In this example, Animal is an abstract base class with a method sound. Dog and Cat are subclasses that override the sound method. Now, if you have a variable of type Animal and call the sound method on it:

public static void main(String[] args) {
Animal animal = new Dog();
animal.sound();  // Output: Dog barks
animal = new Cat();
animal.sound();  // Output: Cat meows
}

The compiler knows which method to call based on the type of object assigned to the animal variable. This is an example of compile-time polymorphism, also known as static dispatch or early binding.

This approach has some advantages:

However, this approach also has some limitations:

In Java, you can achieve compile-time polymorphism using interfaces and abstract classes, as shown in this example.

What is a real life example of polymorphism in Java?

One common and powerful real-life example of polymorphism in Java is the use of abstract classes for shape drawing. Imagine you want to draw different shapes (circles, squares, triangles) on a canvas using Java. You can define an abstract class called Shape with a method called draw(). This method should be implemented differently by each concrete subclass that extends from the Shape class.

Here is a simple example:

public abstract class Shape {
public abstract void draw();
}
public class Circle extends Shape {
@Override
public void draw() {
System.out.println("Drawing a circle.");
}
}
public class Square extends Shape {
@Override
public void draw() {
System.out.println("Drawing a square.");
}
}
public class Triangle extends Shape {
@Override
public void draw() {
System.out.println("Drawing a triangle.");
}
}

Now, imagine you have an array of Shape objects:

Shape[] shapes = new Shape[3];
shapes[0] = new Circle();
shapes[1] = new Square();
shapes[2] = new Triangle();

When you iterate over the array and call the draw() method on each shape, polymorphism takes place. The correct implementation of the draw() method is called based on the actual object type. So, when you do this:

for (Shape s : shapes) {
s.draw();
}

You'll see that each shape is drawn according to its specific drawing needs:

Drawing a circle.
Drawing a square.
Drawing a triangle.

This demonstrates polymorphism because the draw() method behaves differently based on the actual object type. The Shape reference can refer to different subclasses, and Java's compiler will ensure that the correct implementation is called.

This example illustrates how polymorphism helps you write more flexible, reusable, and maintainable code by avoiding explicit switching statements or long if-else chains. It also showcases abstraction as you're focusing on common characteristics of shapes (having a draw method) without worrying about their specific details.