Java / Spring - Interfaces de programmation

Il s'agit de la troisième partie d'une série de tutoriels axés sur la révision des sujets de base du langage Java pour préparer le lecteur à l'utilisation de Spring Framework. La première partie de cette série de tutoriels peut être obtenue ici et la deuxième partie peut être obtenue ici. Dans ce didacticiel, nous parlerons de ce que sont les interfaces, de ce que sont les interfaces de programmation, de leurs avantages et de leur relation avec Spring Framework.
Nous avons déjà vu les concepts d'héritage et de polymorphisme et les interfaces sont un type de classe Java qui se caractérise par la représentation d'une fonctionnalité particulière. Dans sa forme la plus courante, les interfaces sont une classe composée de méthodes sans implémentation.

 interface Drawable {public void draw (); public void chooseColor (couleur de la chaîne); } 

Les interfaces sont toujours publiques et abstraites, que vous définissiez ou non des modificateurs, et représentent la manière dont les autres objets interagissent avec l'objet qui les implémente. Cela peut paraître compliqué mais c'est simple, lorsqu'une classe implémente une interface elle est obligée de donner un corps aux méthodes correspondantes. Cela signifie que tant qu'un objet implémente une interface, vous pouvez être entièrement sûr que cet objet possède les méthodes correspondant à l'interface mentionnée.
En Java, les interfaces sont implémentées avec le mot clé "implements" et une classe peut implémenter une ou plusieurs interfaces mais est obligée de surcharger les méthodes correspondant à chaque interface sans exception ou le compilateur lèvera une erreur.

 public class Square implémente Drawable {public String borderColor; public String fillcolor; public élevé; public int largeur; @Override public void draw () {System.out.println ("Un carré est dessiné avec largeur" ​​+ largeur + ", hauteur" + hauteur + "et couleur" + couleur de remplissage); } @Override public void chooseColor (String color) {fillcolor = color; }} 

 La classe publique Line implémente Drawable {public String strokecolor; chaîne publique longue; @Override public void draw () {System.out.println ("Dessiner une ligne de" + long); } @Override public void chooseColor (String color) {strokecolor = color; }} 

Dans ce cas, l'interface permet de manipuler n'importe quel nombre d'objets sans problème en utilisant le concept de polymorphisme que nous avons vu dans la deuxième partie et ces objets n'ont pas à être intrinsèquement liés les uns aux autres sauf par la manière dont les autres classes interagissent avec eux. Dans le cas de notre exemple, vous pourriez plus tard avoir des objets pentagone, paysage ou même ArtWork qui implémentent l'interface Drawable et ils pourraient tous être gérés par n'importe quelle classe qui peut manipuler l'interface Drawable.

 importer java.awt.Color; importer java.util.*; public class DrawThings {// Cette classe génère des objets pouvant être dessinés au hasard et les dessine dans des couleurs aléatoires public static void main (String [] args) {List l = new ArrayList (); for (int i = 0; i0.5) {l.add (nouvelle ligne ()); } else {l.add (nouveau carré ()); }} pour (Dessinable d : l) {flotteur H, S, B; H = (flottant) Math.aléatoire (); S = (flottant) Math.aléatoire (); B = (flottant) Math.aléatoire (); Couleur c = Couleur.getHSBColor (H, S, ; d.chooseColor (String.valueOf (c)); d. dessiner (); }}} 

Comme vous le verrez dans l'exemple, la méthode principale peut être séparée en 2 méthodes principales, celle qui remplit la liste des objets pouvant être dessinés et celle qui dessine les objets dans la liste. Je vous invite à utiliser ces classes et à voir comment elles se comportent avant de passer à la section suivante où nous verrons pourquoi vous pourriez vouloir programmer l'interface.
En fin de compte, une interface est la même que sa vraie contrepartie, votre clavier et votre souris sont les interfaces avec lesquelles vous interagissez avec votre ordinateur, les détails internes de la façon dont des choses comme "Cliquez" ou "Appuyez sur la touche Echap" sont effectuées à partir de l'interface de votre ordinateur vous est cachée et ne vous est pas nécessaire. La seule chose qui compte est que vous puissiez appuyer sur la touche Échap et cliquer à l'aide de cette interface.
Une fois que vous aurez revu ce qu'est une interface, j'espère que vous comprendrez à quel point il peut être important d'en programmer une. Essentiellement, vous vous concentrez sur la création de vos programmes en pensant à l'interface que vous allez utiliser et pas tellement à l'objet qui vous serait transmis en tant que paramètre. Dans le cas de l'exemple que nous avons traité jusqu'à présent, il peut être réécrit comme suit :

 importer java.awt.Color; importer java.util.*; public class DrawThings {// Cette classe génère des objets pouvant être dessinés au hasard et les dessine dans des couleurs aléatoires public static void main (String [] args) {List l = new ArrayList (); listeremplissage (l); drawList (l); } public static void fillList (List l) {for (int i = 0; i0.5) {l.add (new Line ()); } else {l.add (nouveau carré ()); }}} public static void drawList (List l) {for (Drawable d: l) {float H, S, B; H = (flottant) Math.aléatoire (); S = (flottant) Math.aléatoire (); B = (flottant) Math.aléatoire (); Couleur c = Couleur.getHSBColor (H, S, ; d.chooseColor (String.valueOf (c)); d. dessiner (); }}} 

Certes, je n'ai séparé les parties de la méthode principale que dans les 2 méthodes enfants, mais la beauté de ceci est que ces 2 méthodes conservent leur indépendance l'une par rapport à l'autre et par rapport aux implémentations de l'interface Drawable. Si je voulais changer l'une des 2 méthodes l'autre ne serait pas du tout affectée, si les implémentations Pentagone et ArtWork devaient apparaître, vous pourriez les ajouter dans le processus de création de la méthode fillList (List l) et de la drawList ( List) méthode. l) ne nécessiterait aucune modification car elle a été programmée dans l'interface.
+ ImportantC'est que les deux méthodes peuvent appartenir à des classes différentes, elles peuvent être manipulées dans des environnements différents et elles ne peuvent même jamais savoir quel objet elles manipulent réellement mais, tant qu'elles implémenteront l'interface Drawable, elles pourront la manipuler et elles pouvoir exécuter les 2 méthodes associées à cette interface.
Je sais que cela semble terriblement compliqué pour le moment, mais plus tard, nous verrons comment Spring gère tout ce qui est programmé sur une interface et nous verrons même comment la programmation orientée aspect et la compréhension de cela nous aideront beaucoup à comprendre le fonctionnement de Spring.
J'espère que nous continuerons avec ces tutoriels semaine après semaine, n'oubliez pas de laisser vos commentaires jusqu'à la prochaine fois !Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif