关于java：为什么要使用接口，多重继承与接口，接口的好处？

Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?

我对这件事还是有些困惑。到目前为止我发现的是

(这里已经问过类似的问题，但我还有其他一些问题。)

Interface is collection of ONLY abstract methods and final fields.

There is no multiple inheritance in Java.

Interfaces can be used to achieve multiple inheritance in Java.

One Strong point of Inheritance is that We can use the code of base class in derived class without writing it again. May be this is the most important thing for inheritance to be there.

现在..

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

Q2. If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?

Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

那为什么要做接口呢？

注意：我发现了一种情况，在这种情况下接口是有用的。它的一个例子类似于在可运行接口中，我们有一个公共的void run()方法，在这个方法中我们定义了线程的功能，并且有一个内置的编码，这个方法将作为一个单独的线程运行。所以我们只需要在线程中编写代码，REST是预先定义的。但这一点也可以通过使用抽象类和所有类来实现。

那么使用接口的确切好处是什么呢？我们使用接口实现的是多重继承吗？

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

我们不能。接口不能用来实现多重继承。他们用更安全的替代它，虽然稍微不那么强大的结构。注意关键字implements，而不是extends。

Q2. If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?

它们不是。通过接口，一个类可以有几个"视图"、不同的API或功能。例如，一个类可以同时是Runnable和Callable，而两个方法实际上都在做相同的事情。

Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

接口是一种多重继承，后者没有引入问题(如菱形问题)。

接口的用例很少：

对象实际上有两个身份：Tank既是Vehicle又是Weapon。您可以使用Tank的一个实例，其中前者或后者是预期的(多态性)。这在现实生活中很少出现，实际上是一个有效的例子，多个继承会更好(或更好)。

简单职责：游戏中的Tank对象的一个实例也是Runnable让你在线程中执行它，ActionListener响应鼠标事件。

回调接口：如果对象实现给定的回调接口，则会通知它的生命周期或其他事件。

标记接口：不添加任何方法，但可以通过instanceof轻松访问，以发现对象的功能或愿望。Serializable和Cloneable就是这样的例子。

你所寻找的是特质(比如Scala)，不幸的是在Java中是不可用的。

相关讨论

接口是最终静态场和抽象方法的收集(新Java 8 added support of having static methods in an interface)。

接口是在我们知道必须完成某些任务的情况下制作的，但接口是如何做到的。另一个词，我们可以说我们实现了接口，所以我们的班级开始在一个特定的方式。

让我以一个例子来解释，我们都知道动物是什么。象狮子一样是动物，猴子是动物，象动物，牛是动物，因此也是动物。现在我们知道所有动物都在吃东西和睡觉。但每一种动物的食欲或睡眠方式可能不同。就像狮子吃其他动物吃牛肉一样但两者都吃。所以我们可以有类似的伪码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

interface Animal {
public void eat();
public void sleep();
}

class Lion implements Animal {
public void eat() {
// Lion's way to eat
}

public void sleep(){
// Lion's way to sleep
}
}

class Monkey implements Animal {
public void eat() {
// Monkey's way to eat
}

public void sleep() {
// Monkey's way to sleep
}
}

由于上面提到的伪码，任何能吃或睡的东西都会被称为动物，或者我们可以说，它必须是所有动物的食物和睡眠，但它取决于动物的饮食和睡眠。

在接口的情况下，我们只输入行为，而不是实际代码，如遗传类。

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

实现界面是另一种传统。这与班级的固有遗产并不相似，因为传统的儿童班级从基层班级获得了实际的代码。

BLCK1/

这是因为一个类别能够实现的比一个接口更多。但我们需要了解，这一固有的遗产不同于遗产阶级。

Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

实现一个界面强迫，它必须超越所有抽象方法。

在我的书里读更多

相关讨论

吻

我一直在寻找日子，几周前试图了解接口，似乎也在寻找同样的一般性帮助；我并没有试图消除捐款，但我认为光-球只是点击，所以我跌倒了：)

我宁愿保持简单的愚蠢，所以我将展示我的新的界面视图。

我是一个偶然的编码器，但我想把这个代码邮寄到VB.Net(其他语言的原则是一样的)，以便帮助其他人了解接口。

如果我搞错了，请让其他人知道。

清除

在一个表格上点击三个按钮，每个按钮保存一个不同类别的参照，用于界面变量( data)。The whole point of different class reference s in to an variable interface，i s what I didn't understand as i t seemed redundant，then i t s power becomes evident with the MSGBOX，I only need to call the same method to perform the task I need，in this case getdata()，which use the method in the class that's currently held by the reference VAriable( udata).

