Java 多态

多态是面向对象编程的一个重要概念。它意味着“一种以上形式”。

也就是说，同一个实体（方法或运算符或对象）可以在不同的场景下执行不同的操作。

示例：Java 多态

class Polygon {

  // method to render a shape
  public void render() {
    System.out.println("Rendering Polygon...");
  }
}

class Square extends Polygon {

  // renders Square
  public void render() {
    System.out.println("Rendering Square...");
  }
}

class Circle extends Polygon {

  // renders circle
  public void render() {
    System.out.println("Rendering Circle...");
  }
}

class Main {
  public static void main(String[] args) {
    
    // create an object of Square
    Square s1 = new Square();
    s1.render();

    // create an object of Circle
    Circle c1 = new Circle();
    c1.render();
  }
}

输出

Rendering Square...
Rendering Circle...

在上面的示例中，我们创建了一个超类：Polygon 和两个子类：Square 和 Circle。请注意 render() 方法的使用。

render() 方法的主要目的是渲染形状。但是，渲染正方形的过程与渲染圆的过程不同。

因此，render() 方法在不同类中表现不同。或者说 render() 是多态的。

为什么需要多态？

多态允许我们创建一致的代码。在前面的示例中，我们也可以创建不同的方法：renderSquare() 和 renderCircle() 分别来渲染 Square 和 Circle。

这将完美运行。但是，对于每种形状，都需要创建不同的方法。这会使我们的代码不一致。

为了解决这个问题，Java 中的多态允许我们创建一个单一方法 render()，该方法对于不同的形状会表现出不同的行为。

注意：print() 方法也是多态的一个例子。它用于打印不同类型的值，如 char、int、string 等。

我们可以通过以下方式在 Java 中实现多态

1. 方法重写
2. 方法重载
3. 运算符重载

1. Java 方法重写

在 Java 继承中，如果父类和子类中都存在相同的方法。那么，子类中的方法会覆盖父类中相同的方法。这被称为方法重写。

在这种情况下，相同的方法在父类中执行一个操作，在子类中执行另一个操作。例如，

示例 1：使用方法重写实现多态

class Language {
  public void displayInfo() {
    System.out.println("Common English Language");
  }
}

class Java extends Language {
  @Override
  public void displayInfo() {
    System.out.println("Java Programming Language");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Java class
    Java j1 = new Java();
    j1.displayInfo();

    // create an object of Language class
    Language l1 = new Language();
    l1.displayInfo();
  }
}

输出:

Java Programming Language
Common English Language

在上面的示例中，我们创建了一个名为 Language 的父类和一个名为 Java 的子类。这里，displayInfo() 方法同时存在于 Language 和 Java 中。

displayInfo() 的用途是打印信息。然而，它在 Language 和 Java 中打印的信息不同。

根据用于调用方法的对象，会打印相应的信息。

注意：调用的方法是在程序执行期间确定的。因此，方法重写是运行时多态。

2. Java 方法重载

在 Java 类中，如果方法具有相同的名称但参数不同，我们可以创建它们。例如，

void func() { ... }
void func(int a) { ... }
float func(double a) { ... }
float func(int a, float b) { ... }

这就是 Java 中的方法重载。在这里，相同的方法将根据参数执行不同的操作。

示例 3：使用方法重载实现多态

class Pattern {

  // method without parameter
  public void display() {
    for (int i = 0; i < 10; i++) {
      System.out.print("*");
    }
  }

  // method with single parameter
  public void display(char symbol) {
    for (int i = 0; i < 10; i++) {
      System.out.print(symbol);
    }
  }
}

class Main {
  public static void main(String[] args) {
    Pattern d1 = new Pattern();

    // call method without any argument
    d1.display();
    System.out.println("\n");

    // call method with a single argument
    d1.display('#');
  }
}

输出:

**********

##########

在上面的示例中，我们创建了一个名为 Pattern 的类。该类包含一个名为 display() 的重载方法。

// method with no arguments
display() {...}

// method with a single char type argument
display(char symbol) {...}

这里，display() 的主要功能是打印模式。但是，根据传递的参数，该方法执行不同的操作

• 如果未传递参数，则打印 * 模式，或者
• 如果传递了单个 char 类型参数，则打印参数的模式。

注意：调用的方法是由编译器确定的。因此，它也称为编译时多态。

3. Java 运算符重载

Java 中的某些运算符对不同的操作数表现不同。例如，

• + 运算符被重载以执行数字加法以及字符串连接，以及
• 像 &、| 和 ! 这样的运算符被重载以进行逻辑和位运算。

让我们看看如何使用运算符重载来实现多态。

+ 运算符用于相加两个实体。但是，在 Java 中，+ 运算符执行两个操作。

1. 当 + 与数字（整数和浮点数）一起使用时，它执行数学加法。例如，

int a = 5;
int b = 6;

// + with numbers
int sum = a + b;  // Output = 11

2. 当我们将 + 运算符与字符串一起使用时，它将执行字符串连接（连接两个字符串）。例如，

String first = "Java ";
String second = "Programming";

// + with strings
name = first + second;  // Output = Java Programming

在这里，我们可以看到 + 运算符在 Java 中被重载以执行两个操作：加法和连接。

注意：在 C++ 等语言中，我们可以定义运算符以对不同的操作数执行不同的操作。但是，Java 不支持用户定义的运算符重载。

多态变量

当一个变量在不同条件下引用不同的值时，它被称为多态变量。

对象变量（实例变量）代表了 Java 中多态变量的行为。这是因为一个类的对象变量可以引用该类的对象及其子类的对象。

示例：多态变量

class ProgrammingLanguage {
  public void display() {
    System.out.println("I am Programming Language.");
  }
}

class Java extends ProgrammingLanguage {
  @Override
  public void display() {
    System.out.println("I am Object-Oriented Programming Language.");
  }
}

class Main {
  public static void main(String[] args) {

    // declare an object variable
    ProgrammingLanguage pl;

    // create object of ProgrammingLanguage
    pl = new ProgrammingLanguage();
    pl.display();

    // create object of Java class
    pl = new Java();
    pl.display();
  }
}

输出:

I am Programming Language.
I am Object-Oriented Programming Language.

在上面的示例中，我们创建了一个 ProgrammingLanguage 类的对象变量 pl。这里，pl 是一个多态变量。这是因为，

• 在语句 pl = new ProgrammingLanguage() 中，pl 引用 ProgrammingLanguage 类的对象。
• 而在语句 pl = new Java() 中，pl 引用 Java 类的对象。