Explication détaillée de la différence entre les classes abstraites et les interfaces en C#

Cet article présente principalement la différence entre les classes abstraites et les interfaces en C#. A une très bonne valeur de référence. Jetons un coup d'oeil avec l'éditeur ci-dessous

1 Quelle est la relation entre la programmation orientée interface et la programmation orientée objet

Premier de Dans l'ensemble, la programmation orientée interface n'est pas au même niveau que la programmation orientée objet. Ce n'est pas une idée de programmation indépendante plus avancée que la programmation orientée objet, mais elle est affiliée et fait partie du système idéologique orienté objet. En d’autres termes, c’est l’essence même des idées du système de programmation orientée objet.

2. L'essence des interfaces

Une interface est, en apparence, une collection de plusieurs définitions de méthodes sans code corporel. Implémenté par une classe ou une autre interface (ou on peut aussi dire que hérite de ). Sous sa forme, cela peut ressembler à ceci :

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

Alors, quelle est l'essence d'une interface ? En d’autres termes, quel est le sens de l’existence de l’interface. Je pense que cela peut être considéré sous les deux angles suivants :

1) Une interface est un ensemble de règles, qui stipule qu'une classe ou une interface qui implémente cela l'interface doit avoir un ensemble de règles. Il incarne la philosophie de la nature selon laquelle « si vous êtes..., vous devez être capable de... ».

Par exemple, dans la nature, les gens peuvent manger, c'est-à-dire "si vous êtes un humain, vous devez pouvoir manger". Ensuite, lors de la simulation dans un programme informatique, il devrait y avoir une interface IPerson (habituellement, le nom de l'interface commence par "I") et une méthode appelée Eat(). Nous stipulons ensuite que chaque classe représentant "personne" doit implémenter l'interface IPerson, qui. simule la règle de la nature "Si vous êtes un humain, vous devez pouvoir manger".

À partir de là, je pense que vous pouvez également voir une certaine pensée orientée objet. L'un des cœurs de la pensée orientée objet est de simuler le monde réel et d'abstraire les choses du monde réel en classes. L'ensemble du programme s'appuie sur des instances de chaque classe pour communiquer entre elles et coopérer pour accomplir les fonctions du système. est très cohérent avec les conditions de fonctionnement du monde réel et est également orienté vers l'essence de la pensée objet.

2) Une interface est une représentation abstraite de choses similaires à une certaine granularité View. Notez qu'ici j'insiste sur une certaine vue granulaire, car le concept de « choses similaires » est relatif et il diffère en raison de vues granulaires différentes.

Par exemple, à mes yeux, je suis un être humain, fondamentalement différent d'un cochon. Je peux accepter que mes camarades de classe et moi soyons du même genre, mais je ne pourrai jamais l'accepter. Je suis pareil qu'un cochon. Un cochon est de la même espèce. Cependant, si aux yeux d'un zoologiste, les cochons et moi devrions être de la même espèce, parce que nous sommes tous les deux des animaux, il peut penser que "les gens" et "le cochon" implémentent l'interface IAnimal, et il étudie les animaux comportement , il ne traitera pas moi et le cochon séparément, mais l'étudiera à partir de la plus grande granularité de "animal", mais il pensera qu'il y a une différence essentielle entre moi et un arbre.

Maintenant, j'ai un généticien, et la situation est différente. Parce que tous les êtres vivants peuvent être hérités, donc à ses yeux, je ne suis pas seulement différent d'un cochon, mais aussi d'un moustique, d'une bactérie, un arbre, Il n'y a pas de différence entre un champignon ou même un virus du SRAS, car il pensera que nous implémentons tous l'interface IDescendable (Remarque : descendre vi. héritage), c'est-à-dire que nous sommes tous Les choses héréditaires, et il ne le fera pas. Au lieu de nous étudier séparément, il étudiera tous les êtres vivants comme étant de la même espèce. À ses yeux, il n'y a pas de distinction entre les humains et les virus, seulement le matériel héréditaire et le matériel non héréditaire. Mais au moins il y a une différence entre moi et une pierre.