因此，尽管我希望得到我的数据(从数据库、网页或文本文件中)，但它只是使用了相同的名称；执行后的代码……我不在乎。

然后很容易用界面来改变每一类代码而不依赖于任何接口……这是OO和封装的一个关键目标。

使用时

代码种类，如果你注意到在方法上使用的同一个动词，如获得数据()，那么它是一个很好的候选方，可以实现一个接口，在该组中，并使用该方法作为抽象/接口。

我真诚地希望，这将有助于一个困难的原则。

ZZU1

相关讨论

这是一个非常古老的问题，Java-8版本为接口增加了更多的特性和功能。

接口声明可以包含

方法签名

默认方法

静态方法

常量定义。

只有在接口中有实现的方法是默认方法和静态方法。

接口用途：

定义合同

将不相关的类与具有某种功能的类链接起来(例如，实现可序列化接口的类之间可能存在或可能不存在任何关系，但实现该接口的类除外

提供可互换的实施，如Strategy_pattern。

默认方法允许您向库的接口添加新功能，并确保与为这些接口的旧版本编写的代码的二进制兼容性。

使用静态方法组织库中的助手方法(您可以将特定于接口的静态方法保留在同一个接口中，而不是单独的类中)

请看一下这一相关的SE问题的代码示例，以便更好地理解这些概念：

我应该如何解释接口和抽象类之间的区别？

回到你的问题：

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

Q2. If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?

接口可以包含静态方法和默认方法的代码。这些默认方法提供向后兼容性，静态方法提供帮助程序/实用程序函数。

在Java和接口中不能拥有真正的多重继承，并不是获得它的方法。接口只能包含常量。所以您不能继承状态，但可以实现行为。

您可以用功能替换继承。接口为实现类提供了多种功能。

Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

请参阅我的答案中的"接口的使用"部分。

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

不幸的是，在口语用法中，当类实现接口时，仍然经常使用inheritance这个词，尽管interface implementation是一个比较好的术语-imo，但是术语inheritance应该严格用于具体或抽象类的继承。在C++和C语言等语言中，同样的语法(即EDCOX1，3，EDCX1，4)是用于类继承和接口实现的，这可能有助于使用接口对EDOCX1 0字的滥用。对于EDCOX1，6，Java有不同的语法，而不是EDCOX1，7接口，这是一件好事。

Q2 If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?

您可以通过组合实现多个继承的"效果"——在一个类上实现多个接口，然后为该类上所有接口所需的所有方法、属性和事件提供实现。对具体类执行此操作的一种常见技术是通过执行"has-a"(组合)与类的关系，这些类通过将实现"连接"到每个内部类实现来实现外部接口。(C++等语言直接支持多个具体继承，但会产生其他潜在问题，如菱形问题)。

Q3 Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

接口允许现有类(例如框架)与新类进行交互，而以前从未"见过"过它们，因为它能够通过已知的接口进行通信。把一个接口看作一个契约。通过在一个类上实现这个接口，根据合同，您必须满足它所要求的义务，并且一旦实现了这个合同，那么您的类就应该能够与使用该接口的任何其他代码互换使用。

Real World Example

一个"现实世界"的例子是在一个特定的国家，围绕着一个墙壁电气插座的立法和惯例(接口)。每个插入插座的电器都需要符合当局为插座规定的规范(合同)，例如线路、中性线和接地线的位置、开关的位置和颜色，以及将被抑制的电压、频率和最大电流的一致性。打开时通过interface。

将接口(即标准壁装插座)分离而不仅仅是将电线焊接在一起的好处是，您可以将风扇、水壶、双适配器或明年将要发明的新设备插入(并拔下)，即使在设计接口时该设备并不存在。为什么？因为它将符合接口的要求。

Why use interfaces?

接口对于类的松散耦合是很好的，并且是Bob叔叔的固体范式的支柱之一，特别是Dependency Inversion Principle和Interface Segregation Principles。

简单地说，通过确保类之间的依赖关系仅与接口(抽象)耦合，而不是与其他具体类耦合，它允许将依赖关系替换为满足接口要求的任何其他类实现。

在测试中，可以使用依赖项的存根和模拟对每个类进行单元测试，并且可以"监视"类与依赖项之间的交互。

相关讨论

继承是指一个类从另一个类(可以是抽象的)或接口派生。面向对象(继承)的最强点不是代码的重用(有很多方法可以实现)，而是多态性。

多态性是指当您有使用接口的代码时，它的实例对象可以是从该接口派生的任何类。例如，我可以有这样一个方法：public void pet(iAnimal animal)和此方法将得到一个对象，该对象是从iAnimal继承的狗或猫的实例。或者我可以有这样一个代码：动物动物然后我可以调用这个接口的一个方法：animal.eat()狗或猫可以以不同的方式执行。

接口的主要优点是可以从其中一些继承，但是如果只需要从一个继承，也可以使用抽象类。下面是一篇文章，详细解释了抽象类和接口之间的区别：http://www.codeproject.com/kb/cs/abstractsvsinterfaces.aspx

这两种方法都可以工作(接口和多重继承)。

快速实用的简短回答

如果您有多年的使用多继承的经验，并且这些继承具有只包含方法定义的超级类，并且根本没有代码，那么接口就更好了。

一个补充性的问题可能是："如何以及为什么将代码从抽象类迁移到接口"。

如果您没有在应用程序中使用许多抽象类，或者您没有使用它的很多经验，那么您可能更喜欢跳过接口。

不要急于使用接口。

冗长乏味的回答

接口非常相似，甚至等同于抽象类。

如果您的代码有许多抽象类，那么您就应该开始考虑接口了。

具有抽象类的以下代码：

mystreamsClasss.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/* File name : MyStreamsClasses.java */
import java.lang.*;
// Any number of import statements

public abstract class InputStream {
public void ReadObject(Object MyObject);
}

public abstract class OutputStream {
public void WriteObject(Object MyObject);
}

public abstract class InputOutputStream
imnplements InputStream, OutputStream {
public void DoSomethingElse();
}

可替换为：

mystreamsInterfaces.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/* File name : MyStreamsInterfaces.java */
import java.lang.*;
// Any number of import statements

public interface InputStream {
public void ReadObject(Object MyObject);
}

public interface OutputStream {
public void WriteObject(Object MyObject);
}

public interface InputOutputStream
extends InputStream, OutputStream {
public void DoSomethingElse();
}

干杯。

老问题。我惊讶的是，没有人引用标准源：Java：詹姆斯·高斯林的概述，设计模式：由四人组成的可重用面向对象软件的元素或Joshua Bloch的有效Java(其他来源)。好的。

我将从一个引言开始：好的。

An interface is simply a specification of a set of methods that an object responds to. It does not include any instance variables or implementation. Interfaces can be multiply-inherited (unlike classes) and they can be used in a more flexible way than the usual rigid class
inheritance structure. (Gosling, p.8)

Ok.

现在，让我们一个接一个地接受你的假设和问题(我会主动忽略Java 8的特性)。好的。假设接口只是抽象方法和最终字段的集合。

在Java接口中，你看到了EDOCX1 0的关键字吗？不，那么您不应该将接口视为抽象方法的集合。也许你被C++所谓的接口误导了，它们只是纯虚拟方法的类。通过设计，C++没有(并且不需要拥有)接口，因为它具有多个继承。好的。

正如gosling所解释的，您应该将接口视为"对象响应的一组方法"。我喜欢将接口和相关文档视为服务合同。它描述了可以从实现该接口的对象中得到什么。文档应指定前置和后置条件(例如，参数不应为空，输出始终为正，…)和不变量(不修改对象内部状态的方法)。我认为这份合同是OOP的核心。好的。在Java中没有多重继承。

的确。好的。

JAVA omits many rarely used, poorly understood, confusing features of C++ that in our experience bring more grief than benefit. This primarily consists of operator overloading (although it does have method overloading), multiple inheritance, and extensive automatic coercions. (Gosling, p.2)

Ok.

没有什么可以补充的。好的。接口可以用来在Java中实现多重继承。

不，SimLPY，因为Java中没有多重继承。见上文。好的。继承的一个优点是我们可以在派生类中使用基类的代码，而不必再次编写它。可能这是继承最重要的事情。

这就是所谓的"实现继承"。正如您所写，这是一种重用代码的方便方法。好的。

但它有一个重要的对应物：好的。

parent classes often define at least part of their subclasses' physical representation. Because inheritance exposes a subclass to details of its parent's implementation, it's often said that"inheritance breaks encapsulation" [Sny86]. The implementation of a subclass becomes so bound up with the implementation of its parent class that any change in the parent's implementation will force the subclass to change. (GOF, 1.6)

Ok.

(布洛赫第16项中也有类似的报价。)好的。

实际上，继承还有另一个目的：好的。

Class inheritance combines interface inheritance and implementation inheritance. Interface inheritance defines a new interface in terms of one
or more existing interfaces. Implementation inheritance defines a new implementation in terms of one or more existing implementations. (GOF, Appendix A)

Ok.

两者都在Java中使用关键字EDCOX1 0。您可能具有类的层次结构和接口的层次结构。第一个共享实施，第二个共享义务。好的。问题Q1。因为接口只有抽象方法(没有代码)，所以我们怎么能说，如果我们实现了任何接口，那么它就是继承？我们没有使用它的代码。**

接口的实现不是继承。它的实现。因此关键字implements。好的。Q2。如果实现接口不是继承，那么如何使用接口来实现多重继承？**

在Java中没有多重继承。见上文。好的。Q3。总之，使用接口有什么好处？他们没有任何代码。我们需要在所有实现它的类中一次又一次地编写代码。/那为什么要创建接口呢？/使用接口的确切好处是什么？我们使用接口实现的是多重继承吗？

最重要的问题是：你为什么想要多重继承？我可以想到两个答案：1。给一个对象赋予多个类型；2。重用代码。好的。为对象提供多个类型

在OOP中，一个对象可能有不同的类型。例如，在Java中，EDCOX1〔2〕具有以下类型：EDCOX1，3，EDCOX1，4，EDCOX1，5，EDCOX1，6，EDCOX1，7，EDOCX1，8，EDOCX1 9，EDCOX1 10，EDCOX1 11，(我希望我没有忘记任何人)。如果一个对象有不同的类型，那么不同的消费者可以使用它，而不必知道它的特殊性。我需要一个Iterable，你给我一个ArrayList？没关系。但如果我现在需要一个List，而你给我一个ArrayList，也没关系。等。好的。

如何在OOP中键入对象？您以Runnable接口为例，这个例子很好地说明了这个问题的答案。我引用官方Java文档：好的。< Buff行情>

此外，runnable还提供了一种方法，使类在不子类化线程的情况下处于活动状态。好的。< /块引用>

要点是：继承是一种方便的输入对象的方法。要创建线程吗？让我们对Thread类进行子类划分。您希望一个对象有不同的类型，让我们使用mutliple继承。哎呀。它不存在于Java中。(在C++中，如果希望对象具有不同的类型，那么多继承是方法。)好的。

那么如何给一个对象赋予多个类型呢？在爪哇中，可以直接键入对象。这就是当类implements和Runnable接口时所做的。如果你喜欢继承，为什么要用Runnable？也许是因为你的类已经是另一个类的子类了，比如说A。现在你们班有两种类型：A和Runnable。好的。

通过多个接口，您可以为一个对象提供多个类型。您只需创建一个implements多个接口的类。只要你遵守合同，就可以了。好的。重用代码

这是一个困难的主题；我已经引用了破坏封装的GOF。另一个答案提到了钻石问题。你也可以考虑单一责任原则：好的。

A class should have only one reason to change. (Robert C. Martin, Agile Software Development, Principles, Patterns, and Practices)

Ok.

拥有一个父类可能会给一个类一个改变的理由，除了它自己的职责：好的。

The superclass’s implementation may change from release to release, and if it does, the subclass may break, even though its code has not been touched. As a consequence, a subclass must evolve in tandem with its superclass (Bloch, item 16).

Ok.

我会添加一个更平淡的问题：当我试图在类中找到方法的源代码，却找不到时，我总是有一种奇怪的感觉。然后我记得：它必须在父类的某个地方定义。或者在祖父母班上。或者更高。在这种情况下，一个好的IDE是一种宝贵的资产，但在我看来，它仍然是一种神奇的东西。与接口的层次结构没有任何相似之处，因为JavaDoc是我唯一需要的东西：在IDE中有一个键盘快捷键，我得到了它。好的。

继承方式具有以下优点：好的。

It is safe to use inheritance within a package, where the subclass and the superclass implementations are under the control of the same programmers. It is also safe to use inheritance when extending classes specifically designed and documented for extension (Item 17: Design and document for inheritance or else prohibit it). (Bloch, item 16)

Ok.

在爪哇，一个"专为扩展而设计的文件"的例子是AbstractList。好的。

但是布洛克和戈夫坚持这样的观点："赞成组合而非继承"。好的。

Delegation is a way of making composition as powerful for reuse as inheritance [Lie86, JZ91]. In delegation, two objects are involved in handling a request: a receiving object delegates operations to its delegate. This is analogous to subclasses deferring requests to parent classes. (GOF p.32)

Ok.

如果使用撰写，就不必反复编写相同的代码。只需创建一个处理重复的类，并将该类的实例传递给实现接口的类。这是一种非常简单的代码重用方法。这有助于您遵循单一责任原则，使代码更具可测试性。Rust-and-Go没有继承性(它们也没有类)，但我不认为代码比其他OOP语言更冗余。好的。

此外，如果您使用组合，您会发现自己自然地使用接口来为代码提供所需的结构和灵活性(请参阅有关接口用例的其他答案)。好的。

注意：可以用Java 8接口共享代码好的。

最后，最后一句话：好的。

During the memorable Q&A session, someone asked him [James Gosling]:"If you could do Java over again, what would you change?""I'd leave out classes" (anywhere on the net, don't know if this is true)

Ok.

好啊。

Q1。因为接口只有抽象方法(没有代码)，所以我们怎么能说，如果我们正在实现一个接口，那么它就是继承呢？我们没有使用它的代码。

这不是平等的继承。这只是相似的。让我解释一下：

1
2
3
4
5

VolvoV3 extends VolvoV2, and VolvoV2 extends Volvo (Class)
VolvoV3 extends VolvoV2, and VolvoV2 implements Volvo (Interface)

line1: Volvo v = new VolvoV2();
line2: Volvo v = new VolvoV3();

如果只看到第1行和第2行，则可以推断volvov2和volvov3具有相同的类型。你不能推断沃尔沃是一个超类还是沃尔沃是一个接口。

Q2。如果实现接口不是继承，那么如何使用接口来实现多个继承？

现在使用接口：

1
2
3
4
5
6

VolvoXC90 implements XCModel and Volvo (Interface)
VolvoXC95 implements XCModel and Volvo (Interface)

line1: Volvo a = new VolvoXC90();
line2: Volvo a = new VolvoXC95();
line3: XCModel a = new VolvoXC95();

如果只看到第1行和第2行，则可以推断volvoxc90和volvoxc95具有相同的类型(volvo)。你不能推断沃尔沃是一个超类或沃尔沃是一个接口。

如果你只看到LeN2和LeN3，你可以推断Volvo 95在Java中实现了两种类型XCMODEL和Volvo，你知道至少有一个必须是一个接口。例如，如果这个代码是用C++编写的，它们可以是两个类。因此，多重继承。

Q3。总之，使用接口有什么好处？他们没有任何代码。我们需要在所有实现它的类中反复编写代码。

设想一个系统，在200个其他类中使用volvoxc90类。

1	VolvoXC90 v = new VolvoXC90();

如果你需要升级你的系统来启动volvoxc95，你必须修改200个其他类。

现在，想象一个系统，你在10000000个类中使用沃尔沃接口。

1 2	// Create VolvoXC90 but now we need to create VolvoXC95 Volvo v = new VolvoFactory().newCurrentVolvoModel();

现在，如果您需要改进您的系统来创建volvoxc95模型，您只需要更改一个类，即工厂。

这是一个常识性的问题。如果您的系统只由很少的类组成，并且更新很少，那么在任何地方使用接口都会适得其反。对于大型系统，它可以为您节省大量的痛苦，并避免采用接口的风险。

我建议您阅读更多关于S.O.L.I.D原理的书，并阅读《有效Java》这本书。它从经验丰富的软件工程师那里得到了很好的教训。

接口被制作成这样，一个类别将在接口内实现功能性，并根据接口的要求进行。

界面

接口是定义如何与对象交互的契约。它们对于表达您的内部打算如何与对象交互非常有用。在依赖倒置之后，公共API将具有用接口表示的所有参数。你不在乎它是如何做你需要它做的，只是它做你需要它做的。

示例：您可能只需要一个Vehicle来运输货物，您不关心特定的运输方式。

遗传

继承是特定实现的扩展。该实现可能满足，也可能不满足特定接口。只有当您关心如何实现时，您才应该期望特定实现的祖先。

示例：为了快速运输，您可能需要一个Plane实现的车辆。

作文

组合可以用作继承的替代方法。它不是用扩展基类的类，而是用实现主类职责较小部分的对象创建的。成分用于facade pattern和decorator pattern。

示例：您可以创建一个实现LandVehicle和WaterVehicle的DuckBoat类，这两个类都实现由Truck和Boat实现组成的Vehicle。

答案

Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.

接口不是继承。实现接口表示您希望类以接口定义的方式操作。继承是指当你有一个共同的祖先，并且你得到与祖先相同的行为(inherit)，所以你不需要定义它。

Q2. If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?

接口不能实现多重继承。它们表示一个类可能适合多个角色。

Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it.

接口的主要好处之一是提供关注点分离：

您可以编写一个与另一个类一起执行某些操作的类，而不必关心该类是如何实现的。
任何未来的开发都可以与实现兼容，而无需扩展特定的基类。

根据DRY的精神，如果您利用组合，您可以编写一个满足接口并对其进行更改的实现，同时仍然尊重open/closed principal。

相关讨论