基础第一阶段day10——接口、接口注意事项

最新推荐文章于 2025-05-14 16:32:28 发布

原创最新推荐文章于 2025-05-14 16:32:28 发布 · 282 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#接口

本文探讨了接口在编程中的应用，包括接口的实现、测试类的创建。同时，详细阐述了接口注意事项，如接口中不允许有构造方法和静态代码块，一个类可实现多个接口等。对于接口中的抽象方法和默认方法的重写规则也进行了说明，并通过两种情况分析了接口默认方法与父类方法冲突时的处理策略。

接口

public interface Interface01 {
    //抽象方法
    void method(int num);

    //常量
    int NUM =10;

    //默认方法
    default void method201() {
        methodpri();
        methodsta();
    }

    //默认方法
    default void method202() {
        methodpri();
        methodsta();
    }

    //静态方法
    static void method301() {
        methodsta();
    }

    //静态方法
    static void method302() {
        methodsta();
    }

    private void methodpri() {
        System.out.println("默认方法重复代码");
    }

    private static void methodsta() {
        System.out.println("默认/静态方法重复代码");
    }
}

接口实现类

public class InterfaceImpl implements Interface01 {

    //必须重写抽象方法
    @Override
    public void method(int num) {
        //访问常量
        System.out.println(Interface01.NUM);//建议接口名访问
        System.out.println(NUM);
        System.out.println(InterfaceImpl.NUM);
    }

    //可以重写默认方法,也可以直接继承过来
    @Override
    public void method201() {

    }

    @Override
    public void method202() {

    }

    //不能重写静态方法
//    @Override     报错
//    因此这个method301()是实现类自己的方法
    static void method301() {

    }
}

测试类

public class Test01 {
    public static void main(String[] args) {
        InterfaceImpl anInterface=new InterfaceImpl();

        //接口名访问常量
        System.out.println(Interface01.NUM);//推荐
        System.out.println(anInterface.NUM);//不推荐

        //实现类访问抽象方法
        anInterface.method(10);

        //接口名访问静态方法
        Interface01.method301();
        Interface01.method302();

        //实现类的这个静态方法不是继承接口的,用注解检测会直接报错
        //这是实现类特有的,访问类的静态方法也是类名访问最合适
        InterfaceImpl.method301();//推荐
        anInterface.method301();//不推荐
    }
}

========================================================================================================================================================

接口注意事项

（1）接口中不能有构造方法和静态代码块

public interface Interface02 {

//    public  Interface02(){}	报错

//    static{}	//报错
}

（2）一个类的直接父类只能有一个
正确

public class InterfaceImpl02 extends Object {
}

错误

//public class InterfaceImpl02 extends Object,InterfaceImpl {
}

（2）但是一个类可以实现多个接口

public class InterfaceImpl02 extends Object implements Interface01,Interface02 {
    @Override
    public void method(int num) {
       System.out.println("必须重写接口中所有的抽象方法");
    }
}

（3）实现类实现的多个接口里面存在重复的抽象方法,只需要重写一次即可;但是不重名的抽象方法必须重写

public interface InterfaceA {
    void method();
}

public interface InterfaceB {
    void method();
}

public class InterfaceIml implements InterfaceA,InterfaceB {
    @Override
    public void method() {
        System.out.println("多个接口重复的抽象方法只需重写一次即可");
    }
}

（4）实现类没有重写接口中全部的抽象方法，那么这个类也必须是抽象类

（5）实现类实现的多个接口里面存在重复的默认方法,必须重写这个默认方法;但是不重名的默认方法可以选择重写也可以继承使用

public interface InterfaceA {
    default void method(){
    }
}

public interface InterfaceB {
    default  void method(){
    }
}

public class InterfaceIml implements InterfaceA,InterfaceB{

    @Override
    public void method() {
        System.out.println("多个接口重复的默认方法必须重写");
    }
}

（6）一个类又继承了父类，一个类又实现了接口时，当接口默认方法和父类中的方法重名，优先就近原则

第一种情况，实现类没有重写接口的默认方法，测试结果

public interface InterfaceA {
    default void method(){
        System.out.println("接口默认方法执行");
    }
}

public class Fu {
    //Extension methods can only be used within an interface
  /*  public  default void method(){
    } 父类中不能有默认方法*/
    
  public void method(){
      System.out.println("Fu类方法执行");
  }
}

public class InterfaceIml extends Fu implements InterfaceA{
}

public class Test {
    public static void main(String[] args) {
        InterfaceIml interfaceIml=new InterfaceIml();
        interfaceIml.method();
        //测试结果	Fu类方法执行
    }
}

第二种情况，实现类重写接口的默认方法，测试结果

public interface InterfaceA {

    default void method(){
        System.out.println("接口默认方法执行");
    }
}

public class Fu {
    //Extension methods can only be used within an interface
  /*  public  default void method(){
    }*/
  public void method(){
      System.out.println("Fu类方法执行");
  }
}

public class InterfaceIml extends Fu implements InterfaceA{
    @Override
    public void method() {
        System.out.println("重写的默认方法");
    }
}

public class Test {
    public static void main(String[] args) {
        InterfaceIml interfaceIml=new InterfaceIml();
        interfaceIml.method();
        //测试结果	重写的默认方法
    }
}

（7）类继承接口时，假如重写接口的默认方法，那default关键字不可以保留；

但是当子接口继承父接口，重写默认方法时，关键字default必须保留

public interface InterfaceA {
    default void method(){
        System.out.println("接口默认方法执行");
    }
}

public interface InterfaceB {
    default  void method(){
        System.out.println("接口默认方法执行");
    }
}

public interface InterfaceziA extends InterfaceA,InterfaceB {
    @Override
    default void method() {
	  //default关键字必须保留
    }
}