final关键字

 final关键字有 "不可更改" 或者 "最终" 的含义，它有以下特点：
    1.final修饰的类不能被继承
    2.final修饰的方法不能被子类重写
    3.final修饰的变量是常量，而且前面一般使用static修饰
    4.final修饰的变量如果是一个引用，仍然只能赋一次值，其保存的对象内存地址不会改变，但是
    对象内部的数据是可以改变的

注意： 
    当局部变量使用 final关键字时，可以在声明变量的同时对变量进行赋值，也可以先声明变量然后
    再进行有且只有一次的赋值。当实例变量使用 final关键字时，在声明变量的同时必须进行初始化
    赋值，否则程序编译报错。又因为实例变量是在构造方法执行的时候开始初始化，所以另一种写法
    就是，声明变量时不赋值，在构造方法内再赋值。但这种情况很少出现。
    public class User {
        final double weight;
        public User() {
            this.weight = 80;
        }
    }  

抽象类

 将类和类之间的公共部分抽取出来，就形成了抽象类
    1.abstract 可以用来修饰方法也可以修饰类，修饰方法，那么该方法就是抽象方法;如果修饰类，那么该类就是抽象类。
    2.抽象类中可以没有抽象方法,但是有抽象方法的类，一定要声明为抽象类
    3.抽象类不能创建对象，它是用来让子类继承的
    4.抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
    5.子类继承抽象类，必须要实现抽象类中没有实现的抽象方法,否则该子类也要声明为抽象类

抽象类及抽象方法的格式：
   //定义抽象类
   [修饰符] abstract class 类名 {
       //定义抽象方法
       public abstract 返回值类型 方法名();
  }  

 //定义抽象类
public abstract class Animal {
   //定义抽象方法
   public abstract void shout();
}
============================
//定义Dog类继承抽象类 Animal    
public class Dog extends Animal {
   //实现抽象方法 shout()，编写方法体
   @Override
   public void shout() {
       System.out.println("汪汪。。。");
  }
}
============================
public class Application {
   public static void main(String[] args) {
       Dog dog = new Dog(); //创建 Dog类实例对象
       dog.shout();
  }
}  

接口

 1.接口也是一种"引用数据类型"，编译之后也是一个 class 字节码文件
2.接口是完全抽象的，它是特殊的抽象类

接口的语法：
    [修饰符列表] interface 接口名 {
        ......
    }

3.接口支持多继承，一个接口可以继承多个父接口
4.接口中只有常量和抽象方法两部分内容，常量必须初始化赋值，抽象方法不能有方法体
5.接口中常量可以省略 "public static final"修饰符，抽象方法可以省略"public abstract" 
6.接口中所有的元素都是公开的，public修饰的
7.访问接口中的常量方式："接口名.常量名"
8.接口中的静态方法可以通过 "接口名.方法名" 调用，而抽象方法只能通过接口实现类的对象调用
9.实现类在实例化new对象后，可使用多态机制然后调用方法

定义接口的实现类的语法格式：
    修饰符 class 类名 implements 接口名 {
       ...
    }

1.类和类之间叫继承，类和接口之间叫"实现"，也可以看作是继承，使用关键字 implements ,实现类需要重写接口中的所有抽象方法, public 必须加上
2.一个类可以在继承另一个类的同时实现多个接口，并且多个接口之间使用英文逗号分隔。

注意：
    接口和接口之间在进行强制类型转换时，没有继承关系也可以强转，但是运行时可能出现类型转换异常  

接口特点归纳

 1.在JDK8之前，接口中的方法必须都是抽象的，不能包含方法体。在调用抽象方法时，必须通过接口的实现类的对象才能调用实现方法。从 JDK8开始，接口中的方法除了包含抽象方法以外，还包含默认方法和静态方法，都可以有方法体，且静态方法可以就直接通过"接口名.方法名" 调用。

2.一个类可以通过 implements 关键字同时实现多个接口，被实现的多个接口之间用英文逗号隔开

3.接口之间可通过 extends 关键字实现继承，一个接口可以同时继承多个接口

4.一个类在继承一个类的同时还可实现接口，此时， extends 关键字必须位于 implements 关键字之前  

 //接口使用 interface 关键字,接口都需要有实现类
public interface UserService {
   void add(String name); //增
   void delete(String name); //删
   void update(String name); //改
   void query(String name); //查
}
==================================
//定义一个接口实现类 使用关键字 implements
class UserServiceImpl implements UserService {
   //需要重写接口里面的抽象方法
   @Override
   public void add(String name) {
   }
   @Override
   public void delete(String name) {
   }
   @Override
   public void update(String name) {
   }
   @Override
   public void query(String name) {
   }
}

面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则。接口的使用离不开多态机制。接口都有调用者和实现者，接口可以将调用者和实现者解耦合。调用者面向接口调用，实现者面向接口编写实现。  

访问修饰符

 Java中针对类，成员方法和属性提供了4种访问级别：
    private default protected public
    
1.private（当前类访问级别）：
    如果类的成员被 private 访问控制符来修饰，则这个成员变量只能被该类的其他成员访问，其他类无法直接访问，封装就是通过 private 关键字实现的
    
2.default（包访问级别）：
    如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认控制级别，这个类或者类的成员只能被本包中的其他类访问
    
3.protected（子类访问级别）：
    如果一个类的成员被 protected 访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问
    
4.public（公共访问级别）：
    如果一个类或者类的成员被 public 访问控制符修饰，那么这个类或者类的成员能被所有的类访问