ardoise magique compilation erreur

**domxaline** · 16/01/2014, 18h43

bonjour
j'ai écrit cette prg
en compilant j'ai erreur suivant
"Erreur : la méthode principale est introuvable dans la classe FenetreTest, définissez la méthode principale comme suit :
public static void main(String[] args)"
veuillez m'aidez svp

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
 
import java.awt.Color;
import java.awt.font.*;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JPanel;
 
public class Panneau extends JPanel
{
	 private int posX=-50;
	 private int posY=-50;
	 private int drawSize=50;
	 //boolean pour le mode morphing et pour savoir si la taille doit être réduite
	 private boolean morph=false,reduce=false;
	 private String forme="ROND";	  
 
 
	 /* voici nos deux couleurs */
	 private Color couleurForme=Color.red;
	 private Color couleurFond=Color.white;
 
	 //le compteur de rafraîchissement
	 private int increment=0;	
 
	 public void paintComponent (Graphics g)
	 { 
	  //affectation de la couleur de fond
	  g.setColor (couleurFond);		     
	  g.fillRect (0,0,this.getWidth ( ),this.getHeight ( ));
 
	  //affectation de la couleur de la forme
	  g.setColor(couleurForme);
	  //si le mode morphing est activé, on peint le morphing
	  //g.setColor (Color.red);	    
	  if(this.morph)
	     drawMorph(g);	    
	  else	 	    
	     draw(g);	    
	 }
/* méthode qui redéfinit la couleur du fond */
	 public void setCouleurFond(Color color)
	 {
		 this.couleurFond=color;
		 repaint();
	 }
	 /* methode qui redéfinit la couleur du forme*/
	 public void setCouleurForme(Color color)
	 {
		 this.couleurForme=color;
		 repaint();
	 }
 
	 private void draw(Graphics g)
	 {
	  if(this.forme.equals("ROND")) 
	  {
	   g.fillOval(posX,posY,50,50);
	  }
	  if(this.forme.equals("CARRE")||this.forme.equals("CARRÉ"))
	  {
	   g.fillRect(posX,posY,50,50);
	  } 	  
	  if(this.forme.equals("TRIANGLE"))
	  { 		 
	   int s1X=posX+50/2;
	   int s1Y=posY; 	     
	   int s2X=posX+50;
	   int s2Y=posY+50;   	     
	   int s3X=posX;
	   int s3Y=posY+50;    	          	     
	   int[]ptsX={s1X,s2X,s3X};
	   int[]ptsY={s1Y,s2Y,s3Y};    	          	     
	   g.fillPolygon(ptsX,ptsY,3);
	  }
	  if(this.forme.equals("ETOILE"))
	  {    		 
	   int s1X=posX+50/2;
	   int s1Y=posY;
	   int s2X=posX+50;
	   int s2Y=posY+50;
	   g.drawLine(s1X,s1Y,s2X,s2Y);   	      
	   int s3X=posX;
	   int s3Y=posY+50/3;
	   g.drawLine(s2X,s2Y,s3X,s3Y);    	      
	   int s4X=posX+50;
	   int s4Y=posY+50/3;
	   g.drawLine(s3X,s3Y,s4X,s4Y);    	      
	   int s5X=posX;
	   int s5Y=posY+50;
	   g.drawLine(s4X,s4Y,s5X,s5Y);
	   g.drawLine(s5X,s5Y,s1X,s1Y);
	  }
	 } 
 
