Explication détaillée des classes abstraites et des interfaces en C#

Des problèmes surviennent :

Lorsque nous utilisons des classes et des interfaces abstraites en C#, nous rencontrons souvent les problèmes similaires suivants, qui sont grossièrement résumés comme suit :

( 1) Quelles sont les différences et connexions essentielles entre les classes abstraites et les interfaces ?

(2) Quand devrions-nous choisir d'utiliser des classes abstraites, et quand est-il le plus approprié d'utiliser des interfaces ?

(3) Comment l'utiliser dans le projet pour rendre le projet plus maintenable et évolutif ? Comment le combiner étroitement avec Struct et les classes pour obtenir l'effet ultime d'épée à double tranchant ?

Solution :

C'est aussi un problème que j'ai rencontré lors de l'apprentissage des classes abstraites et des interfaces d'après ce que j'ai résumé de ces trois. questions, il n'est pas difficile de voir que ce sont peut-être les trois étapes où la plupart de nos programmeurs rencontrent des problèmes,

La première étape (concepts de base) : Tout comme la question 1, Ces personnes Ils doivent d’abord éliminer les obstacles des concepts de base. Tout d’abord, ils doivent comprendre ce que sont les classes abstraites et ce que sont les interfaces.

Alors comprenez quelles sont les différences et les connexions entre les classes abstraites et les interfaces ? Bien sûr, cela peut prendre un certain temps à comprendre et à mettre en pratique. Après tout, ces concepts sont relativement abstraits et ne peuvent pas être touchés ou vus. Bien sûr, le plus important est de pratiquer davantage. Lorsque vous n'avez rien à faire, faites une démo. par exemple et utilisez-les tous. Lorsque vous l'utilisez, réfléchissez davantage à la raison pour laquelle vous devez l'utiliser de cette façon ? Quels en sont les avantages ? Des interfaces peuvent-elles être utilisées ? Sinon, quels sont les avantages de l’utilisation de classes abstraites ? Cela peut approfondir votre compréhension d'eux. C'est aussi ma petite expérience, haha ​​! Cela dit, permettez-moi de résumer la question 1. Premièrement, il est pratique pour moi de m'en souvenir, et deuxièmement, cela m'a permis d'approfondir ma compréhension.

Concepts de classes abstraites et d'interfaces : En fait, il existe en gros beaucoup de ces concepts dans les manuels scolaires et les blogs. Les seniors les ont très bien résumés, mais ils peuvent être un peu obscurs et difficiles à comprendre en termes. de popularité et de facilité de compréhension. Je viens de le traduire et d'ajouter un peu de langue vernaculaire du Shaanxi, hehe.

(1) Classe abstraite : fournit un ensemble de méthodes publiques permettant aux classes dérivées d'accéder aux classes de base partagées

Les caractéristiques des classes abstraites sont : (1) Les classes abstraites incluent à la fois des méthodes abstraites et Y compris l'implémentation de méthodes ; (2) Les classes abstraites ne peuvent pas être instanciées ou scellées ; (3) Les méthodes abstraites dans les classes abstraites doivent être soit implémentées dans des classes dérivées, soit héritées par des classes abstraites dérivées (les classes dérivées abstraites peuvent hériter de la méthode abstraite des classes de base), si vous souhaitez implémenter la méthode abstraite de la classe de base dans une classe dérivée, vous devez utiliser le modificateur override ; (4) Les classes abstraites appartiennent à un héritage unique (cela appartient à la même nature de toutes les classes, mentionnez-le ici) (5 ) Résumé Une classe est un groupe d'abstractions, similaire à IS-A

Si ce que j'ai dit ci-dessus n'est pas assez clair, je vous donne l'adresse du site officiel des classes abstraites : https:// docs.microsoft.com/ en-us/dotnet/csharp/langue-reference/keywords/abstract

(2) Interface : un type abstrait qui contient un ensemble de méthodes virtuelles ;

l'interface est : (1) L'interface inclut uniquement la définition des méthodes virtuelles, uniquement les définitions de déclarations et aucune implémentation de fonction (2) Les classes d'interface peuvent inclure des propriétés, des événements, des indexeurs, etc., mais pas des champs (3 ; ) Les classes d'interface appartiennent à un héritage multiple ; (4) Les classes qui héritent d'une interface doivent implémenter toutes les méthodes de l'interface

Différences et connexions entre les classes abstraites et les interfaces :

Mêmes points ; : (1) Ils ne peuvent pas être instanciés directement, seulement ils peuvent être réalisés par héritage

