Java：接口（9）

DemoInterdaceAbstract接口：

package demo19接口;
/*
接口就是多个公共类的规范，接口是一种引用数据类型，最重要的内容就是其中的抽象方法
接口的格式：
public interface 接口名称 {
  //接口内容
}
接口编译生成的还是.claass文件
java7，接口中可以包含的内容有：
1.常量
2.抽象方法

如果是java8，接口中还可以包含
3.默认方法
接口中定义默认方法，可也以解决接口升级问题。
格式：
  public default 返回值类型 方法名称（参数列表）{
     方法体
  }
4.静态方法
如果是java9，还可以包含：
5.私有方法

在任何版本的java中，接口都能定义抽象方法.
格式：
public abstract 返回值类型 方法名称(参数列表);
接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract 这两个关键字可以选择性省略

接口的使用步骤：
1.接口不能直接使用，必须有一个实现类来实现改接口
public class 实现类名称 implements 接口名称 {
   //...
}
2.接口的实现类必须覆盖重写（实现）接口中所有的额抽象方法
3.创建实现类对象进行使用

注意：
如果实现类并没有覆盖重写接口中所有的额抽象放，那么这个实现类自己必须是抽象类


 */
public interface DemoInterdaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这是一个抽象方法
    abstract void mathod2();
    //这是一个抽象方法
    public void method3();
    //这是一个抽象方法
    void method4();

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

 DemoInterface类：

package demo19接口;
/*
子类可以覆盖重写接口的默认方法
 */
public class DemoInterface implements DemoInterdaceAbstract {

    @Override
    public void methodAbs1() {
        System.out.println("1");
    }

    @Override
    public void mathod2() {
        System.out.println("2");
    }

    @Override
    public void method3() {
        System.out.println("3");
    }

    @Override
    public void method4() {
        System.out.println("4");
    }

    //子类可以覆盖重写接口的默认方法
    @Override
    public void methodDefault() {

    }
}

MyInterfaceStatic接口：

package demo19接口;
/*
java8 开始接口当中允许定义静态方法
格式：
public static 返回值类型 方法名称(参数列表){
  方法体
}
提示：
注意不能通过实现类对象来调用接口当中的静态方法

正确使用：
接口名称.静态方法名(参数);

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

DemoInterfaceStatic类：

package demo19接口;

public class DemoInterfaceStatic implements  MyInterfaceStatic {
}

MyInterfacePrivatrA接口：

package demo19接口;
/*
问题描述：
我们需要一个共有的方法，用来解决两个默认方法之间的重复代码的问题
但是这个共有的方法不应该让实现类使用，应该是私有的
解决方案：
从java9开始，接口中允许定义私有方法
1.普通私有方法，解决多个静态方法之间的重复代码问题
格式：
private 返回值类型 方法名称(参数列表){
   方法体
}
 */
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");
    }*/


}

MyInterfacePrivateB接口：

package demo19接口;
/*
静态私有方法，解决多个方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表){
    方法体
}

接口当中可以定义成员变量，但是必须使用public static final三个关键字进行修饰，从效果上看就，这其实就是接口的常量
格式：
Public static final 数据类型 常量名称=值；
注意，一旦使用final关键字进行修饰，说明不可改变
1.接口当中的常量，可以省略public static final，不写也是这样
2.接口当中常量，必须进行赋值，不可以不赋值
3.接口中的常量名称完全大写字母，用下划线进行分隔

 */
public interface MyInterfacePrivateB {
    //这是一个常量，一旦赋值，不可以改变
    public static final int NUM_OF_MYCLASS=10;

    public static void methodDefault1(){
        System.out.println("默认方法1");
        //methodCommon();
    }
    public static void methodDefault2(){
        System.out.println("默认方法2");
        // methodCommon();
    }


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

}

Test类：

package demo19接口;

public class Test {
    public static void main(String[] args) {
        //不能直接new 接口对象使用,这是错误的
        //DemoInterdaceAbstract inter=new DemoInterdaceAbstract();
        //创建实现类的对象使用
        DemoInterface impl=new DemoInterface();
        impl.methodAbs1();
        impl.mathod2();
        impl.method3();
        impl.method4();

        //调用默认方法，如果实现类中没有，那么向上找接口
        impl.methodDefault();

        System.out.println("===================");
        DemoInterfaceStatic imp=new DemoInterfaceStatic();
        //注意不能通过实现类对象来调用接口当中的静态方法
        //imp.methodStatic();错误
       //
        // 通过接口名称.静态方法名(参数);
        MyInterfaceStatic.methodStatic();


        System.out.println("常量");
        //访问接口当中的常量
        System.out.println(MyInterfacePrivateB.NUM_OF_MYCLASS);

    }
}

MyInterface接口：

package demo20接口2;
/*
错误，接口没有静态代码块或者构造方法
 static {

    }
    public MyInterface(){

    }
    1.类与类之间是继承的，直接父类只有一个
    2.类与接口之间是实现的，一个类可以实现多个接口
    3.接口与接口之间是多继承的
    4.多个父接口当中的当中的抽象方法如果重复，没关系 多个接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写
 */

public interface MyInterface {

    public abstract void methodA();
}

 

1.接口是没有静态代码快，或者构造方法
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可
4.如果实现类没有覆盖重写所有接口当中的抽象方法，那么实现类必须是一个抽象类
5.如果实现类的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6.一个类如果直接继承父类当中的方法，和接口当中的默认方法产生冲突，优先用父类当中的方法