	 /* méthode qui peint le morphing */
	 private void drawMorph(Graphics g)
	 {   
	  //on incrémente le tour
	  increment++;   
	  //on regarde si on doit réduire ou non
	  if(drawSize>=50)reduce=true;
	  if(drawSize<=10)reduce=false;    	  
	  if(reduce)
	    drawSize=drawSize-getUsedSize();
	  else
	    drawSize=drawSize+getUsedSize();
 
	  if(this.forme.equals("ROND"))
	  {
	   g.fillOval(posX, posY, drawSize, drawSize);
	  }
	  if(this.forme.equals("CARRE")||this.forme.equals("CARRÉ")) 
	  {		  
	   g.fillRect(posX, posY, drawSize,drawSize);
	  }
	  if(this.forme.equals("TRIANGLE"))
	  {
	   int s1X=posX+drawSize/2;
	   int s1Y=posY;
	   int s2X=posX+drawSize;
	   int s2Y=posY+drawSize;
	   int s3X=posX;
	   int s3Y=posY+drawSize;    		  
	   int[]ptsX={s1X,s2X,s3X};
	   int[]ptsY={s1Y,s2Y,s3Y};    		  
	   g.fillPolygon(ptsX,ptsY,3); 		  
	  }
	  if(this.forme.equals("ETOILE"))
	  {
	   int s1X=posX+drawSize/2;
	   int s1Y=posY;
	   int s2X=posX+drawSize;
	   int s2Y=posY+drawSize;
	   g.drawLine(s1X,s1Y,s2X,s2Y);    		  
	   int s3X=posX;
	   int s3Y=posY+drawSize/3;
	   g.drawLine(s2X,s2Y,s3X,s3Y);   		  
	   int s4X=posX+drawSize;
	   int s4Y=posY+drawSize/3;
	   g.drawLine(s3X,s3Y,s4X,s4Y);    		  
	   int s5X=posX;
	   int s5Y=posY+drawSize;
	   g.drawLine(s4X,s4Y,s5X,s5Y);
	   g.drawLine(s5X,s5Y,s1X,s1Y);
	  }
	 }
	  /* méthode qui retourne le nombre à retrancher ou ajouter pour le morphing */    
	 private int getUsedSize()
	 {
	  int res=0; 
	  //si le nombre de tours est 10
	  //on réinitialise l'incrément et on retourne 1
	  if(increment/10==1)
	  {
	   increment=0;
	   res=1;
	  }
	  return res;	  
	 }
 
	 public int getDrawSize()
	 {
	  return drawSize;
	 }
 
	 public boolean isMorph()
	 {
	  return morph;
	 }
 
	 public void setMorph(boolean bool)
	 {
	  this.morph=bool;
	  //on réinitialise la taille
	  drawSize=50;
	 }
 
	 public void setForme(String form)
	 {
	  this.forme=form.toUpperCase();
	 }      
 
	 public int getPosX( ) 
	 {
	  return posX;
	 }
 
	 public void setPosX (int posX)
	 {
	  this.posX=posX;
	 }
 
	 public int getPosY ( )
	 {
	  return posY;
	 }
 
	 public void setPosY (int posY)
	 {
	  this.posY=posY;
	 } 
	}

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
 
import java.awt.Color;
public class Point 
{
 //Couleur du point
 private Color color=Color.red;
 //Taille
 private int size=10;
 //Position sur l'axe X:initialisé au dehors du conteneur
 private int x=-10;
 //Position sur l'axe Y: initialis& au dehors du conteneur
 private int y=-10;
 //Type de point
 private String type="ROND";
 
 /* Constructeur par défaut */
 public Point()
 {
 
 }
 /* Constructeur avec paramètres*/
 // @param x, @param y, @param size, @param color, @param type
 public Point(int x, int y, int size, Color color, String type)
 {
	 this.size=size;
	 this.x=x;
	 this.y=y;
	 this.color=color;
	 this.type=type;
 }
 //*************************************************************
 //           ACCESSEURS
 //*************************************************************
 public Color getColor()
 {
	 return color;
 }
 public void setColor(Color color)
 {
	 this.color=color;
 }
 
 public int getSize()
 {
	 return size;
 }
 public void setSize(int size)
 {
	 this.size=size;
 }
 
 public int getX()
 {
	 return x;
 }
 public void setX(int x)
 {
	 this.x=x;
 }
 
