blocks|key|3026220|text|要恢复这个想法(全局的，而不是详细的)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3026221|inheritance|code-block|syntax|javascript|3026222|是对extend+from+something的概念，并可选地添加一些新功能或覆盖一些现有功能(以不同的方式执行)。但是使用继承，您可以与父级共享大部分代码。你是a+parent+%2B一些其他的东西。|offset|length|style|CODE|3026223|interface|3026224|代表了一些能力(我们说一个类正在实现一个接口，以表示它具有这些能力)。一个接口可以由两个完全不同的类实现，并且不共享它们的代码(除了它们实现的方法)。当A和B实现接口C时，A不是B，B也不是A。|3026225|而interface的一个原因确实是允许程序员做与多重继承相同的事情，但不会出现多重继承问题。|3026226|这一概念在一些编程语言中使用，如JAVA、PHP……|3026227|entityMap^0|0|0|2|L|0|0|0|1|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@$I|14|J|15|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

To resume the idea (globally, not in detail):

<pre><code>inheritance
</code></pre>

is the notion to <code>extend from something</code>, and optionally add some new feature or override some existing feature (to do differently). But using inheritance, you share a big part of code with the parent. You are a parent + some other things.

<pre><code>interface
</code></pre>

is representing some abilities (we says a class is implementing an interface to says that it has these abilities). An interface can be implemented by 2 classes which are completely different and do not share their code (except for methods they implements). When A and B are implementing interface C, A is not a B and B is not a A.

And one of the reason for <code>interface</code> is indeed to allow programmer to do the same as they could do with multi-inheritance, but without multi-inheritance problems.

This notion is used in some programming languages like JAVA, PHP...

blocks|key|191663|text|我以前考虑过这一点，我能得出的最好的结论是，接口是纯抽象类(c%2B%2B)在逻辑上方便的抽象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|191664|至于为什么你会选择接口而不是抽象类，我引用(a+c%2B%2B+source，但概念是相同的)：|offset|length|191665|191666|请注意，将具体的成员函数和数据添加到纯抽象基类中是一种很大的诱惑。必须抵制这一点，一般来说，这是接口没有很好分解的标志。数据和具体的成员函数往往意味着特定的实现，因此可以从接口继承，但不应该是该接口。相反，如果具体类之间有一些共性，则创建抽象类可以很好地工作，抽象类从纯抽象类继承其接口，并定义具体类的公共数据和成员函数。|blockquote|191667|191668|191669|问题是，当使用接口时，首先想到的是解耦。在使用接口时，用户和实现类是完全解耦的。当你使用一个纯粹的抽象类时也是如此，这个抽象类基本上是一个接口。|191670|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikibooks.org/wiki/C%252B%252B_Programming/Classes/Abstract_Classes/Pure_Abstract_Classes^0|0|M|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|11|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

I have thought about this before, and the best I could conclude was that interfaces are a logically convenient abstraction of a pure abstract class (c++).

As for why you would choose interfaces over abstract classes, I quote (<a href="http://en.wikibooks.org/wiki/C%2B%2B_Programming/Classes/Abstract_Classes/Pure_Abstract_Classes" rel="nofollow">a c++ source</a> but the concepts are the same):

<blockquote>
 Note that there is a great temptation to add concrete member functions and data to pure abstract base classes. This must be resisted, in general it is a sign that the interface is not well factored. Data and concrete member functions tend to imply a particular implementation and as such can inherit from the interface but should not be that interface. Instead if there is some commonality between concrete classes, creation of abstract class which inherits its interface from the pure abstract class and defines the common data and member functions of the concrete classes works well.
</blockquote>

The thing is, when using interfaces, the first thing that comes to mind is decoupling. When using an interface, the user and the implementing-class are totally decoupled. The same applies for when you're using a pure abstract class which is basically an interface.

