Detaillierte Erläuterung abstrakter Klassen und Schnittstellen in C#

Es treten Probleme auf:

Wenn wir abstrakte Klassen und Schnittstellen in C# verwenden, stoßen wir häufig auf die folgenden ähnlichen Probleme, die grob wie folgt zusammengefasst werden:

( 1) Was sind die wesentlichen Unterschiede und Zusammenhänge zwischen abstrakten Klassen und Interfaces?

(2) Wann sollten wir uns für die Verwendung abstrakter Klassen entscheiden und wann ist die Verwendung von Schnittstellen am besten geeignet?

(3) Wie kann man es im Projekt verwenden, um das Projekt wartbarer und skalierbarer zu machen? Wie kann man es eng mit Struct und Klassen kombinieren, um den ultimativen zweischneidigen Schwerteffekt zu erzielen?

Lösung:

Dies ist auch ein Problem, auf das ich beim Erlernen abstrakter Klassen und Schnittstellen gestoßen bin. Aus dem, was ich aus diesen drei zusammengefasst habe Fragen, es ist nicht schwer zu erkennen, dass dies die drei Phasen sein können, in denen die meisten unserer Programmierer auf Probleme stoßen.

Die erste Phase (grundlegende Konzepte): Genau wie Frage 1, Diese Leute Zunächst müssen die Hindernisse grundlegender Konzepte beseitigt werden. Zunächst müssen sie verstehen, was abstrakte Klassen und Schnittstellen sind.

Verstehen Sie dann, was die Unterschiede und Verbindungen zwischen abstrakten Klassen und Schnittstellen sind? Natürlich kann es einige Zeit dauern, dies zu verstehen und zu üben. Schließlich sind diese Konzepte relativ abstrakt und können nicht berührt oder gesehen werden. Das Wichtigste ist natürlich, mehr zu üben Instanz und verwenden Sie sie alle. Denken Sie bei der Verwendung mehr darüber nach, warum Sie es auf diese Weise verwenden müssen. Was sind die Vorteile davon? Können Schnittstellen verwendet werden? Wenn nicht, welche Vorteile bietet die Verwendung abstrakter Klassen? Das kann Ihr Verständnis dafür vertiefen. Das ist auch meine kleine Erfahrung, haha! Nachdem ich so viel gesagt habe, möchte ich Frage 1 zusammenfassen. Erstens ist es für mich praktisch, mich daran zu erinnern, und zweitens dient es dazu, mein Verständnis zu vertiefen.

Konzepte abstrakter Klassen und Schnittstellen: Tatsächlich gibt es im Grunde viele dieser Konzepte in Lehrbüchern und Blogs. Die Senioren haben sie sehr gut zusammengefasst, aber sie sind möglicherweise etwas unklar und schwer zu verstehen Ich übersetze es einfach und füge etwas Shaanxi-Umgangssprache hinzu, hehe.

(1) Abstrakte Klasse: Stellt eine Reihe öffentlicher Methoden für abgeleitete Klassen bereit, um auf gemeinsam genutzte Basisklassen zuzugreifen.

Die Merkmale abstrakter Klassen sind: (1) Abstrakte Klassen umfassen sowohl abstrakte Methoden als auch Einschließlich der Implementierung von Methoden; (2) Abstrakte Klassen können nicht instanziiert oder versiegelt werden. (3) Abstrakte Methoden in abstrakten Klassen müssen entweder in abgeleiteten Klassen implementiert oder von abgeleiteten abstrakten Klassen geerbt werden (abstrakte abgeleitete Klassen können abstrakte Methoden von Basisklassen erben). Wenn Sie die abstrakte Methode der Basisklasse in einer abgeleiteten Klasse implementieren möchten, müssen Sie den Override-Modifikator (4) verwenden. Abstrakte Klassen gehören zur Einzelvererbung (dies gehört zur gleichen Natur aller Klassen, erwähnen Sie es hier) (5 ) Eine abstrakte Klasse ist eine Gruppe von Abstraktionen, ähnlich wie IS-A. Wenn das, was ich oben gesagt habe, nicht klar genug ist, gebe ich Ihnen die Adresse der offiziellen Website zu abstrakten Klassen: https:// docs.microsoft.com/ en-us/dotnet/csharp/Language-Reference/keywords/abstract

