interface 接口类

接口是一种引用数据类型，最重要的内容就是其中的 抽象方法。

    

定义一个接口格式（普通）；

public interface  接口名称 {

//接口的内容

}

接口名称 每个单词首字母都用英文大写（大驼峰格式），和类名称是一样的。 

附加：

如果的Java7， 那么接口中内容包含了

1.常量           2.抽象方法

Java8，        

3.默认方法    4.静态方法 

Java9，

5.私有方法

 

 

接口的抽象方法定义。

创建一个接口类（父类）；

 

 

public interface MyInterfaceAbstract {



    public abstract void methodAbs1();
    public abstract void methodAbs2();
    public abstract void methodAbs3();
    public abstract void methodAbs4();
    //抽象方法
    //抽象方法里的public absstract这2个关键字可以不写，但在初学阶段不要不写，以免发生混淆。

}

 

 

接口的抽象方法使用：

接口使用步骤；

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

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

   //。。。。

}

 

2，接口实现类必须覆盖重写 （实现）接口中所有的抽象方法。

实现：去掉abstract关键字，加上方法体大括号。

 

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

   

创建一个实现类（子类）；

在实现类名称后面加上  impl  ，方便查看知道 是某某的实现类。

public class MyInterfaceAbseractImpl implements MyInterfaceAbstract {
    @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) {
        //错误写法！ 不能直接new接口对象。
       // MyInterfaceAbstract inter = new MyInterfaceAbstract();
        
        //创建实现类的对象使用
        MyInterfaceAbseractImpl Impl = new MyInterfaceAbseractImpl();
        Impl.methodAbs1();
        Impl.methodAbs2();
        Impl.methodAbs3();
        Impl.methodAbs4();
    }
}
   

 

注意事项：
1，如果 实现类并没有覆盖重写接口中所以抽象方法，那么 这个实现类自己就必须是抽象类。、

2，此时 不能new接口对象（父类名称），要new实现类（子类）

 

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 

接口的默认方法定义

 default(关键词)

1，接口默认方法，可以通过接口实现类对象，直接调用。

2，接口的默认方法，也可以被接口实现类进行覆盖重写。

 

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

格式；

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

         方法体

}

 

接口 父类：

public interface MyInterfaceAbstract {



    public abstract void methodAbs1();
    public abstract void methodAbs2();
    public abstract void methodAbs3();
    public abstract void methodAbs4();

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



}

 

 

 

 

实现类；

 

public class MyInterfaceDefaultImpl implements MyInterfaceDefault {

    @Override
    public void methodAbs1() {
        System.out.println("实现类抽象方法，AAA");
    }

 
}

 

 

类：

public class Demo02Interface {
    public static void main(String[] args) {


        //创建了实现类对象
        MyInterfaceDefaultImpl az = new MyInterfaceDefaultImpl();
        az.methodABS();//调用抽象方法，实际运行的是右侧实现类。
        

           //调用默认方法。如果实现类当中没有的话，会向上找接口。
        az.methodABS5();

    }
}

 

 

 

 

默认方法有个特殊用法；

接口类（父类）定义好了默认方法，但现实类（子类）没有定义， 类也可以正常打印调用的，

即使实现类（子类）没有覆盖重写接口类（父类） ，但Java编译器会往上找的。

还有一点需要补充；

如果接口类（父类）和实现类(子类)都有相同名字的默认方法的话，优先用实现类(子类)的。

 

 

在创建一个实现类，然后在普通类输出：new上实现类名称， 实现类名称 .  (父类方法名称）（）；

就能打印出父类的方法体了。

 

 

 

++++++++++++++++++++++++++++++++++++++

接口的静态方法定义 和使用

从java8开始， 接口当中允许定义静态方法。

格式；

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

    方法体

}

注意事项：就是将abstract或者default换成static即可，带上方法体。

正确用法：通过接口名称，直接调用其中的静态方法。

格式；

 

 

 

接口类（父类）：

public interface MyInterfaceStatic {

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

    }

}

实现类（子类）：{在这种情况下 可以不用创建实现类，直接调用就可以了}

public class MyInterfaceStaticImpl implements MyInterfaceStatic{
    
3 }   

 

类（输出类）；

public class DemoInterface {

    public static void main(String[] args) {

        //创建了实现类对象，
        //如果在调用父类的静态方法的话 就是不用创建实现类对象了
       MyInterfaceStaticImpl impl= new MyInterfaceStaticImpl();

        //错误写法！
       // impl.methodStatic();
        
        //直接通过接口名称调用静态方法    
             (父类名称 .  方法名称（）；）
        MyInterfaceStatic.methodStatic();

    }
}

 注意：：静态 对类（子类）有关系 ，既然这样 那就不用多余的 new创建类型类了（父类）

直接通过类名称 调用静态方法就可以了

++++++++++++++++++++++++++++++++++++++++++++

 

接口私有方法定义和使用。

 

假设：如果是有两个方法体之间有重复类容太多了，就需要抽取一把。

问题描述；

1，我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。

2，但是z这个共有方法不应该让实现类使用，应该是私有化的。

 

解决方案：
从Java8 开始，接口当中允许定义私有方法。

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

格式；

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

   方法体

}

例子：

接口；

public interface MyInterfaceDefault {


    public default void method1() {
        System.out.println("这是默认方法aaa");
        Common();


    }
    public default void method2() {
        System.out.println("这是默认方法bbb");
        Common();

    }

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



}

 

类；

public class Demo02Interface {
    public static void main(String[] args) {

        MyInterfaceDefaultImpl a = new MyInterfaceDefaultImpl();
       a. method1();
       a. method2();
    }

 

 

 

 

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

格式；

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

   方法体

}

 例子；

接口类；

public interface MyInterfaceDefault {


    public static void method1() {
        System.out.println("这是静态方法aaa");
        Common();


    }

    public static void method2() {
        System.out.println("这是静态方法bbb");
        Common();

    }

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


}

 类；

public class Demo02Interface {
    public static void main(String[] args) {

        MyInterfaceDefault.method1();
        MyInterfaceDefault.method2();
    }
}

 

效果图；

 

注意事项；私有方法在接口创建后，实现类和类是无法进行其他操作的，它只能在接口特给默认方法和静态方法使用的。

 

 

 

接口的常量定义和使用。

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。

从效果上看，这其实就是接口的【常量】。

格式；

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

备注；

一旦使用final关键字进行修饰，说明不可改变。

注意事项；

1，接口当中的常量，可以省略public static final，但注意，不写它也照样是这样。

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

3，接口中常量的名称，使用完全大写字母，用下划线进行分割。（推荐命名规则）。

（灰色的字体，可以不写，但效果照样可以实现的）考虑到初学，建议 还是写上，便于理解。

 

例子；

public interface MyIntfaceconst {
    
    public static final int NUM_OF_MY_CLASS = 10;
}

 

public class Scout {
    public static void main(String[] args) {

        System.out.println(MyIntfaceconst.NUM_OF_MY_CLASS);
    }
}