blocks|key|115023|text|可以创建包含具体成员的抽象类，如方法或属性。您仍然不能直接实例化抽象类，但是任何实例化的子类都可以从抽象类中定义的实现成员中受益。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|115024|相比之下，接口从不包含任何实现逻辑。由每个实现类提供接口中定义的所有成员的实现。|115025|就我如何看待不同之处而言，抽象的子类是-该类型的类。例如，Dog是一个Animal。我把界面看作是一种做-一种关系。例如，ICanDisplayImages告诉我实现的类可以显示图像，但没有告诉我该类实际表示的是什么。|offset|length|style|CODE|115026|entityMap^0|0|0|T|3|Z|6|1P|H|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]|$F|S|G|T|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

It is possible to create abstract classes that contain concrete members, such as methods or properties. You still can't instantiate the abstract class directly, but any instantiated sub-classes can benefit from implemented members defined in the abstract class.

An interface, by comparison, never contains any implementation logic. It is down to each implementing class to provide the implementation of all members defined in the interface.

In terms of how I view the differences, a sub-class of an abstract is-a class of that type. e.g. <code>Dog</code> is an <code>Animal</code>. I see an interface as a does-a relationship. e.g. <code>ICanDisplayImages</code> tells me that the implementing class can display images, but tells me nothing about what the class actually represents.

blocks|key|863345|text|abstract类在其自身和子类之间形成一种is-a关系，而interface则创建一种关注-a关系。因此，抽象类比接口具体得多，它们还可以包含具体的实现(例如Template+methods)，而接口定义了实现类必须遵循的一组契约方法。这是一个高得多的抽象级别，因为实现类不一定是抽象类。使用它来标准化您的API。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|863346|相关问题：https://stackoverflow.com/search?q=abstract%2Bvs%2Binterface|863347|entityMap|0|LINK|mutability|MUTABLE|url|http://de3.php.net/manual/en/language.oop5.abstract.php|1|http://de3.php.net/manual/en/language.oop5.interfaces.php|2|http://sourcemaking.com/design_patterns/template_method|3|https://stackoverflow.com/search?q=abstract%2Bvs%2Binterface^0|0|8|U|9|0|8|0|U|9|1|28|G|2|0|5|1K|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]|$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|H|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]|R|$5|K|L|M|E|$N|S]]|T|$5|K|L|M|E|$N|U]]]]

An <a href="http://de3.php.net/manual/en/language.oop5.abstract.php" rel="nofollow noreferrer"><code>abstract</code></a> class forms an is-a relationship between itself and the subclass, while an <a href="http://de3.php.net/manual/en/language.oop5.interfaces.php" rel="nofollow noreferrer"><code>interface</code></a> creates a follows-a relationship. As such, abstract classes are much more concrete than interfaces and they may also contain concrete implementations (e.g. <a href="http://sourcemaking.com/design_patterns/template_method" rel="nofollow noreferrer">Template methods</a>) while an interface defines a contractual set of methods an implementing class must follow. This is a much higher level of abstraction as the implementing class must not necessarily be of the abstract class. Use it to standardize your API.

Related questions: <a href="https://stackoverflow.com/search?q=abstract+vs+interface">https://stackoverflow.com/search?q=abstract+vs+interface</a>

blocks|key|863317|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|863318|它们都不包含任何实现..|blockquote|863319|863320|863321|抽象类可以实现所有方法，也可以只实现部分方法。但主要的理念是通过在子类中添加新的方法来扩展现有的抽象类(扩展基本功能)。|863322|在一个子类中，您只能扩展一个类(抽象类)。抽象类定义您必须实现的功能，或者只是由子类中的其他方法扩展的功能。|863323|接口用于定义类的行为。您可以实现多个接口(假设我的子类必须执行this、this和this+thigs!)，但您只能扩展一个抽象类。|863324|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|O|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|R|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|S|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|T|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|U|7|@]|8|@]|9|$]]]|M|$]]

<blockquote>
 They both contain no implementations.. 
</blockquote>

Abstract class can implements all or only part of the methods. But the main philosophy - is extend existing abstract class by to add a new methods in child classes (that extend a basic functionality).

In a child class you can extend only one class (abstract class). Abstract class define functionality that you must implement or just extends by other methods in child classes.

Interfaces are use to define the class behaviors. You can implement more than one interface(and say my child-class must do this,this and this thigs!), but you can extend only one abstract class.

