Detaillierte Erklärung des Unterschieds zwischen abstrakten Klassen und Schnittstellen in C#

In diesem Artikel wird hauptsächlich der Unterschied zwischen abstrakten Klassen und Schnittstellen in C# vorgestellt. Hat einen sehr guten Referenzwert. Werfen wir einen Blick mit dem Editor unten

1 Welche Beziehung besteht zwischen schnittstellenorientierter Programmierung und objektorientierter Programmierung

Erstens Alles in allem ist die schnittstellenorientierte Programmierung nicht auf dem gleichen Niveau wie die objektorientierte Programmierung. Es handelt sich nicht um eine eigenständige Programmieridee, die weiter fortgeschritten ist als die objektorientierte Programmierung, sondern mit dem objektorientierten ideologischen System verbunden und Teil davon ist. Mit anderen Worten, es ist eine der wesentlichen Ideen im objektorientierten Programmiersystem.

2. Die Essenz von Schnittstellen

Eine Schnittstelle ist oberflächlich betrachtet eine Sammlung mehrerer Methodendefinitionen ohne Hauptcode Wird von einer Klasse oder einer anderen Schnittstelle implementiert (oder man kann auch sagen, dass erbt). In der Form könnte es wie folgt aussehen:

interface InterfaceName
{
 void Method1();
 void Method2(int para1);
 void Method3(string para2,string para3);
}

Was ist also das Wesentliche einer Schnittstelle? Mit anderen Worten, welche Bedeutung hat die Existenz der Schnittstelle? Ich denke, es kann aus den folgenden zwei Perspektiven betrachtet werden:

1) Eine Schnittstelle ist eine Reihe von Regeln, die festlegen, dass eine Klasse oder Schnittstelle dies implementiert Die Schnittstelle muss über eine Reihe von Regeln verfügen. Es verkörpert die Philosophie der Natur: „Wenn Sie … sind, müssen Sie dazu in der Lage sein …“.

Zum Beispiel können Menschen in der Natur essen, das heißt: „Wenn Sie ein Mensch sind, müssen Sie essen können.“ Bei der Simulation in einem Computerprogramm sollte es dann eine IPerson-Schnittstelle (normalerweise beginnt der Schnittstellenname mit „I“) und eine Methode namens Eat() geben. Dann legen wir fest, dass jede Klasse, die „Person“ darstellt, die IPerson-Schnittstelle implementieren muss simuliert das Naturgesetz „Wer ein Mensch ist, muss essen können“.

Von hier aus kann man meiner Meinung nach auch etwas objektorientiertes Denken erkennen. Einer der Kerne des objektorientierten Denkens besteht darin, die reale Welt zu simulieren und Dinge in der realen Welt in Klassen zu abstrahieren. Das gesamte Programm ist darauf angewiesen, dass Instanzen jeder Klasse miteinander kommunizieren und miteinander zusammenarbeiten, um Systemfunktionen zu vervollständigen stimmt sehr gut mit den Betriebsbedingungen der realen Welt überein und orientiert sich auch an der Essenz des Objektdenkens.

2) Eine Schnittstelle ist eine abstrakte Darstellung ähnlicher Dinge auf einer bestimmten Granularität Ansicht . Beachten Sie, dass ich hier den Schwerpunkt auf eine bestimmte granulare Sichtweise lege, da das Konzept „ähnlicher Dinge“ relativ ist und sich aufgrund unterschiedlicher granularer Sichtweisen unterscheidet.

Zum Beispiel bin ich in meinen Augen ein Mensch, der sich grundlegend von einem Schwein unterscheidet. Ich kann akzeptieren, dass meine Klassenkameraden und ich gleich sind, aber das kann ich nie Akzeptiere, dass ich dasselbe bin wie ein Schwein. Ein Schwein ist von derselben Art. Wenn jedoch in den Augen eines Zoologen Schweine und ich von der gleichen Art sein sollten, weil wir beide Tiere sind, kann er denken, dass sowohl „Menschen“ als auch „Schwein“ die IAnimal-Schnittstelle implementieren, und er untersucht Tiere Verhalten , er wird mich und das Schwein nicht getrennt behandeln, sondern es aus der größeren Granularität von „Tier“ untersuchen, aber er wird denken, dass es einen wesentlichen Unterschied zwischen mir und einem Baum gibt.

