Java中的接口是什么? [英] What is an interface in Java?

问题描述

就像这个问题的对立面:Java 中的接口是什么?>

Just as a counterpoint to this question: what is an interface in Java?

推荐答案

接口是抽象类的一种特殊形式，它不实现任何方法.在 Java 中，您可以创建这样的接口:

An interface is a special form of an abstract class which does not implement any methods. In Java, you create an interface like this:

interface Interface
{
    void interfaceMethod();
}

由于接口不能实现任何方法，这意味着整个事物，包括所有方法，都是公共的和抽象的(抽象在Java术语中的意思是这个类没有实现").所以上面的界面和下面的界面是一样的:

Since the interface can't implement any methods, it's implied that the entire thing, including all the methods, are both public and abstract (abstract in Java terms means "not implemented by this class"). So the interface above is identical to the interface below:

public interface Interface
{
    abstract public void interfaceMethod();
}

要使用这个接口，你只需要实现这个接口.很多类可以实现一个接口，一个类可以实现很多接口:

To use this interface, you simply need to implement the interface. Many classes can implement an interface, and a class can implement many interfaces:

interface InterfaceA
{
     void interfaceMethodA();
}

interface InterfaceB
{
    void interfaceMethodB();
}

public class ImplementingClassA
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
        System.out.println("interfaceA, interfaceMethodA, implementation A");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation A");
    }
}

public class ImplementingClassB
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
         System.out.println("interfaceA, interfaceMethodA, implementation B");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation B");
    }
}

现在如果你愿意，你可以写一个这样的方法:

Now if you wanted you could write a method like this:

public void testInterfaces()
{
    ImplementingClassA u = new ImplementingClassA();
    ImplementingClassB v = new ImplementingClassB();
    InterfaceA w = new ImplementingClassA();
    InterfaceA x = new ImplementingClassB();
    InterfaceB y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    u.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    u.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    v.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    v.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
    w.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    x.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    y.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    z.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
}

但是，您不能永远执行以下操作:

However, you could never do the following:

public void testInterfaces()
{
    InterfaceA y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    y.interfaceMethodB(); // ERROR!
    z.interfaceMethodA(); // ERROR!
}

不能这样做的原因是y是interfaceA类型，而中没有interfaceMethodB()>interfaceA.同样，z 属于 interfaceB 类型，interfaceB 中没有 interfaceMethodA().

The reason you can't do this is that y is of type interfaceA, and there is no interfaceMethodB() in interfaceA. Likewise, z is of type interfaceB and there is no interfaceMethodA() in interfaceB.

我之前提到过接口只是抽象类的一种特殊形式.为了说明这一点，请查看以下代码.

I mentioned earlier that interfaces are just a special form of an abstract class. To illustrate that point, look at the following code.

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
{
    abstract public void abstractMethod();
}

您将从这些类继承几乎完全相同的方式:

You would inherit from these classes almost exactly the same way:

public class InheritsFromInterface
    implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

public class InteritsFromAbstractClass
    extends AbstractClass
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

事实上，你甚至可以像这样改变接口和抽象类:

In fact, you could even change the interface and the abstract class like this:

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
    implements Interface
{
    abstract public void abstractMethod();
}

public class InheritsFromInterfaceAndAbstractClass
    extends AbstractClass implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

但是，接口和抽象类之间有两个区别.

However, there are two differences between interfaces and abstract classes.

第一个区别是接口不能实现方法.

The first difference is that interfaces cannot implement methods.

interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

上面的接口会产生编译器错误，因为它有implementedMethod() 的实现.如果您想实现该方法但无法实例化该类，则必须这样做:

The interface above generates a compiler error because it has an implementation for implementedMethod(). If you wanted to implement the method but not be able to instantiate the class, you would have to do it like this:

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

这不是一个抽象类，因为它的成员都不是抽象的，但它是合法的 Java.

That's not much of an abstract class because none of its members are abstract, but it is legal Java.

接口和抽象类的另一个区别是一个类可以继承多个接口，但只能继承一个抽象类.

The other difference between interfaces and abstract classes is that a class can inherit from multiple interfaces, but can only inherit from one abstract class.

abstract public class AbstractClassA { }
abstract public class AbstractClassB { }
public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

上面的代码产生编译错误，不是因为类都是空的，而是因为InheritsFromTwoAbstractClasses试图从两个抽象类继承，这是非法的.以下是完全合法的.

The code above generates a compiler error, not because the classes are all empty, but because InheritsFromTwoAbstractClasses is trying to inherit from two abstract classes, which is illegal. The following is perfectly legal.

interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{ }    

接口和抽象类之间的第一个区别是第二个区别的原因.看看下面的代码.

The first difference between interfaces and abstract classes is the reason for the second difference. Take a look at the following code.

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}

上面的代码没有问题，因为InterfaceA 和InterfaceB 没有什么可隐藏的.很容易看出对 method 的调用将打印method()".

There's no problem with the code above because InterfaceA and InterfaceB don't have anything to hide. It's easy to tell that a call to method will print "method()".

现在看下面的代码:

abstract public class AbstractClassA
{
    void method() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void method() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

这和我们的另一个例子完全一样，除了因为我们允许在抽象类中实现方法，我们做到了，而且因为我们不必在继承类中实现已经实现的方法，我们没有'不.但你可能已经注意到，有一个问题.当我们调用 new InheritsFromTwoAbstractClasses().method() 时会发生什么?它打印你好"还是再见"?您可能不知道，Java 编译器也不知道.另一种语言，C++ 允许这种继承，它们以通常非常复杂的方式解决了这些问题.为了避免这种麻烦，Java 决定将这种多重继承"定为非法.

This is exactly the same as our other example, except that because we're allowed to implement methods in abstract classes, we did, and because we don't have to implement already-implemented methods in an inheriting class, we didn't. But you may have noticed, there's a problem. What happens when we call new InheritsFromTwoAbstractClasses().method()? Does it print "Hello" or "Goodbye"? You probably don't know, and neither does the Java compiler. Another language, C++ allowed this kind of inheritance and they resolved these issues in ways that were often very complicated. To avoid this kind of trouble, Java decided to make this "multiple inheritance" illegal.

Java 解决方案的缺点是无法完成以下操作:

The downside to Java's solution that the following can't be done:

abstract public class AbstractClassA
{
    void hi() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void bye() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

AbstractClassA 和 AbstractClassB 是混入"或不打算实例化的类，而是向通过继承混入"的类添加功能.如果你调用 new InheritsFromTwoAbstractClasses().hi() 或 new InheritsFromTwoAbstractClasses().bye() ，弄清楚会发生什么显然没有问题，但你不能这样做因为 Java 不允许.

AbstractClassA and AbstractClassB are "mixins" or classes that aren't intended to be instantiated but add functionality to the classes that they are "mixed into" through inheritance. There's obviously no problem figuring out what happens if you call new InheritsFromTwoAbstractClasses().hi() or new InheritsFromTwoAbstractClasses().bye(), but you can't do that because Java doesn't allow it.

(我知道这是一篇很长的文章，所以如果其中有任何错误，请告诉我，我会更正.)

(I know this is a long post, so if there are any mistakes in it please let me know and I will correct them.)

这篇关于Java中的接口是什么?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！