Programmation java

Qu'est-ce que c'est "un générateur de code java" ?
Qu'est-ce que tu as dans ta feuille Excel, quelles données, quel format ?
Qu'est-ce que c'est le "code Java" que tu veux obtenir ?

Franchement t'aider, on est là pour ça, mais là... il va falloir expliquer beaucoup mieux ton problème, nous dire ce que tu as déjà fait, et où tu bloques !

Je te remercie de m'avoir répondu,

En fait,j'ai représenté automate composé de trois états, trois événements et de trois transitions sur une feuille excel.Tels que les états sont représentés sur les lignes et les événements sur les colonnes,à l'intersection d'une ligne et d'une colonne est représentée la transition.

Ce que je veux faire et de:

* lire l' automate représenté par une feuille excel en java (déjà fait);

*Intégrer le code pour chaque fichier excel crée (les éléments de l'automate),

* générer le code java correspondant sur la base du patron de conception Etat.

Montre moi un exemple, de que tu as dans ta feuille, de comment tu le lis (comment tu le stocke en mémoire) et surtout qu'est-ce que tu veux en faire ?
Tu t'en serviras comment de cet automate ? pour en faire quoi ?
C'est quoi ton "patron de conception d'état" ?

Toutes ces questions je te les ai déjà posé (en vain) il y a deux mois, il va bien falloir que tu y répondes si tu veux de l'aide !!!

Si on prend un exemple d'un feu tricolores composé de trois états: rouge, jaune et vert.
Et on essaye de lui appliquer le patron de conception état qui nous évite l'utilisation des instructions if/else et switch - case on aura la solution suivante qu'on a implémenté en java de cette manière :

IState interface:

1. interface ITrafficLightState
2. {
3. void Handle(TrafficLight trafficLight);
4. }

State implementations:

1. // State "Red Light"
2. class RedLightState : ITrafficLightState
3. {
4. public void Handle(TrafficLight trafficLight)
5. {
6. trafficLight.Color = "Red"; // Switch the traffic light color
7. trafficLight.Pause = 5; // For 5 seconds
8. trafficLight.NextState = new GreenLightState(); // Then green light follows
9. }
10. }
11.
12. // State "Amber Light"
13. class AmberLightState : ITrafficLightState
14. {
15. public void Handle(TrafficLight trafficLight)
16. {
17. trafficLight.Color = "Amber"; // Switch the traffic light color
18. trafficLight.Pause = 2; // For 2 seconds
19. trafficLight.NextState = new RedLightState(); // Then red light follows
20. }
21. }
22.
23. // State "Green Light"
24. class GreenLightState : ITrafficLightState
25. {
26. public void Handle(TrafficLight trafficLight)
27. {
28. trafficLight.Color = "Green"; // Switch the traffic light color
29. trafficLight.Pause = 5; // For 5 seconds
30. trafficLight.NextState = new AmberLightState(); // Then Amber light follows
31. }
32. }

TrafficLight context object:

1. // Context - "Traffic Light", has internal state - one of the above.
2. // The behaviour changes accordingly to the current state
3. class TrafficLight
4. {
5. // Has properties that define it's behaviour
6. public int Pause { get; set; }
7. public string Color { get; set; }
8.
9. // Has internal State
10. public ITrafficLightState NextState { get; set; }
11.
12. // Sets the default state
13. public TrafficLight()
14. {
15. this.NextState = new RedLightState();
16. }
17.
18.
19. // Receives request ...
20. public void Request()
21. {
22. // ... then:
23. // Delegates to the internal State to handle.
24. NextState.Handle(this);
25.
26. // The behaviour has changed, color, time of light, etc.
27. Console.WriteLine(Color);
28. System.Threading.Thread.Sleep(Pause * 1000);
29. }
30. }

sur la feuille excel je représente cet exemple tel que sur chaque ligne je met les états et sur chaque colonne je met les événements qui provoquent le changement d'état et à l'intersection d'une ligne et d'une colonne je représente la transition.
Pour lire cette feuille j'ai utilisé l'API Jexcel.
Après je veux sur mon programme créer un fichier java pour chaque élément lu à partir de la feuille excel et importer le code déjà écris en java basé sur le patron état: je m'explique : par exemple lorsque je crée la classe qui correspond à l'état « Green LightState» je crée le fichier qu'il lui correspond puis je fais: writeln("public class "+ "GreenLightState" +"extends ItrafficLightState;" et ainsi de suite jusqu'à ce je termine tout le code qui correspondant à cet état. Puis je fais la même chose pour tout éléments représenté sur la feuille excel.
Le but du générateur est de générer à l'exécution les classes correspondantes aux élément qu'on ajoute au fur et à mesure sur notre feuille excel automatiquement.
J'espère que j'ai bien expliqué cette fois ci et e te remercie d'avance .

En fait, le feu tricolore n'est qu'un exemple, ça peut être n'importe quel automate, le commun entre eux c'est que chaque automate est constitué d'un ensemble d'états, d'un ensemble de transitions et d'un ensemble d'événements, puisque dans le patron état, nous trouvons la classe contexte qui nous renvoie l'état futur de notre automate, et l'interface State (dans l'exemple c'est ITrafficLightState) sera implémentée dans tous les états possible de n'importe quel automate.

Concernant ma feuille excel, je représente mon automate et en particulier le feu tricolore sous forme de tableau, tels que sur les lignes je met les différent états de l'automate, sur les colonnes je met les événements et l'intersection d'une ligne et d'une colonne je met la transition, pour pouvoir lire le contenu, je parcours les lignes et les colonnes de ma feuille excel et je lit le contenu des cellules tant qu'il y a un élément à lire.

Clairement ton code laisse apparaître de nombreuses méconnaissances...

Déjà ton code est loin d'être du Java correct, l'utilisation des interfaces paraît inutiles et leur utilisation ressemble plus à de l'héritage C++
Surtout, je t'ai plusieurs fois demandé de me montrer un exemple de fichier Excel, mais peut-être n'en a tu pas vraiment déjà de fait, car c'est assez compliqué de mettre toutes les informations dans un seul tableau...
J'ai donc pris un peu de liberté par rapport à ton code, voici un "patron" qui pourrait être utilisé, mais je ne sais pas si cela suffit puisque je ne sais pas comment tu veux t'en servir après.
Remarque : pour l'instant ça ne génère rien automatiquement, mais c'est pour avoir une idée claire de ce qu'il faut faire...

Tout d'abord quelques classes génériques, dont hériteront toutes les classes générées automatiquement.

import java.util.HashMap; 

/**  
 * Un Etat représente un ensemble d'attributs et leurs valeurs. 
 */ 
public class Etat extends HashMap<String,Object> 
{ 
    private static final long serialVersionUID = 1L; 
} 

/** 
 * Un évènement qui permet de passer d'un Etat à un autre. 
 */  
public class Evenement 
{ 
} 

/** 
 * Représentation du graphe des transitions d'un état à un autre état. 
 * @param <E> le type des etats de l'automate 
 */ 
public abstract class Automate<E extends Etat> extends HashMap<E,HashMap<Evenement,E>> 
{ 
    private static final long serialVersionUID = 1L; 

    /** 
     * @return l'état de l'automate au départ, en l'absence d'évènements 
     */ 
    abstract E depart(); 
         
    /** 
     * Ajoute une transition entre deux états pour un évenement donné. 
     * @param evenement l'évenement qui provoque la transition 
     * @param avant l'état de l'automate avant l'évenement 
     * @param apres l'état de l'automate après l'évenement 
     */ 
    public final void ajout(Evenement evenement,E avant,E apres) 
    { 
        if (!containsKey(avant)) 
        { 
            put(avant, new HashMap<Evenement,E>()); 
        } 
         
        if (!containsKey(apres)) 
        { 
            put(apres, new HashMap<Evenement,E>()); 
        } 
         
        get(avant).put(evenement, apres); 
    } 
     
    /** 
     * Pour un état et un évènement donné, on récupère l'état associé. 
     * @param etat l'état donné de l'automate 
     * @param evt l'evenement donné de l'automate 
     * @return l'état généré par l'évenement, ou null si la transition n'existe pas 
     */ 
    public final E suivant(Etat etat, Evenement evt) 
    { 
        return get(etat).get(evt); 
    } 
}

Voici maintenant un exemple d'automate pour un feu tricolore.
Pour ne pas se mélanger les pinceaux, je les représente ici en deux tables, mais elles peuvent se regrouper en une seule.

Première table : Etat/Propriétés

        Pause  Couleur 
Vert    5      Vert 
Orange  2      Orange 
Rouge   5      Rouge

Deuxième table : Etat/Evenements

        Chrono 
Vert    Orange 
Orange  Rouge 
Rouge   Vert

Code qui serait généré automatiquement à partir des informations précédentes.

public class EtatFeuTricolore extends Etat 
{ 
    private static final long serialVersionUID = 1L; 
     
    /** 
     * Partie de code générable en lisant la première ligne de la première table. 
     */ 
    public final String PAUSE = "Pause"; 
    public final String COULEUR = "Couleur"; 
     
    public EtatFeuTricolore(Integer pause,String couleur) 
    { 
        super(); 
        put(PAUSE,pause); 
        put(COULEUR,couleur);         
    } 
} 

public class AutomateFeuTricolore extends Automate<EtatFeuTricolore> 
{ 
    private static final long serialVersionUID = 1L; 
     
    /** 
     * Partie de code générable en lisant les lignes de la première table. 
     */ 
    public final EtatFeuTricolore Vert  = new EtatFeuTricolore(5,"Vert"); 
    public final EtatFeuTricolore Orange= new EtatFeuTricolore(2,"Orange"); 
    public final EtatFeuTricolore Rouge = new EtatFeuTricolore(5,"Rouge"); 
         
    /** 
     * Partie de code générable en lisant la première ligne de la deuxième table. 
     */ 
    public Evenement Chrono = new Evenement(); 
         
    /** 
     * Partie de code générable en lisant les lignes de la deuxième table. 
     */ 
    public AutomateFeuTricolore() 
    { 
        super(); 
         
        ajout(Chrono,Vert,Orange); 
        ajout(Chrono,Orange,Rouge); 
        ajout(Chrono,Rouge,Vert); 
    } 

    @Override 
    EtatFeuTricolore depart()  
    { 
        return Vert; // le premier état décrit dans la table par exemple 
    } 
}

La confiance n'exclut pas le contrôle

Je te remercie pour ton aide bien que cela ne répond pas exactement à mes attentes, mais tu ma donné une idée.