Java中的接口是什么？

2019-09-15 13:00:06 阅读：211 来源： 互联网

正如this question的对应点：Java中的接口是什么？

解决方法:

接口是抽象类的一种特殊形式,它不实现任何方法.在Java中,您可以创建如下界面：

interface Interface
{
    void interfaceMethod();
}

由于接口无法实现任何方法,因此暗示整个事物(包括所有方法)都是公共的和抽象的(Java术语中的抽象意味着“不是由此类实现的”).所以上面的界面与下面的界面相同：

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

要使用此界面,您只需实现该界面即可.许多类可以实现一个接口,一个类可以实现许多接口：

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");
    }
}

现在,如果你想要,你可以写一个像这样的方法：

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"
}

但是,您永远不能执行以下操作：

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

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

你不能这样做的原因是y是interfaceA类型,并且interfaceA中没有interfaceMethodB().同样,z的类型为interfaceB,并且interfaceB中没有interfaceMethodA().

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

interface Interface
{
    void abstractMethod();
}

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

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

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

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

实际上,您甚至可以像这样更改接口和抽象类：

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()"); }
}

但是,接口和抽象类之间存在两个差异.

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

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

上面的接口生成编译器错误,因为它具有implementsMethod()的实现.如果你想实现该方法但不能实例化该类,你必须这样做：

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

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

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

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

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

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

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

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

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

上面的代码没有问题,因为InterfaceA和InterfaceB没有任何隐藏的东西.很容易告诉对方法的调用将打印“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()时会发生什么？它会打印“Hello”还是“Goodbye”？您可能不知道,Java编译器也不知道.另一种语言C允许这种继承,他们以通常非常复杂的方式解决了这些问题.为了避免这种麻烦,Java决定将这种“多重继承”定为非法.

Java解决方案的缺点是无法完成以下任务：

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是“mixins”或类,它们不是要实例化的,而是为通过继承“混入”的类添加功能.如果你调用new InheritsFromTwoAbstractClasses().hi()或者新的InheritsFromTwoAbstractClasses().bye(),显然没有问题,但是你不能这样做,因为Java不允许它.

(我知道这是一个很长的帖子,所以如果有任何错误,请告诉我,我会纠正它们.)

标签：java,oop,inheritance,interface
来源： https://codeday.me/bug/20190915/1804874.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Java中的接口是什么？