(2) Schnittstelle: ein abstrakter Typ, der eine Reihe virtueller Methoden enthält; die Eigenschaften von

Schnittstellen sind: (1) Die Schnittstelle umfasst nur die Definition virtueller Methoden, nur Deklarationsdefinitionen und keine Funktionsimplementierungen (2) Schnittstellenklassen können Eigenschaften, Ereignisse, Indexer usw. enthalten, aber keine Felder; ) Schnittstellenklassen gehören zur Mehrfachvererbung; (4) Klassen, die eine Schnittstelle erben, müssen alle Methoden der Schnittstelle implementieren

Unterschiede und Verbindungen zwischen abstrakten Klassen und Schnittstellen:

Gleiche Punkte : (1) Sie können nicht direkt instanziiert werden, sondern nur durch Vererbung

(2) sind alle Abstraktionen von Verhalten und Objekten und bilden ein bestimmtes Entwurfsmuster:

(1) Schnittstellen unterstützen Mehrfachvererbung;

(2) Schnittstellen umfassen Methoden, Eigenschaften, Ereignisse, Indexer und können keine Felder enthalten Methodenimplementierungen;

(3) Schnittstellen können Rückrufe unterstützen, abstrakte Klassen unterstützen keine Rückrufe

(4) Schnittstellen können als Basisklassen für Werttypen und Referenztypen verwendet werden, während abstrakte Klassen dies können nur als Basisklasse für Referenztypen verwendet werden;

Die zweite Stufe (Nutzungsstufe): Genau wie Frage 2 haben diese Leute ein gewisses Verständnis für die Grundlagen, aber es fehlt ihnen etwas an Übung Erstellen Sie einfach eine einfache Demo. Wann sollten Sie also abstrakte Klassen und wann Schnittstellen verwenden?

Bei der Analyse der zweiten Frage habe ich drei Vorschläge gemacht: Der erste Vorschlag ist, dass die Grundkonzepte nicht nur das Auswendiglernen von Konzepten sind, sondern mehr Übung und Denken und dann Übung Mehr, denken Sie mehr darüber nach, wiederholen Sie es mehrmals, bis Sie damit vertraut sind. Der zweite Vorschlag ist, dass Sie versuchen, dieses Wissen in Ihren eigenen Projekten zu nutzen Wenn Sie über Probleme nachdenken, können Sie darüber nachdenken.

Der dritte Vorschlag besteht darin, die Wissenspunkte der von Ihnen verwendeten abstrakten Klassen und Schnittstellen zusammenzufassen.

Ich habe zusammengefasst, wann abstrakte Klassen und Schnittstellen verwendet werden sollen Die folgenden Punkte basieren auf den Erfahrungen von Senioren und dienen nur als Referenz:

(1) Wenn die entworfene Komponente in Zukunft mehrere Versionen haben wird, werden im Allgemeinen abstrakte Klassen verwendet, um beispielsweise eine Datenbank-DB zu entwerfen. Zu Beginn können Sie SQL Server verwenden Bei großen Projekten muss möglicherweise Oracle verwendet werden. Wenn wir die Klasse entwerfen, entwerfen wir eine abstrakte Basisklasse DB, sodass diese über einige gemeinsame Datenattribute und -methoden verfügt: Datenbankverbindungsname und Version , Datenbanktyp, Datenbank Gemeinsame Methoden: Open()-, Close()-Methoden usw. (2) Wenn die entworfenen Komponenten auch allgemeine Verhaltensweisen unterstützen, können beispielsweise Schnittstellen berücksichtigt werden; und Autos können alle Sounds haben, einschließlich des aufgerufenen Funktionsverhaltens, und es dann in jeder spezifischen Klasse implementieren