Jetzt habe ich einen Genetiker, und die Situation ist anders, weil alle Lebewesen vererbt werden können, also unterscheide ich mich in seinen Augen nicht nur nicht von einem Schwein, sondern auch von einer Mücke, einem Bakterium. ein Baum, Es gibt keinen Unterschied zwischen einem Pilz oder sogar einem SARS-Virus, weil er denken wird, dass wir alle die IDescendfähige Schnittstelle implementieren (Hinweis: Descend vi. Vererbung), das heißt, wir sind alle vererbbare Dinge, und das wird er nicht. Anstatt uns getrennt zu untersuchen, wird er alle Lebewesen als gleichartiges untersuchen. In seinen Augen gibt es keinen Unterschied zwischen Menschen und Viren, sondern nur vererbbares Material und nicht vererbbares Material. Aber zumindest gibt es einen Unterschied zwischen mir und einem Stein.

Aber eines Tages erschien ein großer Mann auf der Erde. Nachdem er die Meisterwerke des dialektischen Materialismus von Marx und Engels gelesen hatte, machte er eine berühmte Definition : Die sogenannte Substanz ist die objektive Realität, die vom Bewusstsein reflektiert werden kann. An diesem Punkt gibt es keinen Unterschied zwischen mir und einem Stein, einem Hauch Luft, einer Redewendung und dem elektromagnetischen Feld, das Mobiltelefonsignale überträgt, denn in Lenins Augen sind wir alle objektive Realitäten, die im Bewusstsein widergespiegelt werden können. Wenn Lenin ein Programmierer wäre, würde er Folgendes sagen: Die sogenannte Materie sind die Instanzen, die von allen Klassen generiert werden, die sowohl die Schnittstellen „IReflectabe“ als auch „IEsse“ implementieren. (Anmerkung: reflektieren v. reflektieren esse n. objektive Realität)

Vielleicht denken Sie, dass mein obiges Beispiel Unsinn ist, aber genau aus diesem Grund gibt es Schnittstellen. Eines der Kernkonzepte des objektorientierten Denkens heißt Polymorphismus. Was ist Polymorphismus? Um es ganz klar auszudrücken: Ähnliche Dinge werden auf einer bestimmten Granularität Ansichtsebene einheitlich und ohne Unterschied behandelt. Der Grund, warum ich mich dazu traue, liegt in der Existenz von Schnittstellen. Wie der Genetiker versteht er, dass alle Organismen die IDescendable-Schnittstelle implementieren. Solange es sich also um einen Organismus handelt, muss er über die Descend()-Methode verfügen, damit er eine einheitliche Forschung durchführen kann, anstatt jeden Organismus einzeln zu untersuchen und schließlich an Erschöpfung zu sterben.

Vielleicht kann ich Ihnen hier keinen intuitiven Eindruck von der Beschaffenheit und Funktion der Schnittstelle vermitteln. In den folgenden Beispielen und der Analyse mehrerer Designmuster werden Sie dann die Konnotation der Schnittstelle intuitiver erleben.

3. Überblick über schnittstellenorientierte Programmierung

Was ist also schnittstellenorientierte Programmierung? Meine persönliche Definition lautet: Unterscheiden Sie in der Systemanalyse und Architektur Ebenen und Abhängigkeiten. Jede Ebene stellt ihrer oberen Schicht nicht direkt Dienste zur Verfügung (d. h. sie wird nicht direkt instanziiert). obere Schicht), aber indem Sie eine Reihe von Schnittstellen definieren, stellen Sie ihre Schnittstellenfunktionen nur der oberen Schicht zur Verfügung. Die obere Schicht verlässt sich nur auf die Schnittstelle für die untere Schicht und nicht auf bestimmte Klassen.

Die Vorteile davon liegen auf der Hand. Erstens ist es großartig für die Systemflexibilität. Wenn die untere Schicht geändert werden muss, muss die obere Schicht keine Änderungen vornehmen, solange die Schnittstelle und die Schnittstellenfunktion unverändert bleiben. Sie können sogar die gesamte untere Schicht austauschen, ohne den Code der oberen Schicht zu ändern, so wie wir eine WD 60G-Festplatte durch eine Seagate 160G-Festplatte ersetzen. Stattdessen müssen wir den Computer ausstecken Schließen Sie einfach die ursprüngliche Festplatte an und installieren Sie sie, da andere Teile des Computers nicht auf eine bestimmte Festplatte angewiesen sind, sondern nur auf eine IDE-Schnittstelle kann ersetzt werden. Von hier aus ist die Schnittstelle im Programm der Schnittstelle in der Realität sehr ähnlich, daher denke ich immer, dass das Wort „Schnittstelle“ wirklich ähnlich ist!

