comment appliquer les principes SOLID?

Bonjour j’essaye de comprendre les principes SOLID mais ils m’échappent complètement, en commençant par le premier.

Single Responsibility Principle

Si une classe a plus d’une responsabilité, alors ces responsabilités deviennent couplées. Des modifications apportées à l’une des responsabilités peuvent porter atteinte ou inhiber la capacité de la classe de remplir les autres. Ce genre de couplage amène à des architectures fragiles qui dysfonctionnent de façon inattendues lorsqu’elles sont modifiées. — Robert C. Martin

J’essaye de trouver un exemple très très simple de code qui ne respecte pas ce principe et que je puisse essayer de corriger. Le tuto où j’apprend donne un exemple très difficile avec des BDD en C#…. et sur d’autres sites, je ne comprends pas leur exemple :

http://image.noelshack.com/fichiers/2019/18/5/1556875169-capture.png

Je vais essayer de vous expliquer ce que j’ai compris de ce principe avec mes mots :

Chaque classe devrait gérer une seule tâche spécifique dans le code global. Une classe représente le modèle d’un objet, donc un objet devrait être dédié à une tâche et s’occuper d’une action spécifique.

Oui, c’est nul comme explication….

Ah d’accord nickel je comprends mieux merci pour ces explications!

Je reviendrai plus tard ici avec un exemple de code pour voir si j’ai bien compris.

qui font de la laine mais pas du lait (des bisons ?).

Des alpagas, stp.

En fait pas besoin de code je pense avoir compris, j’explique sur un nouvel exemple.

Une classe modélise des robots. Cette classe Robot pourrait contenir deux méthodes: rotation() et déplacement() qui gère respectivement la rotation d’un robot sur lui même et son déplacement dans la pièce.

Mais comme il existe des robots qui peuvent se déplacer sans être capable de faire une rotation sur eux-même,il est donc préférable d’avoir une classe absraite Robot et deux interfaces, l’une pour gérer les rotation, l’autre pour gérer le déplacement.

Ainsi chaque interface et chaque classe a une seule responsabilité. C’est plus ou moins ça ?

Merci pour ces explications je reviens si j’ai d’autres question sur SOLID.

Bonjour, j’ai ceci :

class Personnage {
    private Voiture voiture;

    public setEssence(int q) {
        voiture.setEssence(q);
    }
}

Et dans la méthode main :

public static void main(String[] args) {
    monPersonnage.setEssence(30);
}

On est bien d’accord que ce code ne respecte pas le premier principe de SOLID ? (le single responsability)

merci… je vais préciser ma question avec du vrai code parce que j’ai peur d’avoir choisi un mauvais exemple.

public class Game {
    private Map map;
    private Window window;
    private Keyboard keyboard;
    
    public void start() {
        map = new Map();
        window = new Window(map);
        keyboard = new Keyboard();
        
        window.setKeyboard(keyboard);
    }
}

public class Map {
    private Keyboard keyboard;
    
    public void setKeyboard(Keyboard k) {
        keyboard = k;
    }
}

public class Window {
    private Map map; // Le constructeur initialise map
    
    public void setKeyboard(Keyboard k) {
        map.setKeyboard(k);
    }
}

Dans ce code, je pense que le S de SOLID n’est pas respecté. Pour corriger l’erreur, je pense qu’il faut remplacer la ligne 11 par celle-ci :

map.setKeyboard(keyboard);

Je fais ça parce que ça n’a aucun sens que window s’occupe de donner un Keyboard à Map. Par le single responsability principle, je dirais que il faut directement donner à map le keyboard dont il a besoin.

Ça fait quoi un Keyboard dans ce code ? En effet, je vois pas bien pourquoi une Map (renommer en WorldMap, CityMap ou autre peut-être ?) devrait avoir un Keyboard.

J’ai l’impression que ton idée derrière est de réagir à l’utilisation du clavier, auquel cas tu devrais creuser le design pattern Observer, voire même des libs comme Reactor ou ReactiveX si tu as besoin d’un système publish/subscribe efficace pour gérer les interactions entre tes composants et que tu as du temps.

En fait Map est un élément purement graphique du GUI (Map extends JPanel) à qui on associe un Clavier pour pouvoir déplacer des persos. Peut-être que le nom Map est mal choisi?

Mais pourquoi est-ce à la carte de gérer directement les événements provenant du clavier ?

edit : j’ai ça dans le constructeur de Map :

this.addKeyListener(keyboard);

https://docs.oracle.com/javase/7/docs/api/java/awt/event/KeyListener.html

Je pense avoir repéré du code qui ne respecte pas le premier principe de SOLID:

class Game {
    public void movePlayer(int x, int y) {
        if (player.getEnergy() > 0) {
            player.decreaseEnergy();
            player.moveTo(x, y);
        }
        else {
            System.out.println("Pas assez d'énergie pour se déplacer.");
        }
    }
}

En effet je pense que ce n’est pas à la classe Game de s’assurer que le player a assez d’énergie pour avancer. La vérification de l’énergie devrait se faire dans la classe Player :

class Game {
    public void movePlayer(int x, int y) {
        player.moveTo(x, y);
    }
}

class Player {
    public void moveTo(int x, int y) {
        if (this.energy > 0) {
            this.decreaseEnergy();
            this.posX = x;
            this.posY = y;
        }
        else {
            System.out.println("Pas assez d'énergie pour se déplacer.");
        }
    }
}

Est ce bien comme ça?

Mon projet Java étant terminé, je marque ce sujet en résolu.

J’ai finalement opté pour la solution que Game vérifie régulièrement l’énergie du personnage.

Pourquoi ce choix ?
Ça ne respecte pas un autre principe. Si tu veux changer le comportement de player (genre sa vitesse dépend de son énergie, ou il peut courir…), ça t’oblige à modifier la classe game.

En fait mon implémentation est plutôt étrange, l’un et l’autre sont implémentés j’ai l’impression.

Si l’énergie du perso était une donnée interne invisible de l’extérieur sans accesseurs, je me posais alors la question de comment le joueur peut-il notifier le Game qu’il doit aller se reposer ? Je n’ai pas encore compris la bonne solution à ce problème.

https://zestedesavoir.com/forums/sujet/12487/implementation-dun-jeu-de-plateau/

class Game {
    private Player activePlayer; // Défini dans le constructeur de Game
    
    public void movePlayer(int x, int y) {
        int energy = activePlayer.getEnergy();
        
        if (energy <= 0) {
            goToSleep();
            return;
        }
        
        int frontX = activePlayer.getFrontX();
        int frontY = activePlayer.getFrontY();
        
        if (frontX >= 0 && frontX < Level.SIZE_X && frontY >= 0 && frontY < Level.SIZE_Y) {
            for (GameObject o: actualLevel.getObjects()) {
                if (o.isAtPosition(frontX, frontY) && o.isObstacle()) {
                    // Obstacle trouvé devant le joueur
                    return;
                }
            }
            // Déplace le joueur et met à jour la position affichée
            activePlayer.move(x, y);
            window.update();
        }
    }
}

class Player {
    public void move(int x, int y) {
        if (energy > 0) {
            energy--;
        }
        // Pour des raisons d'une autre fonctionnalité,
        // Le joueur "peut" se déplacer sans énergie
        setPos(posX + x, posY + y);
    }
}