java多态深入理解面试_多态的深入理解

对于Java的多态概念的理解

在学习Java的过程中,我们无论如何也绕不过多态这个东西。它到底是个什么东西呢？

其实，它就是指调用相同名字的方法，但是得到的结果是不同的。

第一： 对象是方法

多态的作用范围是方法，不是类不是对象，也不是对象里面的属性

第二： 多态产生的条件

1、有继承---在子类中有方法重写---在方法的调用中，有指向子类的父类的引用

2、有方法的重载，就是相同方法名，但参数不同(个数，类型，顺序)

第三：为什么需要多态？

因为真实世界中的情况是纷繁复杂的，为了应对生活中的种种情况，我们就

需要程序能够分别应对各种情况。即增加了程序的灵活性，来满足客户需求。

第四：Java运行时的多态性

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

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

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

向上转换

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

classA{}class B extendsA{}

A a=new B(); //向上转换...

Java运行时多态性示例1

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

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

classBike {voidrun() {

System.out.println("running");

}

}class Splender extendsBike {voidrun() {

System.out.println("running safely with 60km");

}public static voidmain(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％的利率。

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

classBank {floatgetRateOfInterest() {return 0;

}

}class SBI extendsBank {floatgetRateOfInterest() {return 8.4f;

}

}class ICICI extendsBank {floatgetRateOfInterest() {return 7.3f;

}

}class AXIS extendsBank {floatgetRateOfInterest() {return 9.7f;

}

}classTestPolymorphism {public static voidmain(String args[]) {

Bank b;

b= newSBI();

System.out.println("SBI Rate of Interest: " +b.getRateOfInterest());

b= newICICI();

System.out.println("ICICI Rate of Interest: " +b.getRateOfInterest());

b= newAXIS();

System.out.println("AXIS Rate of Interest: " +b.getRateOfInterest());

}

}

上面代码执行结果如下 -

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

Java运行时多态性示例3：Shape

class Shape { //基类(形状)

voiddraw() {

System.out.println("drawing...");

}

}class Rectangle extendsShape {voiddraw() {

System.out.println("drawing rectangle...");

}

}class Circle extendsShape {voiddraw() {

System.out.println("drawing circle...");

}

}class Triangle extendsShape {voiddraw() {

System.out.println("drawing triangle...");

}

}classTestPolymorphism2 {public static voidmain(String args[]) {

Shape s;

s= newRectangle();

s.draw();

s= newCircle();

s.draw();

s= newTriangle();

s.draw();

}

}

上面代码执行结果如下 -

drawing rectangle...

drawing circle...

drawing triangle...

Java运行时多态性示例4：Animal

classAnimal {voideat() {

System.out.println("eating...");

}

}class Dog extendsAnimal {voideat() {

System.out.println("eating bread...");

}

}class Cat extendsAnimal {voideat() {

System.out.println("eating rat...");

}

}class Lion extendsAnimal {voideat() {

System.out.println("eating meat...");

}

}classTestPolymorphism3 {public static voidmain(String[] args) {

Animal a;

a= newDog();

a.eat();

a= newCat();

a.eat();

a= newLion();

a.eat();

}

}

上面代码执行结果如下 -

eating bread...

eating rat...

eating meat...

Java运行时多态性与数据成员

上面示例中，都是有关方法被覆盖而不是数据成员，因此运行时多态性不能由数据成员实现。

在下面给出的例子中，这两个类都有一个数据成员:speedlimit，通过引用子类对象的父类的

引用变量来访问数据成员。 由于我们访问的数据成员没有被重写，因此它将访问父类的数据成员。

规则： 运行时多态性不能由数据成员实现。

classBike {int speedlimit = 90;

}class Honda3 extendsBike {int speedlimit = 150;public static voidmain(String args[]){

Bike obj=newHonda3();

System.out.println(obj.speedlimit);//90

}

}

上面代码执行结果如下 -

90

总结：在实际使用的时候，我们会定义多个同名的方法，通过方法重载和方法重写的方式。

方法重载： 例如Java自带的println方法，无论是输入数字、字符、字符串，都可以正确的打印出来。

作为用户，它不关心是怎么实现的，只要拿来就能用，就能完成想要程序去完成的任务，

那么，这个程序就是ok的，就酱紫~