8.11 面向对象编程-多态

8.11.2 多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

8.11.3 多态的具体体现

1) 方法的多态 PloyMethod.java  重写和重载就体现多态 [ 案例说明： ]

public class PloyMethod { 
public static void main(String[] args) { 
//方法重载体现多态 
A a = new A(); 
//这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态 
System.out.println(a.sum(10, 20)); 
System.out.println(a.sum(10, 20, 30)); /
/方法重写体现多态 
B b = new B(); 
a.say(); 
b.say();
} 
}
class B { //父类 
public void say() { 
System.out.println("B say() 方法被调用..."); 
} 
}
class A extends B {//子类 
public int sum(int n1, int n2){
//和下面 sum 构成重载 
return n1 + n2; 
}
public int sum(int n1, int n2, int n3){ 
return n1 + n2 + n3; 
}
public void say() { 
System.out.println("A say() 方法被调用..."); 
} 
}

2) 对象的多态 (核心，困难，重点)

8.11.5 多态注意事项和细节讨论  

多态的 前提是 ：两个对象 ( 类 ) 存在继承关系

多态的向上转型

多态向下转型

 

public class Animal { 
String name = "动物"; 
int age = 10; 
public void sleep(){ 
System.out.println("睡"); 
}
public void run(){ 
System.out.println("跑");
}
public void eat(){ 
System.out.println("吃"); 
}
public void show(){ 
System.out.println("hello,你好"); 
}
}
public class Cat extends Animal { 
public void eat(){//方法重写 
System.out.println("猫吃鱼"); 
}
public void catchMouse(){//Cat 特有方法 
System.out.println("猫抓老鼠"); 
} 
}
public class Dog extends Animal {//Dog 是 Animal 的子类 
}
public class PolyDetail {
public static void main(String[] args) { 
//向上转型: 父类的引用指向了子类的对象 
//语法：父类类型引用名 = new 子类类型(); 
Animal animal = new Cat(); 
Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类 
//向上转型调用方法的规则如下: 
//(1)可以调用父类中的所有成员(需遵守访问权限) 
//(2)但是不能调用子类的特有的成员 
//(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的 
//animal.catchMouse();错误 
//(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法 
//，然后调用，规则我前面我们讲的方法调用规则一致。 
animal.eat();//猫吃鱼.. 
animal.run();//跑 
animal.show();//hello,你好 
animal.sleep();//睡 
//老师希望，可以调用 Cat 的 catchMouse 方法 
//多态的向下转型 
//(1)语法：子类类型 引用名 =（子类类型）父类引用; 
//问一个问题? cat 的编译类型 Cat,运行类型是 Cat 
Cat cat = (Cat) animal; 
cat.catchMouse();//猫抓老鼠 
//(2)要求父类的引用必须指向的是当前目标类型的对象
Dog dog = (Dog) animal; //可以吗？ 
System.out.println("ok~~"); 
} 
}

 属性没有重写之说！属性的值看编译类型

instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

8.11.7 java 的动态绑定机制(非常非常重要.)

public class DynamicBinding { 
public static void main(String[] args) { 
//a 的编译类型 A, 运行类型 B 
A a = new B();//向上转型 
System.out.println(a.sum());//?40 -> 30 
System.out.println(a.sum1());//?30-> 20 
} 
}
class A {//父类 
public int i = 10; 
//动态绑定机制: 
public int sum() {//父类 sum() 
return getI() + 10;//20 + 10
}
public int sum1() {//父类 sum1() 
return i + 10;//10 + 10 
}
public int getI() {//父类 
getI return i; 
} 
}
class B extends A {//子类 
public int i = 20; 
// public int sum() { 
// return i + 20; 
// }
public int getI() {//子类 getI() 
return i; 
} 
// public int sum1() { 
// return i + 10; 
// } 
}

 8.11.8 多态的应用

1)多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

2) 多态参数