implementation de membre abstrait herité

Version imprimable

bonsoir mon question consiste à l'implementation de membre abstraite herite.je créer deux classe et j'ecrire un classe abstraite et un autre classe qui hérite de la premier quelque membre et methode et pas tous les membre et tous le methode.
Code:

1 2 3 4 5 6 7 8 9 10 abstract class personnage { public abstract bool EstVivant { get; } public abstract void attaque(personnage personne); public abstract void Subitdegats(int valeur); public int LanceleDE() { return De.LanceLeDe(); } }
et le deuxieme classe:
Code:

1 2 3 4 5 6 7 8 9 10 class personnageAPointsdeVie : personnage { public int PtsDeVies { get; private set; } public override bool EstVivant { get { return PtsDeVies > 0; } } public void LanceleDe(int valeur) { } }
aprés le deboguage je trouve deux erreurs
1-Error 1 'personnageAPointsdeVie' does not implement inherited abstract member 'personnage.Subitdegats(int)'
2-Error 2 'personnageAPointsdeVie' does not implement inherited abstract member 'personnage.attaque(personnage)'

je comprend ces deux erreur que signfie, et pourcela je pose ma question.est ce que c'est obligatoire d'utiliser tous les propriété et methode abstraite lorsqu'on herite ce classe abstraite?

Si tu déclare des membres abstract dans un class abstract, la classe qui en dérive doit les implémentés.

Si tu as une class qui en dérive et dont tu n'a pas besoin de ses membres c'est que tu as peut être un problème de structure de tes classes.

Tu peux envisager plusieurs dériver abstract, mais je pense plus que ta structure est à revoir, pourrai tu nous expliquer comment ça fonctionne (à quoi sert les classes)?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    abstract class personnagebase
    {
        public virtual bool EstVivant { get; }
        public int LanceleDE()
        {
            return De.LanceLeDe();
        }
    }
 
    abstract class personnageAvecDegat : personnagebase
    {
        public abstract void attaque(personnageAvecDegat personne);
        public abstract void Subitdegats(int valeur);
    }
 
    class personnageAPointsdeVie : personnagebase
    {
        public int PtsDeVies { get; private set; }
        public override bool EstVivant
        {
            get { return PtsDeVies > 0; }
        }
        public void LanceleDe(int valeur) { }
    }

02/03/2016, 19h08
wallace1

Bonsoir,

Comme évoqué supra par ericlm128 (au regards de la constitution de tes classes) tu es certainement parti sur de mauvaises bases :

On peut comprendre qu'il existe certainement une autre classe qui se nomme "Personnage" dans laquelle tu pourrais avoir les propriétés suivantes : Name, Avatar, Age, Team, etc.....

Il serait judicieux de se tourner vers les interfaces our palier à ce problème d'héritage et de visibilité de membres.

A+
03/03/2016, 12h51
ammar.dev

Citation:

Envoyé par wallace1

Bonsoir,

Comme évoqué supra par ericlm128 (au regards de la constitution de tes classes) tu es certainement parti sur de mauvaises bases :

On peut comprendre qu'il existe certainement une autre classe qui se nomme "Personnage" dans laquelle tu pourrais avoir les propriétés suivantes : Name, Avatar, Age, Team, etc.....

Il serait judicieux de se tourner vers les interfaces our palier à ce problème d'héritage et de visibilité de membres.

A+

merci pour vos remarques, je suis debutant au C# et j'essaye de comprendre le notions d'orienté objet et je trouve un exercice pour le faire. Dans le schema il me demande de faire l'heritage de classe personnage et classe PersonnageAPointsDeVie, et il m'oblige d'ecrire des methode abraite, en plus dans le cours il me dit

Citation:

Si une classe possède une méthode abstraite, alors la classe doit absolument être abstraite. L’inverse n’est pas vrai
03/03/2016, 13h13
ericlm128

Citation:

Si une classe possède une méthode abstraite, alors la classe doit absolument être abstraite. L’inverse n’est pas vrai

Oui ça parait logique
03/03/2016, 13h32
ammar.dev

2 pièce(s) jointe(s)

Citation:

Envoyé par ericlm128

Oui ça parait logique

mais dans le contrainte de schema ne se fait pas?
Pièce jointe 202744
Pièce jointe 202745
03/03/2016, 17h18
ericlm128

Au vu du schéma. Personnage est obligatoire abstract.
Personnageapointvie doit implémenter les méthode abstract de personnage puisqu'il en hérite (attaque et subitdegat).
Même si ce n'est pas dit explicitement c'est obligatoire.
03/03/2016, 18h25
ericlm128

