Java的多态性的示例

在本教程中，动力节点小编将借助示例了解 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...

在上面的例子中，我们创建了一个超类：多边形和两个子类：正方形和圆圈. 注意render()方法的使用。

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

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

为什么是多态性?

多态性允许我们创建一致的代码。在前面的例子中，我们还可以创建不同的方法：renderSquare()和renderCircle()来渲染正方形和圆圈， 分别。

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

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

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

我们可以使用以下方式在 Java 中实现多态性：

方法覆盖

方法重载

运算符重载

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

在上面的例子中，我们创建了一个名为语和一个名为的子类爪哇. 在这里，该方法displayInfo()同时存在于语和爪哇.

用途displayInfo()是打印信息。但是，它正在打印不同的信息语和爪哇.

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

Java方法重载

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

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

这在 Java 中称为方法重载。在这里，相同的方法会根据参数执行不同的操作。

示例：使用方法重载的多态性

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("
");
    // call method with a single argument
    d1.display('#');
  }
}

输出：

********** 
##########

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

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

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

*如果没有传递参数，则打印 的模式或

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

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

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 中被重载以执行两个操作：加法和连接。

多态变量

如果一个变量在不同的条件下引用不同的值，则称为多态。

对象变量(实例变量)表示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.

在上面的例子中，我们创建了一个对象变量请的编程语言班级。这里，请是一个多态变量。这是因为，在声明中pl = new ProgrammingLanguage()，并且，在声明中pl = new Java()。

以上就是关于“Java的多态性的示例”介绍，大家如果对此比较感兴趣，想了解更多相关知识，可以关注一下动力节点的Java视频教程，里面的课程内容细致全面，通俗易懂，很适合没有基础的小白学习，希望对大家能够有所帮助哦。