 public int getY()
 {
	 return y;
 }
 public void setY(int y)
 {
	 this.y=y;
 }
 
 public String getType()
 {
	 return type;
 }
 public void setType(String type)
 {
	 this.type=type;
 }
}

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
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
 
import javax.swing.JPanel;
 
public class DrawPanel extends JPanel
{
 //Couleur du pointeur
 private Color pointerColor=Color.red;
 
 //Forme du pointeur
 private String pointerType="CIRCLE";
 
 //Position X du pointeur
 private int posX=-10, oldX=-10;
 
 //Position Y du pointeur
 private int posY=-10, oldY=-10;
 
 //pour savoir si on doit dessiner ou non
 private boolean erasing=true;
 
 //Taille du pointeur
 private int pointerSize=15;
 
 //Collection de points!
 private ArrayList<Point>points=new ArrayList<Point>();
 
 /* Constructeur*/
 public DrawPaint()
 {
	 this.addMouseListener(new MouseAdapter()
	 {
		 public void mousePressed(MouseEvent e)
		 {
			 points.add(new Point(e.getX()-(pointerSize/2),e.getY()-(pointerSize/2),pointerSize,pointerColor,pointerType));
		     repaint();
		 }
	 });
 
	 this.addMouseMotionListener(new MouseMotionListener()
	 {
		 public void mouseDragged(MouseEvent e)
		 {
			//On récupère les coordonnées de la souris
			//et on enlève la moitié de la taille du pointeur
			//pour centrer le tracé
			 points.add(new Point(e.getX()-(pointerSize/2),e.getY()-(pointerSize/2),pointerSize,pointerColor,pointerType));
		     repaint();
		 }
		 public void mouseMoved(MouseEvent e)
		 {
 
		 }
	 });
	 }
    /* Vous la connaissez maintenant, celle-là ;*/
    public void paintComponent(Graphics g)
    {
    	g.setColor(Color.white);
        g.fillRect(0,0, this.getWidth(), this.getHeight());
        //Si on doit effacer, on ne passe pas dans le else=>pas de dessin
        if(this.erasing)
        {
        	this.erasing=false;
        }
        else
        {
        	//on parcourt notre collection de points
        	for(Point p:this.points)
        	{
        		//on récupère la couleur
        		g.setColor((p.getColor());
        		//Selon le type de point
        		if(p.getType().equals("SQUARE"))
        		{
        			g.fillRect(p.getX(), p.getY(), p.getSize(),p.getSize());
        		}
        		else
        		{
        			g.fillOval(p.getX(),p.getY(),p.getSize(), p.getSize());
        		}
        	}
        }
    }
    /* Efface le contenu */
    public void erase()
    {
    	this.erasing=true;
    	this.points=new ArrayList<Point>();
    	repaint();  	
    }
    /* Définit la couleur du pointeur */
    public void setPointerColor(Color c)
    {
    	this.pointerColor=c;
    }
 
    /* Définit la forme du pointeur */
    public void setPointerType(String str)
    {
    	this.pointerType=str;
    }
}

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
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.ImageIcon;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
 
public class FenetreTest extends JFrame 
{
	//*******************
	/*      Le Menu    */ 
	//*******************
	private JMenuBar menuBar=new JMenuBar();
	JMenu fichier=new JMenu("Fichier"),
	      edition=new JMenu("Edition"),
	      forme=new JMenu("Forme du pointeur"),
	      couleur=new JMenu("Couleur du pointeur");
	JMenuItem nouveau=new JMenuItem("Effacer"),
	          quitter=new JMenuItem("Quitter"),
	          rond=new JMenuItem("ROND"),
	          carre=new JMenuItem("Carré"),
	          bleu=new JMenuItem("Bleu"),
	          rouge=new JMenuItem("Rouge"),
	          vert=new JMenuItem("Vert");
 
