1:final关键字(掌握)
  (1)是最终的意思,可以修饰类、方法、变量
  (2)特点:
    它修饰的类,不能被继承。
    它修饰的方法,不能被重写。
    它修饰的变量,是一个常量。
  (3)面试相关:
    A:局部变量
      a:基本类型  值不能发生改变
      b:引用类型  地址值不能发生改变,但是对象的内容是可以改变的
    B:初始化时机:
      a:只能初始化一次
      b:常见给值
        定义的时候。(推荐)
        构造方法中。
        
2:多态(掌握)
  (1)同一个对象在不同的时刻体现出不同的状态。
  (2)多态的前提:
    A:有继承或者实现关系。
    B:有方法重写
    C:有父类或者父接口引用指向子类对象。

    多态的分类:
      a:具体类多态
        class Fu{}
        class Zi extends Fu{}
        
        Fu f = new Zi();
      b:抽象类多态
        abstract calss Fu{}
        class Zi extends Fu{}
        
        Fu f = new Zi();
      c:接口多态
        interface Fu{}
        class Zi implements Fu{}
        
        Fu f = new Zi();
  (3)多态中的成员访问特点
    A:成员变量
      编译看左边,运行看右边
    B:构造方法
      子类的构造方法默认访问父类的构造
    C:成员方法
      编译看左边,运行看右边
    D:静态方法
      编译看左边,运行看左边
      
    为什么？
      因为成员方法有重写。
  (4)多态的好处:
    A:提高代码的维护性(继承体现)
    B:提高代码的扩展性(多态体现)
  (5)多态的弊端:
    父类不能使用子的特有功能。
    
    现象:
      子可以当作父使用,父不能当作子使用。
  (6)多态中转型
    A:向上转型
      从子到父
    B:向下转型
      从父到子
  (7)孔子装爹案例多态的问题理解:
    class 孔子爹{
      public int age = 40;
      
      public void teach(){
        System.out.println("讲解JavaSE");
      }
    }
    
    class 孔子 class 孔子爹{
      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();//英雄联盟
  (8)多态的练习
    A:猫狗案例练习
    B:老师和学生案例练习
    
3:抽象类(abstract)(掌握)
  (1)把多个共性的东西提取到一个类中,这是继承的做法。
     但是呢,这多个共性的东西,在有些时候,方法声明一样,但是方法体不同。
     也就是说,方法声明一样,但是每个具体的对象在具体实现的时候内容不一样。
     所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。
     而一个类没有具体的方法体的方法是抽象方法。
     在一个类中如果有抽象方法,该类必须定义为抽象类。
  (2)抽象类的特点
    A:抽象类和抽象方法必须用关键字abstract修饰
    B:抽象类中不一定有抽象方法,但是有抽象方法的类就是抽象类
    C:抽象类不能实例化
    D:抽象类的子类
      a:是一个抽象类。
      b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。  
  (3)抽象类的成员特点:
    A:成员变量
      有变量,有常量
    B:构造方法
      有构造方法
    C:成员方法
      有抽象方法,有非抽象
  (4)抽象类的练习
    A:猫狗案例练习
    B:老师案例练习
    C:学生案例练习
    D:员工案例练习
  (5)抽象类的几个小问题
    A:抽象类有构造方法,不能实例化,那么构造方法有什么用?
      用于子类访问父类数据的初始化
    B:一个类如果没有抽象方法,却定义了抽象类,有什么用?
      为了不让创建对象
    C:abstract不能和那些关键字共存?
      a:final    冲突  抽象方法子类必须重写,而final不能让子类重写了。
      b:private  冲突  抽象方法子类必须重写,而private是私用修饰符,本来要求让子类重写,结果子类无法重写了。
      c:static  无意义  类可以直接调用static,但是调用访问没方法体的方法,无意义。
      
4:接口(interface)(掌握)
  (1)回顾猫狗案例,它们仅仅偍供一些基本功能。
     比如:猫钻火圈,狗跳高等功能,不是动物本身就具备的,
     是在后面的培养中训练出来的,这种额外的功能,java提供了接口表示。
  (2)接口的特点:
    A:接口用关键字interface修饰
      interface 接口名{}
    B:类实现接口用implements修饰
      class 类名 implements 接口名{}
    C:接口不能实例化
    D:接口的实现类
      a:是一个抽象类
      b:是一个具体类,这个类必须重写接口中的所有抽象方法。
  (3)接口的成员特点:
    A:成员变量
      只能是常量
      默认修饰符:public static final
    B:构造方法
      无
    C:成员方法
      只能是抽象的
      默认修饰符:public abstract 
  (4)类与类,类与接口,接口与接口
    A:类与类:
      继承关系,只能单继承,可以多层继承
    B:类与接口:
      实现关系,可以单实现,也可以多实现。
      并且还可以在继承一个类的同时实现多个接口。
    C:接口与接口:
      继承关系,可以单继承,也可以多继承
  (5)抽象类和接口的区别:(面试题)
    A:成员区别
      抽象类:
        成员变量:可以变量,也可以常量
        构造方法:有。
        成员方法:可以抽象,也可以非抽象
      接口:
        成员变量:只可以常量
        成员方法:只可以抽象
    B:关系区别
      类与类
        继承关系,可以单继承,也可以多层继承
      类与接口
        实现关系,可以单实现,也可以多实现
      接口与接口
        继承关系,可以单继承,也可以多继承  
    C:设计理念区别
      抽象类
        被继承体现的是:"is a"的关系。抽象类中定义的是该继承体系的共性功能。("is a" = 什么是什么)
        例:狗是动物
      接口:
        被实现体现的是:"like a"的关系。接口中定义的是该继承体系的扩展功能。("like a" = 什么象什么。
        它本身并不具备,但是随着什么什么发展添加了新东西,这叫接口[相当与电脑上的usb接口,只要按照接口来,就能连接])
        
  (6)练习
    A:猫狗案例,加入跳高功能
    B:老师和学生案例,加入抽烟功能