Supposons que gibbons, les orangs-outans, les gorilles, les chimpanzés et les humains sont tous les singes. J'ai modélisé cette relation en conséquence.
class Ape {}
class Gibbon extends Ape {}
class Orangutan extends Ape {}
class Gorilla extends Ape {}
class Chimpanzee extends Ape {}
class Human extends Ape {}
Je veux maintenant écrire une méthode de chasse () avec un paramètre de type bornées pour les singes de chasse.
public static <T extends Ape> void hunt(T type) {}
Supposons qu'il n'y a rien de mal à la chasse des singes non humains parce qu'ils ne sont que des animaux. Cependant, la chasse est l'homme mauvais parce qu'il est assassiner. Comment ce qui précède le paramètre de type borné puis-je ré-écrire pour exclure les humains en tant que paramètre juridique? Je ne suis pas intéressé par des exceptions ici. Je ne veux pas la méthode de chasse () pour compiler du tout si elle est invoquée avec un paramètre humain.
Vous ne pouvez pas exclure la façon dont vous avez l'intention là d'un particulier. Ce que vous pouvez faire cependant, est de créer une interface « isHuntable », mis en œuvre par les animaux nécessaires à la chasse que vous voulez, et vous l'utiliser comme un type pour la méthode au lieu du type générique lié. Une autre solution peut-être moins élégante est de créer un autre niveau dans la hiérarchie appelée « Monkeys » par exemple qui s'étendent de Ape, ayant tous les animaux s'étendant de celui-ci, et que vous utilisez ce type de singe pour votre méthode. Je vais avec la première approche cependant. Vous pouvez utiliser la vérification de type explicite, mais vous seriez briser le principe ouvert-fermé »dans votre code, il est donc préférable de tirer parti de ces contrôles au système de type.
Juste étendre un peu sur le concept de contrat de comportement interface qui est un outil puissant qui est malheureusement sous-utilisé. Ce que vous avez parmi vos Singes est un « est-une » relation qui étroitement couples vos sujets. Être « chassable » d'autre part, n'est pas une caractéristique inhérente ou la définition de la structure de cette hiérarchie, et est plus une condition supplémentaire / comportement / vérifier que vous souhaitez ajouter à un sous-ensemble de cette hiérarchie. Cela est mieux réalisé en ajoutant des contrats (de mise en œuvre de l'interface) au sous-ensemble vous avez l'intention d'avoir ce comportement. Cela permettra d'ajouter d'autres contrats (implémentations d'interface) dans l'avenir avec un minimum refactoring, la clarté sémantique maximale, moins de bugs et sans bondissant bien un type à un comportement. En bref, vous ne cassez pas le principe de substitution de Liskov, ni le principe fermé ouvert,