Mais quelque chose de malheureux s'est produit. Un jour, un grand homme est apparu sur terre. Son nom était Lénine. Après avoir lu les chefs-d'œuvre du matérialisme dialectique de Marx et d'Engels, il avait beaucoup d'expérience, alors il a donné une définition célèbre. : La soi-disant substance est la réalité objective qui peut être reflétée par la conscience. À ce stade, il n’y a aucune différence entre moi et une pierre, un souffle d’air, un idiome et le champ électromagnétique qui transmet les signaux des téléphones portables, car aux yeux de Lénine, nous sommes tous des réalités objectives qui peuvent être reflétées par la conscience. Si Lénine était programmeur, il dirait ceci : Ce qu'on appelle la matière, ce sont les instances générées par toutes les classes qui implémentent à la fois les interfaces "IReflectabe" et "IEsse". (Remarque : réfléchir v. refléter esse n. réalité objective)

Peut-être penserez-vous que mon exemple ci-dessus est absurde, mais c'est exactement la raison pour laquelle les interfaces existent. L'un des concepts fondamentaux de la pensée orientée objet est appelé polymorphisme. Qu'est-ce que le polymorphisme ? Pour parler franchement, des choses similaires sont traitées uniformément sans distinction à une certaine granularité couche de vue . La raison pour laquelle j'ose le faire est à cause de l'existence d'interfaces. Comme le généticien, il comprend que tous les organismes implémentent l'interface IDescendable, donc tant qu'il s'agit d'un organisme, il doit avoir la méthode Descend(), afin qu'il puisse mener des recherches unifiées au lieu d'étudier chaque organisme séparément et finir par mourir d'épuisement.

Peut-être que je ne peux pas vous donner une impression intuitive de la nature et de la fonction de l'interface ici. Ensuite, dans les exemples suivants et l'analyse de plusieurs modèles de conception , vous découvrirez plus intuitivement la connotation de l'interface.

3. Présentation de la programmation orientée interface

Alors, qu'est-ce que la programmation orientée interface ? Ma définition personnelle est la suivante : Dans l'analyse du système et l'architecture, distinguer les niveaux et les dépendances. Chaque niveau ne fournit pas directement de services à sa couche supérieure (c'est-à-dire qu'il n'est pas directement instancié dans le niveau). couche supérieure) ), mais en définissant un ensemble d'interfaces, exposer uniquement ses fonctions d'interface à la couche supérieure. La couche supérieure s'appuie uniquement sur l'interface de la couche inférieure, et ne s'appuie pas sur des classes spécifiques.

Les avantages de ceci sont évidents. Tout d’abord, c’est excellent pour la flexibilité du système. Lorsque la couche inférieure doit être modifiée, tant que l'interface et la fonction d'interface restent inchangées, la couche supérieure n'a pas besoin d'apporter de modifications. Vous pouvez même remplacer toute la couche inférieure sans modifier le code de la couche supérieure, tout comme nous remplaçons un disque dur WD 60G par un disque dur Seagate 160G. Il n'est pas nécessaire d'apporter des modifications aux autres parties de l'ordinateur. le disque dur d'origine et installez le nouveau disque dur. Branchez-le simplement, car les autres parties de l'ordinateur ne dépendent pas d'un disque dur spécifique, mais uniquement d'une interface IDE. Tant que le disque dur implémente cette interface, il peut être remplacé. À partir de là, l'interface du programme est très similaire à l'interface dans la réalité, donc je pense toujours que le mot interface est vraiment similaire !

Un autre avantage de l'utilisation des interfaces est que les développeurs de différents composants ou niveaux peuvent commencer à travailler en parallèle, tout comme ceux qui construisent des disques durs n'ont pas à attendre ceux qui construisent des processeurs ou des moniteurs. les interfaces sont cohérentes et la conception est raisonnable, le développement complet peut être effectué en parallèle, augmentant ainsi l'efficacité.

Supplément à cet article :

