Java 中的接口，抽象类区别，访问控制符

接口（Interface）
   （1）接口是抽象类的延伸，可以把它看为是纯粹的抽象类，接口中所有的方法都没有方法体。
    都是抽象方法。
   （2）如果一个类中所有的方法都是抽象的，则可以将其定义为接口。
   （3）接口比抽象类更抽象，全抽。
   （4）java中，子类只能继承一个直接的父类（抽象类） ，但是接口可以被多继承
        子类继承 多个接口，严格来说叫实现接口，关键字是 
         implements
   （5）接口的声明
         Interface 接口名{}

　　例子：

public interface Animal {
    //成员属性static final 修饰的 必须要进行初始化
    String name = "动物";
    public static final String type = "活动";
    /*public Animal() {
        会提示这个错误  Interfaces cannot have constructors
    }*/
    
    //abstract  是默认的，不进行声明也是默认存在的
    public abstract void eat();
    public void jump();
}

继承：

public class Tiger implements Animal{

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is eating meat ");
    }

    @Override
    public void jump() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is jumping ");
    }

写一个测试的类：

public class InterfaceTest {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        tiger.eat();
        tiger.jump();

测试结果：

Tiger is eating meat 
Tiger is jumping 

再声明一个接口

public interface Life {
　　//接口中的方法都是抽象方法 可以不用abstract 修饰
    public abstract void breath();
    public void death();
}

测试类的继承：

public class Tiger implements Animal,Life{

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is eating meat ");
    }

    @Override
    public void jump() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is jumping ");
    }

    @Override
    public void breath() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is Breathing");
    }

    @Override
    public void death() {
        // TODO Auto-generated method stub
        System.out.println("Tiger is going to die");
    }

}

测试类：

public class InterfaceTest {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        tiger.eat();
        tiger.jump();
        tiger.breath();
        tiger.death();
    }
}

结果：

Tiger is eating meat 
Tiger is jumping 
Tiger is Breathing
Tiger is going to die

接口和抽象类的区别

接口与抽象类的区别
   （1）接口：
    接口中定义的方法不能有方法体（除了 default 修饰的 1.8新增的特性）默认都是 public abstract
    接口中定义的变量都是常量，默认是 public static final
    接口中不能有构造方法
    接口不能够被实例化
    接口可以被多实现，用implements关键字，多个接口之间的用逗号分开
    （继承只能实现一个直接的父类）
  （2）抽象类
    抽象类可以有抽象方法也可以有普通方法（具体的方法），抽象类中可以有常量，
    也可以有非常量
    抽象类中可以有构造方法
    如果抽象类在子类对象创建时候，会自动创建抽象类的对象。
    抽象类只能够单继承
    一个爹（类包括 抽象类） 多个领导（接口）

访问控制权限（public private protected  default）

1）public:用 public修饰的类、类的属性及方法，可以包内及包外（包括子类和普通类）均可以访问；
（2）protected：用 protected修饰类、属性 及方法，包内的任何类以及包外继承的子类可以访问。
（3）default：可以不用写 只有包内（包括继承了此类的子类）的可以访问，包外的
               任何类不能访问（包括继承的子类）
（4）private：用private修饰的类、属性变量及方法只能被本类访问。
访问级别    访问控制符    同类      同包    子类    不同的包
公开        public       1        1       1         1
受保护      protected    1        1       1         0
默认        default      1        1       0         0
私有        private      1        0       0         0