package JieKou;
//实现类
//使用implements关键字来使普通类MyInterfaceAbstraceImpl实现接口
public class MyInterfaceAbstraceImpl implements MyInterfaceAbstrace {
    @Override
    public void methodAbs1() {
        System.out.println("这是第一个抽象类!");
    }
 
    @Override
    public void methodAbs2() {
        System.out.println("这是第二个抽象类!");
    }
 
    @Override
    public void methodAbs3() {
        System.out.println("这是第三个抽象类!");
    }
 
    @Override
    public void methodAbs4() {
        System.out.println("这是第四个抽象类!");
    }
}

package JieKou;
 
/*
1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法，也可以被接口实现类进行覆盖重写。
 */
 
public class Demo02Interface {
    public static void main(String[] args) {
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); //调用抽象方法，实际运行的是右侧实现类
 
        //调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault(); //这是新添加的默认方法
        System.out.println("=======================");
 
        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); //实现类B覆盖重写了接口的默认方法
 
    }
}

package JieKou;
 
/*
注意：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数)
 */
 
public class Demo03Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();//没有必要写，直接就能通过接口名称调用静态方法
 
        //错误写法!
//        impl.methodStatic();
 
        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
 
    }
}

接口私有方法的定义和使用：

创建一个私有方法接口类MyInterfacePrivateA：

package JieKou;
/*
//私有方法
问题描述：
我们需要抽取一个共有方法，用来解决多个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案：
从Java 9开始，接口当中允许定义私有方法
1. 普通私有方法，解决多个默认方法之间重复代码的问题
格式：
   private 返回值类型 方法名称(参数列表){
       方法体
   }
2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
    private static 返回值类型 方法名称(参数列表){
        方法体
    }
 */
public interface MyInterfacePrivateA {
    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodZong();
    }
 
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodZong();
    }
 
    // 实现类能直接访问到，并不是接口类中的私有化
//    public  default void methodZong(){
//        System.out.println("AAA");
//        System.out.println("BBB");
//        System.out.println("CCC");
//    }
 
    //私有方法
    private void methodZong(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
 
}

package JieKou;
 
public interface MyInterfacePrivateB {
    public static void methodStatic1(){
        System.out.println("静态方法1");
        methodStaticZong();
    }
 
    public static void methodStatic2(){
        System.out.println("静态方法2");
        methodStaticZong();
    }
 
    private static void methodStaticZong(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

package JieKou;
 
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
    public void methodAnother(){
        //直接访问到了接口中的默认方法，这样是错误的！
//        methodZong();
    }
}

package JieKou;
 
public class Demo04Interface {
    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
        //错误写法 methodStaticZong()是私有方法
//        MyInterfacePrivateB.methodStaticZong();
        System.out.println("======================");
 
        MyInterfacePrivateAImpl impl = new MyInterfacePrivateAImpl();
        impl.methodDefault1();
        impl.methodDefault2();
        impl.methodAnother();// 什么也没有写，无输出结果
    }
}

接口常量的定义和使用：

创建一个常量接口类MyInterfaceConst:

package JieKou;
/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】
格式：
public static final 数据类型 常量名称 = 数据值；
备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：
1. 接口当中的常量，可以省略public  static final，注意：不写也照样是这样
2. 接口当中的常量，必须进行赋值，不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分割。（推荐命名规则）
 */
public interface MyInterfaceConst {
    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 100;
}