认识Java的第十一天（上）——接口

接口，是一种引用类型，是方法的集合，如果说类的内部封装了成员变量，成员方法和构造方法，那么接口的内部主要是封装了方法，包含抽象方法(JDK1.7以前),默认方法，静态方法(JDK1.8)，私有方法(JDK1.9)
接口的定义，它与类定义的方法差不多，定义接口使用interface,它也会编译成.class文件，但是一定要明确它并不是一个类，而是另外一种引用类型。
引用类型：数组，类，接口
接口的使用，不能创建对象，但是可以实现(implements，类似于前面的将的继承)，一个实现类（可以看做接口的一个子类），需要实现接口中的所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

定义格式：
public interface 接口名称{
//抽象方法
//默认方法
//静态方法
//私有方法
}

含有抽象方法

抽象方法：使用abstract关键字修饰，可以省略，没有方法体，该方法供子类使用

public interface test11 {
    public abstract void method();
    //含有抽象方法，关键字abstract可以省略，方法中没有方法体，供子类使用
    }

含有默认方法和静态方法

默认方法：使用default修饰，不可以省略，供子类调用或者子类重写
静态方法：使用static关键字修饰，供接口直接调用

public interface test11 {
    //默认方法
    public default void method1(){
        //执行代码
    }
    //默认方法中default不能省略，必须有方法体。子类可以使用也可以选择重写
    //静态方法
    public static  void method2(){
        //执行代码
    }
    //使用static关键字修饰的方法，也可以有方法体的。
}

含有私有方法和私有静态方法

私有方法：使用private修饰，供接口中的默认方法或者静态方法调用（jdk1.9）

public interface test11 {
    //默认方法
    public default void method1(){
        //执行代码
        method3();//在默认方法中调用私有的方法
    }
    //静态方法
    public static  void method2(){
        //执行代码
        method4();
    }
    //私有方法
    private void method3(){
    //代码
    }
    //私有静态的方法
    private static void method4(){
    //代码
    }
}

基本实现

类和接口的关系就是实现关系，即类实现接口，该类就称为我们的接口的实现类，或者接口的子类。用到我们的implements关键字。

非抽象的子类实现接口：
1 、必须要重写接口中的所有的抽象方法
2、继承了接口的默认方法，即可直接调用方法，也可以选择重写。
class 类名 implements 接口名{
//重写接口中的所有的抽象方法）[必须重写]
/ /重写接口中的默认方法[选择性]
}

抽象方法的使用

必须全部实现

public interface test12 {
    public abstract void eat();
    public abstract void sleep();
}

public class test121 implements test12{
    @Override
    public void eat() {
        System.out.println("苹果");
    }

    @Override
    public void sleep() {
        System.out.println("家");
    }
}

public class test1211 {
    public static void main(String[] args) {
        test121 animal=new test121();
        animal.eat();
        animal.sleep();
    }
}

默认方法的使用

可以继承，也可以重写，但是只能通过实现类的对象去使用
继承:

public interface test12 {
    public  default void fly(){
        System.out.println("我可以飞");
    }
}

public class test121 implements test12{

}

public class test1211 {
    public static void main(String[] args) {
        test121 animal=new test121();
        animal.fly();
    }
}

重写：

public class test121 implements test12{
    @Override
    public void fly() {
        System.out.println("我不飞了");
    }
}

静态方法的使用

静态与class文件有关系，只能使用接口名去调用，不可以通过实现类或者实现类的对象去调用

public interface test12 {

    //静态的方法
    public static void run(){
        System.out.println("我可以跑！");
    }
}

public class test121 implements test12{
//在子类这种不可以重写接口中的静态方法
}

public class test1211 {
    public static void main(String[] args) {
        test12.run();//调用接口中的静态方法的发法
        //test121.run();只能通过接口名去调用方法，其他的方式都不行
        //animal.run();
    }
}

私有的方法使用

私有方法：只能默认方法可以调用
私有静态方法：默认方法和静态方法可以调用
如果一个接口中的有多个默认方法，并且方法中有重复内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用，从设计角度来看，私有方法就是对默认方法和静态方法辅助的一个特点。

public interface  Interface{
//默认方法
    default void fun(){
        fun1();
    }
    //私有方法
    private void fun1(){
        System.out.println("aa");
    }
}

public class test {
    public static void main(String[] args) {
       Animal1 animal=new Animal();
        animal.fun();
    }
}