Java 接口

接口的定义：

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

定义一个接口的格式：
public interface 接口名称 {
// 接口内容
}

备注：换成关键字interface之后，编译生成的字节码文件仍然是 .java -----> .class

如果是Java7，那么接口中可以包含的内容有：
1. 常量
2. 抽象方法
如果是Java8，还可以额外包含有：
3. 默认方法
4. 静态方法
如果是Java9，还可以额外包含有：
5. 私有方法

接口使用步骤：
1. 接口不能直接使用，必须有实现类来实现该接口
    public class 实现类名称 implements 接口名称 {
        //...
    }
2. 接口的实现类必须覆盖重写接口中所有的抽象方法 （去掉abstract关键字，加上方法体大括号），否则这个实现类必须是抽象类
3. 创建实现类对象，进行使用

接口抽象方法：

/*
在任何版本的Java中，接口都能定义抽象方法；
格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1. 接口的抽象方法中，修饰词必须是两个固定的关键字：public abstract
2. public abstract这两个关键字修饰符，可以选择性的省略
3. 方法三要素可以随意定义 （返回值类型，方法名，参数列表）
 */
public interface MyInterfaceAbs {

    //这是一个抽象方法
    public abstract void methodAbs1();

    //这也是一个抽象方法
    abstract void methodAbs2();

    //这也是一个抽象方法
    public void methodAbs3();

    //这也是一个抽象方法
    void methodAbs4();
}


// 接口实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbs {
    @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("这是第四个方法");
    }
}


//接口测试
public class Demo01Interface {
    public static void main(String[] args) {
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs3();
    }
}

 

接口默认方法：

从Java8开始，接口里允许定义默认方法

public default 返回值类型 方法名称(参数列表) {
    // 方法体
}

备注：接口中的默认方法，可以解决接口升级的问题。（已经有一些实现类投入使用，但是接口中需要新加一个方法，如果是加抽象方法，那之前所有的实现类都会报错。由此出现了默认方法）

public interface MyInterfaceDefault {

    //抽象方法
    public abstract void methodAbs();

    //默认方法
    public default void methodDefault() {
        System.out.println("这是新添加的默认方法");
    }
}

// 接口实现类
public class MyInterfaceDefaultA implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

//测试
/*
1. 接口默认方法可以通过接口实现类直接调用
2. 接口默认方法也可以被接口实现类覆盖重写
 */
public class Demo02Interface {

    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs();

        a.methodDefault();

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();

        b.methodDefault();
    }
}

 

接口静态方法：

从Java8开始，接口中允许定义静态方法

public static 返回值类型 方法名称(参数列表) {
    // 方法体
}

注意事项：不能通过接口实现类对象来调用接口中的静态方法，而是要通过接口名称，直接调用其中的静态方法
格式：接口名称.静态方法名(参数列表)

public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口静态方法");
    }

}

//接口实现类
public class MyInterfaceStaticImpl implements MyInterfaceStatic {

}

//测试
public class Demo03Interface {
    public static void main(String[] args) {
        // 实现类对象
        //MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        // 错误写法，因为要调用接口静态方法直接使用接口名称即可
//        impl.methodStatic();

//        正确写法
        MyInterfaceStatic.methodStatic();
    }
}

 

接口私有方法：

问题描述：需要抽取一个共有方法，来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的

解决办法：从Java9开始，接口当中允许定义私有方法

1. 普通私有方法: 解决多个默认方法之间的重复代码问题

private 返回值类型 方法名称(参数列表){

方法体

}

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

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

方法体

}

public interface MyInterfacePrivateA {
    public default void methodDefault1() {
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2() {
        System.out.println("默认方法2");
        methodCommon();
    }

    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}



public interface MyInterfacePrivateB {
    public static void methodStatic1() {
        System.out.println("静态方法1");
        methodCommon();
    }

    public static void methodStatic2() {
        System.out.println("静态方法2");
        methodCommon();
    }

    private static void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

接口中的常量：

接口当中也可以定义"成员变量"，但是必须使用 public static final 三个关键字来修饰，从效果上看，这就是接口的【常量】

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

注意：
1. 接口中的常量，可以省略 public static final 任何一个关键字，但是不写也照样默认是用这三个关键字修饰
2. 接口中的常量，必须进行赋值，不能不赋值
3. 接口中常量的名称使用完全的大写字母，使用下划线进行分隔

public interface MyInterfaceConst {

    public static final int NUM_OF_CLASS = 10;
}


public class Demo05Interface {
    public static void main(String[] args) {
        // 访问接口中的常量
        System.out.println(MyInterfaceConst.NUM_OF_CLASS);
    }
}