Discussion :

[Raiden1234]

Bonjour,

J'ai réalisé un petit programme java qui permet de donner la liste des nombres premiers entre une certaine intervalle précisé par l'utilisateur.

Le programme donne la liste des nombres premiers (avec le crible d'Eratosthène), ainsi que les couples jumeaux et enfin il met en oeuvre le théorème de Fermat. Mais là n'est pas le problème.

Mon problème réside dans l'interface graphique que j'ai développé autour de ce programme. Je m'explique :

J'ai créé, outre le Main, trois classes dont deux correspondent à une fenêtre (elles héritent chacune d'une JFrame). La troisième hérite d'un JPanel qui sera instancié dans une des classe héritant de JFrame.

Concrètement :

Fenetre.java hérite d'une JFrame, c'est la fenêtre qui instancie Dessin.java qui hérite d'un JPanel. C'est la classe Fenetre qui contient tout le contenu du programme.

Cependant, c'est la classe EventsFrame, héritant de JFrame aussi, qui affiche la liste des nombres premiers, le nombres jumeaux etc.. C'est une sorte de log en fait voila.

Et moi j'aimerais afficher (dans le JPanel principal de Fenetre) un point (à travers ma classe Dessin) pour chaque nombre premiers. Ces points sont bien sûre espacés mais pour le moment tous affichés en ligne. (Pour plus de précision là dessus, c'est un peu le théorème d'Ulam que j'essai de mettre en oeuvre).

Mon but final est donc de représenter à travers ces points les espaces dans les nombres premiers.

Mais voila, je n'arrive que à afficher le premier et le dernier point de mon intervalle.

Je ne comprends pas d'où vient mon erreur.

Voici mes classes Fenetre et Dessin :

