【Java】面向对象之接口详解

Java 中的接口是面向对象编程中的一个重要概念，它定义了一组抽象方法，是一种用来实现多态和契约式编程的工具。接口提供了一个协议，规定了类必须实现哪些方法，但不规定如何实现这些方法。这种特性使得接口在设计模式、API 设计、组件开发等方面都有着广泛的应用。下面我们将详细讲解 Java 接口的各个方面，包括其定义、用法、特性，以及接口在 Java 8 和 Java 9 中的新特性。

Java 接口的定义和语法

1. 接口的定义

在 Java 中，接口是一种抽象类型，用 interface 关键字定义。接口只包含方法签名（即方法的声明，不包括方法体）和常量（默认 public static final 修饰）。实现接口的类必须实现接口中定义的所有方法。

public interface Animal {
    
    
    // 接口中的常量
    int AGE = 5;  // 等同于 public static final int AGE = 5;

    // 抽象方法
    void eat();   // 等同于 public abstract void eat();
    void sleep();
}

2. 实现接口

一个类通过 implements 关键字实现接口。类必须实现接口中定义的所有方法，否则需要将类声明为抽象类。

public class Dog implements Animal {
    
    
    @Override
    public void eat() {
    
    
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
    
    
        System.out.println("Dog is sleeping.");
    }
}

关键点：

• 一个类可以实现多个接口，使用逗号分隔。
• 如果一个类实现了某个接口，则必须提供接口中所有方法的具体实现。
• 接口中的方法默认是 public 和 abstract，类实现时必须以 public 访问修饰符实现这些方法。

3. 接口的多继承

Java 接口支持多继承，一个接口可以继承多个其他接口。子接口继承父接口的所有方法。

public interface Flyable {
    
    
    void fly();
}

public interface Swimmable {
    
    
    void swim();
}

public interface Duck extends Flyable, Swimmable {
    
    
    void quack();
}

public class MallardDuck implements Duck {
    
    
    @Override
    public void fly() {
    
    
        System.out.println("Mallard Duck is flying.");
    }

    @Override
    public void swim() {
    
    
        System.out.println("Mallard Duck is swimming.");
    }

    @Override
    public void quack() {
    
    
        System.out.println("Mallard Duck is quacking.");
    }
}

Java 接口的特性

1. 多态性

接口是实现多态性的重要工具。在 Java 中，接口引用可以指向实现该接口的类的对象。这种多态性允许程序在编译时不知道对象的确切类型，而是在运行时确定。

Animal animal = new Dog();
animal.eat();    // 输出: Dog is eating.
animal.sleep();  // 输出: Dog is sleeping.

2. 解耦与灵活性

接口提供了一种解耦机制，使得实现类可以在不影响其他代码的情况下进行更改。通过定义接口，可以将方法调用与实现解耦，从而提高代码的灵活性和可维护性。

public interface Printer {
    
    
    void print(String message);
}

public class ConsolePrinter implements Printer {
    
    
    @Override
    public void print(String message) {
    
    
        System.out.println("Console: " + message);
    }
}

public class FilePrinter implements Printer {
    
    
    @Override
    public void print(String message) {
    
    
        // 将消息打印到文件
    }
}

public class Document {
    
    
    private Printer printer;

    public Document(Printer printer) {
    
    
        this.printer = printer;
    }

    public void output(String message) {
    
    
        printer.print(message);
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Printer consolePrinter = new ConsolePrinter();
        Document doc = new Document(consolePrinter);
        doc.output("Hello, World!");
    }
}

在上面的例子中，Document 类与具体的打印实现解耦，可以轻松更换打印实现而不影响 Document 的代码。

3. 接口与抽象类的区别

特性	接口	抽象类
默认访问修饰符	public，接口中的所有方法默认是 public 和 abstract。	protected 或 public，可以包含非抽象方法。
方法实现	不能包含方法实现（Java 8 及以上版本可有默认方法）。	可以包含非抽象方法的实现。
多重继承	支持多重继承，一个接口可以继承多个接口。	不支持多重继承，一个类只能继承一个抽象类。
变量	默认是 public static final，即常量。	可以定义实例变量。
构造函数	没有构造函数。	可以有构造函数，供子类调用。
设计目的	用于定义行为规范，实现解耦。	用于提供部分实现，供子类扩展。

