Partage
  • Partager sur Facebook
  • Partager sur Twitter

[JAVA]Problème modularité des classes

    24 février 2007 à 23:51:38

    Salut à tous! :)
    J'ai essayé de transposer le tuto de Matheo sur l'objet avec C++ en java.
    Ce tuto prenait pour exemple un personnage dans le cadre d'un rpg. Je me suis simplement contenté de rajouter une interface.

    Mais je me hurte à un souci non pas au niveau du code mais au niveau de la gestion de mes classes:
    -En gros j'ai mon interface contenant la declaration des méthodes (basiques et celles de combat) que je vais utiliser nommée Personnage.
    -J'ai ma classe principale (nommée PersonnageImpl) contenant toutes les méthodes basiques qui implante l'interface Personnage(class PersonnageImpl impléments Personnage).

    Or j'aurais voulu avoir une troisieme class qui contiendrait toutes les méthodes relatives aux combats.
    Je l'ai donc nommée CombatImpl et je l'ai étendue à ma class PersonnageImpl (class Combat extends PersonnageImpl)

    Mais alors un souci se pose:
    Eclipse me dit que la class PersonnageImpl, du fait qu'elle implante l'interface Personnage contenant toutes les méthodes(basiques et combat), doit contenir toutes les méthodes aussi bien les basiques que celles de combat ce qui m'empêche de séparer dans 2 fichiers les différentes méthodes pour des raisons de lisibilité.

    J'aimerais donc savoir comment faire pour avoir une interface regroupant toutes les méthodes(basiques et combat), et deux classes l'une contenant les méthodes basique et l'autre celle de combat sans que eclipse me sorte un "The type PersonnageImpl must implement the inherited abstract method Personnage.choisirArme (String, int)".

    Mon code est le suivant:
    Interface:

    public interface Personnage {
            /*
             * Methodes basiques
             */

            public Personnage deplacementX(int nbCase);
            public Personnage deplacementY(int nbCase);
            public int positionCouranteX();
            public int positionCouranteY();
            public String nomPerso();
            public Personnage setNomPerso(String nomPerso);
            public int pvPerso();
           
            /*
             * Methodes de combat
             */

            public Personnage choisirArme(String nomArme, int puissanceArme);
            public Personnage attaquer(Personnage cible);
            public Personnage recevoirCoup(int puissanceArme);
           
    }




    Class contenant les methodes basiques:



    public class PersonnageImpl implements Personnage{
            protected String nomPerso, armeCourante;
            protected int pvPerso, puissanceArme, positionX, positionY;
           
            public PersonnageImpl(){
                    nomPerso = "Unknow";
                    armeCourante = "Aucune arme équipée";
                    pvPerso = 100;
                    puissanceArme = 0;
                    positionX = 0;
                    positionY = 0;
            }
           
            public Personnage setNomPerso(String nomPerso){
                    this.nomPerso = nomPerso;
                    return this;
            }
           
            public String nomPerso(){
                    return nomPerso;
            }
           
            public Personnage deplacementX(int nbCase){
                    if((positionX + nbCase > 0) && (positionX + nbCase < 100)){
                            positionX += nbCase;
                            return this;
                    }
                    return this;
            }       

            public Personnage deplacementY(int nbCase){
                    if((positionY + nbCase > 0) && (positionY + nbCase < 100)){
                            positionY += nbCase;
                            return this;
                    }
                    return this;
                   
            }
           
            public int positionCouranteX(){
                    return positionX;
            }
           
            public int positionCouranteY(){
                    return positionY;
            }
           
            public int pvPerso(){
                    return pvPerso;
            }
    }



    Class contenant les méthodes combat:



    public class CombatImpl extends PersonnageImpl{
           
            public Personnage choisirArme(String nomArme, int puissanceArme){
                    armeCourante = nomArme;
                    this.puissanceArme = puissanceArme;
                    return this;
            }
           
            public Personnage attaquer(Personnage cible){
                    cible.recevoirCoup(puissanceArme);
                    return this;
            }
           
            public Personnage recevoirCoup(int puissanceArme){
                    if(pvPerso - puissanceArme >= 0) pvPerso -= puissanceArme;
                    else pvPerso = 0;
                    return this;
            }

    }




    Pour info si je vire la class Combat et que je met toutes les méthodes dans la class PersonnageImpl tout marche correctement.
    J'espère avoir été assez clair!
    Merci par avance pour vos réponses!

    EDIT:
    Apres reflexion je me demande si il ne serait pas mieux de faire une seconde interface relative aux methodes de combat, virer celles-ci de la première interface et d'implanter la class Combat dans les deux interfaces tout en l'étendant à la class PersonnageImpl (class CombatImpl extends PersonnageImpl implements Personnage, Combat) c'est une bonne méthode, ou alors il y a moyen de conserver une seule interface ce qui m'arrangerait bien? :p
    • Partager sur Facebook
    • Partager sur Twitter
      25 février 2007 à 0:24:48

      si j'ai bien compris t'a une classe personnage qui implémente une interface et une interface pour gérer les combats. le plus simple est de faire une classe qui implémente ton interface pour les combats et dedans d'utiliser ta classe qui implémente la classe personnage

      donc en gros
      class combatimpl extends combat {

      private personnage perso;
      }

      et donc tu pourra utiliser et interagir avec la classe personnage dans ta classe comabt tout en ayant des fichier séparé pour les deux.

      Voilà j'espère que ca répond à ta question.
      • Partager sur Facebook
      • Partager sur Twitter
        25 février 2007 à 11:17:30

        Plop! Merci d'avoir répondu :D

        Je ne suis pas sûre d'avoir bien compris ta réponse...
        Je reessai de résumer:

        J'ai une interface contenant toutes les actions pouvant êtres exécutées par le personnage.
        Je voudrais avoir une class qui implémente cette interface avec toutes les actions de bases, et une secondes class qui serait en quelquesorte liée à cette première contenant les actions "avancées" (le combat en gros) dans le seul but de séparer mes différentes actions par type dans différents fichiers pour des raisons de lisibilité.

        Mais la première class (celle contenant les actions de base) étant implémentée dans mon interface(qui contient toutes les actions que peut executer mon personnage) , eclipse me dit qu'elle doit impérativement contenir les méthodes déclarées dans cette interface (soit les methodes pour les actions de base et celles pour le combat) alors que moi je desire bien séparer mes methodes dans différentes class (qui seraient donc liées entre eux) pour ne pas avoir un gros bordel...

        En faite mon problème vient du faite que je ne sais pas comment lier mes classes de telle sorte que les méthodes de ma seconde class (class combat donc) soient accessible à ma première class (actions de bases).

        En gros une interface declarant toutes les methodes, une classe principale avec les methodes de bases, et une seconde avec les methodes avancées...
        • Partager sur Facebook
        • Partager sur Twitter
          25 février 2007 à 16:26:45

          je pense qu'en fait tu ne prend pas le problème dans le bon sens. si j'ai bien compris ce que tu veux, c'est un perso qui a des fonctions de bases, et un autre qui à des fonctions de combats en plus :p ........

          moi à mon sens un perso il a des caractéristiques et un équipement (imaginons) et on utilise ces donner là en combat c'est tout.

          mais bon pour revenir à ton problème. ici faut utiliser l'héritage en fait. en gros tu as ta classe de perso de base et ta classe de perso de comabt qui étend la classe de perso de base.. comme ca tu n'aura plus à te préocuper des actions de bases mais tu pourra toujours les utiliser comme si elle faisait partie de la classe.

          mais c'est à mon avis une très mauvaises utilisation de l'héritage.
          • Partager sur Facebook
          • Partager sur Twitter
            25 février 2007 à 18:23:53

            Recoucou :)
            Oui on est d'accord qu'il faudrait étendre la class combat à la class de base, c'est ce que je souhaite faire, mais le souci vient du faire que comme ma class de base implémente l'interface qui contient les methodes de base et de combat, alors eclipse me dit que il faut impérativement que la class de base contienne toute les methodes déclarées dans l'interface soit base + combat.

            Toi si tu voulais avoir une interface contenant toutes les méthodes, une class gérant les methodes de bases et une autre gérant les methodes de combat comment tu lierais tes classes?
            • Partager sur Facebook
            • Partager sur Twitter

            [JAVA]Problème modularité des classes

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
            • Editeur
            • Markdown