blocks|key|115045|text|除了在其他答案中描述的OOP哲学之外，我认为抽象类的主要用途是一种骨架。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|115046|当你设计一个应用程序，或者和一个团队一起工作时，它很有用，因为你有一个可以使用的基本代码，并扩展了它接近界面，但使用了更高级的工作流程。|115047|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Beyond the OOP philosophy described in other answers, I think the major use of abstract class is kind of a skeleton.

It's usefull when you design an application, or work with a team, because you have a base code to work with and extends it's close to interface but with a more advanced workflow.

blocks|key|1192570|text|抽象类和接口之间的主要区别是接口定义公共行为，其中抽象类是继承的基础类。换句话说，抽象类定义了子类可能共享的一些核心方法和属性集。考虑一个定义许可证的类。所有许可证都具有某种类型的id号，并发放给某个个人或团体。license类可以由Driver's+License类、Bicycle+License类和Hunting+License类等扩展。将license类抽象的主要原因是因为它定义了License的抽象概念。没有许可证这样的东西，所以通过声明类抽象，它不能被实例化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192571|另一方面，接口根本不定义对象。它定义了方法签名。任何实现接口的非抽象类都必须为接口中的所有方法提供实现。这里的优点是该方法提供了一个跨不同类型对象的公共接口，例如，compareTo()在与字符串或任何其他对象一起使用时看起来是相同的。|1192572|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The main difference between an abstract class and an interface is that an interface defines common behaviors, where an abstract class is a foundation class for inheritance. In other words, an abstract class defines some core set of methods and properties that subclasses might share. Consider a class that defines a License. All licenses have an id number of some type and are issued to some individual or group. A license class might be extended by a Driver's License class, a Bicycle License class, and Hunting License class, and so on. The main reason one would make the License class abstract is because it defines an abstract idea of a license. There is no such thing as a license, so by declaring the class abstract, it cannot be instantiated. 
An interface, on the other hand, does not define an object at all. It defines method signatures. Any non-abstract class that implements an interface must provide an implementation for all of the methods in the interface. The advantage here is the method provides a common interface across different types of objects, e.g. compareTo() looks the same when used with Strings or any other object.

blocks|key|861028|text|如果方法未定义为抽象，则抽象类可以包含方法实现。如果该方法被定义为抽象的，则它不包含实现，但它需要由其继承者实现。抽象类不能实例化，而只能继承自，以便继承者允许它使用其行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|861029|接口仅定义方法签名，任何从该接口继承的类都必须实现该接口中包含的所有方法。|861030|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

An abstract class can contain method implementations if the method is not defined as abstract. If the method is defined as abstract, it does not contain an implementation, but it needs to be implemented by its inheritors. An abstract class cannot be instantiated, but only inherited from, for the inheritor to allow it to use its behaviors.

An interface only defines method signatures and any class inheriting from it must implement all methods contained in the interface.

blocks|key|861153|text|通常接口是用来定义契约的，所以你需要进行类型检查。还有一种称为“针对接口编程”的编程风格，这是一个好主意。请参阅Dependency+Inversion+Principle|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|861154|861155|+A.高级模块不应该依赖于低级模块。两者都应该依赖于抽象。|blockquote|861156|861157|B.抽象不应该依赖于细节。细节应该取决于抽象。“|861158|861159|因此，如果您定义函数和方法，而不是针对类定义type+hinting，则只需针对接口进行提示。|861160|下面是一个例子。假设您为输入流和和输出流定义接口，如下所示：|861161|interface+OutputStream{
++write($string);+//+Writes+a+string+to+the+output.
++close();+//+Closes+the+output+stream.
}

