接口的注意事项

接口中的常量和静态方法可以直接在测试类中通过接口名调用！

接口中只有静态方法不能被实现类继承

接口的定义格式：

public interface 接口名称 {
    // 常量
    // 抽象方法
    // 默认方法
    // 静态方法
}

实现接口：

public interface IA{
    public void show1();
}
public interface IB{
    public void show2();
}
public class Zi implements IA ,IB{
    public void show1(){
    }
    public void show2(){
    }
}

public class Fu{}//有继承的情况
public interface IA{}
public interface IB{}
public class Zi extends Fu implements IA,IB{//一定要先继承，后实现
}

接口中成员的访问特点:

1、接口中的常量:        主要是供接口直接使用

通过接口名直接调用即可

System.out.println(IA.NUM);// 10

2、接口中的抽象方法: 供实现类重写的

供实现类重写的
@Override
    public void method1() {
        System.out.println("重写接口中的method1抽象方法");
    }

3、接口中的默认方法: 供实现类继承的(实现类中可以直接调用,实现类对象也可以直接调用)

（供实现类继承使用）实现类可以直接调用  或者  实现类对象直接调用
public default void method2(){
        System.out.println("默认方法method2");
        method4();
        method5();
    }
非静态的默认方法可以被实现类继承

4、接口中的静态方法: 只供接口直接调用,实现类继承不了

接口中的静态方法只供接口直接调用，不能被继承
// 接口中的静态方法: 只供接口直接调用,实现类继承不了
    public static void method3(){
        System.out.println("静态方法method3");
        method5();
    }
private static void method5(){//
        // 方法体
    }

接口中的私有方法: 只能在接口中直接调用,实现类继承不了

 

多实现时的冲突情况：

1、公有静态常量的冲突：

当一个实现类继承了两个接口，这两个接口中有相同的公有静态常量时测试调用会显示编译错误

interface IA{
    public static final int a = 10;
    public static final int b= 20;
}
interface IB{
    public static final int a = 30;
}
class Zi implements IA,IB{
    //只继承了b，没有继承a，因为a冲突了
}

public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
     //   System.out.println(z.a);//编译错误
        System.out.println(z.b);
    }
}

2、公有抽象类的冲突情况：

当一个实现类同时实现两个接口，这两个接口中有同名的公有抽象方法，那么会要求实现类重写一个抽象方法即可。

interface IA{
    public void show();
}
interface IB{
    public void show();
}
class Zi implements IA,IB{
    @Override
    public void show() {//子类只需要重写一个show()即可
        System.out.println("子类的show()...");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

3、公有默认方法的冲突：

当一个实现类同时实现两个接口，这两个接口中有同名的公有默认方法，那么实现类必须重写一次该名的默认方法作为最终版本。

interface IA{
    public default void show(){
        System.out.println("IA");
    }
}
interface IB{
    public default void show(){
        System.out.println("IB");
    }
}
class Zi implements IA,IB{
    @Override
    public void show() {//必须重写一次的show()
        System.out.println("Zi的show()....");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

4、静态方法时直接属于接口的，不能被继承到实现类，所以不存在冲突的情况

5、私有方法只能在自己本身所在的接口中使用，不存在冲突。

 

实现类继承父类又实现接口时的冲突

1、父类和接口的公有静态常量的冲突：

因为实现类会继承接口的静态常量也会继承父类的静态常量，当两个常量同名时，测试类就会报错。

class Fu{
public static final int a = 10;
}
interface IA{
public static final int a = 20;
}
class Zi extends Fu implements IA{//没有继承a变量
}
public class Demo {
public static void main(String[] args) {
System.out.println(Zi.a);//编译错误
}
}

2、父类和接口的抽象方法冲突：重写即可

3、父类和接口的公有默认方法的冲突：优先继承关系

4、父类和接口的公有静态方法：接口的静态方法不能被继承，所以测试类输出的是父类的静态方法