Fenetre : (J'ai mis en rouge dans le code l'endroit précis ou je dessine le point)

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
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Fenetre extends JFrame{

	private static final long serialVersionUID = 1L;

	public JPanel panelPrincipal;
	public JPanel panelNorth;
	public JButton lancer;
	public JLabel labelNbMax;	
	public Dessin dessin;
	public JTextField txtNb;
	public int valMax;
	public int abs;
	public int ord;
	
	public EventsFrame ef;

	public Fenetre(){

		creerWidget();

		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setTitle("Nombres Premiers");	// titre de la fenetre
    	this.setSize(890,400);
    	this.setLocation(200,390);
		//this.pack();
		this.setVisible(true);
	}

	
	public void creerWidget() {

		/********* Instanciations **********/

		this.panelPrincipal = new JPanel(new BorderLayout());
		this.panelNorth = new JPanel();
		this.labelNbMax = new JLabel("Nombre Max : ");
		this.lancer = new JButton("Lancer");
		this.abs = 50;
		this.ord = 50;
		this.txtNb = new JTextField("100", 5);

		this.dessin = new Dessin(abs,ord);
		this.ef = new EventsFrame();

		/********** Events ************/

		this.lancer.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e){
					valMax = Integer.parseInt(txtNb.getText());
					lancer(valMax, abs, ord);			
			}
		});
	


		/********* Affichage **********/

		this.panelPrincipal.add(panelNorth, BorderLayout.NORTH);
		this.panelNorth.add(labelNbMax);
		this.panelNorth.add(txtNb);
		this.panelNorth.add(lancer);

		this.panelPrincipal.add(dessin);


		this.setContentPane(panelPrincipal);

	}

	public void lancer(int a, int b, int c) {
	
		ArrayList <Integer> tab1A = new ArrayList<Integer>();
		ArrayList <Integer> tab2A = new ArrayList<Integer>();
		String chaine = "";
		String chaine2 = "";
		int i,j,q,k,nb;
		int nbMax = valMax;
		int total = valMax - 2;
		int limitBoucle;
		boolean test = false;
		Integer ii,jj;
		String cha = "";
		String chb = "";
		int [] tab1 = new int[valMax];
		int [] tab2 = new int[valMax];

		for (i=2;i<=valMax;i++) {
			ii = new Integer(i);
			tab1A.add(ii);	// On ajoute tous les entiers de 2 à n dans notre liste.
			//ef.printEvent(i+" vient d'être ajouté à la liste\n");
		}
	
		for (i=0;i<=total;i++) {
			cha = (tab1A.get(i)).toString();	// Conversion de liste vers tableau
			tab1[i] = Integer.parseInt(cha);
		}

		q = 0;
		
		while (q <= total) {	// On parcours tous les éléments de notre tableau. On commence par le début tab[0] jusqu'à tab[n-2].
					// En effet, si on ajoute les entiers de 2 à 5, 5 se trouvera à l'emplacement 5-2 soit à tab[3].
			for (j=2;j<tab1[q];j++) {	// Pour chaque élément du tableau, on regarde s'il est divisible par tous ses entiers inférieurs à partir de 2.
				if (tab1[q]%j == 0) {	// Dire que l'élément est divisible revient à dire que son modulo avec l'entier en question vaut 0.
					//ef.printEvent(tab1[q]+" est divisible par "+j);
					// Si il est divisible, on le remplace par un 0 dans le tableau.
					//ef.printEvent(tab1[q]+" a été divisible. Nous écrivons 0 à la place de "+tab1[q]+"\n");
					tab1[q] = 0;
					this.abs += 1;
					break;	// Il a été divisible, il n'est donc pas premier. Inutile de continuer à essayer de lui trouver un autre diviseur.
				}else{	// L'élément du tableau n'a pas été divisible par aucun de ses entiers inférieur a compté de 2. Il est premier !
					ef.printEvent(tab1[q]+" n'est pas divisible par "+j);
					
					if (j == tab1[q]-1) {
						ef.printEvent(tab1[q]+" n'a pas été divisible. Il est premier, nous le gardons\n");
					}
					this.abs += 1;
					dessin.dessiner(abs,ord); // Le problème se trouve ici
				}
			}
			q = q + 1;
			//ef.printEvent("--------------------------\n");
		}
			
		i = 0;
		nb = 0;
		// Une fois les tests fait sur tous les éléments du tableau, nous reparcourons tout le tableau et 
		// tant que l'élément du tableau ne vaut pas 0, nous avons affaire à un nombre premier.
		while (i <= total) {
			if (tab1[i] != 0) {	// Si l'élément du tableau est différent de 0
				if (i != 0) {
					chaine += ", ";	// On concatène tous les nombres premiers dans une chaine de caractère séparé par une virgule.		 	
				}
				chaine += Integer.toString(tab1[i]);
				jj = new Integer(tab1[i]);		
				tab2A.add(jj);	// On ajoute tous les nombres premiers dans une nouvelle liste.
				nb = nb + 1;
			}
			i = i + 1;
		}
		
		ef.printEvent("\nLa liste des nombres premiers allant de 2 à "+nbMax+" est "+chaine+"\n");	// On affiche cette chaine de caractère (et donc les nombres premier !).
		for (i=0;i<nb;i++) {
			chb = (tab2A.get(i)).toString();	// Conversion de notre nouvelle liste en un nouveau tableau
			tab2[i] = Integer.parseInt(chb);
		}
		
		/************************ NOMBRES PREMIERS JUMEAUX *************************/
		j = 0;
		
		while (j < nb-1) {
			if (tab2[j+1]-tab2[j] == 2) {
				if (j != 1) {
					chaine2 += ", ";
				}
				chaine2 += Integer.toString(tab2[j])+'-'+Integer.toString(tab2[j+1]);
			}
			j = j + 1;
		}
			
		ef.printEvent("Les nombres premiers jumeaux sont "+chaine2+"\n");
		
		/****************************** FERMAT *********************************/
		k = 0;
		
		while (k < nb) {
			test = false;
			if (tab2[k]%4 == 1) {
			
				limitBoucle = (int)(Math.sqrt(tab2[k]));
				
				for (i=1;i<=limitBoucle;i++) {
					j = limitBoucle;
					if (test == true) {
						break;
					}
					while (j >= limitBoucle/2) {
						if (i*i + j*j == tab2[k]) {
							test = true;
							ef.printEvent(tab2[k]+" est la somme de deux carres des entiers "+i+" et "+j);
						}
						j = j - 1;
					}
				}
			}
			k = k + 1;
		}
		
		ef.printEvent("\n----------------------------------------------------");
			
		/***************************** GOLDBACH *****************************/
		
	}

}