blocks|key|191672|text|抽象|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|191673|抽象类关注的是一种事物的相似性。|191674|人们被认为是mammal类型，因此不会被认为是vehicle类型。|CODE|191675|接口|191676|接口侧重于相似函数的排序。|191677|例如:你是一个人，属于mammal类型。如果你想飞行，那么你需要实现一个flying+Interface。如果你想边飞边拍，那么你还需要实现gun+Interface。|191678|请参见下面的示例：|191679|abstract+class+Mammal+{
++++++protected+$age_;
++++++//below+are+functions+I+think+all+mammals+will+have,including+people
++++++abstract+public+function+setAge($age);
++++++abstract+public+function+getAge();
++++++abstract+public+function+eat($food);
}
class+Person+extends+Mammal+{
++++++protected+$job_;+//Person's+feature
++++++public+function+setAge($age){
++++++++$this->age_+=+$age;
++++++}

++++++public+function+getAge(){
++++++++return+$this->age_;
++++++}

++++++public+function+eat($food){
++++++++echo+'I+eat+'+,$food+,'today';
++++++}

++++++//People+only+attribute
++++++public+function+setJob($job){
+++++++++$this->job_+=+$job;
++++++}
++++++public+function+getJob(){
+++++++++echo+'My+job+is+'+,+$this->job_;
++++++}

}

//Now+a+person+wants+to+fly,+but+they+are+typically+not+able+to+do+so.
//So+we+implement+an+interface
interface+Plane{
++public+function+Fly();+
}

//I+also+want+shoot+enemy
interface+Gun{
++public+function+shoot();
}

class+Person2+extends+Mammal+implements+Plane,Gun{

++++++protected+$job_;//Person+feature
++++++public+function+setAge($age){
++++++++$this->age_+=+$age;
++++++}
++++++public+function+getAge(){
++++++++return+$this->age_;
++++++}
++++++public+function+eat($food){
++++++++echo+' I+eat+'+,$food+,'+today ';
++++++}
++++++//Only+a+person+has+this+feature.
++++++public+function+setJob($job){
+++++++++$this->job_+=+$job;
++++++}
++++++public+function+getJob(){
+++++++++echo+'My+job+is+'+,+$this->job_;
++++++}

++++++//-----------------------------------------
++++++//below+implementations+from+interfaces+function.+(features+that+humans+do+not+have).
++++++//Person+implements+from+other+class
++++++public+function+fly(){
++++++++echo+' I+use+plane,so+I+can+fly ';
++++++}
++++++public+function+shoot(){
++++++++echo+'I+use+gun,so+I+can+shoot ';
++++++}
}

$People+=+new+Person();
echo+'<pre>';
print_r(+get_class_methods('People'));
echo+'</pre>';

echo+'<pre>';
print_r(+get_class_methods('People2'));
echo+'</pre>';

$People2+=+new+Person2();
$People2->setAge(24);
echo+$People2->getAge();
$People2->eat('egg');
$People2->setJob('PHP+devepop');
echo+$People2->getJob();

$People2->fly();
$People2->shoot();|code-block|syntax|javascript|191680|entityMap^0|0|2|0|0|6|6|N|7|0|0|2|0|0|B|6|10|G|1Y|D|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|13|8|@$9|14|A|15|B|J]|$9|16|A|17|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|J]|$9|1F|A|1G|B|J]|$9|1H|A|1I|B|J]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|U|7|1M|8|@]|D|@]|E|$V|W]]|$1|X|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|Y|$]]

Abstract 

Abstract Classes focus on a kind of things similarity.

People are considered of type <code>mammal</code> and as such would not be considered of type <code>vehicle</code>.

Interface

Interfaces focus on collation of similar function.

For example: You are a human being and are of type <code>mammal</code>. If you want to fly then you will need to implement a <code>flying Interface</code>. If you want to shoot while flying, then you also need to implement the <code>gun Interface</code>.

See the examples below:

