Java多态

作者：--    发布时间：2019-11-20

java中的多态是一个概念，通过它我们可以通过不同的方式执行单个动作(方法)。 多态性派生自2个希腊词：“poly”和“morphs”。 词语“poly”意为许多，“morphs”意为形式。 所以多态表示为多种形式。

在java中有两种类型的多态性：编译时多态性和运行时多态性。 我们可以通过方法重载和方法覆盖在java中执行多态性。

如果在java中重载静态方法，它就是编译时多态性的例子。 这里，我们将关注java中的运行时多态性。

1. java运行时多态性

运行时多态性或动态方法分派是一个过程，它对重写方法的调用在运行时体现而不是编译时。

在此过程中，通过超类的引用变量调用重写的方法。 要调用的方法基于引用的对象。

了解运行时多态性之前，让我们先来向上转换。

向上转换

当父类的引用变量引用子类的对象时，称为向上转换。 例如：

class a{}  
class b extends a{}  
a a=new b();  //向上转换...

java运行时多态性示例1

在这个例子中，我们创建两个类：bike和splendar。 splendar类扩展bike类并覆盖其run()方法。通过父类(bike)的引用变量调用run方法。 因为它引用子类对象，并且子类方法覆盖父类方法，子类方法在运行时被调用。

因为方法调用是由jvm不是编译器决定的，所以它被称为运行时多态性。

class bike {
    void run() {
        system.out.println("running");
    }
}

class splender extends bike {
    void run() {
        system.out.println("running safely with 60km");
    }

    public static void main(string args[]) {
        bike b = new splender();// upcasting - 向上转换
        b.run();
    }
}

执行上面代码得到以下结果 -

running safely with 60km.

java运行时多态性示例2：bank

考虑一种情况，bank类是一个提供获得利率的方法的类。 但是，利率可能因银行而异。 例如，sbi，icici和axis银行分别提供8.4％，7.3％和9.7％的利率。

注意：此示例也在方法覆盖中给出，但没有向上转换。

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运行时多态性示例3：shape

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运行时多态性示例4：animal

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不会覆盖eat()方法，所以这里是dog类的eat()方法被调用。