Bonjour à tous, je suis étudiant en DUT info et je rencontre quelques problèmes avec les interfaces. Je commence tout juste à comprendre à quoi elles servent réellement et je rencontre un petit problème dans un programme.

Voici l'énoncé du programme :

J'ai mis la procédure dans la class ModificateurDarker, mon Interface dans un autre fichier et je suppose qu'il ne restait qu'un main à faire.

public static void main (String [] args)
{
Picture pic = new Picture("MonImage.jpg");
transformerImage(pic, ??????);
}

Voici ce que j'ai pensé faire mais je ne sais pas quoi mettre à la place de mes "??????". J'ai essayé de mettre modif mais visiblement ce n'est pas ça.

Pouvez vous m'apportez votre aide

il faut creer une nouvelle classe (ModificateurBrighter) qui va implémenter ton interface

Mais ModificateurBrigther c'est pour la question d'après

public static void main (String [] args)
{
Picture pic = new Picture("MonImage.jpg");
ModificateurDarker darker = new ModificateurDarker();
transformerImage(pic, darker);
}

l'interet de l'interface c'est que tu vas pouvoir faire ca :
public static void main (String [] args)
{
Picture pic = new Picture("MonImage.jpg");
ModificateurDarker darker = new ModificateurDarker();
ModificateurBrighter brighter = new ModificateurBrighter();
transformerImage(pic, darker);
transformerImage(pic, brighter);
}

Ah okey !! En fait il faut faire un new de l'interface dans le main !

J'ai compris, merci beaucoup

un new de la classe qui implémente l'interface ;)
Les interfaces ne s'instancient pas (pas de "new") elles servent juste à déclarer une ou plusieurs méthodes.

Sur ce cas précis tu as une interface ModificateurCouleur dont le role est d'avoir une méthode qui va altérer une couleur. Mais tu ne sais pas quelle modif ça fait.

Chaque classe qui va implémenter ton Interface va préciser de quelle manière on va altérer la couleur en définissant la méthode modifierCouleur()

Okey okey, merci

Petit up juste pour quelques précisions. J'ai vraiment du mal à comprendre l'utilité des interfaces dans certains cas ...

L'interface Comparable par exemple, étant donné que l'on doit définir la méthode CompareTo dans la classe implémenté à quoi sert réellement l'interface ?
Pourquoi ne pas déclarer simplement notre compareTo comme n'importe quelle autre méthode ?

Merci de m'aider parce que là je suis vraiment perdu

Justement, compareTo compare un autre Comparable, et étant donné qu'on ne sait pas à l'avance comment tu veux faire ta comparaison (Valeur, liste, etc...), c'est plus simple et logique de te laisser la définir.

D'accord mais comme on définit le compareTo dans la classe si on enlève le implements Comparable ça marche quand même.

Alors pourquoi

Désolé j'ai vraiment du mal avec cette notion

Quand tu définis une interface, tu manipules l'interface.

Exemple concret :
Tu as des objets Légumes et des objets Fruits qui étendent respectivement Comparable<Légumes> et Comparable<Fruits>. Tu veux les afficher selon leur nom.
Tu n'en a rien a secouer que ce soit des Légumes ou des Fruits, tu faits une List<Comparable<?>>. Rajoutons ensuite des pièces de moteurs, qui implémente aussi Comparable<PieceDeMoteur>. Toujours pareil, tu manipules uniquement des Comparable

Remarque : dans la réalité, y'aura quand même quelques conflits, mais l'idée est là

Manipuler des interfaces en lieu et place des classes te permet de mutualiser les traitements. Tu sais que chaque classe implémentant l'interface répondra aux méthodes qu'elle énonce. Les classes réellement manipulées ne sont pas ton affaire.

Si je comprends bien, la réelle utilité est quand on a plusieurs objets différents. Aussi, dans ton exemple, on utilise Comparable comme un type ?

Je comprends rien

Pour le moment ce que je comprends des interfaces c'est qu'on pourrait très bien s'en passer mais que ça apporte des informations supplémentaires pour la lisibilité du code par quelqu'un d'autres.

Aussi dans certains l'interface peut être utilisé comme un type mais là aussi, je trouve ça très confus

Pour comprendre l'utilité des interfaces, imagine que ce n'est pas toi qui crée les classes qui l'implémente, mais quelqu'un qui à besoin que ton programme manipule son objet.

En forçant l'autre programmeur à implémenter certaines méthode grâce à ton interface, tu pourra être sur que sa classe contiendra les méthodes dont tu as besoin pour faire le traitement.

Il y a d'autres utilités aux interfaces il me semble, et c'est très utiles dans certains design pattern comme l'observateur/sujet d'observation ou encore les class factory.

Mais je ne suis pas un pro, donc je vais pas trop m'aventurer.

Les interface c'est utile car ça te garantir que les classes qui implémentent l'interface auront déclaré du code pour les méthodes décrites dans l'interface.
Aussi, le fait de manipuler des interfaces au lieu de classes fait que le code qui manipule des interfaces n'aura pas à changer chaque fois qu'un ajoute ou qu'on supprime ou qu'on modifie le code d'une classe qui implémente l'interface.
Si tu avais jeté à la poubelle l'interface, tu es bon pour devoir identifier à l'avance toutes les classes que tu auras à gérer un jour, ce qui n'est pas possible.

Exemple :

Une console de jeu vidéo PS3, permet de lancer des jeux PS3 peu importe s'ils sont différents les uns des autres, tant qu'ils implémentent l'interface JeuPS3 qui contient les méthodes "lancer()", "sauver()", "arrêter()", et "mettreAJour()" par exemple :p

Les développeurs de jeux de n'importe quel éditeur fourniront sur chaque nouveau jeu la classe qui correspond au jeu. la classe KillZone pour Killzone, etc. Killzone implémentant l'interface JeuPS3, il pourra tourner sur la PS3 qui a pourtant été créée bien avant, car la console ne manipule pas des classes mais des interfaces et donc fonctionne indépendemment de l'implémentation des classes qui implémentent JeuPS3

Bon concrètement je crois pas que les classes Killzone et interface JeuPS3 existent mais bon, c'est l'idée.