interface+InputStream{
++read($length);+//+Reads+at+most+$length+characters.
++eof();+//+TRUE,+if+the+input+stream+is+empty.
}|code-block|syntax|javascript|861162|您现在可以创建copy函数或方法，它将流的完整输出复制到输入，而不需要它们中的任何一个：|style|CODE|861163|//+50+is+just+chosen+randomly.
function+copy(InputStream+$input,+OutputStream+$output){
++while(!$input->eof()){
++++$output->write($input->read(50));}}|861164|恭喜，您的copy实现现在可以处理输入流和输出流的每种组合，甚至不需要实现一个流。|861165|另一方面，抽象类可用于实现通用功能，而不必实现全功能类。|861166|再举一个例子。比方说，你想要有输出流。您需要一个write($s)方法，它将字符串写入输出，还需要一个writeLine($s)方法，它将字符串和额外的换行符写入输出。那么这将是适当的：|861167|abstract+class+AbstractOutputStream{
++public+function+writeLine($s){
++++$this->write($s."\n");}}|861168|具体的输出流现在可以从抽象输出流继承，只实现write并免费获取writeLine！|861169|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Dependency_inversion_principle|1|http://www.php.net/manual/en/language.oop5.typehinting.php^0|1K|U|0|0|0|0|0|0|0|M|C|1|0|0|0|7|4|0|0|5|4|0|0|O|9|1F|D|0|0|M|5|W|9|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|D|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1P|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|1R|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1T|8|@]|9|@$A|1U|B|1V|1|1W]]|C|$]]|$1|N|3|O|5|6|7|1X|8|@]|9|@]|C|$]]|$1|P|3|Q|5|R|7|1Y|8|@]|9|@]|C|$S|T]]|$1|U|3|V|5|6|7|1Z|8|@$A|20|B|21|W|X]]|9|@]|C|$]]|$1|Y|3|Z|5|R|7|22|8|@]|9|@]|C|$S|T]]|$1|10|3|11|5|6|7|23|8|@$A|24|B|25|W|X]]|9|@]|C|$]]|$1|12|3|13|5|6|7|26|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|27|8|@$A|28|B|29|W|X]|$A|2A|B|2B|W|X]]|9|@]|C|$]]|$1|16|3|17|5|R|7|2C|8|@]|9|@]|C|$S|T]]|$1|18|3|19|5|6|7|2D|8|@$A|2E|B|2F|W|X]|$A|2G|B|2H|W|X]]|9|@]|C|$]]|$1|1A|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]]|1B|$1C|$5|1D|1E|1F|C|$1G|1H]]|1I|$5|1D|1E|1F|C|$1G|1J]]]]

Usually interfaces are used to define contracts, so you get type checking. There is also a programming style called "programming against interfaces", which is a good idea. See the <a href="http://en.wikipedia.org/wiki/Dependency_inversion_principle" rel="nofollow noreferrer">Dependency Inversion Principle</a>:

<blockquote>
 A. High-level modules should not depend on low-level modules. Both should depend on abstractions.
 
 B. Abstractions should not depend upon details. Details should depend upon abstractions."
</blockquote>

So if you define functions and methods, instead of <a href="http://www.php.net/manual/en/language.oop5.typehinting.php" rel="nofollow noreferrer">type hinting</a> against classes, you just hint against interfaces.

Here is an example. Let's say, you define interfaces for input streams and and output streams as follows:

<pre><code>interface OutputStream{
 write($string); // Writes a string to the output.
 close(); // Closes the output stream.
}

interface InputStream{
 read($length); // Reads at most $length characters.
 eof(); // TRUE, if the input stream is empty.
}
</code></pre>

You could now create <code>copy</code> function or method, which copies the complete output of a stream to an input, without having any of them:

<pre><code>// 50 is just chosen randomly.
function copy(InputStream $input, OutputStream $output){
 while(!$input-&gt;eof()){
 $output-&gt;write($input-&gt;read(50));}}
</code></pre>

Congratulations, your <code>copy</code> implementation now works for every combination of an input and output stream, without even implementing one.

Abstract classes, on the other hand, can be used to implement common functionality without having to implement a fully functional class.

Again, an example. Let's say, you want to have output streams. You want a method <code>write($s)</code>, which writes a string to the output, and you want a method <code>writeLine($s)</code>, which writes the string and an additional newline to the output. Then this would be appropriate:

<pre><code>abstract class AbstractOutputStream{
 public function writeLine($s){
 $this-&gt;write($s."\n");}}
</code></pre>

Concrete output streams now could inherit from the abstract output stream, implement just <code>write</code> and get <code>writeLine</code> for free!

I am trying to learn OOP in PHP, and I have some confusion about interfaces and abstract classes. They both contain no implementations, only definitions, and should be implemented through their sub-classes. What part of abstract classes clearly distinguishes them from interfaces? Also, due to their apparent similarities, based on what reasons should I decide to use one over the other?

What is the purpose of abstract classes?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我正在尝试学习PHP中的OOP，我对接口和抽象类有一些困惑。它们都不包含任何实现，只包含定义，并且应该通过它们的子类来实现。抽象类的哪个部分明确地将它们与接口区分开来？另外，由于它们明显的相似性，基于什么原因，我应该决定使用其中一个而不是另一个？

问抽象类的目的是什么？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问抽象类的目的是什么？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问抽象类的目的是什么？
EN