1.什么是多态性?
多态是指“许多形式”。 在OOP中,多态性意味着类型可以在不同时间指向不同的对象。 换句话说,引用类型所引用的实际对象可以在运行时确定。
在Java中,多态性基于继承和重写。
2.如何用Java实现多态?
在Java中,如果您具有带有两个或多个子类的超类(或超接口),则可以实现多态。
superInterface:Animal.interface
package Bean;
public interface Animal {
public void move();
}
subclass:Bird.class
package Bean;
public class Bird implements Animal {
@Override
public void move() {
System.out.println("Flying...");
}
}
subclass:Fish.class
package Bean;
public class Fish implements Animal {
@Override
public void move() {
System.out.println("Swimming...");
}
}
As you can see, we have Animal as the super interface, and 2 sub classes: Bird and Fish.
Because the Bird implements Animal, or Bird is an Animal, we can write:
Animal animal = new Bird();
Because Fish is an Animal, it’s legal to write:
Animal animal1 = new Fish();
As you can see, we declare a reference variable called anim, which is of type Animal. Then we assign this reference variable to 3 different kinds of object: Dog, Bird and Fish.
You see? A reference type can take different objects (many forms). This is the simplest form of polymorphism, got it?
Now we come to a more interesting example to see the power of polymorphism.
java多态的概念
多态性是OOPs特性之一,它允许我们以不同的方式执行单个操作。例如,假设我们有一个类Animal,它有一个方法sound()。因为这是一个泛型类,所以我们不能给它一个实现,比如:咆哮,喵喵,呜呜等等。我们必须给出一个通用的消息。
示例1:运行时多态
Animal.java
package Bean;
public class Animal {
public void sound()
{
System.out.println("Animal is making a sound");
}
}
现在,让我们说说动物类的两个子类:扩展了动物类的马和猫(请参见继承)。 我们可以为相同的方法提供实现,如下所示:
Horse.java:
package Bean;
public class Horse extends Animal {
@Override
public void sound() {
System.out.println("Neigh");
}
}
and
Cat.java:
package Bean;
public class Cat extends Animal {
@Override
public void sound() {
System.out.println("Meow");
}
}
As you can see that although we had the common action for all subclasses sound() but there were different ways to do the same action.
This is a perfect example of polymorphism (feature that allows us to perform a single action in different ways).
It would not make any sense to just call the generic sound() method as each Animal has a different sound. Thus we can say that the action this method performs is based on the type of object.
什么是程序设计中的多态性?
多态性是一个方法基于它所作用的对象做不同事情的能力。换句话说,多态性允许定义一个接口并有多个实现。正如我们在上面的例子中看到的,我们定义了sound()方法,并在不同的-2个子类中实现了它。
将在运行时确定将调用哪个sound()方法,因此我们上面给出的示例是一个运行时多态示例。
测试Animal,Horse,Cat的运行时多态性
public static void main(String[] args) {
Animal animal = new Horse();
animal.sound();
Animal animal1 = new Cat();
animal1.sound();
}
示例2:编译时多态
另一方面,方法重载是一个编译时多态性示例。
package Bean;
public class OverLoad {
void demo(int a) {
System.out.println("a:" + a);
}
void demo(int a, int b) {
System.out.println("a and b:" + a + "," + b);
}
double demo(double a) {
System.out.println("double a:" + a);
return a * a;
}
public static void main(String[] args) {
OverLoad overLoad = new OverLoad();
double result;
overLoad.demo(10);
overLoad.demo(10, 20);
result = overLoad.demo(5.5);
System.out.println("O/P:" + result);
}
}
这里的方法demo()被重载了3次:第一个方法有1个int参数,第二个方法有2个int参数,第三个有double参数。 调用哪种方法取决于我们在调用方法时传递的参数。 这是在运行时编译时发生的,因此这种类型的多态被称为编译时多态。