day11_java多态(java三大特性之三)以及抽象和接口

多态

某一个事物在不同时刻表现出的不同状态。

举例：

猫 cat = new 猫();

动物 cat = new 猫();

注：new xxx赋值时，永远从右往左说就不会错

多态：同一对象，在不同时刻体现出来的不同状态

1、多态的前提

1. 有继承关系

2. 有方法重写：如果没有方法重写（调用的方法是一样的）使用意义就不大

3. 有父类的引用指向子类

   父类 对象名 = new 子类(); // 这就是多态
   

2、多态的特点

多态中成员访问的特点

1. 成员变量

   编译看左边，运行看左边（只能写父类有的）

2. 构造方法

   子类构造方法会默认访问父类的构造方法，对父类初始化

3. 成员方法

   编译看左边，运行看右边（父类有该方法，子类重写这个方法）

   why？？？

   因为成员方法有重写（覆盖）（override），所以运行时看右边

4. 静态方法（静态方法是属于类的，只能被继承，不能被重写）

   编译看左边，运行看左边（父类）

3、多态的优缺点

1. 多态的优点:

   1. 提高了代码的维护性（有继承保证）
   2. 提高了代码的扩展性（多态来保证）

   class Animal { // 动物类
       public void eat(){
           System.out.println("吃饭");
       }
       public void sleep(){
           System.out.println("睡觉");
       }
   }
   class Cat extends Animal{ // 猫 < 动物
       public void eat(){
           System.out.println("吃猫粮");
       }
       public void sleep() {
           System.out.println("躺着睡");
       }
   }
   class AnimalUtils { // 动物工具类
       static void useAnimal(Animal animal){
           animal.eat();
           animal.sleep();
       }
   }
   public class Test { // 测试类
       public static void main(String[] args) {
           Animal cat = new Cat();
           AnimalUtils.useAnimal(cat);
       }
   }
   

2. 多态的缺点:

   1. 父类不能用子类特有的方法。

      如果想用子类的特有方法，怎么办？？？

      • 创建子类对象调用方法即可（不推荐）

      Cat cat = new Cat(); // 在堆中重写开辟空间，性能降低。
      

      • 把多态的父类对象强制向下转型

      Animal animal = new cat();// 创建父类多态对象
      Cat cat = (Cat) animal; // 将父类Animal对象强制转型为Cat对象
      

   3、理解多态案例：

自行查看java装爹案例

class 孔子爹 {
    public int age = 40;
    public void teach() {
        System.out.println("讲解JavaSE");
    }
}
class 孔子 extends 孔子爹 {
    public int age = 20;
    public void teach() {
        System.out.println("讲解论语");
    }
    public void playGame() {
        System.out.println("玩原批");
    }
}
 
//Java培训特别火，很多人来请孔子爹去讲课，这一天孔子爹被请走了。
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢？
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹。
//其实就是向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了。
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语(有点露馅)
//k爹.playGame(); //这是儿子才能做的(不能做，做了就露馅了。)
//讲完了，下班回家了。
//脱下爹的装备，换上自己的装备。
//其实就是向下转型
孔子 k = (孔子)k爹; 
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //玩原批

4、多态内存图

抽象

1、抽象的概念：

​ 回想前面的猫狗动物案例其实把他们提取成一个类是不对的。

why？？？

​ 因为：我们不知道是什么动物，只有在看到具体的动物后才知道这是什么动物。所以动物并不是一个具体事物，而是一个抽象事物。只有猫狗才是具体事物。

​ 在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

​ 抽象类，除了子类必须重写抽象方法外，其他的和继承一样

2、抽象类的特点：

1. 抽象类与抽象方法用**abstract**关键字来修饰

2. 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类

3. 抽象类不能直接实例化

4. 抽象类的子类

   1. 抽象类的子类也是抽象类，它可以不用实现具体的抽象方法
   2. 如果子类不是抽象类（具体类），必须重写所有父类的抽象方法

5. 抽象类有具体的子类后，抽象类可以通过多态来实现实例化（向上转型）

   抽象类 对象名 = new 具体子类(xxx);
   

3、抽象类的成员特点：

1. 成员变量：既可以是变量（可以static修饰），也可以是常量（final修饰）

2. 构造方法：抽象类有构造方法

   • 作用：用于子类访问父类时进行数据初始化

