Java接口知识总结

接口通常定义一组公用方法，它们是多个类共同的公共行为规范，是与外部交流的通道。

接口的定义

接口使用关键字 interface 定义，接口里可以包含成员变量（只能是静态常量）、方法（只能是抽象实例方法、类方法或默认方法）、内部类（包括内部接口、枚举），其基本语法如下：

[修饰符] interface 接口名 [extends 父接口1，父接口2...] {
    
    
  零到多个常量定义...
  零到多个抽象方法定义...
  零到多个内部类、接口、枚举定义...
  零到多个默认方法或类方法定义...
}

说明：

修饰符可以是 public 或者省略，人如果省略 public 访问控制符，则默认采用包权限访问控制符。
接口名与类名遵守相同的命名规范，若仅从语法角度看，接口名只要是合法的标识符即可；若要遵守Java命名规范，则接口名应由多个有意义的单词连缀而成，单词与单词之间无需任何分隔符。
一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类

接口定义的实例

public interface Output{
    
    
  //接口中定义的成员变量，只能为常量
  int MAX_CACHE_LINE = 50;

  //接口中的普通方法只能为public的抽象方法，不能有实现
  void out();
  void getData(String msg);

  //在接口中定义默认方法，需要使用default修饰
  default void print(String... msgs){
    
    
    for(String msg : msgs){
    
    
      System.out.println(msg);
    }
  }

  default void test(){
    
    
    System.out.println(msg);
  }

  //在接口中定义类方法，使用static修饰
  static String staticTest(){
    
    
    return "接口类方法";
  }
}

接口的特性

接口中的所有成员，包括常量、方法、内部类和内部枚举都是 public 访问权限。
接口中的每一个普通方法都是隐式抽象的，因此在定义普通方法时，不管是否使用 public abstract 修饰符，都会被隐式的指定为 public abstract。（只能是 public abstract，其他修饰符都会报错）
接口中可以定义变量。在接口中定义成员变量时，不管是否使用 public static final 修饰符，都会被隐式的指定为 public static final。（只能是 public static final，其他修饰符都会报错）
接口里的普通方法不能有方法实现（方法体），只能由实现接口的类来实现；但类方法、默认方法都必须有方法实现。

接口与抽象类的异同

接口与抽象类的相似点：

接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。
接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

接口与抽象类的区别：

一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过多个接口可以弥补Java单继承的不足。
接口里只能包含抽象方法、静态方法和默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。
接口中不能包含初始化块；但抽象类则完全可以包含初始化块。
接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。

接口的实现

一个类可以实现一个或者多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。其基本语法如下：

[修饰符] class 类名 [extends 父类] implements 接口1[,接口2...]{
    
    
  类体部分
}

说明：

implements 部分必须放在 extends 部分之后。
一个类实现了一个或者多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。
实现接口方法时，必须使用 public 访问控制修饰符，因为接口里的方法都是 public 的。

实现接口的实例

//定义一个接口
interface Product{
    
    
  int getProduceTime();
}

//Printer 类实现 Output接口和 Product 接口
public class Printer implements Output, Product{
    
    
  private String[] printData = new String[MAX_CACHE_LINE];
  //记录当前需要打印的作业数
  private int dataNum = 0;

  public void out(){
    
    
    //循环打印作业
    while(dataNum > 0){
    
    
      System.out.println("打印机打印：" + printData[0]);
      //把作业队列整体前移一位，并将剩下的作业数减一
      System.arraycopy(printData, 1, printData, 0, --dataNum);
    }
  }

  public void getData(String msg){
    
    
    if(dataNum >=  MAX_CACHE_LINE){
    
    
      System.out.println("输出队列已满，添加失败");
    }
    else{
    
    
      //把打印数据添加到队列里，已保存的数据的数量加一
      printData[dataNum++] = msg;
    }
  }

  public int getProduceTime(){
    
    
    return 45;
  }

  public static void main(String[] args){
    
    
    Output o = new Printer();
    o.getData("第一个作业");
    o.getData("第二个作业");
    o.out();  //输出已经添加的两个作业
    o.getData("第三个作业");
    o.getData("第四个作业");
    o.out();  //输出已经添加的四个作业

    o.print("孙悟空", "猪八戒", "沙和尚");
    o.test();

    Product p = new Printer();
    System.out.println(p.getProduceTime());
  }
}

接口的应用——简单工厂模式

//定义一个水果接口
interface Fruit{
    
    
    public void eat();
}

//定义苹果类实现水果接口
class Apple implements Fruit{
    
    
    public void eat() {
    
    
        System.out.println("吃苹果");
    }
}

//定义橘子类实现水果接口
class Orange implements Fruit{
    
    
    public void eat() {
    
    
        System.out.println("吃橘子");
    }
}

//定义工厂类
class Factory{
    
    
    public static Fruit getInstance(){
    
    
        return new Apple();
    }
}

//定义一个客户端类进行调用
public class Client {
    
    
    public static void main(String[] args) {
    
    
        //通过工厂类得到想要的水果对象
        Fruit fruit = Factory.getInstance();
        fruit.eat();  //输出“吃苹果”
    }
}

简单工厂模式通过设计一个工厂类，实现了客户端类与水果类的分离，将生成水果对象的逻辑集中在工厂类中管理,通过工厂类来连接水果类与客户端类，当客户端想将苹果类替换成橘子类时，不需要修改客户端类中的代码，只需要修改工厂类中的 getInstance() 方法的实现即可。

Java基础知识总结——接口

文章目录