java 变量类型为接口 java定义接口类型变量

在java 9+ 版本中，接口的内容可以有：

1. 成员变量其实是常量
格式为：
（public）（ static）（final） 数据类型 常量名称=数据值；
注意：
常量必须进行赋值，而且一旦赋值不能改变。
常量名称必须完全大写，用下划线进行分隔。
接口：

public interface InterfaceConst {
//    这是一个常量，一旦赋值，没有办法改变。
    public static final int NUM_OF_CLASS_1 =10;
    public static final int NUM_OF_CLASS_2 =20;//常量名称必须完全大写，用下划线分隔
}

主方法：

public class demo01main {
    public static void main(String[] args) {
//         访问接口当中的常量
        System.out.println(InterfaceConst.NUM_OF_CLASS_1);
        System.out.println(InterfaceConst.NUM_OF_CLASS_2);//接口名称.变量名称实现调用
    }
}

结果：

2.接口中最重要的就是抽象方法

格式：

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

注意：实现类必须覆盖重写接口中所有的抽象方法，除非实现类就是抽象类。

//接口，定义了四个抽象方法
public interface demo01InterfaceAbs {
//    关键字必须是public abstract,不能改变为别的关键字
//    关键字可以省略其中的一个，或者全部省略。
//    方法中没有大括号，其他三要素可以随意更改。返回值类型，方法名称，参数列表
    public abstract void Abs();
    public void abs1();
    abstract void abs2();
    void abs3();
}

//实现类，必须覆盖重写接口中所有的抽象方法
public class InterfaceAbstractImpl implements demo01InterfaceAbs
{
    @Override
    public void Abs() {
        System.out.println("接口方法1执行");
    }

    @Override
    public void abs1() {
        System.out.println("接口方法2执行");
    }

    @Override
    public void abs2() {
        System.out.println("接口方法3执行");
    }

    @Override
    public void abs3() {
        System.out.println("接口方法4执行");
    }
}

public class demo01 {
    public static void main(String[] args) {
        InterfaceAbstractImpl cc=new InterfaceAbstractImpl();//创建实现类对象
        cc.Abs();//对象名称.方法名称
        cc.abs1();
        cc.abs2();
        cc.abs3();
    }
}

结果：

3.从java8开始，接口里允许定义默认方法，格式：

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

注意：默认方法也可以被覆盖重写

public abstract interface demo01Interface {
//    接口抽象方法
    public abstract void Method1();
//    接口默认方法
    public default void Method2(){
        System.out.println("接口默认方法执行-接口");
    };
}

//实现类1，覆盖重写默认方法
public class InterfaceAbs1 implements demo01Interface{
    @Override
    public void Method1() {
        System.out.println("覆盖重写接口方法1-AAA实现类");//抽象方法必须被覆盖重写
    }
    @Override
    public void Method2() {
        System.out.println("覆盖重写接口默认方法2-AAA实现类");//默认方法也可以被覆盖重写
    }
}

//实现类2，不覆盖重写默认方法
public class InterfaceAbs2 implements demo01Interface {
    @Override
    public void Method1() {
        System.out.println("覆盖重写接口方法1-BBB实现类");
    }
}

public class  demo01InterfaceDefault {
    public static void main(String[] args) {
        InterfaceAbs1 abs1=new InterfaceAbs1();//类1
        abs1.Method1();//覆盖重写接口方法1-AAA实现类
        abs1.Method2();//覆盖重写接口默认方法2-AAA实现类
        System.out.println("===============");
        InterfaceAbs2 abs2=new InterfaceAbs2();//类2
        abs2.Method1();//覆盖重写接口方法1-BBB实现类
//       调用默认方法，如果实现类里没有，会向上找接口
        abs2.Method2();//接口默认方法执行-接口
    }
}

结果：

4.从java8开始，接口里面允许定义静态方法，格式：

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

注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

//接口：
public interface InterfaceStat {
    public static void Method(){
        System.out.println("接口静态方法执行！");
    }
}
//主方法：
public class demo01InterfaceStatic {
    public static void main(String[] args) {
//        静态方法：直接通过接口名称调用静态方法
        InterfaceStat.Method();
    }
}

结果：

5.从java9开始，接口里面允许定义私有方法，格式：

普通私有方法：private 返回值类型 方法名称（参数列表）{方法体}；

静态私有方法：private static 返回值类型 方法名称（参数列表）{方法体}；

private的方法只有接口自己可以才可以调用，不能被实现类或者别人调用。

普通私有方法：

public interface InterfacePrivate {
    public default void method1(){
        System.out.println("接口默认方法1");
        methodcommon();
    }
    public default void method2(){
        System.out.println("接口默认方法2");
        methodcommon();
    }
    private void methodcommon(){
        System.out.println("接口私有方法-AAA");
    }
}
//实现类
public class demo01InterfacePrivate implements InterfacePrivate {
}
//主方法
public class demo01main {
    public static void main(String[] args) {
        demo01InterfacePrivate pr=new demo01InterfacePrivate();
        pr.method1();
        pr.method2();
    }
}

结果：

静态私有方法：

public interface InterfacePrivate {
    static void method1(){
        System.out.println("接口静态方法1");
        methodcommon();
    }
    static void method2(){
        System.out.println("接口静态方法2");
        methodcommon();
    }
    //静态私有方法
    private static void methodcommon()
    {
        System.out.println("BBB");
    }
}
public class demo01main {
    public static void main(String[] args) {
        InterfacePrivate.method1();//静态方法，直接调用，不需要实现类
        InterfacePrivate.method2();
    }
}

结果：