12-Java中的多态是什么以及如何实现它？

咬到舌头的小蛇

2024-01-17

Java

要理解面向对象编程范式，Java中的多态是您需要学习的关键概念之一。Java中的多态是对象可以获得从不同角度操作的能力的现象。

什么是多态？

Polymorphism_in_Java.p

根据化学原理，多晶性指的是一个物体可以以不同的晶体形式存在。例如，碳可以以三种常见类型存在。煤、石墨和钻石是碳的三种不同晶型。

类似地，在Java中，多态是一种对象现象，它可以表现出从不同角度执行数学和逻辑运算的属性。

Example:

package polymorphism;
class AnimalSounds {
public void Sound() {
System.out.println("The animals make different sounds when asked to speak. For example:");
}
}

class Cow extends AnimalSounds {
public void Sound() {
System.out.println("The cow says: moh moh");
}
}

class cat extends AnimalSounds {
public void Sound() {
System.out.println("The cat says: mew mew");
}
}

class Dog extends AnimalSounds {
public void Sound() {
System.out.println("The dog says: bow wow");
}
}

public class AnimalMain {
public static void main(String[] args) {
AnimalSounds Animal = new AnimalSounds();
AnimalSounds cow = new Cow();
AnimalSounds cat = new cat();
AnimalSounds Dog = new Dog();
Animal.Sound();
cow.Sound();
cow.Sound();
Dog.Sound();
}
}

现在我们对Java中的多态性有了更好的理解，让我们进入Java中多态性的特征。

多态的特征/特征

以下是Java中多态的重要特征：

方法的功能在不同方案中的行为不同。
方法的行为取决于提供的数据。
它允许具有不同类型的类中的成员或方法具有相同的名称。
多态性支持隐式类型转换。

接下来，我们将了解Java中不同类型的多态。

多态的类型

Java中有两种不同类型的多态。它们是：

编译时多态
运行时多态

编译时多态

一个典型的Java程序在编译阶段会遇到编译时多态性。这里，重载方法解析发生在编译阶段。存在两种时间多态性，它们是：

方法重载

方法重载是类具有两个或多个同名方法的过程。然而，特定方法的实现取决于方法调用中的参数数量。

Example:
//Method Overloading.
package polymorphism;
public class Addition {
public int add(int x, int y) {
return (x + y);
}

public double add(double d, double e, double f, double g) {
return (d + e + f + g);
}

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

public static void main(String args[]) {
Addition a = new Addition();
System.out.println(a.add(25, 30));
System.out.println(a.add(10.0, 15.0, 20.0, 25.0));
System.out.println(a.add(127.5, 123.5));
}
}

运算符重载

方法重载是一个类具有两个或多个同名方法的过程。尽管如此，特定方法的实现仍根据方法定义中的参数数量进行。

Java不支持操作符重载以避免多义性。

超级关键字

运行时多态

运行时多态是程序在运行时执行的过程。在这里，重写的解析发生在执行阶段。运行时多态出现了两次。

方法重写

方法重写是编译器允许子类实现父类中已提供的特定方法的过程。

Example:

//Method Overriding.
package polymorphism;
class CargoPilot {
public void FlyPlane() {
System.out.println("This is the Cargo Pilot, Ready to Take off");
}
}

class CivilianPilot extends CargoPilot {
public void FlyPlane() {
System.out.println("This is the Civilian Pilot, Ready to Takeoff");
}
}

public class Takeoff {
public static void main(String args[]) {
CargoPilot CPObj = new CargoPilot();
CPObj.FlyPlane();
//CivilianPilot CivilianObj = new CivilianPilot();
//CivilianObj.FlyPlane();
}
}

运算符重写

运算符重写一个过程，在该过程中，您可以在父类和子类中定义具有相同签名但具有不同运算能力的运算符。

Java不允许操作符覆盖以避免歧义。

为了更好地理解，让我们来概括一下编译时和运行时多态之间的区别。

编译时多态与运行时多态

编译时多态	运行时多态
- 方法调用由编译器处理	- 编译器不能在运行时控制方法调用
- 编译时多态的灵活性较低，因为它需要在编译时处理所有方法调用	- 运行时多态表现出更高的灵活性，因为方法调用是在运行时处理的
- 编译时多态的执行周期较短	- 运行时多态的执行周期更长
- 将正确的方法调用与正确的方法集成在编译时完成	- 在运行时将正确的方法调用与正确的方法组合在一起
- 在方法重载和运算符重载期间发生	- 在方法重写期间发生

有了这些，我们就了解了Java中的多态类型与运行时多态和编译时多态的工作术语之间的区别。

因为多态过程涉及到扩展父类的方法和成员，所以我们需要知道如何扩展成员和方法，特别是从父类扩展。

在下一部分中，我们将学习用于引用父类对象的Reference关键字。与“This”关键字不同，“Super”关键字是我们将要探索的内容。

超级关键字

术语“super”是Java中的一个关键字，指的是程序的直接父类对象或方法。在此过程中，每当您自动创建子类的实例时，编译器都会隐式创建父类的实例。超级引用变量将引用父类的实例。

Example:

//Super Keyword
package polymorphism;
public class SuperKeyWord {
public static void main(String[] args) {
triangle two = new triangle();
two.countsides();
}
}

class square {
int sides = 4;
}

class triangle extends square {
int sides = 3;
public void countsides() {
System.out.println("Number of sides in the square : " + sides);
System.out.println("Number of sides in the triangle : " + super.sides);
}
}