1、关键字final（最终的）
    (1) 可以修饰变量，变量只能被赋值一次；
    (2) 可以修饰方法，方法不能被重写；
    (3) 可以修饰类，这个类不能被继承；
    Final关键字修饰属性（成员变量）时，属性必须初始化（赋值）。
    声明属性时直接初始化 public static final
    通过构造方法对属性进行初始化。
    2、常量
    Static 和final 一起修饰的属性，才可以称之为常量。
    常量在定义时直接赋值，且属性名称全部大写，多个单词中间用下划线隔开。

    1. //常量的调用格式：类名 . 属性名
    2. Public static final int SARRAY = 2000；
    3. Public People(byte age){
    4. This.age = age ;
    5. }
    6. //属性调用
    7. People p = new People((byte) 21);
    8. P.name = “姓名”;

    3、抽象类
    关键词abstract：抽象
    抽象方法：只有方法的声明，没有方法体。 

    1. Public abstract void running();
    2. Public abstract void sleep();

    抽象类中可以包含： 成员变量、静态变量、成员方法、静态方法、也可以有抽象方法
    抽象类不能被实例化（不能创建对象），不能多继承。
    只要一个类中有抽象方法，那么这个类一定（必须）是抽象类
    只要类上有abstract声明，这个类一定是抽象类；抽象类中不一定有抽象方法。

    1. public abstract class Animal {
    3.     public String name;
    4.     public static byte age ;
    5.     public String color;
    7.     public void eat() {
    8.         System.out.println("eat......");
    9.     }

    构造方法、静态方法、私有权限的方法、添加final关键词的方法都不能是抽象方法。
    原因：构造方法、静态方法、私有方法、final方法都不能被继承，而抽象方法必须被重写才能使用，两者互相矛盾。
    普通子类继承抽象类后，必须重写（实现）父类的抽象方法

    1. public class Dog extends Animal{
    3.     @Override
    4.     public void running() {
    5.         System.out.println("在地上跑");
    6.     }
    8.     @Override
    9.     public void sleep() {
    10.         System.out.println("睡觉");
    11.     }
    12. }

    4、接口
    Interface 定义接口的关键词
    接口文件中，所有的属性都是静态常量，所有的方法都是抽象方法。
    接口中只包含静态常量和抽象方法。
    定义接口中的常量时, 前面会自动添加 public static final；
    定义接口中的抽象方法时，方法前会自动添加 public abstract void；
    接口不可以直接被实例化，且不包含构造方法。
    一个类可以实现多个接口，接口不能继承抽象类，抽象类可以实现接口。

    1. Public interface Demo{
    2. //定义静态常量
    3. Public styatic final byte AGE = 20;
    4. String name = “姓名”；
    5. //定义抽象方法
    6. Public abstract void sleep();
    7. //jdk1.8 版本后，抽象类中可以使用静态方法
    8. Public static void eat(){
    9. System.out.println(“吃饭”)
    10. }
    11. }