4. Java 8 中的接口新特性

Java 8 为接口引入了几个新的特性，包括默认方法和静态方法。

默认方法 (Default Methods)

默认方法允许在接口中提供方法的默认实现。这样，接口的实现类可以选择性地覆盖这些方法。

public interface Animal {
    
    
    void eat();
    void sleep();

    // 默认方法
    default void run() {
    
    
        System.out.println("Animal is running.");
    }
}

public class Dog implements Animal {
    
    
    @Override
    public void eat() {
    
    
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
    
    
        System.out.println("Dog is sleeping.");
    }

    // 可以选择覆盖默认方法
    @Override
    public void run() {
    
    
        System.out.println("Dog is running fast.");
    }
}

使用场景：

• 为已有接口添加新方法而不影响现有实现。
• 提供通用实现，供子类复用。

静态方法 (Static Methods)

接口中的静态方法与类中的静态方法类似，属于接口本身而不是实现类。它们可以直接通过接口名调用。

public interface Utility {
    
    
    static void printInfo() {
    
    
        System.out.println("This is a utility interface.");
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Utility.printInfo();  // 直接通过接口名调用静态方法
    }
}

使用场景：

• 提供与接口相关的工具方法。
• 实现特定逻辑而不依赖于实例。

5. Java 9 中的接口新特性

Java 9 引入了接口中的私有方法，使得接口内部的代码更具可读性和重用性。

私有方法 (Private Methods)

私有方法允许接口中的默认方法和静态方法共享代码逻辑，这些方法不能被实现类访问，只能在接口内部使用。

public interface Calculator {
    
    
    default int add(int a, int b) {
    
    
        return doOperation(a, b, "+");
    }

    default int subtract(int a, int b) {
    
    
        return doOperation(a, b, "-");
    }

    // 私有方法
    private int doOperation(int a, int b, String operator) {
    
    
        switch (operator) {
    
    
            case "+":
                return a + b;
            case "-":
                return a - b;
            default:
                throw new UnsupportedOperationException("Operation not supported");
        }
    }
}

使用场景：

• 共享接口内部逻辑。
• 提高代码的可读性和重用性。

Java 接口的高级用法

1. 函数式接口

Java 8 引入了函数式接口的概念，函数式接口是指仅包含一个抽象方法的接口。它们可以用于 lambda 表达式和方法引用。

@FunctionalInterface
public interface GreetingService {
    
    
    void sayHello(String name);
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 使用 lambda 表达式
        GreetingService greeting = (name) -> System.out.println("Hello, " + name);
        greeting.sayHello("World");
    }
}

Java 提供了一些常用的函数式接口，如 Runnable、Callable、Comparator 等。可以使用 @FunctionalInterface 注解来标记函数式接口，以帮助编译器进行检查。

2. 标记接口

标记接口是一个不包含任何方法和属性的接口，主要用于标识类的一种能力或特征。Java 提供了一些标记接口，如 Serializable、Cloneable、Remote 等。

public interface Serializable {
    
    
    // 无方法
}

public class Person implements Serializable {
    
    
    private String name;
    private int age;

    // getter 和 setter 方法


}

标记接口的使用场景：

• 标识某种能力或特征。
• 作为安全或序列化机制的标识。

3. 接口与设计模式

接口在设计模式中扮演着重要角色，常用于实现以下设计模式：

