JAVA学习_13 接口的概念、抽象方法定义、默认方法定义、静态方法定义和私有方法定义，接口的多继承

1.接口的概念

（1）定义：接口就是一种公用的规范标准。只要符合规范标准，大家都可以使用。

计算机中的接口：接口就是多个类的公共规范，它是一种引用类型，最重要的内容就是其中的：抽象方法。

（2）定义接口的格式：

public interface 接口名称{

      //接口内容

}

（3）接口中包含的内容：

Java 7 ：常量、抽象方法

Java 8 ：常量、抽象方法、默认方法、静态方法

Java 9 ：常量、抽象方法、默认方法、静态方法、私有方法

2.接口中抽象方法的定义和使用。

（1）定义：在任何版本的java中，接口都可以定义抽象方法。抽象方法的格式和普通类中的定义一样：

public abstract 返回值类型 方法名称（参数列表）;

注意：

*接口中的抽象方法，前面两个修饰符public abstract是固定的。但是没有{方法体}；

*这两个关键字修饰符，可以选择性的省略。只写一个或者全部写都对，但是都表示抽象方法。

*方法的返回值类型、参数列表、名称可以随意定义。

（2）接口使用的步骤（创建实现类->覆盖重写接口类的抽象方法->创建实现类的对象）

*实现：接口类不能直接使用，必须要有一个“实现类”来“实现”接口。

格式： public class 实现类名称 implements 接口名称{

           //...

}

*接口的实现类必须覆盖重写接口中的所有的抽象方法。（这里重写抽象类的方法和规则和继承一致）

*创建实现类的对象，进行使用。

3.接口中默认方法的定义和使用。（默认方法可以解决方法升级的问题）

格式：

public default 返回值类型 方法名称（参数列表）{

          //方法体

}

升级：如果一个接口已经有了实现类，且已经投入使用了，但是又需要向接口中添加新的方法，这时候直接添加抽象方法，实现类会因为没有完全重写覆盖所有的抽象类而报错，所以这里提出了默认方法，解决这个问题。

注意：定义接口的默认方法，即使实现类没有重写，实现类的对象也可以直接访问默认方法。因为调用方法时，如果实现类当中没有，会自动向上找接口的。

4.接口中静态方法的定义和使用。

格式：（就是将abstract或者default关键字换成static关键字，带上方法体）

public static 返回值类型 方法名称（参数列表）{

          //方法体

}

注意：不能通过接口实现类的对象来调用接口中的静态方法。（其实跟类中的静态方法一样，静态方法直接由【类名.静态方法】；同理在接口中，也用【接口名.静态方法】）

5.接口中私有方法的定义和使用。

解决问题：当在接口中的两个默认方法存在重复代码时，我们希望把重复的部分抽取出来作为一个新的方法，这个共有的方法仅能让两个默认方法使用，此时这个共有方法应该是私有的。

普通私有方法：解决多个【默认方法】之间的重发代码问题

private 返回值类型 方法名称（参数列表）{

//方法体

}

静态私有方法：解决多个【静态方法】之间的重复代码问题

private static 返回值类型 方法名称（参数列表）{

//方法体

}

6.接口中的常量定义和使用。

接口中也可以定义“成员变量”，但是必须用public static final三个关键字进行修饰，所以这也就是【常量】。（一旦被final修饰了，就说明这是一个常量，数值不能再变了）

格式：public static final 数据类型 常量名称 = 数据值；

注意：

（1）接口中的常量，可以省略public static final关键字，但是省略了也表示一个常量。

（2）接口中的常量，必须进行赋值，不能不赋值。

（3）接口中常量的名称，最好都用大写命名，然后用下划线隔开。

总结：

接口实现的注意事项：

（1）接口是没有静态代码块或者构造方法的。

（2）一个类的直接父类是唯一的，但是一个实现类可以实现多个接口。

（3）如果实现类的所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一遍就可以了。

（4）如果实现类的所实现的多个接口中，存在重复的默认方法，那么已经要对冲突的默认方法进行覆盖重写。

（5）如果实现类没有对多个接口中的所有抽象方法进行覆盖重写，那么这个实现类已经是一个抽象类。

（6）一个类如果既有继承，又有接口，并且直接父类中的方法名和接口中的方法名产生冲突，那么优先使用父类中的方法。

编程演示：

接口A

public interface MyInterfaceA {
    public abstract void methodAAbstract();

    public default void methodADefault(){
        System.out.println("这是接口A的默认方法");
    }

    public static void methodAStatic(){
        System.out.println("这是接口A的静态方法");
        System.out.println("这个静态方法还调用了静态私有方法");
        method2();
    }

    public default void methodPrivate(){
        System.out.println("这是一个调用了私有方法的默认方法");
        method();
    }
    private void method(){
        System.out.println("这是一个普通私有方法");
    }
    private static void method2(){
        System.out.println("这是一个静态私有方法");
    }

接口B 

public interface MyInterfaceB {
    public abstract void methodBAbstract();

    public default void methodBDefault(){
        System.out.println("这是接口B的默认方法");
    };

    public static void methodBStatic(){
        System.out.println("这是接口B的静态方法");
    };


}

 接口A和接口B的实现类

public class InterfaceImpl implements MyInterfaceA,MyInterfaceB{
    @Override
    public void methodAAbstract() {
        System.out.println("实现类重写覆盖了接口A的抽象类方法");
    }

    @Override
    public void methodBAbstract() {
        System.out.println("实现类重写覆盖了接口B的抽象类方法");
    }

}

 主方法，创建实现类的对象，访问接口类中的各种方法。

public class InterFace {
    public static void main(String[] args) {
        InterfaceImpl lmpl = new InterfaceImpl();
        //实现类调用抽象方法，需要在实现类中覆盖重写
        lmpl.methodAAbstract();
        lmpl.methodBAbstract();
        System.out.println("==================");

        //实现类调用默认方法，如果没有内容要添加可以不用覆盖重写，直接可以调用接口的默认方法
        lmpl.methodADefault();
        lmpl.methodBDefault();
        System.out.println("==================");

        //调用静态方法时，不需要用实现类的对象调用，直接用 【接口名.静态方法名（）】
        MyInterfaceA.methodAStatic();
        MyInterfaceB.methodBStatic();
        System.out.println("==================");

        //接口中的private方法其实是为default和static做事，让他们能够访问，但是外界不能访问
        lmpl.methodPrivate();

    }
}

7.接口与接口的多继承关系。

类与类之间是单继承关系的，直接父类只能有一个。（extends）

接口和接口之间可以是多继承的，接口的直接父接口可以有多个。（extends）

类和接口之间是多实现的，一个类可以实现多个接口。（implements）

注意：

（1）多个父接口中的抽象方法重复，没关系。

（2）多个父接口中的默认方法重复，那么子接口必须对默认方法进行覆盖重写。【并且要带着default关键字，因为你还是一个接口】