Ein weiterer Vorteil der Verwendung von Schnittstellen besteht darin, dass Entwickler verschiedener Komponenten oder Ebenen parallel mit der Arbeit beginnen können, so wie diejenigen, die Festplatten bauen, nicht so lange warten müssen Da die Schnittstellen konsistent und das Design sinnvoll sind, kann die gesamte Entwicklung parallel erfolgen, was die Effizienz erhöht.

Ergänzung zu diesem Artikel:

Über die „Schnittstelle“ in „Schnittstellenorientierte Programmierung“ und spezifische Objekt- orientierte Sprachen Das Wort „Schnittstelle“ in

sah einen Freund vorschlagen, dass das Wort „Schnittstelle“ in „schnittstellenorientierter Programmierung“ einen größeren Umfang haben sollte als das Wort „Schnittstelle“ in einem einfachen Programmiersprache . Nachdem ich darüber nachgedacht habe, denke ich, dass es Sinn macht. Was ich hier geschrieben habe, ist in der Tat unvernünftig. Ich denke, dass sich „Schnittstelle“ in objektorientierten Sprachen auf eine bestimmte Codestruktur bezieht, beispielsweise auf die Schnittstelle, die mit dem Schlüsselwort „interface“ in C# definiert ist. Man kann sagen, dass sich die „Schnittstelle“ in der „schnittstellenorientierten Programmierung“ auf eine Strukturkomponente bezieht, die dazu dient, bestimmte zugrunde liegende Klassen zu verbergen und Polymorphismus aus Sicht der Softwarearchitektur und auf einer abstrakteren Ebene zu implementieren. In diesem Sinne halte ich es für sinnvoll, diese abstrakte Klasse als „Schnittstelle“ zu bezeichnen, wenn eine abstrakte Klasse definiert ist und der Zweck darin besteht, Polymorphismus zu erreichen. Aber ist es sinnvoll, abstrakte Klassen zur Implementierung von Polymorphismus zu verwenden? Wird im zweiten Artikel unten besprochen.

Zusammenfassend denke ich, dass sich die beiden Konzepte der „Schnittstelle“ voneinander unterscheiden und miteinander zusammenhängen. Die Schnittstelle in der „schnittstellenorientierten Programmierung“ ist eine ideologische Architekturkomponente, die verwendet wird, um Polymorphismus zu erreichen und die Flexibilität und Wartbarkeit der Software zu verbessern, während die „Schnittstelle“ in einer bestimmten Sprache eine konkrete Komponente auf dieser ideologischen Ebene ist und in den Code implementiert wird.

2. Über abstrakte Klassen und Schnittstellen

