Java多态性

本文概述

• 在Java运行时多态
• Java运行时多态的例子:银行
• Java运行时多态的例子:形状
• Java运行时多态的例子:动物
• Java运行时多态数据成员
• Java运行时多态与多级继承

多态性在Java是一个概念，我们可以以不同的方式执行一个动作。多态性是来自2希腊词:保利和变种。“聚”这个词意味着许多和“变种”是指形式。所以多态性意味着许多形式。

有两种类型的Java的多态性:多态性编译时和运行时多态。我们可以执行java方法重载和方法重写的多态性。

如果你超载一个静态方法在Java中，这是编译时多态的例子。在这里，我们将集中在java运行时的多态性。

在Java运行时多态

运行时多态或动态方法调度是一个过程，在运行时调用一个覆盖方法解决，而不是编译时。

在这个过程中，通过调用一个覆盖方法引用父类的变量。的确定要调用的方法是基于引用的对象被称为变量。

运行时多态之前我们先了解向上转型。

向上转型

如果父类的引用变量指的是子类的对象，它被称为向上转型。例如:

class A{}
class B extends A{}

A a=new B();//upcasting

向上转型，我们可以使用类类型或接口的引用变量的类型。例如:

interface I{}
class A{}
class B extends A implements I{}

在这里，B类的关系是:

B IS-A A
B IS-A I
B IS-A Object

因为对象是所有类的根类在Java中，我们可以写B是一个对象。

Java运行时多态的例子

在这个例子中，我们创建两个类自行车和辉煌。辉煌类扩展了自行车类并覆盖其运行()方法。我们调用run方法的引用父类的变量。因为它指的是子类对象和子类方法覆盖父类的方法，在运行时调用子类的方法。

因为方法调用是由JVM没有编译器，它被称为运行时多态。

class Bike{
   void run(){System.out.println("running");}
 }
 class Splendor extends Bike{
   void run(){System.out.println("running safely with 60km");}
 
   public static void main(String args[]){
     Bike b = new Splendor();//upcasting
     b.run();
   }
 }

输出:

running safely with 60km.

Java运行时多态的例子:银行

考虑这样一个场景，银行是一个类，它提供了一个方法来得到利率。然而，根据银行利率可能有所不同。

注意:本例中给出的方法覆盖但没有向上转型。

class Bank{
float getRateOfInterest(){return 0;}
}
class SBI extends Bank{
float getRateOfInterest(){return 8.4f;}
}
class ICICI extends Bank{
float getRateOfInterest(){return 7.3f;}
}
class AXIS extends Bank{
float getRateOfInterest(){return 9.7f;}
}
class TestPolymorphism{
public static void main(String args[]){
Bank b;
b=new SBI();
System.out.println("SBI Rate of Interest: "+b.getRateOfInterest());
b=new ICICI();
System.out.println("ICICI Rate of Interest: "+b.getRateOfInterest());
b=new AXIS();
System.out.println("AXIS Rate of Interest: "+b.getRateOfInterest());
}
}

输出:

SBI Rate of Interest: 8.4
ICICI Rate of Interest: 7.3
AXIS Rate of Interest: 9.7

Java运行时多态的例子:形状

class Shape{
void draw(){System.out.println("drawing...");}
}
class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle...");}
}
class Circle extends Shape{
void draw(){System.out.println("drawing circle...");}
}
class Triangle extends Shape{
void draw(){System.out.println("drawing triangle...");}
}
class TestPolymorphism2{
public static void main(String args[]){
Shape s;
s=new Rectangle();
s.draw();
s=new Circle();
s.draw();
s=new Triangle();
s.draw();
}
}

输出:

drawing rectangle...
drawing circle...
drawing triangle...

Java运行时多态的例子:动物

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void eat(){System.out.println("eating bread...");}
}
class Cat extends Animal{
void eat(){System.out.println("eating rat...");}
}
class Lion extends Animal{
void eat(){System.out.println("eating meat...");}
}
class TestPolymorphism3{
public static void main(String[] args){
Animal a;
a=new Dog();
a.eat();
a=new Cat();
a.eat();
a=new Lion();
a.eat();
}}

输出:

eating bread...
eating rat...
eating meat...

Java运行时多态数据成员

方法覆盖，而不是数据成员，所以运行时多态不能通过数据成员。

在下面的例子中，speedlimit两类数据成员。我们访问父类的数据成员的引用变量指的是子类对象。因为我们正在访问的数据成员不覆盖，因此它将访问父类的数据成员。

规则:运行时多态不能通过数据成员。

class Bike{
  int speedlimit=90;
 }
 class Honda3 extends Bike{
  int speedlimit=150;
 
  public static void main(String args[]){
   Bike obj=new Honda3();
   System.out.println(obj.speedlimit);//90
 }
}

输出:

90

Java运行时多态与多级继承

让我们看看运行时的多态性与多级继承的简单的例子。

class Animal{
void eat(){System.out.println("eating");}
}
class Dog extends Animal{
void eat(){System.out.println("eating fruits");}
}
class BabyDog extends Dog{
void eat(){System.out.println("drinking milk");}
public static void main(String args[]){
Animal a1，a2，a3;
a1=new Animal();
a2=new Dog();
a3=new BabyDog();
a1.eat();
a2.eat();
a3.eat();
}
}

输出:

eating
eating fruits
drinking Milk

尝试为输出

class Animal{
void eat(){System.out.println("animal is eating...");}
}
class Dog extends Animal{
void eat(){System.out.println("dog is eating...");}
}
class BabyDog1 extends Dog{
public static void main(String args[]){
Animal a=new BabyDog1();
a.eat();
}}

输出:

Dog is eating

以来，BabyDog不是覆盖吃()方法，所以吃狗类的()方法被调用。