Java 多态 - Java教程

由网友 大卫 发布 阅读 13

在本教程中,我们将通过示例学习多态,不同类型的多态以及如何在Java中实现它们。

多态是面向对象编程的重要概念。它只是意味着不止一种形式。也就是说,同一实体(方法,运算符或对象)在不同情况下的行为会有所不同。例如,

Java中的+运算符用于执行两个特定功能。与数字(整数和浮点数)一起使用时,将执行加法运算。

int a = 5;
int b = 6;
int sum = a + b;     //  sum = 11

当我们将+运算符与字符串一起使用时,它将执行字符串连接。例如,

String firstName = "abc ";
String lastName = "xyz";
name = firstName + lastName;     //  name = abc xyz

多态性的类型

在Java中,多态可以分为两种类型:

  • 运行时多态

  • 编译时多态

运行时多态

在Java中,可以通过方法重写来实现运行时多态。

假设在父类及其子类中创建了相同的方法。在这种情况下,将要调用的方法取决于用于调用该方法的对象。例如,

示例1:方法重写

abstract class Animal {
   public abstract void makeSound();
}

class Dog extends Animal {
   @Override
   public void makeSound() {
      System.out.println("Bark bark..");
   }
}

class Cat extends Animal {
   @Override
   public void makeSound() {
      System.out.println("Meow meow..");
   }
}

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

      Cat c1 = new Cat();
      c1.makeSound();
   }
}

输出

Bark bark…
Meow-meow...

要了解方法重写的工作原理,请访问Java中的方法重写

在上面的示例中,该方法makeSound()在两个不同的类中具有不同的实现。当我们运行程序时

  • 表达式d1.makeSound()将调用Dog类的方法。这是因为d1是Dog类的对象。

  • 表达式c1.makeSound()将调用Cat类的方法。这是因为c1是Cat类的对象。

Java中使用方法覆盖的运行时多态

在程序执行期间确定将要调用的方法。因此,方法重写是运行时多态。

编译时多态

可以通过Java中的方法重载和运算符重载来实现编译时多态。

方法重载

在Java类中,如果参数不同,则可以使用相同的名称创建方法。例如,

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

这在Java中称为方法重载。

让我们以方法重载为例。

示例3:方法重载

class Demo {
 public void displayPattern(){
   for(int i = 0; i < 10; i++) {
     System.out.print("*");
   }
 }

 public void displayPattern(char symbol) {
   for(int i = 0; i < 10; i++) {
     System.out.print(symbol);
   }
 }
}

class Main {
 public static void main(String[] args) {
   Demo d1 = new Demo();
   d1.displayPattern();
   System.out.println("\n");
   d1.displayPattern('#');
 }
}

输出

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

在上面的程序中,displayPattern()方法已重载。

  •  如果我们在不传递任何参数的情况下调用该方法,则会创建 * 字符的图案。

  •  如果我们通过将字符作为参数传递来调用该方法,则会创建 # 字符的图案。

使用方法重载在Java中编译时间多态

要了解有关方法重载的更多信息,请访问方法重载

Java方法重载 VS 方法重写

  • 在方法重写的情况下,方法应该在不同的类中。然而,在方法重载的情况下,方法应该在同一个类中。

  •  方法重写在运行时执行,而方法重载在编译时执行。

运算符重载

Java中的某些运算符对不同的操作数的行为有所不同。例如,

  • + 运算符被重载以执行数字加法和字符串连接。

  • &、|和!为逻辑和按位操作重载。

让我们看看运算符如何在Java中重载。

Java中的+运算符用于执行两个特定功能。与数字(整数和浮点数)一起使用时,将执行加法运算。例如,

int a = 5;
int b = 6;
int sum = a + b;     //  sum = 11

当我们将+运算符与字符串一起使用时,它将执行字符串连接。例如,

String firstName = "abc ";
String lastName = "xyz";
name = firstName + lastName;     //  name = abc xyz

在像C ++这样的语言中,我们可以定义运算符以对不同的操作数进行不同的处理。但是,Java不支持用户定义的运算符重载。

为什么要多态?

多态允许我们创建一致的代码。例如,

假设我们需要绘制一个圆和一个正方形。为此,我们可以创建一个Polygon类,Circle和square从中继承两个子类。 在这种情况下,有必要在这两个子类中创建一个具有相同名称render()的方法,而不是创建具有不同名称的方法。

在我们的方法重载示例中,我们使用相同的方法名称displayPattern()来显示两个不同的图案,以保持一致性。

Java中的print()方法也是多态性(方法重载)的一个实例。同样的方法用于打印不同类型的值,如char、int、String等。我们还可以使用相同的方法一次打印多个值。

多态变量

在Java中,对象变量(实例变量)表示多态变量的行为。这是因为类的对象变量可以引用其类的对象及其子类的对象。例如,

class Animal {
   public void displayInfo() {
      System.out.println("I am an animal.");
   }
}

class Dog extends Animal {
   @Override
   public void displayInfo() {
      System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
    
      //声明Animal类的对象变量a1
      Animal a1;
    
     //创建Animal类的对象
      a1 = new Animal();
      a1.displayInfo();
     //dog类的对象创建
      a1 = new Dog();
      a1.displayInfo();
   }
}

输出

I am an animal.
I am a dog.

在上面的示例中,我们创建了Animal类的对象变量a1。在这里,a1是一个多态变量。

这是因为,

  • 在语句中 a1 = new Animal(),a1引用Animal类的对象。

  • 在语句中 a1 = new Dog(),a1引用Dog类的对象。

这是Java中的向上转型示例。要了解更多信息,请访问Java向上转换和向下转换