3. 成员方法：可以是抽象方法，也可以是非抽象方法（具体/普通方法）

   抽象类中成员方法的特点：

   1、抽象方法 要求具体子类（非抽象子类）必须做（重写）的方法
   2、非抽象方法  子类继承父类的方法（提高代码的复用性）
   

案例：

猫狗案例：
猫：
成员变量：姓名，年龄
成员方法：吃饭（吃鱼），睡觉（趴着睡）
狗：
成员变量：姓名，年龄
成员方法：吃饭（吃狗粮），睡觉（躺着睡）

因为发现上面多个类有共同属性方法，所以我们提取出来单独的类，放这些方法和属性。==》继承

但是他们的吃饭和睡觉方法的具体实现是不一样的，所以我们不用在父类写具体的方法体。==》这个时候我们选择用抽象

abstract class Animal { // 抽象父类
    public String name;
    public int age;
    abstract void eat();
    abstract void sleep();
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Cat extends Animal{ // 实现抽象方法的具体子类
    public void eat(){
        System.out.println("吃鱼");
    }
    public void sleep() {
        System.out.println("躺着睡");
    }
    public Cat(String name, int age) {
        super(name, age);
    }
}
public class Test { // 测试
    public static void main(String[] args) {
        Animal cat = new Cat("小米",2);
        cat.eat(); // 吃鱼
    }
}

4、抽象类中的问题：

1. 一个类没有抽象方法，可不可以被定义为抽象类？？？

   可以，为了不让它被直接实例化

2. abstract不能和哪些关键字共存？

   • private：私有的方法，不能被继承，不能组合
   • final：最终的方法，不能被重写和abstract不符
   • static：静态的方法：由于加载的时间不同static修饰的方法不算重写，所以不能与abstract组合

接口

还是以猫狗案例为例：

如果某一只狗额外的可以钻火圈？？？那么怎么做？？？
为了某一事物，实现额外功能，就可以使用接口来定义，然后谁实现了这个接口，谁就有这个功能

1、接口的特点

1. 用**interface**关键字定义（表示）

   interface 接口名{
       // 接口中的方法是抽象方法，不能写方法体
   	public void study();
   }
   

2. 类实现接口用**implements**来实现

3. 接口不能实例化

   接口不能直接使用，但是**可以通过多态来进行实例化**

4. 接口的子类

   1. 可以是抽象类，但意义不大（不用实现接口的方法）
   2. 可以是具体类，必须重写接口的方法

   由此可见：

   1. 接口的多态：最常用
   2. 抽象类的多态：常用
   3. 具体类的多态：较少用

2、接口的成员特点：

1. 成员变量：都是常量，不管怎么定义，默认会加上**public static final修饰符。建议自己手动给出**
2. 构造方法：没有构造方法，接口主要是扩展功能的
3. 成员方法：只能是抽象方法，默认是**public abstract**修饰

注：接口实现类命名：一般：接口名+impl命名

3、类与类，类与接口，接口与接口

1. 类与类：继承关系，只能单继承，可以多层继承
2. 类与接口：实现关系，可以*实现多个*，可以在继承一个类的同时，实现多个接口
3. 接口与接口：继承关系，可以*多继承*，可以多层继承

4、抽象类与接口的区别

1. 成员区别：

   1. 抽象类：

      ​ 成员变量：可以是变量也可以是常量

      ​ 构造方法：有

      ​ 成员方法：可以是抽象方法，也可以是非抽象方法

   2. 接口：

      ​ 成员变量：常量

      ​ 构造方法：无

      ​ 成员方法：抽象方法（jdk1.8支持default方法和static方法，jdk1.9支持private供default方法调用）

2. 关系区别：

   1. 类与类：继承关系，只能单继承，可以多层继承
   2. 类与接口：实现关系，可以*实现多个*，可以在继承一个类的同时，实现多个接口
   3. 接口与接口：继承关系，可以单继承*多继承*，可以多层继承

3. 设计理念区别：

   1. 抽象类 is a（共性功能）

   2. 接口 like a（扩展功能）

      ​ 构造方法：无

      ​ 成员方法：抽象方法（jdk1.8支持default方法和static方法，jdk1.9支持private供default方法调用）

4. 关系区别：

   1. 类与类：继承关系，只能单继承，可以多层继承
   2. 类与接口：实现关系，可以*实现多个*，可以在继承一个类的同时，实现多个接口
   3. 接口与接口：继承关系，可以单继承*多继承*，可以多层继承

5. 设计理念区别：

   1. 抽象类 is a（共性功能）
   2. 接口 like a（扩展功能）