【尚硅谷-Java学习】5.4 面向对象的特征之三 多态性
面向对象的三大特征：
- 封装性、
- 继承性、
- 多态性、
- （抽象性）
多态性
1.对象的多态性
- 父类的引用 指向 子类的对象(或子类的对象赋给父类的引用)。
//例如有父类Person，子类Man、Woman。
Person p1 = new Man();
- 调用子父类同名同参的方法时，实际执行的是子类重写的方法–虚拟方法调用。
2.多态的使用：虚拟方法调用
- 在编译期，只能调用父类所声明的方法，不能调用子类特有的方法。
- 在运行期，实际执行的是子类重写的方法。此时父类方法称为虚拟方法。
总结：编译看左边，运行看右边。
3.对象的多态性只适用于方法，不适用于属性。
public class Test {
public static void main(String[] args) {
Person p1 = new Man();
System.out.println(p1.id);//1001
}
}
class Person{
int id = 1001;
}
class Man extends Person{
int id = 1002;
}
4.使用前提
- 有类的继承关系
- 子类重写父类的方法
5.应用
一、
public class AnimalTest {
public static void main(String[] args) {
AnimalTest at1 = new AnimalTest();
at1.func(new Dog());
at1.func(new Cat());
}
public void func(Animal animal){
animal.eat();
}
}
class Animal{
public void eat(){
System.out.println("吃");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("吃骨头");
}
}
有了多态性，一个func()方法就足够，否则需要写三个（func(Animal)、func(Dog)、func(Cat)）
二、
public void method(Object obj){
}
创建的任何子类对象都能用method方法。例如equals()。
6.多态是运行时行为
在编译时对象是父类类型，在运行时根据赋予的不同子类对象，动态调用该子类的方法，称为动态绑定。
7.多态性的实质：将子类转换成父类，也被称为向上转型。
8.练习
练习（1）
有父类Base：
class Base{
String name = "Base";
public void display(){
System.out.println(name);
}
}
子类Sub：
class Sub extends Base{
String name = "Sub";
public void display(){
System.out.println(name);
}
}
语句1.
Sub s = new Sub();
System.out.println(s.name);
输出：Sub
语句2.
s.display();
输出：Sub
语句3. 多态的应用.
对于引用数据类型，" == " 比较的是地址值。" = "将s的地址值赋给b，因此结果为true。
Base b = s;//多态
System.out.println(b == s);
输出：true
语句4. 多态的应用.
多态性不包含属性，调用属性时，编译运行都看左边：Base类
System.out.println(b.name);
输出：Base
语句5. 多态的应用.
调用方法时，编译看左边：Base。运行时看右边：即Sub类
b.display();
输出：Sub
练习（2）
有父类GeometricObject代表几何形状。
子类Circle圆形、MyRectangle矩形。定义了findArea（）方法计算面积。
当使用多态性进行动态绑定（即调用虚拟方法）时，需要在父类添加方法findArea（），因无法确定具体形状，该方法返回0.0即可。
public class GeometricObject {
//
...
//
public double findArea(){
return 0.0;
}
}
练习（3）
有父类Base，子类Sub：
class Base{
public void add(int a, int... arr){
System.out.println(base);
}
}
class Sub extends Base{
public void add(int a, int[] arr){
System.out.println(sub);
}
}
运行语句：
Base b = New Sub();
b.add(1,2,3);
关键点在于：int… 与 int[ ]是否看作同一参数。是的话子类对add方法进行重写，多态后b调用的是子类方法，输出“sub”。否则add(int a, int[] arr)是子类特有的方法，b无法调用。
答案是：int… 与 int[ ] 看作同一参数
练习（3）进阶
在子类Sub中添加方法add
class Sub extends Base{
public void add(int a, int[] arr){
System.out.println(sub);
}
public void add(int a,int b,int c){
System.out.println(sub_2);
}
}
add(int a,int b,int c)是子类特有的方法，多态后，通过b只能调用子类的add(int a, int[] arr)，输出为“sub”。
练习（3）进阶之进阶
运行语句
Sub s = (Sub)b;
s.add(1,2,3);
不确定参数的add(int a, int[] arr)与确定参数的add(int a,int b,int c)，优先调用确定参数的方法。输出“sub_2”