Java中的接口是什么？

就像这个问题的对应点：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 ，并没有interfaceMethodB()中interfaceA 。 同样地， z是类型的interfaceB并且没有interfaceMethodA()中interfaceB 。

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

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

上面的接口生成一个编译器错误，因为它具有implementedMethod() 。 如果你想实现这个方法，但是不能实例化这个类，你必须这样做：

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会打印“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是“mixins”或类，它们不打算被实例化，但为通过继承“混合到”的类添加功能。 如果调用new InheritsFromTwoAbstractClasses().hi()或new InheritsFromTwoAbstractClasses().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();  
 }  
}

---

界面是一个阶级的蓝图。

有一个叫做数据抽象的概念，有两个类，一个是抽象类 ，另一个是接口 。

抽象类仅实现部分抽象，但接口实现了完全抽象。

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

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

接口不能被实例化。

interface A() {
    void print()
}

链接地址: http://www.djcxy.com/p/54265.html

上一篇: What is an interface in Java?

下一篇: Inheriting an abstract class vs implementing an interface