Java 多态性

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...

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

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

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

为什么要多态？

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

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

为了解决这个问题，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

在上面的示例中，我们创建了一个名为 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 中被重载以执行两个操作：addition 和串联 .

注意：在像 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.

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

在语句pl = new ProgrammingLanguage()中 , pl 引用 ProgrammingLanguage 的对象类。
并且，在语句 pl = new Java() , pl 引用 Java 的对象类。

这是 Java 中向上转换的示例。

Java 接口 Java 封装

java