As tu lu et comprit le cours sur lequel se base ton exercice ?

l'exercice se base sur ce code source.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
namespace ActiviteOrienteObjet
{
    class Program
    {
        private static Random random = new Random();
 
        static void Main(string[] args)
        {
            AfficheMenu();
            ConsoleKeyInfo consoleKeyInfo = Console.ReadKey(true);
            while (consoleKeyInfo.Key != ConsoleKey.D1 && consoleKeyInfo.Key != ConsoleKey.D2 && consoleKeyInfo.Key != ConsoleKey.NumPad1 && consoleKeyInfo.Key != ConsoleKey.NumPad2)
            {
                AfficheMenu();
                consoleKeyInfo = Console.ReadKey(true);
            }
            if (consoleKeyInfo.Key == ConsoleKey.D1 || consoleKeyInfo.Key == ConsoleKey.NumPad1)
                Jeu1();
            else
                Jeu2();
        }
 
        private static void AfficheMenu()
        {
            Console.Clear();
            Console.WriteLine("Veuillez choisir votre mode de jeu :");
            Console.WriteLine("\t1 : Contre les monstres");
            Console.WriteLine("\t2 : Contre le boss de fin");
        }
        private static void Jeu1()
        {
            Joueur nicolas = new Joueur(150);
            int cptFacile = 0;
            int cptDifficile = 0;
            while (nicolas.EstVivant)
            {
                MonstreFacile monstre = FabriqueDeMonstre();
                while (monstre.EstVivant && nicolas.EstVivant)
                {
                    nicolas.Attaque(monstre);
                    if (monstre.EstVivant)
                        monstre.Attaque(nicolas);
                }
 
                if (nicolas.EstVivant)
                {
                    if (monstre is MonstreDifficile)
                        cptDifficile++;
                    else
                        cptFacile++;
                }
                else
                {
                    Console.WriteLine("Snif, vous êtes mort...");
                    break;
                }
            }
            Console.WriteLine("Bravo !!! Vous avez tué {0} monstres faciles et {1} monstres difficiles. Vous avez {2} points.", cptFacile, cptDifficile, cptFacile + cptDifficile * 2);
        }
 
        private static MonstreFacile FabriqueDeMonstre()
        {
            if (random.Next(2) == 0)
                return new MonstreFacile();
            else
                return new MonstreDifficile();
        }
 
 
        private static void Jeu2()
        {
            Joueur nicolas = new Joueur(150);
            BossDeFin boss = new BossDeFin(250);
            while (nicolas.EstVivant && boss.EstVivant)
            {
                nicolas.Attaque(boss);
                if (boss.EstVivant)
                    boss.Attaque(nicolas);
            }
            if (nicolas.EstVivant)
                Console.WriteLine("Bravo, vous avez sauvé la princesse (ou le prince !)");
            else
                Console.WriteLine("Game over...");
        }
    }
 
    public static class De
    {
        private static Random random = new Random();
 
        public static int LanceLeDe()
        {
            return random.Next(1, 7);
        }
 
        public static int LanceLeDe(int valeur)
        {
            return random.Next(1, valeur);
        }
    }
 
    public class MonstreFacile
    {
        private const int degats = 10;
        public bool EstVivant { get; private set; }
 
        public MonstreFacile()
        {
            EstVivant = true;
        }
 
        public virtual void Attaque(Joueur joueur)
        {
            int lanceMonstre = LanceLeDe();
            int lanceJoueur = joueur.LanceLeDe();
            if (lanceMonstre > lanceJoueur)
                joueur.SubitDegats(degats);
        }
 
        public void SubitDegats()
        {
            EstVivant = false;
        }
 
        public int LanceLeDe()
        {
            return De.LanceLeDe();
        }
    }
 
    public class MonstreDifficile : MonstreFacile
    {
        private const int degatsSort = 5;
 
        public override void Attaque(Joueur joueur)
        {
            base.Attaque(joueur);
            joueur.SubitDegats(SortMagique());
        }
 
        private int SortMagique()
        {
            int valeur = De.LanceLeDe();
            if (valeur == 6)
                return 0;
            return degatsSort * valeur;
        }
    }
 
    public class Joueur
    {
        public int PtsDeVies { get; private set; }
        public bool EstVivant
        {
            get { return PtsDeVies > 0; }
        }
 
        public Joueur(int points)
        {
            PtsDeVies = points;
        }
 
        public void Attaque(MonstreFacile monstre)
        {
            int lanceJoueur = LanceLeDe();
            int lanceMonstre = monstre.LanceLeDe();
            if (lanceJoueur >= lanceMonstre)
                monstre.SubitDegats();
        }
 