• 策略模式：定义算法族，通过接口实现不同的算法。

  public interface PaymentStrategy {
        
        
      void pay(int amount);
  }
  
  public class CreditCardPayment implements PaymentStrategy {
        
        
      @Override
      public void pay(int amount) {
        
        
          System.out.println("Paid " + amount + " using Credit Card.");
      }
  }
  
  public class PaypalPayment implements PaymentStrategy {
        
        
      @Override
      public void pay(int amount) {
        
        
          System.out.println("Paid " + amount + " using PayPal.");
      }
  }
  
  public class ShoppingCart {
        
        
      private PaymentStrategy paymentStrategy;
  
      public ShoppingCart(PaymentStrategy paymentStrategy) {
        
        
          this.paymentStrategy = paymentStrategy;
      }
  
      public void checkout(int amount) {
        
        
          paymentStrategy.pay(amount);
      }
  }
  
  public class Main {
        
        
      public static void main(String[] args) {
        
        
          ShoppingCart cart = new ShoppingCart(new CreditCardPayment());
          cart.checkout(100);
  
          cart = new ShoppingCart(new PaypalPayment());
          cart.checkout(200);
      }
  }
  

• 观察者模式：定义对象间的一对多依赖关系，通过接口通知观察者。

  public interface Observer {
        
        
      void update(String message);
  }
  
  public class ConcreteObserver implements Observer {
        
        
      private String name;
  
      public ConcreteObserver(String name) {
        
        
          this.name = name;
      }
  
      @Override
      public void update(String message) {
        
        
          System.out.println(name + " received update: " + message);
      }
  }
  
  public interface Subject {
        
        
      void addObserver(Observer observer);
      void removeObserver(Observer observer);
      void notifyObservers(String message);
  }
  
  public class ConcreteSubject implements Subject {
        
        
      private List<Observer> observers = new ArrayList<>();
  
      @Override
      public void addObserver(Observer observer) {
        
        
          observers.add(observer);
      }
  
      @Override
      public void removeObserver(Observer observer) {
        
        
          observers.remove(observer);
      }
  
      @Override
      public void notifyObservers(String message) {
        
        
          for (Observer observer : observers) {
        
        
              observer.update(message);
          }
      }
  }
  
  public class Main {
        
        
      public static void main(String[] args) {
        
        
          ConcreteSubject subject = new ConcreteSubject();
  
          Observer observer1 = new ConcreteObserver("Observer 1");
          Observer observer2 = new ConcreteObserver("Observer 2");
  
          subject.addObserver(observer1);
          subject.addObserver(observer2);
  
          subject.notifyObservers("Hello Observers!");
      }
  }
  

• 工厂模式：定义创建对象的接口，让子类决定实例化哪个类。

  public interface Shape {
        
        
      void draw();
  }
  
  public class Circle implements Shape {
        
        
      @Override
      public void draw() {
        
        
          System.out.println("Drawing a circle.");
      }
  }
  
  public class Rectangle implements Shape {
        
        
      @Override
      public void draw() {
        
        
          System.out.println("Drawing a rectangle.");
      }
  }
  
  public interface ShapeFactory {
        
        
      Shape createShape();
  }
  
  public class CircleFactory implements ShapeFactory {
        
        
      @Override
      public Shape createShape() {
        
        
          return new Circle();
      }
  }
  
  public class RectangleFactory implements ShapeFactory {
        
        
      @Override
      public Shape createShape() {
        
        
          return new Rectangle();
      }
  }
  
  public class Main {
        
        
      public static void main(String[] args) {
        
        
          ShapeFactory circleFactory = new CircleFactory();
          Shape circle = circleFactory.createShape();
          circle.draw();
  
          ShapeFactory rectangleFactory = new RectangleFactory();
          Shape rectangle = rectangleFactory.createShape();
          rectangle.draw();
      }
  }
  

总结

Java 中的接口是定义抽象方法和行为规范的重要工具。通过接口，可以实现多态、解耦和灵活的代码设计。在 Java 8 和 Java 9 中，接口引入了默认方法、静态方法和私有方法，进一步增强了接口的功能。在软件设计中，接口广泛应用于设计模式中，实现模块化和可扩展的系统架构。

• 接口定义行为规范，规定实现类必须实现哪些方法。
• 接口支持多重继承，允许接口继承多个父接口。
• 接口提供多态性，允许接口引用指向不同实现类的对象。
• Java 8 和 Java 9 增强接口功能，引入默认方法、静态方法和私有方法。