	/************************************************/
	//         LA BARRE D'OUTILS
	//***********************************************
	JToolBar toolBar=new JToolBar();
	JButton square=new JButton(new ImageIcon("images/carré.jpg")),
	        circle=new JButton(new ImageIcon("images/rond.jpg")),
	        red=new JButton(new ImageIcon("images/rouge.jpg")),
	        green=new JButton(new ImageIcon("images/vert.jpg")),
	        blue=new JButton(new ImageIcon("images/bleu.jpg"));
	/*****************************************/
	//         LES ECOUTEURS
	//****************************************
    private FormeListener fListener=new FormeListener();
	private CouleurListener cListener=new CouleurListener();
 
	//Notre zone de dessin
	private DrawPanel drawPanel=new DrawPanel();
 
	 public FenetreTest()
	 {
	  //this.setTitle("Animation");
	  this.setSize(700, 500);
	  this.setLocationRelativeTo(null);
	  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  //On initalise le menu
	  this.initMenu();
	  //Idem pour la barre d'outils
	  this.initToolBar();
	  //On positionne notre zone de dessin
	  this.getContentPane().add(drawPanel,BorderLayout.CENTER);
	  this.setVisible(true);
	 }
 
	 //*************************************
	 //      Initialise le menu
	 //*************************************
	  private void initMenu()
	  {
	   nouveau.addActionListener(new ActionListener()
	   {
		   public void actionPerformed(ActionEvent arg0)
		   {
			   drawPanel.erase();
		   }
	   });
	   nouveau.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,KeyEvent.CTRL_DOWN_MASK));
	   quitter.addActionListener(new ActionListener()
	   {
		   public void actionPerformed(ActionEvent arg0)
		   {
			   System.exit(0);
		   }
	   });
	   quitter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W,KeyEvent.CTRL_DOWN_MASK));
	   fichier.add(nouveau);
	   fichier.addSeparator();
	   fichier.add(quitter);
	   fichier.setMnemonic('F');
 
	   carre.addActionListener(fListener);
	   rond.addActionListener(fListener);
	   forme.add(rond);
	   forme.add(carre);
 
	   rouge.addActionListener(cListener);
	   vert.addActionListener(cListener);
	   bleu.addActionListener(cListener);
	   couleur.add(rouge);
	   couleur.add(vert);
	   couleur.add(bleu);
 
	   edition.setMnemonic('E');
	   edition.add(forme);
	   edition.addSeparator();
	   edition.add(couleur);
 
	   menuBar.add(fichier);
	   menuBar.add(edition);
 
	   this.setJMenuBar(menuBar);
	 }
	   /* Initialise 1 barre d'outils*/
	   private void initToolBar()
	   {
		  JPanel panneau=new JPanel();
			square.addActionListener(fListener);
			circle.addActionListener(fListener);
			red.addActionListener(cListener);
			green.addActionListener(cListener);
			blue.addActionListener(cListener);
 
			toolBar.add(square);
			toolBar.add(circle);
 
			toolBar.addSeparator();
			toolBar.add(red);
			toolBar.add(bleu);
			toolBar.add(green);
 
			this.getContentPane().add(toolBar,BorderLayout.NORTH);
		  }
 
		  //ECOUTEUR POUR LE CHANGEMENT DE FORME
		  //*************************************
		  class FormeListener implements ActionListener
		  {
			  public void actionPerformed(ActionEvent e)
			  {
				  if(e.getSource().getClass().getName().equals("javax.swing.JMenuItem"))
				  {
					  if(e.getSource()==carre)drawPanel.setPointerType("SQUARE");
					  else drawPanel.setPointerType("CIRCLE");
				  }
				  else
				  {
					  if(e.getSource()==carre)drawPanel.setPointerType("SQUARE");
					  else drawPanel.setPointerType("CIRCLE");
				  }
			  }
		  }
			  //ECOUTEUR POUR LE CHANGEMENT DE COULEUR
			  //***************************************
			  class CouleurListener implements ActionListener
			  {
				  public void actionPerformed(ActionEvent e)
				  {
					  System.out.println(e.getSource().getClass().getName());
					  if(e.getSource().getClass().getName().equals("javax.swing.JMenuItem"))
					  {
						  System.out.println("OK!");
						  if(e.getSource()==vert)drawPanel.setPointerColor(Color.green);
						  else
							  if(e.getSource()==bleu)drawPanel.setPointerColor(Color.blue);
							  else drawPanel.setPointerColor(Color.red);
					  }
					  else
					  {
						  if(e.getSource()==green)drawPanel.setPointerColor(Color.green);
						  else
						  {
							  if(e.getSource()==bleu)drawPanel.setPointerColor(Color.blue);
							  else drawPanel.setPointerColor(Color.red);
						  }
					  }
				  }
	 public static void main(String[] args)
	  {
	    FenetreTest fen=new FenetreTest();
	  }
	}}