1 À propos de "l'interface" dans la "programmation orientée interface" et d'objets spécifiques. langages orientés Le mot "interface" dans

a vu un ami suggérer que le mot "interface" dans "programmation orientée interface" devrait avoir une portée plus large que le mot "interface" dans un simple langage de programmation . Après réflexion, je pense que c'est logique. Ce que j'ai écrit ici est en effet déraisonnable. Je pense que « interface » dans les langages orientés objet fait référence à une structure de code spécifique, telle que l'interface définie avec le mot-clé interface en C#. L'« interface » dans la « programmation orientée interface » peut être considérée comme faisant référence à un composant structurel utilisé pour masquer des classes sous-jacentes spécifiques et implémenter le polymorphisme du point de vue de l'architecture logicielle et à un niveau plus abstrait. En ce sens, si une classe abstraite est définie et que le but est de réaliser le polymorphisme, alors je pense qu'il est raisonnable d'appeler cette classe abstraite une « interface ». Mais est-il raisonnable d’utiliser des classes abstraites pour implémenter le polymorphisme ? Discuté dans le deuxième article ci-dessous.

En résumé, je pense que les deux concepts d'"interface" sont à la fois différents l'un de l'autre et liés l'un à l'autre. L'interface dans la « programmation orientée interface » est un composant architectural au niveau idéologique utilisé pour réaliser le polymorphisme et améliorer la flexibilité et la maintenabilité du logiciel, tandis que « l'interface » dans un langage spécifique est un composant concret à ce niveau idéologique implémenté dans le code. .

2. À propos des classes abstraites et des interfaces

Si vous regardez uniquement le code spécifique, il est facile de brouiller ces deux concepts, et même de penser que les interfaces sont redondantes , car Du point de vue de fonctions spécifiques, outre l'héritage multiple (en C#, Java), les classes abstraites semblent pouvoir remplacer complètement les interfaces. Mais l’interface existe-t-elle pour implémenter l’héritage multiple ? Bien sûr que non. À mon avis, la différence entre les classes abstraites et les interfaces réside dans la motivation de leur utilisation. Le but de l'utilisation de classes abstraites est la réutilisation du code, tandis que la motivation de l'utilisation des interfaces est d'atteindre le polymorphisme. Donc, si vous ne savez pas si vous devez utiliser une interface ou une classe abstraite quelque part, réfléchissez à votre motivation.

J'ai vu des amis remettre en question l'interface IPerson. Ma compréhension personnelle est que la définition de l'interface IPerson dépend de l'application spécifique. Si nous avons Women et Man dans notre projet, tous deux héritent de Person, et que la plupart des méthodes de Women et Man sont les mêmes, une seule méthode DoSomethingInWC() est différente (l'exemple est plutôt vulgaire, pardonnez-moi), alors bien sûr il est plus raisonnable de définir une classe abstraite AbstractPerson, car elle peut inclure toutes les autres méthodes, et la sous-classe définit uniquement DoSomethingInWC(), ce qui réduit considérablement la quantité de code répété.

但是，如果我们程序中的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) La classe abstraite est un concept abstrait d'une série d'objets liés, elle reflète donc les points communs internes des choses ; l'interface est un accord fonctionnel défini pour répondre aux appels externes, elle reflète donc les caractéristiques externes des choses. >

(6) L'interface n'a fondamentalement aucune caractéristique spécifique d'héritage. Elle promet uniquement des méthodes qui peuvent être appelées

(7) L'interface peut être utilisée pour prendre en charge les rappels, mais pas l'héritage. avoir ces fonctionnalités

(8) Les méthodes spécifiques implémentées par les classes abstraites sont virtuelles par défaut, mais les méthodes d'interface de la classe qui implémente l'interface sont non virtuelles par défaut. Bien sûr, vous pouvez également les déclarer. comme virtuel

(9) Si la classe abstraite implémente l'interface, vous pouvez mapper les méthodes de l'interface à la classe abstraite en tant que méthodes abstraites sans avoir à les implémenter, et implémenter les méthodes de l'interface dans la sous-classe de la classe abstraite

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!