Java Interfaces – Java接口

最后修改: 2019年 1月 9日

中文/混合/英文(键盘快捷键：t)

1. Overview

1.概述

In this tutorial, we’re going to talk about interfaces in Java. We’ll also see how Java uses them to implement polymorphism and multiple inheritances.

在本教程中，我们将讨论Java中的接口。我们还将看到Java是如何使用它们来实现多态性和多重继承的。

2. What Are Interfaces in Java?

2.什么是Java中的接口？

In Java, an interface is an abstract type that contains a collection of methods and constant variables. It is one of the core concepts in Java and is used to achieve abstraction, polymorphism and multiple inheritances.

在Java中，接口是一种抽象的类型，它包含了方法和常量变量的集合。它是Java的核心概念之一，用于实现抽象、polymorphism和multiple inheritances。

Let’s see a simple example of an interface in Java:

让我们看看Java中接口的一个简单例子。

public interface Electronic {

    // Constant variable
    String LED = "LED";

    // Abstract method
    int getElectricityUse();

    // Static method
    static boolean isEnergyEfficient(String electtronicType) {
        if (electtronicType.equals(LED)) {
            return true;
        }
        return false;
    }

    //Default method
    default void printDescription() {
        System.out.println("Electronic Description");
    }
}

We can implement an interface in a Java class by using the implements keyword.

我们可以通过使用implements关键字在一个Java类中实现一个接口。

Next, let’s also create a Computer class that implements the Electronic interface we just created:

接下来，让我们也创建一个计算机类，实现我们刚刚创建的电子接口。

public class Computer implements Electronic {

    @Override
    public int getElectricityUse() {
        return 1000;
    }
}

2.1. Rules for Creating Interfaces

2.1.创建接口的规则

In an interface, we’re allowed to use:

在一个界面中，我们被允许使用。

We also should remember that:

我们还应该记住，。

  • we can’t instantiate interfaces directly
  • an interface can be empty, with no methods or variables in it
  • we can’t use the final word in the interface definition, as it will result in a compiler error
  • all interface declarations should have the public or default access modifier; the abstract modifier will be added automatically by the compiler
  • an interface method can’t be protected or final
  • up until Java 9, interface methods could not be private; however, Java 9 introduced the possibility to define private methods in interfaces
  • interface variables are public, static, and final by definition; we’re not allowed to change their visibility

3. What Can We Achieve by Using Them?

3.我们通过使用它们可以实现什么？

3.1. Behavioral Functionality

3.1.行为功能

We use interfaces to add certain behavioral functionality that can be used by unrelated classes. For instance, Comparable, Comparator, and Cloneable are Java interfaces that can be implemented by unrelated classes. Below is an example of the Comparator interface that is used to compare two instances of the Employee class:

我们使用接口来添加某些行为功能，这些功能可以被不相关的类使用。例如，Comparable、Comparator和Cloneable是Java接口，可以由不相关的类来实现。下面是一个Comparator接口的例子，它被用来比较Employee类的两个实例。

public class Employee {

    private double salary;

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

public class EmployeeSalaryComparator implements Comparator<Employee> {

    @Override
    public int compare(Employee employeeA, Employee employeeB) {
        if (employeeA.getSalary() < employeeB.getSalary()) {
            return -1;
        } else if (employeeA.getSalary() > employeeB.getSalary()) { 
            return 1;
        } else {
            return 0;
        }
    }
}

For more information, please visit our tutorial on Comparator and Comparable in Java.

更多信息，请访问我们的Comparator和Comparable的教程。

3.2. Multiple Inheritances

3.2.多重继承

Java classes support singular inheritance. However, by using interfaces, we’re also able to implement multiple inheritances.

Java类支持单一的继承。然而，通过使用接口，我们也能够实现多继承。

For instance, in the example below, we notice that the Car class implements the Fly and Transform interfaces. By doing so, it inherits the methods fly and transform:

例如，在下面的例子中，我们注意到Car类实现了Fly和Transform接口。通过这样做，它继承了fly和transform方法。

public interface Transform {
    void transform();
}

public interface Fly {
    void fly();
}

public class Car implements Fly, Transform {

    @Override
    public void fly() {
        System.out.println("I can Fly!!");
    }

    @Override
    public void transform() {
        System.out.println("I can Transform!!");
    }
}

3.3. Polymorphism

3.3.多态性

Let’s start with asking the question: what is polymorphism? It’s the ability for an object to take different forms during runtime. To be more specific it’s the execution of the override method that is related to a specific object type at runtime.

让我们先问一个问题：什么是polymorphism？它是指一个对象在运行时采取不同形式的能力。更具体地说，它是在运行时执行与特定对象类型相关的覆盖方法。

In Java, we can achieve polymorphism using interfaces. For example, the Shape interface can take different forms — it can be a Circle or a Square.

在Java中，我们可以使用接口实现多态性。例如，形状接口可以采取不同的形式–它可以是一个圆形或一个方形。

Let’s start by defining the Shape interface:

让我们从定义Shape接口开始。

public interface Shape {
    String name();
}

Now let’s also create the Circle class:

现在我们也来创建Circle类。

public class Circle implements Shape {