(3) In der abgeleiteten Klasse oder Schnittstelle, die das erbt Schnittstelle: Sobald die Schnittstelle Verhaltensmethoden hinzufügen muss, handelt es sich um einen Vergleich. Das Problem besteht darin, dass die gesamte Vererbung ihre Methoden implementieren muss. Zu diesem Zeitpunkt können Sie eine neue Schnittstelle in der abgeleiteten Klasse implementieren, um die eindeutigen Aktionen der abgeleiteten Klasse zu realisieren. Zum Beispiel:

Oben Der Code veranschaulicht nur das Problem und ist relativ einfach

/// <summary>
/// 实现一个爬行动物的动作接口
/// </summary>
interface IAnimalClimb
{
void Climb();
}
/// <summary>
/// 实现一个会叫的动物的动作接口
/// </summary>
interface ICry
{
void Cry();
}
/// <summary>
/// 实现一个动物抽象类
/// </summary>
public abstract class Animal
{
//动物的名字
public string Name { get; set; }
//动物的颜色
public string Color { get; set; }
//动物抽象类的共有方法
public abstract void Sleep();
public abstract void Breathe();
}
/// <summary>
/// 定义鸟类，通用方法是会飞
/// </summary>
public class Bird : Animal,ICry
{
public override void Sleep()
{
Console.WriteLine("Bird派生类继承了基类的Sleep()方法");
}
public override void Breathe()
{
Console.WriteLine("Bird派生类继承了基类的Breathe()方法");
}
//鸟类可以继承统一的接口动作，例如：叫
public void Cry()
{
Console.WriteLine("Bird派生类继承了接口ICry的叫的方法");
}
}
/// <summary>
/// 定义爬行动物类
/// </summary>
public class Snake : Animal, IAnimalClimb
{
public override void Breathe()
{
Console.WriteLine("Snake派生类继承了基类的Sleep()方法");
}
public override void Sleep()
{
Console.WriteLine("Snake派生类继承了基类的Sleep()方法");
}
//爬行动物可以继承统一的接口动物，例如：爬
public void Climb()
{
Console.WriteLine("Snake派生类继承了接口IAnimalClimb的爬的方法");
}
}

Die dritte Stufe (Optimierungsstufe): Genau wie Frage 3, wenn wir eine abstrakte Klasse erstellen oder Schnittstelle, das erste, was wir berücksichtigen, ist, dass es verwendet werden kann, und das Ergebnis ist die Definition. Es gibt viele Klassen oder Schnittstellen, die schwer zu pflegen und zu erweitern sind, oder es gibt Schnittpunkte zwischen Klassen. Wie kann man also die Vererbungsbeziehung optimieren? Wie können wir das Programm wartbar und skalierbar machen?
Ich persönlich empfehle, dass Sie über die folgenden Aspekte verfügen: (1) Sie müssen über solide Grundkenntnisse und tiefe Grundkenntnisse verfügen;
(2) Sie müssen eine Person haben, die mehr Fragen stellt und nachdenkt Seien Sie vorsichtig; fragen Sie mehr nach abstrakten Klassen und Schnittstellen. Warum nicht abstrakte Klassen verwenden, sondern Schnittstellen? Warum ist es sinnvoll, an dieser Stelle eine Schnittstelle zu verwenden?
(3) Schauen Sie sich genauer an, wie Senioren Benutzeroberflächen und Kurse entwerfen. Es gibt viele Informationen in diesem Bereich online.
(4) Ich persönlich empfehle, mehr über Designmuster zu lesen, da es sich dabei um Erfahrung handelt Gedanken von Senioren im Design;

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung abstrakter Klassen und Schnittstellen in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!