面向对象-接口interface

接口就是多个类的公共规范
接口就是一种引用数据类型，最重要的就是其中的：抽象方法

//定义一个接口格式：
public interface 接口名称{
接口内容...
}

接口使用步骤：

• 1.接口不能直接使用，必须有一个实现类来实现该接口
• 格式：

public class 实现类名称  implements 接口名称{
}

• 2.接口实现类必须覆盖重写（实现）接口中所有的抽线方法
• 3.创建实现类的对象，使用

注意事项：

• 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

接口中的成员变量：

接口中也可以定义"成员变量"，但是必须使用public static final 三个关键字修饰
从效果上看，这其实就是接口中的常量
格式：

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

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

public interface MyInterfaceConst {
//接口中的变量，也就是常量
public static final int NUM = 20;
}

注意事项：

• 1.接口当中的常量，可以省略public static final ，注意：不写也照样是这样
• 2.接口当中的常量，必须进行赋值
• 3.接口中的常量名称，必须完全使用大写字母，用下划线进行分割连接(推荐命名规则)

接口中的抽象方法：

//一个接口，
public interface MyInterface {
public abstract  void method1();
public abstract  void method2();
public abstract  void method3();
}

注意事项：

• 1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
• 2.这两个关键字修饰符，可以选择性的省略
• 3.方法的三要素可以随意定义

从java8开始，接口中允许定义默认方法：

格式：
public default 返回值类型 方法名称(参数列表){
方法体；
}

• 备注：接口当中的默认方法，可以解决接口升级问题
  默认方法有方法体，具体使用：实现类对象直接调用默认方法名称，类似于继承，也可以重写

//接口类
public interface MyInterfaceDefault {
//接口中的抽象方法
public abstract void show();

//新添加一个方法，将此方法换为默认方法
public default void method(){
System.out.println("新添加的默认方法");
}
}

//实现类，实现了接口类
public class Impl implements MyInterfaceDefault{

public void show(){
System.out.println("覆盖重写接口抽象方法");
}
}

public class Demo{
public static void main(String[] args){
Impl i = new Impl();//创建实现类对象
i.method();//对象可以直接调用接口中的默认方法
}
}

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

• 格式

public static 返回值类型 静态方法名称(参数列表){
方法体；
}

• 注意事项：不能通过接口实现类的对象来调用接口中的静态方法
• 正确用法：通过接口名称，直接调用其中静态方法，也可以调用接口中的常量
• 格式：

接口名称.静态方法名(参数)；

public interface MyInterfaceStatic {
//接口中的常量
public static final int NUM = 25;
//接口中的静态方法
public static void methodStatic(){
System.out.println("接口静态方法");
}
}

public class Demo{

public static void main(String[] args){
//直接接口名称调用
System.out.println(MyInterfaceStatic.NUM);// 25
MyInterfaceStatic.methodStatic();// 接口静态方法
}
}

从java9开始，接口当中允许定义私有方法:

如果接口中多个默认或者静态方法中的代码有重复代码问题，那么可以将这段代码抽取为一个共有方法，但是这个共有方法不应该让实现类使用，应该私有化。

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

• 格式：

private 返回值类型 方法名称(参数列表){
方法体；
}

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

• 格式：

private static 返回值类型 方法名称(参数列表){
方法体；
}

public interface MyInterfacePrivate {
public static void show1(){
common();
}
public static void show2(){
common();
}

private static void common(){
System.out.println("重复代码");
}
}

接口与接口子类、接口与实现类的使用注意：

1.类与类之间是单继承的，直接父类只有一个
2.类与接口之间是多实现的，一个类可以实现多个接口
3.接口与接口之间是多继承的

• 子类接口注意事项：
  1.多个父类接口当中的抽象方法如果重复，没关系，因为抽象方法没有方法体
  2.多个接口父类当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字

实现类使用接口的时候，需要注意：

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

//接口A
public interface InterfaceA {
public abstract void method();//接口A中的抽象方法
public default  void methodI(){//接口A中的默认方法
System.out.println("AAA");
}
//接口中的另一个默认方法，与实现类的父类方法重复
public default void show(){
System.out.println("接口默认方法");
}
}

//接口B
public interface InterfaceB {
public abstract void method();//接口B中的抽象方法
public default  void methodI(){//接口B中的默认方法
System.out.println("BBB");
}
}

//接口C继承了接口A、B
public interface InterfaceC extends InterfaceA,InterfaceB {

//对于两个父类接口中的重复抽象方法，不需要重写，没有方法体
//对于重复的默认方法必须要重写，还要带着关键字default
public default void methodI(){
System.out.println("CCC");
}
}
----------------------------------------------------------------------------
//实现类父类
public class Fu {
//父类方法，与子类实现的接口中的方法重复
public void show(){
System.out.println("父类方法");
}
}
//实现类继承父类，实现了A，B接口
public class Zi extends Fu implements InterfaceA,InterfaceB {

//A,B接口中重复的抽象方法
public void method(){
System.out.println("重写一次两个接口中重复的抽象的方法");
}

//A，B接口中重复的默认方法
public void methodI(){
System.out.println("对接口中冲突的默认方法进行覆盖重写");
}
}

public class Demo{

public static void main(String[] args){
Zi zi = new Zi();
//当父类方法，与接口中的默认方法重复时，会优先使用父类方法
zi.show();// 父类方法
}
}

• 点赞
• 收藏
• 分享
• 文章举报