    @Override
    public String name() {
        return "Circle";
    }
}

And also the Square class:

还有就是Square类。

public class Square implements Shape {

    @Override
    public String name() {
        return "Square";
    }
}

Finally, it’s time to see polymorphism in action using our Shape interface and its implementations. Let’s instantiate some Shape objects, add them to a List, and, finally, print their names in a loop:

最后，是时候使用我们的Shape接口及其实现来看看多态性的作用了。让我们实例化一些Shape对象，将它们添加到List，，最后，在一个循环中打印它们的名字。

List<Shape> shapes = new ArrayList<>();
Shape circleShape = new Circle();
Shape squareShape = new Square();

shapes.add(circleShape);
shapes.add(squareShape);

for (Shape shape : shapes) {
    System.out.println(shape.name());
}

4. Default Methods in Interfaces

4.接口中的默认方法

Traditional interfaces in Java 7 and below don’t offer backward compatibility.

Java 7及以下版本的传统接口不提供后向兼容性。

What this means is that if you have legacy code written in Java 7 or earlier, and you decide to add an abstract method to an existing interface, then all the classes that implement that interface must override the new abstract method. Otherwise, the code will break.

这意味着，如果你有用Java 7或更早编写的遗留代码，并且你决定为一个现有的接口添加一个抽象方法，那么所有实现该接口的类必须覆盖新的抽象方法。否则，代码将被破坏。

Java 8 solved this problem by introducing the default method that is optional and can be implemented at the interface level.

Java 8通过引入默认方法解决了这个问题，该方法是可选的，可以在接口层实现。

5. Interface Inheritance Rules

5.接口继承规则

In order to achieve multiple inheritances thru interfaces, we have to remember a few rules. Let’s go over these in detail.

为了实现通过接口的多重继承，我们必须记住一些规则。让我们来详细看看这些规则。

5.1. Interface Extending Another Interface

5.1.接口扩展另一个接口

When an interface extends another interface, it inherits all of that interface’s abstract methods. Let’s start by creating two interfaces, HasColor and Shape:

当一个接口扩展另一个接口时，它继承了该接口的所有抽象方法。让我们先创建两个接口，HasColor和Shape。

public interface HasColor {
    String getColor();
}

public interface Box extends HasColor {
    int getHeight()
}

In the example above, Box inherits from HasColor using the keyword extends. By doing so, the Box interface inherits getColor. As a result, the Box interface now has two methods: getColor and getHeight.

在上面的示例中，Box 使用关键字extends.从HasColor继承。通过这样做，Box 接口继承了getColor。因此，Box接口现在有两个方法。getColor和getHeight。

5.2. Abstract Class Implementing an Interface

5.2.实现一个接口的抽象类

When an abstract class implements an interface, it inherits all of its abstract and default methods. Let’s consider the Transform interface and the abstract class Vehicle that implements it:

当一个抽象类实现了一个接口时，它继承了其所有的抽象和默认方法。让我们考虑一下Transform接口和实现它的抽象类Vehicle。

public interface Transform {
    
    void transform();
    default void printSpecs(){
        System.out.println("Transform Specification");
    }
}

public abstract class Vehicle implements Transform {}

In this example, the Vehicle class inherits two methods: the abstract transform method and the default printSpecs method.

在这个例子中，Vehicle类继承了两个方法：抽象的transform方法和默认的printSpecs方法。

6. Functional Interfaces

6.功能接口

Java has had many functional interfaces since its early days, such as Comparable (since Java 1.2) and Runnable (since Java 1.0).

Java从早期就有很多功能接口，比如Comparable（从Java 1.2开始）和Runnable（从Java 1.0开始）。

Java 8 introduced new functional interfaces such as Predicate, Consumer, and Function. To learn more about these, please visit our tutorial on Functional Interfaces in Java 8.

Java 8 引入了新的功能接口，例如Predicate、Consumer和Function。要了解有关这些的更多信息，请访问我们关于Java 8 中的功能接口的教程。

7. Conclusion

7.结语

In this tutorial, we gave an overview of Java interfaces, and we talked about how to use them to achieve polymorphism and multiple inheritances.

在本教程中，我们对Java接口进行了概述，并谈到了如何利用接口实现多态性和多继承性。

As always, the complete code samples are available over on GitHub.

像往常一样，完整的代码样本在GitHub上可用。。