IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

probleme de conception pour un Conway's life


Sujet :

avec Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut probleme de conception pour un Conway's life
    Bonjour,

    Voilà, j'essaye de programmer un Consway' s Life mais j'ai tout le mal du monde a concevoir le fonctionnement du programme.

    Pour le moment, je me suis attaqué a l'interface, voici ce que j'ai fait

    une classe MainWin qui herite de JFrame avec
    - BoderLayout
    - North, South, East, West sont des JPanel classiques. South contient un JButton pour demarrer l'appli.

    une classe Cellule avec
    - un constructeur minimaliste, avec juste 3 variables
    -> int posX;
    -> int posY;
    -> boolean vivante= false;

    - une methode paint qui dessine un rectangle de 5 par 5, couleur rouge ou noire selon que la cellule est vivante ou non

    une classe MondeCellule qui herite de JPanel avec un constructeur minimaliste. (rien de declaré pour le moment)

    Je mets une instance de MondeCellule dans MainWin.

    C'est tout pour le moment car je n'arrive pas a attaquer le probleme.
    --------------------------
    Apres lecture d'une page: http://www.mines.inpl-nancy.fr/~tiss...t/jeu_vie.html (j'ai prefere ne pas regarder le code) qui dit:
    1. une classe pour l'espace, le plan composé de cellules,
    2. une classe pour les objets cellules.

    Les fonctionnalités du plan, la classe "espace cellulaire" sont de :

    * encapsuler le tableau de cellules,
    * créer une population initiale, en créant ses objets "cellule",
    * faire tourner l'algorithme, c'est à dire boucler sur
    1. afficher l'automate,
    2. calculer la génération suivante ;
    * et de gérer l'attirail technique nécessaire au graphisme en Java et au séquencement des affichages.

    Cette classe accède aux cellules par les méthodes correspondant aux fonctionnalités de la classe "cellule" :

    * encapsuler les données sur la position géographique de la cellule et son état (occupé ou vide),
    * initialiser un objet cellule,
    * rendre occupée une cellule qui était vide,
    * savoir si une cellule est vide ou occupée,
    * calculer l'état à la génération suivante d'une cellule en fonction de son état et de son nombre de voisins,
    * mémoriser l'état d'une cellule pour que les calculs de changement de génération se fassent sur l'ancien état des cellules tout en créant le nouveau tableau des états,
    * et l'attirail technique pour afficher graphiquement la cellule.
    --------------------------

    je m'apercois qu'il me faut un tableau bidimensionnel (je ne souhaite pas pour le moment travailler avec des Vector ou LinkedList, etc, etc). Dc oui
    pour le tableau bidimensionnel, pas de probleme (enfin pas trop, je pense).

    mais j'ai pas mal de questions:
    1°: dans ma classe MondeCellule, pour afficher mes cellules, il me faut un LayoutManager??? je pense, oui, dc un simple GridLayout
    2°: la methode de recherche proprement dite.
    il faut bien qu'une Celllule interroge ses voisines pour savoir si elle doit vivre ou non mais dans une simple grille, y'a t'il differents types de voisines?
    je m'explique
    les Cellules au centre, ont 8 voisines
    celles sur les cotes ont seulement 5 voisines
    celles ds les coins ont 3 voisines
    en plus suivant ou se situe ma Cellule, les voisines ne sont pas placées au meme endroit
    si la Cellule est en bas alors on a:
    xxx
    x?x
    -----

    Si la Cellule est en haut c'est le contraire:
    -----
    x?x
    xxx

    et ainsi de suite

    est ce que je dois faire differentes methodes selon la place qu'occupe une Cellule?

    Enfin bref comme vous le voyez, je patauge, je patauge.

    Pourriez vous m'indiquer des pistes, des... conseils, je demande pas le code, juste une aide à la conception.

    En vous remerciant
    areuh

  2. #2
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut
    Encore moi,

    Bon j'ai fait qque chose mais evidemment, ca marche pas.

    Pour le moment, j'affiche dans la console et je pars avec comme objectif de faire un clignoteur simple en definissant moi meme mes 3 1° Cellules vivantes


    Voici le code de la classe MondeCellule.java

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
     
    import javax.swing.JPanel;
     
    import java.awt.GridLayout;
     
    public class MondeCellule extends JPanel {
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// variables
     
    	// CONSTANTE: cote du GridLayout
    	int COTE= 10;
     
    	// nbre de generation au debut de la simulation
    	int generation= 0;
     
    	Cellule[][] tabGenerationN= new Cellule[this.COTE][this.COTE];
    	Cellule[][] tabGenerationNMoinsUn= new Cellule[this.COTE][this.COTE];
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// objets crees/importes
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// constructeur
    	MondeCellule() {
    		this.setLayout(new GridLayout(this.COTE, this.COTE));
    		//--------------------------------------------------------------------------------------------------------
    		initCellules();
     
    		// creer la generation initiale
    		// this.tabGenerationN[3][0].etat= false; // n'est pas pris en compte ds la recherche
    		// this.tabGenerationN[3][1].etat= true;
    		this.tabGenerationN[3][2].etat= true;
    		this.tabGenerationN[3][3].etat= true;
    		this.tabGenerationN[3][4].etat= true;
    		/*
    		this.tabGenerationN[3][5].etat= true;
    		this.tabGenerationN[3][6].etat= true;
    		this.tabGenerationN[3][7].etat= true;
    		this.tabGenerationN[3][8].etat= true;
    		this.tabGenerationN[3][9].etat= false; // n'est pas pris en compte ds la recherche
    		*/
    		/*
    		this.tabGenerationN[0][3].etat= false; // n'est pas pris en compte ds la recherche
    		this.tabGenerationN[1][3].etat= true;
    		this.tabGenerationN[2][3].etat= true;
    		this.tabGenerationN[3][3].etat= true;
    		this.tabGenerationN[4][3].etat= true;
    		this.tabGenerationN[5][3].etat= true;
    		this.tabGenerationN[6][3].etat= true;
    		this.tabGenerationN[7][3].etat= true;
    		this.tabGenerationN[8][3].etat= false; // n'est pas pris en compte ds la recherche
    		this.tabGenerationN[9][3].etat= false; // n'est pas pris en compte ds la recherche
    		*/
     
    		// afficher this.tabGenerationN
    		this.afficheGenerationN();
     
    	}
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// getters
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// setters
     
    	//------------------------------------------------------------------------------------------------------------
    	//------------------------------------------------------------------------------------------------------------
    	// methodes de classe
    	public void initCellules() {
    		for(int i= 0; i< this.tabGenerationN.length; i++) {
    			for(int j= 0; j< this.tabGenerationN.length; j++) {
    				this.tabGenerationN[i][j]= new Cellule();
    				this.add(this.tabGenerationN[i][j]);
    			}
    		}
    	}
     
    	public void rechercheVoisines() {
    		for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
    			for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
     
    				if(this.tabGenerationNMoinsUn[i- 1][j- 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i][j- 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i+ 1][j- 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i- 1][j].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i+ 1][j].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if (this.tabGenerationNMoinsUn[i- 1][j+ 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i][j+ 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
    				if(this.tabGenerationNMoinsUn[i+ 1][j+ 1].etat== true) {
    					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
    				}
     
    				/*
    				// affichage de MondeCellule ds la console
    				// ATTENTION, si i= 0, 8 ou 9 et j= 0 ou 9, ce n'est pas pris en compte ds la recherche
    				if(i< this.tabGenerationN.length- 2) {
    					System.out.print(this.tabGenerationN[i][j].etat);
    					if(j== this.tabGenerationN.length- 2) {
    						System.out.println(" ");
    					}
    				}
    				*/
     
    			}
    		}
    	}
     
    	public void copie() {
     
    			// System.out.println("-----------------------------------");
    			System.arraycopy(tabGenerationN, 0, tabGenerationNMoinsUn, 0, COTE);
     
    			// affichage de this.tabGenerationNMoinsUn
    			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
    				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
    					if(i< this.tabGenerationN.length- 2) {
    						System.out.print(this.tabGenerationNMoinsUn[i][j].etat);
    						if(j== this.tabGenerationN.length- 2) {
    							System.out.println(" ");
    						}
    					}
    				}
    			}
     
    			System.out.println("-----------------------------------");
    		}
     
    	public void update() {
    		for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
    			for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
    				// naissance d'une Cellule: nbre de Cellules voisines vivantes= 3 et etat= false
    				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 3 && this.tabGenerationNMoinsUn[i][j].etat== false) {
    					this.tabGenerationN[i][j].etat= true;
    				}
    				// survie d'une Cellule: nbre de Cellules voisines vivantes= 2 ou 3 et etat= true
    				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 2 && this.tabGenerationNMoinsUn[i][j].etat== true
    						|| this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 3 && this.tabGenerationNMoinsUn[i][j].etat== true) {
    							this.tabGenerationN[i][j].etat= true;
    				}
    				// mort d'une Cellule:
    				// etouffement: nbre de Cellules voisines vivantes >= 4
    				// isolation: nbre de Cellules voisines vivantes <= 1
    				// etat= true
    				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes <= 1 && this.tabGenerationNMoinsUn[i][j].etat== true
    						|| this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes >= 4 && this.tabGenerationNMoinsUn[i][j].etat== true) {
    							this.tabGenerationN[i][j].etat= false;
    				}
    			}
    		}
    	}
     
    	public void afficheGenerationN() {
    		System.out.println("-----------------------------------");
    		if(this.generation== 0) {
    			System.out.println("ancienne generation: "+ (this.generation- 1));
    			this.copie();
    			System.out.println("nouvelle generation: "+ this.generation);
    			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
    				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
    					if(i< this.tabGenerationN.length- 2) {
    						System.out.print(this.tabGenerationN[i][j].etat);
    						if(j== this.tabGenerationN.length- 2) {
    							System.out.println(" ");
    						}
    					}
    				}
    			}
    		}
     
    		if(this.generation > 0) {
    			System.out.println("ancienne generation: "+ (this.generation- 1));
    			this.copie();
    			System.out.println("nouvelle generation: "+ this.generation);
    			this.rechercheVoisines();
    			this.update();
    			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
    				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
    					if(i< this.tabGenerationN.length- 2) {
    						System.out.print(this.tabGenerationN[i][j].etat);
    						if(j== this.tabGenerationN.length- 2) {
    							System.out.println(" ");
    						}
    					}
    				}
    			}
    		}
    		System.out.println("-----------------------------------");
    	}
     
    	public void clic() {
    		this.generation ++;
    		this.afficheGenerationN();
     
    	}
    }
    Je trouve que c'est super bordelique, comme code, je m'y retrouve pas toujours avec ces boucles imbriquées.

    Voici ce que j'obtiens ds la console (un simple affichage de tableaux boolean)
    -----------------------------------
    ancienne generation: -1
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsetruetruetruefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------
    nouvelle generation: 0
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsetruetruetruefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------
    -----------------------------------
    ancienne generation: 0
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsetruetruetruefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------
    nouvelle generation: 1
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------
    -----------------------------------
    ancienne generation: 1
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsetruefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------
    nouvelle generation: 2
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    falsefalsefalsefalsefalsefalsefalsefalse
    -----------------------------------

    explication:
    ancienne generation: -1, une copie du tableau nouvelle generation: 0 que j'initialise en dur dans le constructeur

    nouvelle generation: 0, le tableau defini en dur ds le constructeur

    ancienne generation: 0, de nouveau une copie du tableau que je definis ds le constructeur

    nouvelle generation: 1, le programme defini correctement la nouvelle generation

    ancienne generation: 1, le programme copie la nouvelle generation: 1

    ensuite ca deconne puisque
    nouvelle generation: 2, le programme ne definit pas a partir de ancienne generation: 1

    Si vous pouviez m'expliquer ou je foire svp, je seche un peu là.

    Merci bien
    areuh

  3. #3
    Membre expérimenté Avatar de Tux++
    Étudiant
    Inscrit en
    Avril 2008
    Messages
    281
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2008
    Messages : 281
    Par défaut
    Bonjour,

    Je peux te donner le lien d'un conway life bien développé,

    je peux comprendre que tu veuilles le dev. toi-même mais pourquoi ne pas partir de là?


    http://www.bitstorm.org/gameoflife/

  4. #4
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut
    Salut tux++

    j'espere que c'est pas bitstorm ton lien car le serveur met trop de temps a repondre... lol

    Sinon, ouais, j'avoue, j'ai regardé le code de la page que j'ai donné + haut et je pensais sincerement avoir fait qque chose d'analogue mais non, c'est pas ça.

    pfffff, put*** de programme, malgré tout, je continue!!!!

    Merci pour l'adresse, je reessaierai (ca s'ecrit comme ça??) de temps en temps, histoire de savoir comment on fait.

    a+
    areuh

    edit]
    ok le lien fonctionne, merci
    [/edit]

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut
    re,

    bon j'ai regardé... ca fait peur, j'ai une autre adresse qui donne aussi un UML avec la javadoc, je vais partir avec ceci:

    http://gameoflife.free.fr/doc_fr.htm

    moins de classe (deja que je m'y perds avec seulement 3) et surtout la javadoc

    j'essaierai de poster regulierement (mais je suis pas pressé non plus).

    Si tu (vous) veux (voulez) me filer un coup de main.

    a+
    areuh

  6. #6
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut
    salut,

    bon je viens de faire les 2 classes qui, à mon avis sont les + simples
    State
    Cell

    déja qques questions que je me pose
    Dans ses constructeurs, les noms de leurs parametres sont les memes que les variables d'attribut
    exemple avec la classe Cell
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    // variables
    	public short row;
    	public short col;
     
    	public State state;
     
    	// constructeurs
    	public Cell(int row, int col) {
     
    	}
     
    	public Cell(int row, int col, State state) {
     
    	}
    personnellement, je les aurai différenciés (comme ce que j'ai vu dans tous les exemples adresses aux débutants).
    exemple
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    // variables
    	public short row;
    	public short col;
     
    	public State state;
     
    	// constructeurs
    	public Cell(int pRow, int pCol) {
     
    	}
     
    	public Cell(int pRow, int pCol, State pState) {
     
    	}
    et puis je fais la relation entre variables d'attribut et parametres des constructeurs
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     
    // variables
    	public short row;
    	public short col;
     
    	public State state;
     
    	// constructeurs
    	public Cell(int pRow, int pCol) {
    		this.row= pRow;
    		this.col= pCol;
    	}
     
    	public Cell(int pRow, int pCol, State pState) {
    		this.row= pRow;
    		this.col= pCol;
    		this.state= pState;
    	}
    le truc c'est que les variables d'attribut st de type short alors que les parametres sont de type int... alors ou je caste (faut que je cherche) ou je modifie le type des variables (ou des parametres)?

    le cas se represente pour le setter setState(): l'affectation de la variable est sans effet (dixit Eclipse).

    Derniere question en ce qui concerne le getter getPosition() qui retourne une valeur de type String. je n'ai aucune String dans la classe Cell, dc a mon avis , la methode doit recuperer indexState de la classe State?

    Voilà pour ce post, je vais aller au plus simple:
    - modifier le type de mes variables d'attribut
    - faire les relations entre variables et parametres du constructeur (idem pour la methode setState())
    - recuperer cette String indexState de la classe State.

    Derniere question qui me turlupine mais c'est au niveau du diagramme, comment se fait il que sur certains noms de classe, il y ait (avec ou sans t?) des triangles d'avertissement?

    Voili, voilou, si vous avez les réponses... merci bien
    a+
    areuh

  7. #7
    Membre expérimenté Avatar de Tux++
    Étudiant
    Inscrit en
    Avril 2008
    Messages
    281
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2008
    Messages : 281
    Par défaut
    Bonjour,

    en ce qui concerne les noms de variables, c'est une nomenclature fortement utilisée, elles se différencient par le fait qu'une correspond à l'instance de this et l'autre est un paramètre:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ...
    private int a;
    private int b;
     
    public void test(int a, int b){
     
    this.a = a;
    this.b = b;
     
    }
    Cela permets de s'y retrouver plus facilement pour un autre lecteur, ou une maintenance quelconque. Si on conseille au débutant l'inverse c'est pour éviter qu'ils ne s'emmêlent les pinceaux

    Pour ce qui concerne tes int->short, si tu es sur d'obtenir des short à chaque fois, tu peux caster, sinon tu dois tout déclarer en int.


    Et j'ai pas trop compris ta 3eme question, manque de code mais en tout cas rien ne t'empêche de rajouter des attributs dans des classes

  8. #8
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2003
    Messages
    76
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 76
    Par défaut
    Re,

    t'as pas trop compris ma 3° question... Ah ouais, tu veux dire sans doute ma derniere question qui se trouve avant ma derniere question, celle concernant le getter getPosition()... et j'essaye d'apprendre a programmer... je suis pas sorti de l'auberge.

    ok, dc dans son diagramme de la classe Cell, il declare une methode:
    getPosition(): String
    C'est dc une methode qui renvoie une variable de type String mais dans cette meme classe, dans les variables d'attribut, il n'a y aucune String de declarée.

    En plus dans sa javadoc, on trouve ceci concernant cette methode:

    [javadoc]
    getPosition

    public java.lang.String getPosition()

    Get String Position. Like: '12/1'
    [/javadoc]

    je pense dc que sa methode getPosition() doit renvoyer la String déclarée dans sa classe State (indexState)
    ce qui donne:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    public String getPosition() {
    		String position= state.getIndexState();
    		return position;
    	}
    Ton avis?

    Sinon
    - etant donné que je ne suis sur de rien, je mets tout en int (c'est plus simple)
    - rajouter des attributs euh... ouais... mais non, je prefere essayer de suivre son diagramme. le reste, je verrai apres.

    prochaine etape (sans doute ce we):
    ecrire ses 2 classes algorithm, l'une hérite de l'autre
    ecrire la classe States (faut que je vois les HashMap)
    ecrire la classe Shape (faut que je vois les Hashtable)

    a+
    Merci pour l'aide.
    areuh

  9. #9
    Membre émérite
    Profil pro
    Inscrit en
    Avril 2007
    Messages
    764
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2007
    Messages : 764
    Par défaut
    Citation Envoyé par areuh_fr Voir le message
    le cas se represente pour le setter setState(): l'affectation de la variable est sans effet (dixit Eclipse).
    Si tu voulais qu'on t'explique ton erreur, il vaudrait mieux poster ton code...
    Cependant, je suppose que tu as du faire quelque chose dans ce genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    public void setState(State state) {
       state = state;
       // la variable locale masque le champ de la classe du même nom
       // du coup cette instruction signifie : la variable locale prend la valeur d'elle-même... et donc l'affectation n'a pas d'effet
    }
    Au lieu de :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public void setState(State state) {
       this.state = state;
       // il faut dire explicitement que c'est au champ de la classe (et non à la variable locale) qu'on affecte une valeur
    }
    Ou encore :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public void setState(State s) {
       state = s;
       // on donne un nom différent au paramètre de la fonction : plus de problème ! "state" ne peut désigner que le champ de la classe...
    }
    C'est exactement le même problème que celui que tu évoquais avec les noms des paramètres du constructeur : on peut prendre les mêmes noms de paramètres que ceux des champs de la classe, mais alors pour désigner les champs il faudra le faire explicitement avec this.nomDuChamp.




    Citation Envoyé par areuh_fr Voir le message
    Derniere question qui me turlupine mais c'est au niveau du diagramme, comment se fait il que sur certains noms de classe, il y ait (avec ou sans t?) des triangles d'avertissement?
    La signification de ces triangles dépend évidemment de l'outil qui a généré ce diagramme.
    Cependant, comme toutes les icônes utilisées ressemblent fortement à celles d'Eclipse, je vais supposer qu'ils indiquent simplement la présence d'avertissements. L'auteur de la page web a du laisser dans son code quelques "maladresses" (intentionnelles dans le but de développements futurs, ou non) : importations de packages, déclarations de variables ou instructions inutiles. Eclipse signale ces "erreurs" (qui ne posent aucun problème en elles-même) par un triangle d'avertissement, qui ne signifie donc absolument rien du point de vue du diagramme de classe (quoique... cela peut signaler qu'un champ ou une méthode est en fait inutilisé et que tu n'as pas besoin de le reproduire... mais cela peut aussi signaler qu'un avertissement est présent à l'intérieur de la méthode, on ne peut pas savoir).

Discussions similaires

  1. Conway's life (jeu de la vie) pour images
    Par O( N ) dans le forum C
    Réponses: 1
    Dernier message: 26/09/2006, 02h13
  2. [Conception] probleme d'id pour cree un forum php
    Par ghyslain dans le forum PHP & Base de données
    Réponses: 3
    Dernier message: 02/05/2006, 19h39
  3. problème de conception : cycle
    Par FarookFreeman dans le forum Diagrammes de Classes
    Réponses: 13
    Dernier message: 20/10/2005, 10h15
  4. Probleme de conception pour un update Oracle!
    Par vempiria dans le forum Langage SQL
    Réponses: 3
    Dernier message: 27/09/2005, 10h28
  5. Réponses: 2
    Dernier message: 01/06/2004, 16h12

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo