Etendre les états d'une classe.

Bonjour,

Je me pose une question sur la gestion des états d'une classe et de ces classes filles.
Si les états doivent être identiques entre mère et filles: pas de soucis j'utilise un enum,
mais dans le cas contraire j'ai un pb.

Les enums ne peuvent être étendu et ne souhaitant pas utiliser de simples int pour coder les états
j'ai pensé passer par des classes "état" internes à la classe .
Chaque nouvel état étend une superClasse état et les états atteignables sont stockés dans une ArrayList spécialisée.

Je joins un exemple de ce que cela peut donner sur un cas trivial de boite de vitesse (pas très réaliste j'en conviens mais ce n'est pas la finalité).

Si vous avez des remarques et/ou des idées pour améliorer la façon de faire je suis preneur car il y quelques points qui ne me satisfont pas.

merci,

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
package main;
 
public interface IBoiteDeVitesses {
 
    public float calculerVitesseEnSortie(float vitesseEnEntree_in);
    public void passerMarcheArriere();
    public void passerPointMort();
 
    public interface IBoiteDeVitessesManuelle4Rapports extends IBoiteDeVitesses{
        public void passerPremierRapport();
        public void passerSecondRapport();
        public void passerTroisiemeRapport();
        public void passerQuatriemeRapport();
    }
 
    public interface IBoiteDeVitessesManuelle5Rapports extends IBoiteDeVitessesManuelle4Rapports{
        public void passerCiquiemeRapport();
    }
 
    public interface IBoiteDeVitessesManuelle6Rapports extends IBoiteDeVitessesManuelle5Rapports{
        public void passerSixiemeRapport();
    }
 
    public interface IBoiteDeVitessesAutomatique extends IBoiteDeVitesses{
        public void passerMarcheAvant();
    }
 
    public interface IBoiteDeVitessesSequentielle extends IBoiteDeVitesses{
        public void monterUnRapport();
        public void descendreUnRapport();
    }
 
}

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
package main;
 
import java.util.*;
 
public abstract class CBoiteDeVitesses implements IBoiteDeVitesses {
 
    protected static class Rapport{}    
    protected static class MarcheArriere extends Rapport{}
    protected static class PointMort extends Rapport{}
    protected static class MarcheAvant extends Rapport{}
    protected final static MarcheArriere marcheArriere=new MarcheArriere();
    protected final static PointMort pointMort=new PointMort();
    protected final static MarcheAvant marcheAvant=new MarcheAvant();
 
    private static ArrayList<Rapport> rapportsAuthorises;
    protected int rapportSelectionne=0;
    protected final float[] demultiplications;
 
    public CBoiteDeVitesses(float[] demultiplications_in){
        this.demultiplications=demultiplications_in;
        this.rapportsAuthorises=new ArrayList<Rapport>();
        this.rapportsAuthorises.add(this.marcheArriere);
        this.rapportsAuthorises.add(this.pointMort);
        this.rapportsAuthorises.add(this.marcheAvant); 
    }
 
    protected void verifierCoherance() throws Exception{
        boolean returnValue=false;
        if(
            (this.demultiplications==null)||
            (this.getRapportsAuthorises()==null)||
            (this.demultiplications.length!=this.getRapportsAuthorises().size())
        ){
            throw new Exception("Incoherance entre le nombre de rapports et le nombre de demultiplications!");
        }
    }
 
    protected ArrayList<Rapport> getRapportsAuthorises(){
        return this.rapportsAuthorises;
    }
 
    protected void passerRapport(Rapport nouveauRapport){
        if(this.getRapportsAuthorises().contains(nouveauRapport)){
            this.rapportSelectionne=this.getRapportsAuthorises().indexOf(nouveauRapport);           
        }
    }
 
    protected Float getDemultiplication(){
        Float returnedValue=null; 
        if((this.rapportSelectionne>=0)&&(this.rapportSelectionne<this.demultiplications.length))
            returnedValue=this.demultiplications[this.rapportSelectionne];
        return returnedValue;
    }
 
    protected void monterUnRapport(){
        if(this.getRapportsAuthorises().get(this.rapportSelectionne) instanceof MarcheAvant){
            if(
                (this.rapportSelectionne>1)&&
                (this.rapportSelectionne<this.demultiplications.length-1)
            ){
                this.passerRapport(this.getRapportsAuthorises().get(this.rapportSelectionne+1));
            }
        }
    }
 
    protected void descendreUnRapport(){
        if(this.getRapportsAuthorises().get(this.rapportSelectionne) instanceof MarcheAvant){
            if(
                (this.rapportSelectionne>2)&&
                (this.rapportSelectionne<this.demultiplications.length)
            ){
                this.passerRapport(this.getRapportsAuthorises().get(this.rapportSelectionne-1));
            }
        }
    }
 
    protected void adapterRapportALaVitesseEnEntree(float vitesseEnEntree_in){
        /* L'implementation de cette methode n'a pas pour but d'etre realiste */
        /* En dessous de 1000t/mn on descend d'un rapport */
        if(vitesseEnEntree_in<1000){
            this.descendreUnRapport();
        /* Au dessus de 5000t/mn on monte d'un rapport */
        }else if(vitesseEnEntree_in>5000){
            this.monterUnRapport();
        }
    }
 
    public float calculerVitesseEnSortie(float vitesseEnEntree_in){
        return(vitesseEnEntree_in*this.getDemultiplication());
    }
 
    protected float calculerVitesseEnSortieAvecAdaptation(float vitesseEnEntree_in){
        this.adapterRapportALaVitesseEnEntree(vitesseEnEntree_in);
        return(vitesseEnEntree_in*this.getDemultiplication());
    }
 
    public void passerMarcheArriere(){
        this.passerRapport(this.marcheArriere);
    }
 
    public void passerPointMort(){
        this.passerRapport(this.pointMort);
    }
 
    protected void passerMarcheAvant(){
        this.passerRapport(this.marcheAvant);
    }
 
}

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
package main;
 
import java.util.*;
 
public abstract class CBoiteDeVitesses4Rapports
    extends CBoiteDeVitesses{
 
    protected static class PremierRapport extends MarcheAvant{}
    protected static class SecondRapport extends MarcheAvant{}
    protected static class TroisiemeRapport extends MarcheAvant{}
    protected static class QuatriemeRapport extends MarcheAvant{}
    protected final static PremierRapport premierRapport=new PremierRapport();
    protected final static SecondRapport secondRapport=new SecondRapport();
    protected final static TroisiemeRapport troisiemeRapport=new TroisiemeRapport();
    protected final static QuatriemeRapport quatriemeRapport=new QuatriemeRapport();
 
    private static ArrayList<Rapport> rapportsAuthorises;
 
    public CBoiteDeVitesses4Rapports(float[] demultiplications_in){
        super(demultiplications_in);
        this.rapportsAuthorises=new ArrayList<Rapport>();
        this.rapportsAuthorises.add(this.marcheArriere);
        this.rapportsAuthorises.add(this.pointMort);
        this.rapportsAuthorises.add(this.premierRapport);  
        this.rapportsAuthorises.add(this.secondRapport);
        this.rapportsAuthorises.add(this.troisiemeRapport);
        this.rapportsAuthorises.add(this.quatriemeRapport);
    }
 
    protected ArrayList<Rapport> getRapportsAuthorises(){
        return this.rapportsAuthorises;
    }
 
    protected void passerMarcheAvant(){
        this.passerPremierRapport();
    }
    protected void passerPremierRapport(){
        this.passerRapport(this.premierRapport);
    };
    protected void passerSecondRapport(){
        this.passerRapport(this.secondRapport);
    };
    protected void passerTroisiemeRapport(){
        this.passerRapport(this.troisiemeRapport);
    };
    protected void passerQuatriemeRapport(){
        this.passerRapport(this.quatriemeRapport);
    };
}

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
 
package main;
 
import java.util.*;
 
public class CBoiteDeVitessesManuelle4Rapports 
    extends CBoiteDeVitesses4Rapports
    implements IBoiteDeVitesses.IBoiteDeVitessesManuelle4Rapports{
 
 
    public CBoiteDeVitessesManuelle4Rapports(float[] demultiplications_in){
        super(demultiplications_in);
    }
 
    public static CBoiteDeVitessesManuelle4Rapports creerBoiteDeVitessesStandard()
        throws Exception {
        CBoiteDeVitessesManuelle4Rapports returnedValue=null;
        float[] tmpDemultiplications={-1,0,1,2,3,4};
        returnedValue= new CBoiteDeVitessesManuelle4Rapports(tmpDemultiplications);
        returnedValue.verifierCoherance();
        return returnedValue;
    }
 
    public void passerPremierRapport(){
        super.passerPremierRapport();
    };
    public void passerSecondRapport(){
        super.passerSecondRapport();
    };
    public void passerTroisiemeRapport(){
        super.passerTroisiemeRapport();
    };
    public void passerQuatriemeRapport(){
        super.passerQuatriemeRapport();
    };
}

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
package main;
 
public class CBoiteDeVitessesAutomatique4Rapports
    extends CBoiteDeVitesses4Rapports
        implements IBoiteDeVitesses.IBoiteDeVitessesAutomatique{
 
    public CBoiteDeVitessesAutomatique4Rapports(float[] demultiplications_in){
        super(demultiplications_in);
    }
 
    public static CBoiteDeVitessesAutomatique4Rapports creerBoiteDeVitessesStandard()
    throws Exception {
        CBoiteDeVitessesAutomatique4Rapports returnedValue=null;
        float[] tmpDemultiplications={-1,0,1,2,3,4};
        returnedValue= new CBoiteDeVitessesAutomatique4Rapports(tmpDemultiplications);
        returnedValue.verifierCoherance();
        return returnedValue;
    }
 
    public void passerMarcheAvant(){
        super.passerMarcheAvant();
    }
 
    public float calculerVitesseEnSortie(float vitesseEnEntree_in){
        return this.calculerVitesseEnSortieAvecAdaptation(vitesseEnEntree_in);
    }   
}

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
package main;
 
public class CBoiteDeVitessesSequentielle4Rapports
    extends CBoiteDeVitesses4Rapports
        implements IBoiteDeVitesses.IBoiteDeVitessesSequentielle{
 
    public CBoiteDeVitessesSequentielle4Rapports(float[] demultiplications_in){
        super(demultiplications_in);
    }
 
    public static CBoiteDeVitessesSequentielle4Rapports creerBoiteDeVitessesStandard()
    throws Exception {
        CBoiteDeVitessesSequentielle4Rapports returnedValue=null;
        float[] tmpDemultiplications={-1,0,1,2,3,4};
        returnedValue= new CBoiteDeVitessesSequentielle4Rapports(tmpDemultiplications);
        returnedValue.verifierCoherance();
        return returnedValue;
    }
 
    public void monterUnRapport(){
        super.monterUnRapport();
    }
    public void descendreUnRapport(){
        super.descendreUnRapport();
    };
}