        public void Attaque(BossDeFin boss)
        {
            int nbPoints = LanceLeDe(26);
            boss.SubitDegats(nbPoints);
        }
 
        public int LanceLeDe()
        {
            return De.LanceLeDe();
        }
 
        public int LanceLeDe(int valeur)
        {
            return De.LanceLeDe(valeur);
        }
 
        public void SubitDegats(int degats)
        {
            if (!BouclierFonctionne())
                PtsDeVies -= degats;
        }
 
        private bool BouclierFonctionne()
        {
            return De.LanceLeDe() <= 2;
        }
    }
 
    public class BossDeFin
    {
        public int PtsDeVies { get; private set; }
        public bool EstVivant
        {
            get { return PtsDeVies > 0; }
        }
 
        public BossDeFin(int points)
        {
            PtsDeVies = points;
        }
 
        public void Attaque(Joueur personnage)
        {
            int nbPoints = LanceLeDe(26);
            personnage.SubitDegats(nbPoints);
        }
 
        public void SubitDegats(int valeur)
        {
            PtsDeVies -= valeur;
        }
 
        private int LanceLeDe(int valeur)
        {
            return De.LanceLeDe(valeur);
        }
    }
}

c'est une code source de jeu monstre qui nous demande d'améliorer le code.
voilà leur enoncé:

Citation:

Le but de cette activité est que vous remaniez le code du jeu à partir de vos connaissances en POO, afin de le rendre plus lisible et plus facile à maintenir.
Votre objectif : remanier ce fichier pour maximiser la réutilisation du code, manipuler les classes abstraites et pousser à fond l’héritage.

Le code tel que vous allez le trouver fonctionne (enfin, j’espère ^^), mais vous allez pouvoir tirer parti de l’orienté objet pour factoriser du code dupliqué.
On se rend compte que le joueur attaque le monstre facile de la même façon que le monstre difficile et que les monstres attaquent le joueur quasiment de cette même façon. Les lancers de dé se ressemblent ...De même, le boss de fin et le joueur partagent le fait d’avoir des points de vie… Bref, ça vaudrait le coup de faire dériver certaines classes entre elles ! Vous allez devoir :
1.Créer de nouvelles classes structurées
2.Inclure dans ces nouvelles classes les méthodes et fonctionnalités nécessaires.
Et voilà, si tout a bien été fait, les modes de jeu ne doivent pas changer suite au remaniement (on parle également de refactoring en anglais).

pour moi j'atteint à ecrire ces cinque classe et je ne sais pas est-ce que c'est vrai ce chemin ou pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
abstract class personnage
    {
       public abstract bool EstVivant { get; set; }
       public abstract void attaque(personnage personne);
        public abstract void Subitdegats(int valeur);
        public abstract void Subitdegats();
        public int LanceleDE()
        {
            return De.LanceLeDe();
        }
    }
 
class personnageAPointsdeVie : personnage
   {
       public int PtsDeVies { get;  set; }
       public override bool EstVivant
       {
           get { return PtsDeVies > 0; }
       }
       public int LanceleDe(int valeur) { return base.LanceleDE(); }
       public override void attaque(personnage personne) { }
       public override void Subitdegats(int valeur) { }
       public override void Subitdegats() { }
 
   }
 class Joueur : personnageAPointsdeVie
   {
       public Joueur(int points)
       {
           base.PtsDeVies = points;
       }
       public override void Attaque(personnage personne)
       {
           int lanceJoueur = base.LanceleDE();
           int lanceMonstre = personne.LanceleDE();
           if (lanceJoueur >= lanceMonstre)
               personne.Subitdegats();
 
 
       }
   }
class MonstreFacile : personnage
   {
       private const int degats = 10;
 
       public MonstreFacile()
       {
           EstVivant = true;
       }
       public override void Attaque(personnage personne)
       {
           int lanceMonstre = base.LanceleDE();
           int lanceJoueur = personne.LanceleDE();
           if (lanceMonstre > lanceJoueur)
               personne.Subitdegats(degats);
       }
       public override void Subitdegats()
       {
           EstVivant = false;
       }
       public void LanceLeDe()
       {
           base.LanceleDE();
       }
   }
 
 public static class De
   {
       private static Random random = new Random();
 
       public static int LanceLeDe()
       {
           return random.Next(1, 7);
       }
 
       public static int LanceLeDe(int valeur)
       {
           return random.Next(1, valeur);
       }
   }

j'attend vos remarque s'ils vous plait