Fatal编程技术网
  • java/
  • Java中的接口是什么？

Java中的接口是什么？

java inheritance interface oop

Java中的接口是什么？,java,inheritance,interface,oop,Java,Inheritance,Interface,Oop,与之相对应的是：什么是Java中的接口？接口是抽象类的一种特殊形式，它不实现任何方法。在Java中，您可以创建如下接口： interface Interface { void interfaceMethod(); } public void testInterfaces() { ImplementingClassA u = new ImplementingClassA(); ImplementingClassB v = new ImplementingClassB();

与之相对应的是：什么是Java中的接口？

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

interface Interface
{
    void interfaceMethod();
}

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

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

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
由于接口不能实现任何方法，这就意味着整个东西，包括所有的方法，都是公共的和抽象的（抽象在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");
    }
}
现在，如果需要，可以编写如下方法：

interface Interface
{
    void interfaceMethod();
}

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

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

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
但是，您可以从不执行以下操作：

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

    y.interfaceMethodB(); // ERROR!
    z.interfaceMethodA(); // ERROR!
}
无法执行此操作的原因是
y
属于
interfaceea
类型，并且
interfaceea
中没有
interfaceMethodB（）
。同样，
z
属于
interfaceB
类型，并且
interfaceB
中没有
interfaceMethodA（）

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

interface Interface
{
    void abstractMethod();
}

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

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}
您将以几乎完全相同的方式从这些类继承：

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

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

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

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
然而，接口和抽象类之间有两个区别

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

interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
上面的接口生成编译器错误，因为它有
implementedMethod（）
的实现。如果您想实现该方法，但无法实例化该类，则必须按如下方式执行：

interface Interface
{
    void interfaceMethod();
}

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

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

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
{ }
上面的代码生成一个编译器错误，不是因为类都为空，而是因为
inheritsfromtwoaxtractClasses
试图从两个抽象类继承，这是非法的。以下是完全合法的

interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{ }
接口和抽象类之间的第一个差异是第二个差异的原因。看看下面的代码

interface Interface
{
    void abstractMethod();
}

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

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}
上面的代码没有问题，因为
InterfaceA
和
InterfaceB
没有任何要隐藏的内容。很容易看出，调用
method
将打印“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决定将这种“多重继承”定为非法

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
是“混入”或不打算实例化的类，但通过继承将功能添加到它们“混入”的类中。如果调用
new-inheritsfromtwoaxtractclasses（）.hi（）
或
new-inheritsfromtwoaxtractclasses（）.bye（）
，显然没有问题，但是您不能这样做，因为Java不允许这样做

（我知道这是一篇很长的文章，如果其中有任何错误，请告诉我，我会纠正它们。）
java中的接口是类的蓝图。java中的接口是一种实现完全抽象的机制。java接口中只能有抽象方法，而不能有方法体。它用于在Java中实现完全抽象和多重继承。接口是抽象方法的集合。类实现接口，从而继承接口的抽象方法。
接口不是类。编写接口类似于编写类，但它们是两个不同的概念。类描述对象的属性和行为。接口包含类实现的行为（抽象方法）。
除非实现接口的类是抽象的，否则接口的所有方法都需要在类中定义。因为java中不允许多重继承，所以接口是实现多重继承的唯一方法。
下面是一个理解接口的示例


interface Printable{  
void print();  
}  

interface Showable{  
void print();  
}  

class testinterface1 implements Printable,Showable{  

public void print(){System.out.println("Hello");}  

public static void main(String args[]){  
testinterface1 obj = new testinterface1();  
obj.print();  
 }  
}



接口是类的蓝图。

有一个oop的概念叫做数据抽象，它分为两类，一类是抽象类，另一类是接口

抽象类只实现部分抽象，而接口实现完全抽象

接口中只有抽象方法和最终变量。您可以扩展任意数量的接口，也可以实现任意数量的类

如果任何类正在实现接口，那么该类也必须实现抽象方法

无法实例化接口


interface A() {
    void print()
}



这个问题已经提出6年了，多年来很多事情改变了接口的定义

从oracle页面（Java 8发布后）：

在Java编程语言中，接口是一种引用类型，类似于类，可以包含