「学完这个」

1.多态

1.1 多态的概念

什么是多态
- 同一个对象，在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象

1.2多态中的成员访问特点

成员访问特点
- 成员变量编译看父类，运行看父类
- 成员方法编译看父类，运行看子类
案例
- 动物类

     public class Animal {
     public int age = 10;

     public void eat() {
         System.out.println("动物吃东西");
         }
    }

猫类

      public class Cat extends Animal {
        public int age = 20;
        public int weight = 10;
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        public void playGame() {
            System.out.println("猫玩游戏");
        }
      }

1.3多态的好处和弊端

好处
- 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端
- 不能使用子类的特有成员

1.4多态中的转型

向上转型
- 父类引用指向子类对象就是向上转型
向下转型
- 格式：子类型对象名 = (子类型)父类引用
代码

   //描述动物类，并抽取共性eat方法
 abstract class Animal {
  abstract void eat();
 }
  
 // 描述狗类，继承动物类，重写eat方法，增加lookHome方法
 class Dog extends Animal {
  void eat() {
   System.out.println("啃骨头");
  }
 
  void lookHome() {
   System.out.println("看家");
  }
 }
 
 // 描述猫类，继承动物类，重写eat方法，增加catchMouse方法
 class Cat extends Animal {
  void eat() {
   System.out.println("吃鱼");
  }
 
  void catchMouse() {
   System.out.println("抓老鼠");
  }
 }
 
 public class Test {
  public static void main(String[] args) {
   Animal a = new Dog(); //多态形式，创建一个狗对象
   a.eat(); // 调用对象中的方法，会执行狗类中的eat方法
   // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用
   
   // 为了使用狗类的lookHome方法，需要向下转型
 // 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常
   // 那么，在转之前需要做判断 
   if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
      System.out.println("类型不匹配，不能转换"); 
      return; 
   } 
   Dog d = (Dog) a; //向下转型
   d.lookHome();//调用狗类的lookHome方法
  }
 }

多态总结
什么时候使用向上转型：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。

如：Animal a = new Dog(); a.eat();

什么时候使用向下转型当要使用子类特有功能时，就需要使用向下转型。

如：Dog d = (Dog) a; //向下转型

d.lookHome();//调用狗类的lookHome方法

向下转型的好处：可以使用子类特有功能。

弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。如：if( !a instanceof Dog){…}

2.抽象类

2.1 抽象类的概述

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

2.2 抽象类的特点

被「abstract」关键字修饰

  //抽象类的定义
 public abstract class 类名 {}

 //抽象方法的定义
 public abstract void eat();

「抽象类」中不一定有「抽象方法」，有抽象方法的「类」一定是「抽象类」
抽象类不能实例化
- 那咋整？通过子类对象实例化抽象类，以抽象类多态的方式完成这个操作就OK。
抽象类的子类
- 要么重写抽象类里面的方法
- 要么，一样作为抽象类

2.3抽象类的成员特点

成员的特点
- 成员变量
  - 既可以是常量
  - 也可以是变量
- 构造方法
  - 空参
  - 有参
- 成员方法
  - 普通方法
  - 抽象方法（abstract）
例子

 public abstract class Animal {
  private int age = 20;
    private final String city = "北京";
    public Animal() {}
 
    public Animal(int age) {
        this.age = age;
    }
    public void show() {
        age = 40;
        System.out.println(age);
 //        city = "上海";
        System.out.println(city);
    }
 
    public abstract void eat();
 
 }

3接口

3.1 接口的概述

其实就是比抽象类更抽象的东西，是个规范代码的模板

3.2接口的特点

使用关键字interface修饰

  public interface 接口名 {}

类实现接口用implements表示

    public class 类名 implements 接口名 {}

接口不能实例化
- 接口只能够参照多态的方式，通过实现类对象实例化。其中，「多态的形式」：具体类多态，抽象类多态，接口多态
接口的子类
- 要么重写接口中的所有抽象方法
- 要么子类也是抽象类

3.3 接口的成员特点

成员特点
- 成员变量
  - 只能是常量，默认修饰符： public static final
- 构造方法
  - 没有，因为接口只要是扩展功能的，而没有具体存在
- 成员方法
  - 只能是抽象方法
  - 默认修饰符： public abstract

3.4 接口的总结

接口用来个别具体类的实现，会自动继承接口中的抽象方法给这类继承他的类。
接口解耦性非常棒，一个优秀的系统，耦合性越低越好
接口中的方法一定都会被继承他的类实现，如果少继承了或者没有继承会报错。
接口在Java中拥有多继承的意义，因为c++里有多继承，而Java为了完整的面对对象就拒绝了多继承，使用接口。

别跑，还有一个点接口用实现类实现其方法，便于无损替换，维护很方便这里打个比方例如你采用List list = new ArrayList (); 有一天觉得ArrayList线程安全问题困扰了你，需要换成LinkedList ，这时候只需要更换指向就可以了。 (此处摘抄自简书作者@博博_ )

学完了这个，我只想说