多态性的理解：
何为多态性：
- 对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p = new Man();Object obj = new Date();
多态性的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。多态性的使用前提：
① 类的继承关系
- ② 方法的重写
多态性的应用举例：
举例一：
举例二： ```java public void method(Object obj){public void func(Animal animal){//Animal animal = new Dog();animal.eat();animal.shout();}
}
举例三：```javaclass Driver{public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();//规范的步骤去操作数据// conn.method1();// conn.method2();// conn.method3();}}
多态性使用的注意点：
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
关于向上转型与向下转型：
7.1 向上转型：多态
- 7.2 向下转型：
- 7.2.1 为什么使用向下转型：
- 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
- 7.2.2 如何实现向下转型：使用强制类型转换符：()
- 7.2.3 使用时的注意点：
- ① 使用强转时，可能出现ClassCastException的异常。
- ② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
- 7.2.4 instanceof的使用：
- ① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
- ② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
- ③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。\
- 7.2.5 图示：
- 7.2.1 为什么使用向下转型：
面试题：
- 8.1 谈谈你对多态性的理解？
- ① 实现代码的通用性。
- ② Object类中定义的
public boolean equals(Object obj){ }
JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server) - ③ 抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）
- 8.2 多态是编译时行为还是运行时行为？
好的例子
多态的好处
提高了代码的维护性（继承保证）；提高了代码的扩展性。
原代码，不易扩展：
（借用本代码，也进一步理解一下工具类）
//父类：动物类class Animal{public void eat(){System.out.println("eat");}public void sleep(){System.out.println("sleep");}}//猫类class Cat extends Animal{//方法重写public void eat(){System.out.println("狗吃肉");}//方法重写public void sleep(){System.out.println("狗坐着睡");}}//狗类class Dog extends Animal{public void eat(){System.out.println("猫吃鱼");}public void sleep(){System.out.println("猫趴着睡");}}//添加猪类class Pig extends Animal{ //----------note:老忘记写extends!!!!!!!!!!public void eat(){System.out.println("猪吃白菜");}public void sleep(){System.out.println("猪躺着睡");}}//针对动物操作的工具类class AnimalTool{private AnimalTool(){}//最好把工具类的构造方法私有，防止别人创建该类的对象。该类是工具类。//调用猫的功能public static void feedCat(Cat c){ //工具类，方法就写成static的，然后直接在测试类：工具类名.方法 使用。c.eat();c.sleep();}//调用狗的功能public static void feedDog(Dog d){d.eat();d.sleep();}//添加猪的，调用猪的功能public static void feedDog(Dog d){d.eat();d.sleep();}}/*测试类测试类里面不放其他东西（如，定义其他方法）！只能是建对象，调方法。所以新定义了个操作动物的工具类去放feedCat(),feedDog()方法。*/class DuotaiTest{public static void main(String[] args){//我喜欢猫，我养3只猫Cat c= new Cat();Cat c2= new Cat();Cat c3= new Cat();AnimalTool.feedCat(c);AnimalTool.feedCat(c2);AnimalTool.feedCat(c3);//我喜欢狗，我养3只狗Dog d= new Dog();Dog d2= new Dog();Dog d3= new Dog();AnimalTool.feedDog(d);AnimalTool.feedDog(d2);AnimalTool.feesDog(d3);//我喜欢宠物猪//需要定义一个猪类，它继承自动物类，提供两个方法。且在工具类里添加方法。//我喜欢宠物兔、老虎、狼.....//若按上述添加猪的办法做，定义类，继承类，提供方法都是必须要的。//但是在工具类里面改过来改过去，不好。能否做到不改？//能。//见DuotaiTest2.java 中工具类的写法}}
改进后：
采用多态后，易于扩展。
重点在：用Fu f做形参接收参数，用Zi z的z做实参。有了父类引用指向子类。即动物类引用指向各具体的动物类。同时又有方法重写，运行的时候肯定是个各子类重写的方法在起作用。从而利用多态实现好的扩展性。
/*多态的扩展性*//*程序输出结果：狗吃肉狗坐着睡狗吃肉狗坐着睡狗吃肉狗坐着睡---------------猫吃鱼猫趴着睡猫吃鱼猫趴着睡猫吃鱼猫趴着睡---------------猪吃白菜猪躺着睡*///父类：动物类class Animal{public void eat(){System.out.println("eat");}public void sleep(){System.out.println("sleep");}}//猫类class Cat extends Animal{public void eat(){System.out.println("狗吃肉");}public void sleep(){System.out.println("狗坐着睡");}}//狗类class Dog extends Animal{public void eat(){System.out.println("猫吃鱼");}public void sleep(){System.out.println("猫趴着睡");}}//添加猪类class Pig extends Animal{ //----------note:老忘记写extends!!!!!!!!!!public void eat(){System.out.println("猪吃白菜");}public void sleep(){System.out.println("猪躺着睡");}}//针对动物操作的工具类class AnimalTool{private AnimalTool(){}//最好把工具类的构造方法私有，防止别人创建该类的对象。该类是工具类。/*-------------改动-----------------------*///注意：形参是Animal a，用动物接收。 到时候左边是 Fu f, 右边是Zi z， Fu f= Zi zpublic static void feedAnimal(Animal a){ //工具类，方法就写成static的，然后直接在测试类：工具类名.方法 使用。a.eat(); //成员方法：运行看右边：各子类的。（ 不然干嘛方法重写）a.sleep();}}/*测试类测试类里面不放其他东西（如，定义其他方法）！只能是建对象，调方法。所以新定义了个操作动物的工具类去放feedCat(),feedDog()方法。*/class DuotaiTest2{public static void main(String[] args){//我喜欢猫，我养3只猫Cat c= new Cat();Cat c2= new Cat();Cat c3= new Cat();AnimalTool.feedAnimal(c);AnimalTool.feedAnimal(c2);AnimalTool.feedAnimal(c3);System.out.println("---------------");//我喜欢狗，我养3只狗Dog d= new Dog();Dog d2= new Dog();Dog d3= new Dog();AnimalTool.feedAnimal(d);AnimalTool.feedAnimal(d2);AnimalTool.feedAnimal(d3);System.out.println("---------------");//我喜欢宠物猪//需要定义一个猪类，它继承自动物类，提供两个方法。且在工具类里添加方法。//我喜欢宠物兔、老虎、狼.....//若按上述添加猪的办法做，定义类，继承类，提供方法都是必须要的。//但是在工具类里面改过来改过去，不好。能否做到不改？//能。//猫、狗、猪...都是动物，feedAnimal(Animal a)参数接收动物Pig p= new Pig();AnimalTool.feedAnimal(p);}}
多态
1、多态：同一个对象，在不同时刻体现出来的不同状态。
2、多态的前提：
1）要有继承关系或实现关系（接口）；
2）要有方法重写；
3）要有父类或者父接口引用指向子类`Fu f= new Zi()；
注意：形参实参形式的（形参父类实参子类）。
3、多态的分类：
1）具体类多态
class Fu{}class Zi extends Fu{}Fu f= new Zi()//父类引用指向子类
2）抽象类多态（常用）
abstract class Fu{}class Zi extends Fu{}Fu f= new Zi();//抽象父类引用指向子类
3）接口多态（常用）
interface Fu{}class Zi implements Fu{}Fu f= new Zi();//父接口引用指向子类
多态中成员访问特点
如，Fu f= new Zi();//左父类右子类
重点：成员方法，运行时，结果为子类重写的成员方法的结果。
成员变量：编译看左边，运行看左边。
构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
成员方法：编译看左边，运行看右边。（方法重写的意义）
静态方法：编译看左边，运行看左边。静态和类相关，算不上重写，所以访问还是左边的。
提醒：理解这些的时候要记得继承啊方法重写它们存在的意义所在。就好理解啦。
若有收获，就点个赞吧
0 人点赞