Wenn man sich nur den spezifischen Code ansieht, kann man diese beiden Konzepte leicht verwischen und sogar denken, dass Schnittstellen überflüssig sind , denn Aus der Sicht spezifischer Funktionen scheinen abstrakte Klassen neben der Mehrfachvererbung (in C#, Java) in der Lage zu sein, Schnittstellen vollständig zu ersetzen. Aber existiert die Schnittstelle zur Implementierung der Mehrfachvererbung? Natürlich nicht. Meiner Meinung nach ist der Unterschied zwischen abstrakten Klassen und Schnittstellen die Motivation für deren Verwendung. Der Zweck der Verwendung abstrakter Klassen besteht in der Wiederverwendung von Code, während die Motivation für die Verwendung von Schnittstellen darin besteht, Polymorphismus zu erreichen. Wenn Sie sich also nicht sicher sind, ob Sie irgendwo ein Interface oder eine abstrakte Klasse verwenden sollen, denken Sie über Ihre Motivation nach.

Ich habe einige Freunde gesehen, die die IPerson-Schnittstelle in Frage gestellt haben. Mein persönliches Verständnis ist, dass es von der spezifischen Anwendung abhängt, ob die IPerson-Schnittstelle definiert werden sollte. Wenn wir Frauen und Männer in unserem Projekt haben, erben beide Personen und die meisten Methoden von Frauen und Männern sind gleich, nur eine Methode DoSomethingInWC() ist unterschiedlich (das Beispiel ist ziemlich vulgär, bitte verzeihen Sie mir), dann natürlich Es ist sinnvoller, eine abstrakte Klasse „AbstractPerson“ zu definieren, da sie alle anderen Methoden enthalten kann und die Unterklasse nur DoSomethingInWC() definiert, wodurch die Menge an wiederholtem Code erheblich reduziert wird.

但是，如果我们程序中的Women和Man两个类基本没有共同代码，而且有一个PersonHandle类需要实例化他们，并且不希望知道他们是男是女，而只需把他们当作人看待，并实现多态，那么定义成接口就有必要了。

总而言之，接口与抽象类的区别主要在于使用的动机，而不在于其本身。而一个东西该定义成抽象类还是接口，要根据具体环境的上下文决定。

再者，我认为接口和抽象类的另一个区别在于，抽象类和它的子类之间应该是一般和特殊的关系，而接口仅仅是它的子类应该实现的一组规则。（当然，有时也可能存在一般与特殊的关系，但我们使用接口的目的不在这里）如，交通工具定义成抽象类，汽车、飞机、轮船定义成子类，是可以接受的，因为汽车、飞机、轮船都是一种特殊的交通工具。再譬如Icomparable接口，它只是说，实现这个接口的类必须要可以进行比较，这是一条规则。如果Car这个类实现了Icomparable，只是说，我们的Car中有一个方法可以对两个Car的实例进行比较，可能是比哪辆车更贵，也可能比哪辆车更大，这都无所谓，但我们不能说“汽车是一种特殊的可以比较”，这在文法上都不通。

C#.NET里面抽象类和接口有什么区别?

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。

人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。

而抽象类在代码实现方面发挥作用，可以实现代码的重用

模板方法设计模式是抽象类的一个典型应用

最佳答案：

1抽象类

(1) 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法

(2) 抽象类不能被实例化

(3) 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类

(4) 具体派生类必须覆盖基类的抽象方法

(5) 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。如果不覆盖，则其具体派生类必须覆盖它们。如：

using System;
public abstract class A //抽象类A 
{ 
 private int num=0;
 public int Num //抽象类包含属性 
 { 
  get 
  { 
   return num; 
  } 
  set 
  { 
   num = value; 
  }   
 }
 public virtual int getNum() //抽象类包含虚方法 
 { 
  return num; 
 }
 public void setNum(int n) // //抽象类包含普通方法 
 { 
  this.num = n; 
 }
 public abstract void E(); //类A中的抽象方法E  
}
public abstract class B : A //由于类B继承了类A中的抽象方法E,所以类B也变成了抽象类 
{
}
public class C : B 
{ 
 public override void E() //重写从类A继承的抽象方法。如果类B自己还定义了抽象方法，也必须重写 
 { 
  //throw new Exception("The method or operation is not implemented."); 
 } 
}
public class Test 
{ 
 static void Main() 
 { 
  C c = new C(); 
  c.E(); 
 } 
}

二、接 口

(1) 接口不能被实例化

(2) 接口只能包含方法声明

(3) 接口的成员包括方法、属性、索引器、事件

(4) 接口中不能包含常量、字段(域)、构造函数、析构函数、静态成员。如：

public delegate void EventHandler(object sender, Event e);
public interface ITest 
{ 
 //int x = 0;
 int A 
 { 
  get; 
  set; 
 }
 void Test();
 event EventHandler Event; 
 int this[int index] 
 { 
  get;
  set; 
 } 
}

(5) 接口中的所有成员默认为public，因此接口中不能有private修饰符

(6) 派生类必须实现接口的所有成员

(7) 一个类可以直接实现多个接口，接口之间用逗号隔开

(8) 一个接口可以有多个父接口，实现该接口的类必须实现所有父接口中的所有成员

三、抽象类和接口

相同点：

(1) 都可以被继承

(2) 都不能被实例化

(3) 都可以包含方法声明

(4) 派生类必须实现未实现的方法

区 别：

(1) 抽象基类可以定义字段、属性、方法实现。接口只能定义属性、索引器、事件、和方法声明，不能包含字段。

(2) 抽象类是一个不完整的类，需要进一步细化，而接口是一个行为规范。微软的自定义接口总是后带able字段，证明其是表述一类“我能做。。。”

(3) 接口可以被多重实现，抽象类只能被单一继承

(4) 抽象类更多的是定义在一系列紧密相关的类间，而接口大多数是关系疏松但都实现某一功能的类中

(5) Eine abstrakte Klasse ist ein aus einer Reihe verwandter Objekte abstrahiertes Konzept, das die interne Gemeinsamkeit von Dingen widerspiegelt. Die Schnittstelle ist eine funktionale Vereinbarung, die zur Erfüllung externer Aufrufe definiert ist und daher die externen Eigenschaften von Dingen widerspiegelt >

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung des Unterschieds zwischen abstrakten Klassen und Schnittstellen in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!