Type abstrait - Abstract type

Dans les langages de programmation , un type abstrait est un type dans un système de type nominatif qui ne peut pas être instancié directement ; un type qui n'est pas abstrait – qui peut être instancié – est appelé un type concret . Chaque instance d'un type abstrait est une instance d'un sous-type concret . Les types abstraits sont également appelés types existentiels .

Un type abstrait peut ne fournir aucune implémentation, ou une implémentation incomplète. Dans certains langages, les types abstraits sans implémentation (plutôt qu'une implémentation incomplète) sont appelés protocoles , interfaces , signatures ou types de classe . Dans la programmation orientée objet basée sur les classes , les types abstraits sont implémentés en tant que classes abstraites (également appelées classes de base abstraites ) et les types concrets en tant que classes concrètes . Dans la programmation générique , la notion analogue est un concept , qui spécifie de la même manière la syntaxe et la sémantique, mais ne nécessite pas de relation de sous-type : deux types non liés peuvent satisfaire le même concept.

Souvent, les types abstraits auront une ou plusieurs implémentations fournies séparément, par exemple, sous la forme de sous-types concrets qui peuvent être instanciés. Dans la programmation orientée objet, une classe abstraite peut inclure des méthodes abstraites ou des propriétés abstraites qui sont partagées par ses sous-classes. D'autres noms pour les fonctionnalités de langage qui sont (ou peuvent être) utilisés pour implémenter des types abstraits incluent traits , mixins , saveurs , rôles ou classes de types .

Signification des types abstraits

Les classes abstraites peuvent être créées, signifiées ou simulées de plusieurs manières :

• En utilisant le mot clé explicite abstractdans la définition de classe, comme en Java , D ou C# .
• En incluant, dans la définition de la classe, une ou plusieurs méthodes abstraites (appelées fonctions virtuelles pures en C++ ), que la classe est déclarée accepter dans le cadre de son protocole, mais pour lesquelles aucune implémentation n'est fournie.
• En héritant d'un type abstrait et en ne remplaçant pas toutes les fonctionnalités manquantes nécessaires pour compléter la définition de la classe. En d'autres termes, un type enfant qui n'implémente pas toutes les méthodes abstraites de son parent devient lui-même abstrait.
• Dans de nombreux langages à typage dynamique tels que Smalltalk , toute classe qui envoie une méthode particulière à this , mais n'implémente pas cette méthode, peut être considérée comme abstraite. (Cependant, dans de nombreux langages, comme Objective-C , l'erreur n'est détectée que lorsque la classe est utilisée, et le message renvoie des résultats dans un message d'erreur d'exception tel que "Ne reconnaît pas le sélecteur : xxx" comme il - [NSObject doesNotRecognizeSelector:(SEL)selector]est invoqué lors de la détection de une méthode non implémentée).

Exemple (Java)

//By default, all methods in all classes are concrete, unless the abstract keyword is used.
abstract class Demo {
    // An abstract class may include abstract methods, which have no implementation.
    abstract public int sum(int x, int y);

    // An abstract class may also include concrete methods.
    public int product(int x, int y) { return x*y; }
}

//By default, all methods in all interfaces are abstract, unless the default keyword is used.
interface DemoInterface {
    [abstract] int getLength(); //Abstract can be used here, though is completely useless
    
    //The default keyword can be used in this context to specify a concrete method in an interface
    default int product(int x, int y) {
        return x * y;
    }
}

Utilisation de types abstraits

Les types abstraits sont une caractéristique importante des langages POO à typage statique . De nombreux langages à typage dynamique n'ont pas de fonctionnalité équivalente (bien que l'utilisation du typage duck rende les types abstraits inutiles) ; cependant, des traits sont trouvés dans certaines langues modernes à typage dynamique.

Certains auteurs soutiennent que les classes devraient être des classes feuilles (n'avoir aucun sous-type), ou bien être abstraites.

Les types abstraits sont utiles dans la mesure où ils peuvent être utilisés pour définir et appliquer un protocole ; un ensemble d'opérations que tous les objets implémentant le protocole doivent prendre en charge.

Les types abstraits sont également une partie essentielle du modèle de méthode de modèle .

Voir également

• Classer
• Concept
• Classe de type

Les références

Lectures complémentaires

• Tête d'abord Java . O'Reilly Media. 2003. p.  688 . ISBN 0-596-00920-8.
• Core Java : une approche intégrée par R. Nageswara Rao

Liens externes

• « Interfaces abstraites ou squelettiques expliquées » [1]
• Types et langages de programmation par Benjamin Pierce (MIT Press 2002) [2]
• Type abstrait à Rosetta Code