多态是面向对象编程的一个重要概念。它意味着“一种以上形式”。
也就是说，同一个实体（方法或运算符或对象）可以在不同的场景下执行不同的操作。
示例：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. 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 中打印的信息不同。
根据用于调用方法的对象，会打印相应的信息。
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 类的对象。