How Does Java Achieve Polymorphism with Both Static and Dynamic Mechanisms?

Polymorphism in Java: A Comprehensive Guide

In object-oriented programming, polymorphism allows objects of different classes to be treated as objects of a common superclass. Java supports polymorphism through two main mechanisms: static polymorphism and dynamic polymorphism.

Static Polymorphism

Static polymorphism, also known as method overloading, occurs when two or more methods in the same class have the same name but different parameter lists. During compilation, the compiler determines which method to invoke based on the number and types of the arguments passed.

Example:

<code class="java">class Calculation {
  void sum(int a, int b) {}
  void sum(int a, int b, int c) {}
}

// Main method
Calculation obj = new Calculation();
obj.sum(10, 10, 10); // 30
obj.sum(20, 20); // 40</code>

In this example, the method sum is overloaded with two different parameter lists. When the method is called with three arguments, the compiler chooses the sum method with three parameters. Conversely, when the method is called with two arguments, the compiler chooses the sum method with two parameters.

Dynamic Polymorphism

Dynamic polymorphism, also known as method overriding, occurs when two or more methods in different classes have the same name and signature. During runtime, the virtual machine determines which method to invoke based on the runtime type of the object.

Example:

<code class="java">class Animal {
  public void move() {}
}

class Dog extends Animal {
  public void move() {}
}

// Main method
Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object

a.move(); // "Animals can move"
b.move(); // "Dogs can walk and run"</code>

In this example, the method move is overridden in the Dog class. When the move method is called on the Animal reference a, the Animal implementation of move is invoked. However, when the move method is called on the Dog reference b, the Dog implementation of move is invoked, demonstrating dynamic polymorphism.

The above is the detailed content of How Does Java Achieve Polymorphism with Both Static and Dynamic Mechanisms?. For more information, please follow other related articles on the PHP Chinese website!