« Bonjour, Amigo ! C'est encore moi. J'aimerais t'offrir un autre point de vue sur les interfaces. Tu vois, la plupart du temps une classe est un modèle d'un objet particulier. À l'inverse, les interfaces représentent plutôt les capacités ou les rôles de l'objet, plutôt que l'objet lui-même. »

Une interface est bien plus qu'une interface. C'est un comportement. - 1

Par exemple, des choses comme les voitures, les vélos, les motos et les roues sont mieux représentées sous forme de classes et d'objets. Mais leurs capacités, comme « je peux me déplacer », « je peux transporter des personnes » et « je peux me garer » sont mieux représentées sous forme d'interfaces. Regarde cet exemple :

Code Java Description 
interface Moveable
{
void move(String newAddress);
}
 Correspond à la capacité de se déplacer. 
interface Driveable
{
void drive(Driver driver);
}
 - Correspond à la capacité de se déplacer. 
interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}
 - Correspond à la capacité de transporter des choses. 
class Wheel implements Moveable
{
...
}
 - Une classe de « roue ». A la capacité de se déplacer. 
class Car implements Moveable, Drivable, Transport
{
...
}
 - Une classe de « voiture ». A la capacité de se déplacer, d'être conduite par une personne et de transporter des choses. 
class Skateboard implements Moveable, Driveable
{
...
}
 - Une classe de « skateboard ». A la capacité de se déplacer et d'être contrôlé par une personne.

Les interfaces simplifient considérablement la vie du programmeur. Les programmes ont très souvent des milliers d'objets, des centaines de classes, et quelques dizaines d'interfaces (rôles). Il y a peu de rôles, mais ils peuvent être combinés de nombreuses façons (classes).

L'intérêt est que tu n'as pas besoin d'écrire du code définissant individuellement l'interaction avec toutes les autres classes. Tout ce que tu as à faire est d'interagir avec des rôles (interfaces).

Imagine que tu fabriques des robots. Tu as des dizaines de robots parmi tes subordonnés, et chacun peut avoir différentes compétences. Supposons que tu dois rapidement finir de construire un mur. Tu rassembles tous les robots qui ont la capacité de « construire », et tu leur dis de construire le mur. Tu ne te soucies pas vraiment de quels robots le font. Ça pourrait aussi bien être un arrosoir robotique. S'il sait comment construire, laisse-le construire.

Voici à quoi cela ressemblerait dans le code :

Code Java Description 
static interface WallBuilder
{
void buildWall();
}
 - Capacité de « construire un mur ». Comprend la commande « construire un mur » (a la méthode appropriée). 
static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}
 - Les robots qui ont cette capacité/compétence.

- Un arrosoir ne peut pas construire un mur (il n'implémente pas l'interface WallBuilder).

 
public static void main(String[] args)
{
 //add all robots to a list
 ArrayList robots = new ArrayList();
 robots.add(new WorkerRobot());
 robots.add(new GuardRobot());
 robots.add(new WateringCan());

 //build a wall if you can
 for (Object robot: robots)
 {
  if (robot instanceof WallBuilder)
  {
   WallBuilder builder = (WallBuilder) robot;
   builder.buildWall();
   }
  }
 }
}
 - Comment donner l'ordre de construire un mur ?

« C'est incroyablement intéressant. Je n'aurais jamais imaginé que les interfaces pouvaient être un sujet si intéressant. »

« Et tu n'as pas encore tout vu. Associées au polymorphisme, elles sont tout simplement hallucinantes. »

Java webinar