<pre><code>abstract class Mammal {
 protected $age_;
 //below are functions I think all mammals will have,including people
 abstract public function setAge($age);
 abstract public function getAge();
 abstract public function eat($food);
}
class Person extends Mammal {
 protected $job_; //Person's feature
 public function setAge($age){
 $this-&gt;age_ = $age;
 }

 public function getAge(){
 return $this-&gt;age_;
 }

 public function eat($food){
 echo 'I eat ' ,$food ,'today';
 }

 //People only attribute
 public function setJob($job){
 $this-&gt;job_ = $job;
 }
 public function getJob(){
 echo 'My job is ' , $this-&gt;job_;
 }

}

//Now a person wants to fly, but they are typically not able to do so.
//So we implement an interface
interface Plane{
 public function Fly(); 
}

//I also want shoot enemy
interface Gun{
 public function shoot();
}

class Person2 extends Mammal implements Plane,Gun{

 protected $job_;//Person feature
 public function setAge($age){
 $this-&gt;age_ = $age;
 }
 public function getAge(){
 return $this-&gt;age_;
 }
 public function eat($food){
 echo '&lt;br/&gt;I eat ' ,$food ,' today&lt;br/&gt;';
 }
 //Only a person has this feature.
 public function setJob($job){
 $this-&gt;job_ = $job;
 }
 public function getJob(){
 echo 'My job is ' , $this-&gt;job_;
 }

 //-----------------------------------------
 //below implementations from interfaces function. (features that humans do not have).
 //Person implements from other class
 public function fly(){
 echo '&lt;br/&gt;I use plane,so I can fly&lt;br/&gt;';
 }
 public function shoot(){
 echo 'I use gun,so I can shoot&lt;br/&gt;';
 }
}

$People = new Person();
echo '&lt;pre&gt;';
print_r( get_class_methods('People'));
echo '&lt;/pre&gt;';

echo '&lt;pre&gt;';
print_r( get_class_methods('People2'));
echo '&lt;/pre&gt;';

$People2 = new Person2();
$People2-&gt;setAge(24);
echo $People2-&gt;getAge();
$People2-&gt;eat('egg');
$People2-&gt;setJob('PHP devepop');
echo $People2-&gt;getJob();

$People2-&gt;fly();
$People2-&gt;shoot();
</code></pre>

blocks|key|193793|text|简单地说，接口是标准化一组函数，而抽象类是定义派生类的基本框架。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|193794|entityMap^0|5|2|H|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Briefly speaking, interface is to standardize a set of functions，while abstract class is to define a basic skeleton for classes to derive from.

I have searched around SO as well as the rest of the web for a good answer but I have't found one that I really understand. I am going to present this in a different way and hopefully the answers will help others as well. 

As far as I understand, the two concepts have the same rules except an abstract class is more flexible due to the method implementation ability. Also, I am aware you can implement multiple interfaces and only extend a single class but I'm sure there are more differences than the two I mentioned.

Please look at the two snippets of code and give me an example what I can do with each of my examples that would make me want or not want to use the other. 

<h1>Abstract Class</h1>

<pre><code>abstract class Foo {
 abstract public function getValue();
 abstract public function setValue($value); 
}


class myObj extends Foo {
 function getValue() {

 }
 function setValue($value) {

 }
}
</code></pre>

<h1>Interface</h1>

<pre><code>interface Foo {
 public function getValue();
 public function setValue($value);
}

class myObj implements Foo {
 function getValue() {

 }
 function setValue($value) {

 }
}
</code></pre>

Abstract Class vs. Interface

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我已经在网络上到处寻找了一个好的答案，但我还没有找到一个我真正理解的答案。我将以一种不同的方式介绍这个问题，希望这些答案也能对其他人有所帮助。据我所知，这两个概念有相同的规则，除了抽象类由于方法实现能力而更灵活。此外，我知道你可以实现多个接口，并且只扩展一个类，但我相信比我提到的两个更多的区别。请看这两个代码片段，并给...

问抽象类与接口
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问抽象类与接口EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问抽象类与接口
EN