**plawyx** · 16/01/2014, 19h20

comment as-tu compilé ton code car, j'ai des erreurs à la compilation, mais pas celle que tu indiques.

**domxaline** · 16/01/2014, 19h26

oui vous avez raison il manqué une classBody,je l'ai mis
après mon correction:
lors de compilation erreur était ça:

"public static void main(String[] args)"

**joel.drigo** · 16/01/2014, 19h27

Salut,

C'est juste que ta méthode main() est déclarée dans la classe CouleurListener et pas FenetreTest. Avec une indentation propre, tu l'aurais tout de suite vue.

Fin de ta classe FenetreTest (indentée) :

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
	// ECOUTEUR POUR LE CHANGEMENT DE COULEUR
	// ***************************************
	class CouleurListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			System.out.println(e.getSource().getClass().getName());
			if (e.getSource().getClass().getName()
					.equals("javax.swing.JMenuItem")) {
				System.out.println("OK!");
				if (e.getSource() == vert)
					drawPanel.setPointerColor(Color.green);
				else if (e.getSource() == bleu)
					drawPanel.setPointerColor(Color.blue);
				else
					drawPanel.setPointerColor(Color.red);
			} else {
				if (e.getSource() == green)
					drawPanel.setPointerColor(Color.green);
				else {
					if (e.getSource() == bleu)
						drawPanel.setPointerColor(Color.blue);
					else
						drawPanel.setPointerColor(Color.red);
				}
			}
		}

		public static void main(String[] args) {
			FenetreTest fen = new FenetreTest();
		}
	}
}

L'accolade en rouge tu la remontes au dessus de la signature de main() et c'est bon !

D'ailleurs, je suis étonné que tu n'aies pas une erreur de compilation (ou signalée par ton IDE) qui dise qu'une méthode statique ne peut pas être déclarée dans un contexte non-statique, ce qui est le cas d'une classe interne non statique.

**domxaline** · 16/01/2014, 19h44

ok c'est ça ,j'ai corrigé,merci beaucoup
et encore, pourquoi la couleur bleu icon marche pas?

**joel.drigo** · 16/01/2014, 19h55

Parce que tes noms de variables ne sont pas significatifs et que tu fais des erreurs de confusions

Si au lieu de blue et bleu tu avais blueMenuItem et blueButton, tu n'aurais probablement pas écrit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
toolBar.add(square);
toolBar.add(circle);
 
toolBar.addSeparator();
toolBar.add(red);
toolBar.add(bleu);
toolBar.add(green);

au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

toolBar.add(blue);

**domxaline** · 16/01/2014, 21h07

oui maintenant tous les icônes marchent,
mais quand je clique sur icône bleu mon pinceau en rouge
c'est pas normal,svp

**joel.drigo** · 16/01/2014, 21h13

Mais as tu cherché un peu toi-même ? Parce que c'est exactement le même problème

mais dans le listener CouleurListener !

ardoise magique compilation erreur

avec Java

Vue hybride

Discussions similaires

Partager

Partager