(2) sont toutes des abstractions de comportement et d'objets, formant un certain modèle de conception

Différences :

🎜>

(1) Les interfaces prennent en charge l'héritage multiple ; les classes abstraites ne peuvent pas implémenter l'héritage multiple

(2) Les interfaces incluent des méthodes, des propriétés, des événements et des indexeurs, mais ne peuvent pas inclure de champs ; et implémentations de méthodes ;

(3) Les interfaces peuvent prendre en charge les rappels, les classes abstraites ne prennent pas en charge les rappels

(4) Les interfaces peuvent être utilisées comme classes de base pour les types valeur et les types référence, tandis que les classes abstraites ne peut être utilisé que comme classes de base pour les types de référence ;

La deuxième étape (étape d'utilisation) : tout comme la question 2, ces personnes ont une certaine compréhension des bases, mais elles manquent peut-être d'un peu de pratique. ils font juste une simple démo, alors quand utiliser des classes abstraites et quand utiliser des interfaces ?

En analysant la deuxième question, j'ai avancé 3 suggestions :

La première suggestion est que les concepts de base ne sont pas seulement la mémorisation de concepts, mais plus de pratique et plus de réflexion, et ensuite Pratiquez davantage, réfléchissez davantage, répétez-le plusieurs fois jusqu'à ce que vous en soyez familier ;

La deuxième suggestion est d'essayer d'utiliser ces connaissances dans vos propres projets. Ce n'est qu'en les utilisant que vous pourrez trouver des problèmes et les résoudre. Ce n'est que lorsque vous réfléchissez aux problèmes que vous pouvez réfléchir :

La troisième suggestion est de résumer et de résumer les points de connaissance des projets dans lesquels vous avez utilisé des classes et des interfaces abstraites
J'ai résumé quand utiliser des classes et des interfaces abstraites ; Les points suivants sont donnés en fonction de l'expérience des seniors, à titre indicatif seulement :

(1) Lorsque le composant conçu aura plusieurs versions à l'avenir, des classes abstraites sont généralement utilisées, par exemple, en utilisant C# pour concevoir une base de données. Au début, vous pourrez utiliser un serveur SQL, mysql. , les grands projets peuvent avoir besoin d'utiliser Oracle. Pour un grand système de base de données comme DB, lorsque nous concevons la classe, nous concevons une classe de base abstraite, afin qu'elle ait certains attributs et méthodes de données communs : nom de connexion à la base de données, version. , type de base de données, base de données Méthodes universelles : méthodes Open(), Close(), etc. ;

(2) Lorsque les composants conçus prennent également en charge des comportements courants, les interfaces peuvent être considérées par exemple, les oiseaux, les humains, et les voitures peuvent toutes avoir des sons. À ce stade, vous pouvez concevoir l'interface, y compris le comportement de la fonction appelée, puis l'implémenter dans chaque classe spécifique

(3) Dans la classe dérivée ou l'interface qui hérite du ; interface, une fois que l'interface doit ajouter des méthodes comportementales, c'est une comparaison. Le casse-tête est que tout héritage doit implémenter ses méthodes. À ce stade, vous pouvez implémenter une nouvelle interface dans la classe dérivée pour réaliser les actions uniques de la classe dérivée. Par exemple :

/// <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的爬的方法");
}
}

Ci-dessus Le code illustre juste le problème et est relativement simple
La troisième étape (étape d'optimisation) : Tout comme la question 3, quand on fait une classe abstraite ou interface, la première chose que nous considérons est qu'elle peut être utilisée, et le résultat est la définition. Il existe de nombreuses classes ou interfaces difficiles à maintenir et à étendre, ou il y a des intersections entre les classes. Alors, comment optimiser la relation d'héritage ? Comment pouvons-nous rendre le programme maintenable et évolutif ?
Je vous recommande personnellement d'avoir les aspects suivants :
(1) Vous devez avoir de solides connaissances de base et des compétences de base approfondies
(2) Vous devez avoir une personne qui pose plus de questions et réfléchit ; plus. Soyez prudent ; renseignez-vous davantage sur les classes abstraites et les interfaces, pourquoi ne pas utiliser des classes abstraites mais utiliser des interfaces ? Pourquoi est-il approprié d’utiliser une interface à cet endroit ?
(3) Examinez de plus près la façon dont les seniors conçoivent les interfaces et les cours. Il existe de nombreuses informations dans ce domaine disponibles en ligne
(4) Je recommande personnellement d'en savoir plus sur les modèles de conception, car ils sont de l'expérience et ; pensées des seniors dans le design

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!