第十五节（多态，接口和抽象类的区别，类之间的关系）

多态的定义：


1. 多态是同一个行为具有多个不同表现形式或形态的能力

2. 多态性是对象多种表现形式的体现 

比如我们说"宠物"这个对象，它就有很多不同的表达或实现，比如有小猫、小狗、蜥蜴等等。

那么我到宠物店说"请给我一只宠物"，服务员给我小猫、小狗或者蜥蜴都可以，我们就说"宠物"

这个对象就具备多态性。


多态的条件是：有继承或实现，有方法覆盖或实现，父类对象(接口) 指向子类对象

public class Animal{
    
    // 成员方法
    public void eat(){
        System.out.println("动物在吃 ！");    
    }

}


/*
    小猫

*/
public class Cat extends Animal{

    public void eat(){
        System.out.println("猫吃鱼 ！");    
    }
    
    // Cat特有的方法
    public void move(){
        System.out.println("猫走猫步 ！");    
    }
    
}
/*
    小狗
*/
public class Dog extends Animal{

    public void eat(){
        System.out.println("小狗啃骨头 ！");    
    }
    
    
}
public class Test01{
    
    // java入口
    public static void main(String[] args){
        
        Animal a = new Animal();
        a.eat();
        
        Cat c = new Cat();
        c.eat();
        c.move();
        
        Dog d = new Dog();
        d.eat();               
    }

}

/*
    关于Java语言中向上转型和向下转型
        1. 向上转型：子 --> 父类
        2. 向下转型：父 --> 子
    
    注： 无论是向上转型 还是 向下转型，两个类之间必须要有继承关系
    
    使用多态的好处：
        1. 使用多态可以使代码之间的耦合度降低
        2. 项目的拓展能力增强
        
    多态的条件是：
        1. 有继承或实现
        2. 有方法的覆盖 或 实现
        3. 父类对象（接口）指向子类对象

*/
public class Test02{

    public static void main(String[] args){
        
        // 向上转型又被称为：自动类型转换
        // 父类型的引用指向子类对象
        // 程序分为两个阶段：编译阶段，运行阶段
        // 程序编译阶段只知道a1是一个Animal类型
        // 程序在运行的时候堆中的实际对象 是Cat类型
        Animal a1 = new Cat();
        
        // 程序在编译阶段a1被编译器看做是 Animal类型
        // 所以程序在编译阶段 a1引用绑定的是Animal类中的eat方法
        // 程序在运行的时候堆中的对象实际上是 Cat类型，而Cat已经重写了eat方法
        // 所以程序在运行时阶段对象绑定的方法是Cat中的eat方法 （动态绑定）
        a1.eat();
        
        // 向下转型：强制类型转换
        Animal a2 = new Cat();
        
        Cat c1 = (Cat)a2;
        
        c1.move();
        
        
        // 向下转型: 
/*        Animal a3 = new Dog();
        Cat c2 = (Cat)a3; //报错java.lang.ClassCastException
*/

        // 在做强制类型转换的时候，程序是存在风险的 ！
        // 为了避免 ClassCastException 的发生，Java中使用 instanceof
        
        /*
            用法： 
                1. instanceof运算符的运算结果是 boolean类型
                2. （引用 instanceof 类型） ---> true/false
        */
        
        Animal a4 = new Dog();
        
        // a4 instanceof Cat 如果结果是true表示： a4引用指向堆中的Java对象是Cat类型
        System.out.println(a4 instanceof Dog); // false
        
        
        // 推荐：在做向下转型时候需要使用到instanceof 运算符判断，避免ClassCastException
        if(a4 instanceof Dog){
            System.out.println("为真 ！");
            Dog c3 = (Dog)a4;    
        }
        
    }

}

接口和抽象类的区别？
a) 接口描述了方法的特征，不给出实现，一方面解决 java 的单继承问题，实现了强大的可接插性

b) 抽象类提供了部分实现，抽象类是不能实例化的，抽象类的存在主要是可以把公共的代码移植到抽象类中

c) 面向接口编程，而不要面向具体编程（面向抽象编程，而不要面向具体编程）

d) 优先选择接口（因为继承抽象类后，此类将无法再继承，所以会丧失此类的灵活性）

类之间的关系
1. 泛化关系：
          类和类之间的继承关系及接口与接口之间的继承关系
  2. 实现关系：
          类对接口的实现
  3. 关联关系：
          类与类之间的连接，一个类可以知道另一个类的属性和方法，在 java 语言中使用成员变量体现
  4. 聚合关系：
          是关联关系的一种， 是较强的关联关系，是整体和部分的关系，如：汽车和轮胎， 它与关联关系不同关联关系的类处在同一个
层次上， 而聚合关系的类处在不平等的层次上，一个代表整体，一个代表部分，在 java 语言中使用实例变量体现。
  5. 合成关系：
          是关系的一种， 比聚合关系强的关联关系， 如：人和四肢，整体对象决定部分对象的生命周期，部分对象每一时刻只与一个对
象发生合成关系，在 java 语言中使用实例变量体现
6. 依赖关系：
依赖关系是比关联关系弱的关系，在 java 语言中体现为返回值，参数，局部变量和静态方法调用