simplifier ce code?

Version imprimable

simplifier ce code?

pensez-vous qu'on puisse simplifier ce code ?

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
 
 
 
public class retourDebut {
 
    public static void main(String[] args) {
 
 
        Cas A = new Cas("A");
        Cas B = new Cas("B");
        Cas C = new Cas("C");
 
        A.setCaseSuivant(B);
        B.setCaseSuivant(C);
        C.setCaseSuivant(A);
 
        A.setPasDe(2);//on souahite avance de 2 par rapport au A
        Cas obj = A;
        System.out.println("je suis l'objet:" + obj.monNom());
 
        System.out.println("je souhaite avancer de:" + obj.getPasRestant());
        boolean trouve = true;
        while (trouve) {
            System.out.println("je suis à la case :" + obj.monNom());
            Cas obj_next = obj.getCaseSuivant();
            System.out.println("la case suivant est :" + obj_next.monNom());
            System.out.println("pas restant :" + obj_next.getPasRestant());
            obj = obj_next;
            obj.moinPas();
            if (obj.getPasRestant() <=0) {
                trouve = false;
            }
        }
            System.out.print("case arrivé :: " + obj.monNom());
        // Tourtable start = new Tourtable();
    }
 
}
 
class Cas {
 
    private static int pas_restant;
 
    private String nom_case;
 
    private Cas case_suivant;
 
    public Cas(String nom) {
 
        nom_case = nom;
    }
 
    public void moinPas()
    {
        pas_restant --;
    }
 
    public String monNom() {
        return nom_case;
    }
 
    public int getPasRestant() {
        return Cas.pas_restant;
    }
 
    public void setCaseSuivant(Cas case_suivant) {
 
        this.case_suivant = case_suivant;
 
    }
 
    public Cas getCaseSuivant() {
 
        return case_suivant;
 
    }
 
    public void setPasDe(int pas) {
        pas_restant = pas;
    }
 
}

merci de la réponse :)

Salut,

J'ai amélioré le nom des variables et méthodes, corrigé les petites violations des conventions de nommage en Java et simplifié quelques bouts. J'ai également passé le nombre de pas restants en non static car ça me semblait beaucoup plus logique. Dernier gros changement, la méthode moinPas qui n'était pas très utile, que j'ai remplacée par nextStep() qui modifie en même temps la valeur de caseSuivante comme ça pas besoin de faire obj = obj_next, ce qui t'obligeait à mettre ton nombre de pas en static mais qui n'était pas du tout logique à mon sens.

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
 
public class RetourDebut {
 
	public static void main(String[] args) {
 
		Cas A = new Cas("A");
		Cas B = new Cas("B");
		Cas C = new Cas("C");
 
		A.setCaseSuivante(B);
		B.setCaseSuivante(C);
		C.setCaseSuivante(A);
 
		A.setPasRestants(2);// on souahite avance de 2 par rapport au A
 
		Cas obj = A;
		System.out.println("Je souhaite avancer de : " + obj.getPasRestants());
		do {
			System.out.println("Je suis à la case : " + obj.getNomCase());
			System.out.println("La case suivante est :" + obj.getCaseSuivante().getNomCase());
 
			obj.nextStep();
			System.out.println("Pas restants : " + obj.getPasRestants());
		} while (obj.getPasRestants() > 0);
		System.out.print("Case d'arrivée : " + obj.getNomCase());
	}
 
}
 
class Cas {
 
	private int pasRestants;
	private String nomCase;
	private Cas caseSuivante;
 
	public Cas(String nom) {
		nomCase = nom;
	}
 
	public void nextStep() {
		if (caseSuivante != null) {
			nomCase      = caseSuivante.getNomCase();
			caseSuivante = caseSuivante.getCaseSuivante();
			pasRestants --;
		}
	}
 
	public String getNomCase() {
		return nomCase;
	}
 
	public int getPasRestants() {
		return pasRestants;
	}
 
	public void setPasRestants(int pas) {
		pasRestants = pas;
	}
 
	public void setCaseSuivante(Cas caseSuivante) {
		this.caseSuivante = caseSuivante;
	}
 
	public Cas getCaseSuivante() {
		return caseSuivante;
	}
}

On peut simplifier le début en faisant en sorte que les void retournent this :
Code:

1 2 3 4 5 6 7 public Cas setPasRestants(int pas) { pasRestants = pas; return this; } public Cas setCaseSuivante(Cas caseSuivante) { this.caseSuivante = caseSuivante; return this; }
Du coup le début de "main" devient :
Code:

1 2 3 4 5 6 7 8 public static void main(String[] args) { Cas C = new Cas("C"); Cas obj = new Cas ("A") .setCaseSuivante(new Cas("B") .setCaseSuivante(C)) .setPasRestants(2); C.setCaseSuivante(obj); System.out.println("Je souhaite avancer de : " + obj.getPasRestants());
Perso je préfère comme ça, mais bon, ce n'est pas du goût de tout le monde.

Après, au lieu de obj.nextStep(), la logique serait d'écrire plutôt

Code:

obj = obj.getCaseSuivante();

(ou même

Code:

obj = obj.caseSuivante;

si on renonce à mettre tout en private). Du coup la méthode "nextStep" disparaît.

Je ne garantis pas qu'il n'y a pas d'erreur, mais bon c'est l'idée générale.