Classes abtraites et interfaces ont chacune une fonction bien distincte : les classes abstraites servent à factoriser du code, tandis que les interfaces servent à définir des contrats de service.
Les différences entre les interfaces et les classes abstraites : Une interface n'implémente aucune méthode. Une classe, ou une classe abstraite peut implémenter plusieurs interfaces, mais n'a qu'une super classe, alors qu'une interface peut dériver de plusieurs autres interfaces.
une classe est abstraite si elle contient au moins une méthode abstraite ; elle ne peut pas être instanciée, mais ses sous-classes non abstraites le peuvent. une classe abstarite est déclarée avec le modificateur abstract. une classe est abstraite ne peut être instanciée.
Une interface se déclare avec le mot-clé interface. Comme pour une classe, une interface a une portée, un nom et un bloc de déclaration. Une interface est déclarée dans son propre fichier qui porte le même nom que l'interface. Pour l'exemple ci-dessus, le fichier doit s'appeler Compte.
Les interfaces servent à créer des comportements génériques: si plusieurs classes doivent obéir à un comportement particulier, on créé une interface décrivant ce comportement, on est la fait implémenter par les classes qui en ont besoin.
Une interface est une liste de noms de méthodes (uniquement les signatures des méthodes). Une interface est un prototype de classe. Elle définit la signature des méthodes qui doivent être implémentées dans les classes construites à partir de ce prototype.
En informatique, jonction entre deux matériels ou logiciels leur permettant d'échanger des informations par l'adoption de règles communes ; module matériel ou logiciel permettant la communication d'un système avec l'extérieur.
Formellement une classe abstraite n'est pas différente d'une classe normale. Simplement, elle est déclarée en ajoutant le mot-clé abstract , comme dans l'exemple suivant. On peut déclarer autant de méthodes abstraites que l'on veut dans une classe abstraite, y compris ne pas en déclarer du tout.
Le polymorphisme est un mécanisme important dans la programmation objet. Il permet de modifier le comportement d'une classe fille par rapport à sa classe mère. Le polymorphisme permet d'utiliser l'héritage comme un mécanisme d'extension en adaptant le comportement des objets.
Le mécanisme des classes abstraites permet de définir des comportements (méthodes) dont l'implémentation (le code dans la méthode) se fait dans les classes filles. Ainsi, on a l'assurance que les classes filles respecteront le contrat défini par la classe mère abstraite. Ce contrat est une interface de programmation.
L'intérêt principal de définir une classe comme abstraite va être justement de fournir un cadre plus strict lorsqu'ils vont utiliser notre code en les forçant à définir certaines méthodes et etc. En effet, une classe abstraite ne peut pas être instanciée directement et contient généralement des méthodes abstraites.
Définition du polymorphisme
Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs formes. Cette caractéristique est un des concepts essentiels de la programmation orientée objet. Alors que l'héritage concerne les classes (et leur hiérarchie), le polymorphisme est relatif aux méthodes des objets.
Classes abtraites et interfaces ont chacune une fonction bien distincte : les classes abstraites servent à factoriser du code, tandis que les interfaces servent à définir des contrats de service.
La classe abstraite peut avoir un modificateur d'accès. Il est préférable d'utiliser l'interface lorsque plusieurs implémentations partagent uniquement la signature de méthode. Il doit être utilisé lorsque différentes implémentations du même type partagent un comportement commun.
Une classe abstraite peut contenir ou non des méthodes abstraites. Une classe concrète ne peut pas contenir de méthode abstraite. Une classe abstraite ne peut pas être déclarée finale. Une classe concrète peut être déclarée finale.
L'encapsulation permet de définir des niveaux de visibilité des éléments de la classe. Ces niveaux de visibilité définissent les droits d'accès aux données selon que l'on y accède par une méthode de la classe elle-même, d'une classe héritière, ou bien d'une classe quelconque.
En Programmation Orientée Object (POO), la généricité est un concept permettant de définir des algorithmes (types de données et méthodes) identiques qui peuvent être utilisés sur de multiples types de données. Cela permet donc de réduire les quantités de codes à produire.
Une sous-classe d'une classe abstraite sera encore abstraite si elle ne définit pas toutes les méthodes abstraites dont elle hérite. Les classes abstraites sont très utiles pour définir des méthodes dépendant d'autres méthodes qui ne sont pas précisées.
Une interface peut en étendre une autre, et même plusieurs. Elle ne peut pas étendre de classe, abstraite ou concrète. Une classe n' étend pas une interface, elle l'implémente. On utilise pour cela le mot-clé implements .
Une interface ne peut pas être instanciée directement. Ses membres sont implémentées par une classe ou un struct qui implémentent l'interface. Une classe ou un struct peuvent implémenter plusieurs interfaces. Une classe peut hériter d'une classe de base et également implémenter une ou plusieurs interfaces.
Plusieurs types d'interface utilisateur
Celles que nous utilisons le plus, dans la vie de tous les jours, sont l'interface graphique et l'interface Web.
Le terme interface est généralement utilisé en informatique pour désigner un programme permettant un échange de données : Il peut s'agir d'un échange entre deux logiciels : l'interface est, par exemple, un programme qui reformate les données pour assurer la compatibilité entre ces deux logiciels.