package duotai.javase.test001;
public class Animal {
public void move(){
System.out.println("动物在移动");
}
}
package duotai.javase.test001;
//鸟儿类
public class Bird extends Animal {
//重写父类中继承过来的方法
public void move(){
System.out.println("鸟儿在飞翔");
}
//子类对象特有的行为
public void fly(){
System.out.println("Bird fly!");
}
}
package duotai.javase.test001;
//猫类
public class Cat extends Animal {
//重写父类中继承过来的方法
public void move(){
System.out.println("猫在走猫步");
}
//不是从父类中继承过来的方法
//这个方法是子类对象特有的行为
public void catchMouse(){
System.out.println("猫捉老鼠");
}
}
package duotai.javase.test001;
/**
* 关于java语言当中的多态语法机制
* 1、Animal、Cat、Bird三个类之间的关系：
* Cat继承Animal
* Bird继承Animal
* Cat和Bird之间没有任何继承关系
*
* 2、面向对象三大特征：封装、继承、多态
*
* 3、关于多态中设计的几个概念：
*
* * 向上转型（upcasting）
* 子类型 --> 父类型
* 又被称为：自动类型转换
*
* * 向下转型（downcasting）
* 父类型 --> 子类型
* 又被称为：强制类型转换【需要加强制类型转换符】
*
* * 需要记忆：
* 无论向上转型或向下转型，两种类型之间必须要有继承关系
* 没有继承关系，程序是无法编译通过的
*
*/
public class Test {
public static void main(String[] args) {
//以前编写的程序
Animal a1 = new Animal();
a1.move(); //动物在移动
Cat c1 = new Cat();
c1.move(); //猫在走猫步
c1.catchMouse(); //猫捉老鼠
Bird b1 = new Bird();
b1.move(); //鸟儿在飞翔
//使用多态语法机制
/**
* 1、Animal和Cat之间存在继承关系，Animal是父类，Cat是子类
*
* 2、Cat is a Animal【合理】
*
* 3、new Cat()创建的对象的类型是Cat，
* a2这个引用的数据类型是Animal，
* 可见它们进行了类型转换，子类型转换成父类型，
* 称为向上转型，或者称为自动类型转换
*
* 4、java中允许这种语法：父类型引用指向子类型对象
*/
Animal a2 = new Cat();
//Bird b2 = new Cat();
//编译报错，因为两种类型之间不存在任何继承关系。
//无法向上或者向下转型
/**
* 1、java程序永远分为编译阶段和运行阶段
*
* 2、先分析编译阶段，再分析运行阶段，编译无法通过，无法运行
*
* 3、编译阶段编译器检查a2这个引用的数据类型为 Animal，
* 由于 Animal.class字节码当中有move()方法，所以编译诵过了。
* 这个过程我们成为静态绑定，编译阶段绑定。
* 只有静态绑定成功之后才有后续的运行。
*
* 4、在程序运行阶段，JVM堆内存当中真实创建的对象是Cat对象，
* 那么以下程序在运行阶段一定会调用Cat对象的move()方法，
* 此时发生了程序的动态绑定，运行阶段绑定。
*
* 5、无论是Cat类有没有重写move方法，
* 运行阶段一定调用的是Cat对象的move方法，
* 因为底层真实对象就是Cat对象。
*
* 6、父类型引用指向子类型对象这种机制导致程序存在
* 编译阶段绑定和运行阶段绑定两种不同的形态/状态，
* 这种机制可以称为一种多态语法机制
*/
a2.move(); //猫在走猫步
/**
* 分析以下程序为什么不能调用？
*
* 因为编译阶段编译器检查到a2的类型是Anima1类型，
* 从Animal.class字节码文件当中查找catchMouse()方法，
* 最终没找到该方法，导致静态绑定失败，没有绑定成功，
* 也就是说编译失败了。别谈运行了。
*/
//a2.catchMouse() //编译错误
/**
* 需求
* 假设想让以上的对象执行catchMouse()方法，怎么办？
* a2无法直接调用的，因为a2的类型Animal，
* Animal中没有catchMouse()方法。
* 我们可以将a2强制类型转换为Cat类型。
* a2的类型是Animal（父类），转换成Cat类型（子类），
* 被称为向下转型/downcasting/强制类型转换。
*
* 注：向下转型也需要两种类型之间必须有继承关系。
* 不然编译报错。强制类型转换需要加强制类型转换符。
*
* 什么时候需要使用向下转型呢？
* 当调用的方法是子类型中特有的，
* 在父类型当中不存在，必须进行向下转型。
*/
Cat c2 = (Cat)a2;
c2.catchMouse(); //猫捉老鼠
//父类型引用指向子类型对象【多态】
Animal a3 = new Bird();
/**
* 1、以下程序编译是没有问题的，因为编译器检查到
* a3的数据类型是Animal，Animal和Cat之间存在继承关系，
* 并且Animal是父类型，Cat是子类型，
* 父类型转换成子类型叫做向下转型，语法合格
*
* 2、程序虽然编译通过了，但是程序在运行阶段会出现异常，
* 因为JVM堆内存当中真实存在的对象是Bird类型，
* Bird对象无法转换成Cat对象，因为两种类型之间不存在
* 任何继承关系，此时出现了著名的异常：
* java.lang.ClassCastException
* 类型转换异常，这种异常总是在向下转型的时候会发生。
*/
//Cat c3 = (Cat)a3;
/**
* 1、以上异常只有在强制类型转换的时候会发生，
* 也就是说向下转型存在隐患（编译过了，但是运行错了！）
*
* 2、向上转型只要编译通过，
* 运行一定不会出问题：Animal a = new Cat()
*
* 3、向下转型编译通过，运行可能错误：
* Anima1 a3 = new Bird(); Cat c3 = (cat)a3;
*
* 4、怎么避免向下转型出现的ClassCastException呢？
* 使用 instanceof运算符可以避免出现以上的异常。
*
* 5、 instanceof运算符怎么用？
*
* 5.1、语法格式：
* （引用 instanceof 数据类型名）
*
* 5.2、以上运算符的执行结果类型是布尔类型，
* 结果可能是true/false
*
* 5.3、关于运算结果true/false：
* 假设：（a instanceof Animal）
* true表示：
* a这个引用指向的对象是一个Animal类型。
* fa1se表示：
* a这个引用指向的对象不是一个Animal类型。
*
* 6、Java规范中要求：在进行强制类型转换之前，
* 建议采用instanceof运算符进行判断，
* 避免ClassCastException异常的发生。这是一种编程好习惯
*/
if(a3 instanceof Cat){
Cat c3 = (Cat)a3;
c3.catchMouse();
}else if(a3 instanceof Bird){
Bird b2 = (Bird)a3;
b2.fly();
}
}
}
package duotai.javase.test001;
public class Test2 {
public static void main(String[] args) {
//父类型引用指向子类型对象
//向上转型
Animal a1 = new Cat();
Animal a2 = new Bird();
//向下转型【只有当访问子类型对象当中特有的方法】
if(a1 instanceof Cat){
Cat c1 = (Cat)a1;
}
if(a2 instanceof Bird){
Bird b1 = (Bird)a2;
}
}
}
package duotai.javase.test002;
/**
* 宠物
*/
public class Pet {
/**
* 所有的宠物都可以吃东西
*/
public void eat(){
}
}
package duotai.javase.test002;
/**
* 宠物小猫
*/
public class Cat extends Pet{
//小猫爱吃鱼
public void eat(){
System.out.println("小猫正在吃鱼！");
}
}
package duotai.javase.test002;
/**
* 宠物小狗
*/
public class Dog extends Pet{
//宠物小狗爱吃骨头
public void eat(){
System.out.println("小狗爱啃骨头!");
}
}
package duotai.javase.test002;
/**
* 主人
*/
//这种方式没有使用java语言当中的多态机制，
//存在的缺点：Master的扩展力很差，
//因为只要加一个新的宠物，Master类就需要添加新的方法。
/*
public class Master {
//喂养宠物的方法
public void feed(Cat c){
c.eat();
}
public void feed(Dog d){
d.eat();
}
}
//Master和Cat、Dog这两个类型的关联程度很强，耦合度很高，扩展力差。
*/
//降低程序的耦合度【解耦合】，
//提高程序的扩展力【软件开发的一个很重要的目标】
public class Master {
//Master主人类面问的是一个抽象的Pet，不再面向具体的宠物
//提倡：面向抽象编程，不要面向具体编程。
//面向抽象编程的好处是，耦合度低，扩展力强。
public void feed(Pet pet){ //Pet pet 是一个父类型的引用
pet.eat();
}
}
package duotai.javase.test002;
/**
* 多态在实际开发中的作用，以下以主人喂养宠物为例说明多态的作用：
*
* 1、分析：主人喂养宠物这个场景要实现需要进行类型的抽象：
* - 主人【类】
* - 主人可以喂养宠物，所有主人有喂养的这个动作
* - 宠物【类】
* - 宠物可以吃东西，所有宠物有吃东西的这个动作
*
* 2、面向对象的核心：定义好类，然后将类实例化为对象，
* 给一个环境驱使一下，让各个对象之间协作起来形成一个系统。
*
* 3、多态的作用是什么？
* 降低程序的耦合度，提高程序的扩展力。
* 能使用多态尽量使用多态。
* 父类型引用指向子类型对象。
*
* 核心：面向抽象编程，尽量不要面向具体编程。
*/
public class Test {
public static void main(String[] args){
//创建主人对象
Master zhangsan = new Master();
//创建猫对象
Cat tom = new Cat();
//主人喂猫
zhangsan.feed(tom); //小猫正在吃鱼！
//创建小狗对象
Dog erHa = new Dog();
//主人喂养小狗
zhangsan.feed(erHa); //小狗爱啃骨头!
}
}
浙公网安备 33010602011771号