Dessin :

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
import javax.swing.*;
import java.awt.*;
 
public class Dessin extends JPanel {
 
	private static final long serialVersionUID = 1L;
 
	public int abs;
	public int ord;
 
	public Dessin(int abs, int ord){
		this.abs = abs;
		this.ord = ord;
		this.setPreferredSize(new Dimension(100,200));
 
	}
 
	public void paintComponent(Graphics g) {
		//super.paintComponent(g); // repeint le fond du JPanel
		g.setColor(Color.RED);
		//g.setBackground(Color.RED);
		g.drawOval(abs,ord,2,2);
 
 
	}
 
	public void dessiner(int abs, int ord) {
		this.abs = abs;
		this.ord = ord;
		repaint();
	}
 
}

Vous pouvez distinguer sur cette image deux petits points rouges, pour les nombres premiers de 2 à 30. Sauf qu'il n'affiche que le point pour 2 et pour 29.

Voila, merci de bien vouloir m'aider, j'ai essayé d'être le plus clair possible

Andréas

[m_piou]

Bonjour,

juste pour etre sur, t'as vérifié le nombre de fois que ton programme passait dans la méthode dessiner de la classe Dessin?

Cdlt

[Raiden1234]

En voulant faire des tests comme tu me l'a conseillé, je me suis rendu compte que j'affichais les points dans une mauvaise boucle.

J'ai rectifié cela, l'endroit exacte de l'affichage est ici :

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
		while (i <= total) {
			if (tab1[i] != 0) {	// Si l'élément du tableau est différent de 0
				if (i != 0) {
					chaine += ", ";	// On concatène tous les nombres premiers dans une chaine de caractère séparé par une virgule.
				}
				chaine += Integer.toString(tab1[i]);
				jj = new Integer(tab1[i]);		
				tab2A.add(jj);	// On ajoute tous les nombres premiers dans une nouvelle liste.
				nb = nb + 1;
 
				this.abs += 1;
				dessin.dessiner(this.abs,ord);
				System.out.println(this.abs);
			}else{
				this.abs += 1;
			}
			i = i + 1;
		}

J'ai fais des tests (comme on peut le voir avec le System.out.println(this.abs); ) et mes informations s'affiche comme prévu dans la console.

J'obtiens :

51
52
54
56
60
62
66
68

quand l'intervalle des nombres premiers est [2;20] et j'ai vérifié ça correspond. J'ai bien mes 8 nombres premiers avec leur correspondance en abscisse exacte.

Mais voila, toujours le même problème avec les points

Je comprends encore moins la raison..

[sinok]

Le problème vient de la compréhension de ta part du modèle de dessin de Swing (ou AWT c'est idem dans ce cas).

En effet le contexte graphique d'un JComponent est effacé à chaque repaint.

Or la méthode dessiner effectue un repaint à chaque fois que tu l'appelle. Donc on ne verra probablement que le dernier point dessiné.

Ce qu'il faut que tu fasse c'est dessiner l'ensemble des points dans la méthode paintComponent.

Donc grosso modo il faut que tu passes en paramètre à ton composant dessin ton tableau entier (a la construction par exemple, et éventuellement modifiable avec un setter). Puis que dans ton paintComponent tu le balaye et dessine les points en fonction des valeurs.
Donc tout le code calculant la position des points qui se trouve dans la classe Fenetre doit être effectué lors de l'appel à la méthode paintComponent de la classe dessin...

++

[Raiden1234]

J'ai suivi ton explication sinok et ça marche , en voici la preuve :



merci sinok

A bientôt