day09总结

final关键字：

1. 是最终的意思，可以修饰类，方法，变量；
2. 特点：
   • 它修饰的类，不能被继承。
   • 它修饰的方法，不能被重写。
   • 它修饰的变量，是一个常量，只能进行第一次的赋值
3. 面试相关：
   1. 局部变量：
      1. 基本类型：值不能发生改变。
      2. 引用类型：地址值不能发生改变，但是对象的内容却是可以改变的。
   2. 初始化时机
      1. 只能初始化一次。
      2. 常见的给值：定义的时候（推荐），构造方法中

多态：

1. 同一个对象在不同的时刻体现出来的不同状态。
2. 多态的前提：
   1. 有继承或者实现的关系
   2. 有方法重写
   3. 有父类或者父接口引用指向子类对象
3. 多态的分类：
   1. 具体类多态（父类调用子类）
      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();
4. 多态中的成员访问特点
   1. 成员变量：
      编译看左边，运行看左边
   2. 构造方法：
      子类的构造都会默认访问父类构造
   3. 成员方法：
      编译看左边，运行看右边
   4. 静态方法：
      编译看左边，运行看左边
      
      为什么只有成员的方法运行看右边呢？
                 因为成员方法有重写。
5. 多态的好处：
   1. 提高代码的维护性（继承体现）
   2. 提高代码的扩展性（多态体现）
6. 多态的弊端：
          父不能使用子的特有功能。
   
         现象：
                  子可以当做父使用（因为子类的功能比父类多），但是父不能当做子使用。
7. 多态的转型
   1. 向上转型：从子到父
   2. 向下转型：从父到子
8. 孔子装爹的案例帮助大家理解多态
9. 多态的练习
   1. 猫狗案例
   2. 老师和学生案例

 

抽象类

1. 把多个共性的东西提取到一个类中，这是继承的做法。
   但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体不一样。
   也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
   所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
   而一个没有具体的方法体的方法是抽象的方法。
   在一个类中如果有抽象方法，该类就必须定义为抽象类。
    
2. 抽象类的特点
   1. 抽象类和抽象方法必须时候关键字abstract修饰
   2. 抽象类中不一定有抽象方法，但是有抽象方法的类一定是一个抽象类
   3. 抽象类不能实例化
   4. 抽象类的子类
      1. 是一个抽象类
      2. 是一个具体类（但是这个类必须重写父抽象类中的所有抽象方法）
3. 抽象类的成员提点：
   1. 成员变量：
           有变量，有常量
   2. 构造方法：
           有构造方法
   3. 成员方法：
           有抽象方法，也有非抽象的方法
4. 抽象类的练习
   1. 猫狗案例练习
   2. 老师案例练习
   3. 学生案例练习
   4. 员工案例练习
5. 抽象类的几个小问题
   1. 抽象类有构造方法，而且不能够被实例化，那么构造方法有什么用呢？
           用于子类访问父类数据的初始化
   2. 一个类如果没有抽象方法，却定义为了一个抽象类，有什么用？
           为了不让创建对象
   3. abstract关键字不能和哪些关键字共存
      1. final 冲突
      2. private 冲突
      3. static 无意义

 

接口

1. 回顾猫狗案例，它们仅仅提供一些基本的功能
        比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
        是在后面的培养中训练出来的，这种额外的功能，JAVA提供了接口表示
2. 接口的特点：
   1. 接口用关键字interface修饰
            interface    接口名   {}
   2. 类实现接口用implements修饰
            class  类名  implements   接口名{}
   3. 接口不能实例化（同抽象类一样，都不许被实例化）
   4. 接口的实现类
      1. 是一个抽象类
      2. 是一个具体类，这个类必须重写接口中的所有抽象方法。
3. 接口的成员特点：
   1. 成员变量
           只能是常量
           默认修饰符：public static final
   2. 构造方法
           没有构造方法
   3. 成员方法
           只能是抽象的
           默认修饰符：public abstract
4. 类与类，类与接口，接口与接口
   1. 类与类
           继承关系，只能单继承，但是可以进行多层继承
   2. 类与接口
           实现关系，可以单实现，也可以多实现。
           还可以在继承一个类的同时，实现多个接口。
   3. 接口与接口
           继承关系，可以单继承，也可以多继承
5. 抽象类与接口的区别？
   1. 成员区别
           抽象类：可以是常量，也可以是变量
           接口：只能是常量
   2. 关系区别：
           类与类：继承关系，只能单继承，但是可以进行多层继承
           类与接口：实现关系，可以单实现，也可以多实现。
           还可以在继承一个类的同时，实现多个接口。
           接口与接口：继承关系，可以单继承，也可以多继承
   3. 设计理念不同
           抽象类：is a，抽象类中定义的是共性功能。
           接口：like a ，接口中定义的是扩展性的功能。
6. 练习：
   1. 猫狗案例，加入跳高功能
   2. 老师和学生案例，加入抽烟功能