Discussion :

[Magicien d'Oz]

Salut à tous,

bon je comprends rien au concept de programmation objet mais je suis obligé de m'y mettre alors... j'ai des gros problèmes !!!

Voilà ma question : pour dessiner un rectangle dans une fenêtre, le code suivant est - il le plus simple pour y arriver ? (C'est le mien et il marche bien mais je trouve ça tordu de redéfinir paintComponent et tout ça, par rapport au basic...)

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
 
import java.awt.*;
import javax.swing.*;
 
public class Graph2 
{
	public static void main(String[] args) 
	{
		JFrame fenetre = new JFrame();
		fenetre.setName("Fenêtre Graphique");
		fenetre.setSize(600, 600);
		Rect r1 = new Rect();
 
		fenetre.add(r1);
 
		fenetre.setVisible(true);
	}
}
 
class Rect extends JPanel
{
	public void paintComponent (Graphics g)
	{
		g.setColor(Color.BLACK);
		g.drawRect(20, 20, 100, 300);
	}
}

Merci à vous !!

[sinok]

Sisi c'est bien ce qu'il faut faire, toute les opérations de dessin du panel sont à effectuer dans cette méthode

Eventuellement fait un appel à super.paintComponent(g) dans ton paintComponent pour que ton panel se redessine correctement

[dazz_x]

j'ajouterai que cette méthode est plus réservée pour le dessin du composant... Si tu veux dessiner dessus (t'en servir comme d'un canvas) tu peux surcharger la méthode paint(Graphics g)

[Magicien d'Oz]

Merci Sinok !

Mais Dazz, j'ai surchargé paint au lieu de paintComponent et si j'essaie de dessiner une deuxième fois dans la fenetre,ça efface la première fois, tu as une idée ? Ou j'ai ptêt mal compris...

[dazz_x]

Qu'est-ce que tu entends par dessiner une deuxième fois ?

[sinok]

Pour le dessin comme tu cherches à le faire reste sur paintComponent
Et si tu veux que tes dessins restent en mémoire il faut que tu les srocke dans une structure typa ArrayList et que tu les redessine à chaque fois dans le paintComponent (enfin si tu cherche à utiliser ce panel pour contenir d'autres composants (boutons et tout le toutim)

[dazz_x]

merci Sinok, c'est ce que j'entendais par "t'en servir comme canvas", mais je me suis mal exprimé !

[Magicien d'Oz]

et j'imagine que le arry list tu le passes en paramètre de la classe à chaquez fois que tu redessines un truc en plus non ?

[dazz_x]

ben non, ton ArrayList, elle est membre de ta classe et elle dessine genre des ObjetGraphique (une interface qui contient la méthode draw(Graphics g)) et tu crées une classe abstraite AbstractObjetGraphique implements ObjetGraphiquedont tu hérites pour les différents objets que tu veux dessiner (par exemple class Rectangle extends AbstractObjetGraphique )... Ensuite à chaque dessin, tu parcoures ton ArrayList en faisant monObjet.draw(g) dans ton paint(Graphics g);

Enfin bon, c'est une méthode comme une autre !

[Magicien d'Oz]

J'ai rien compris désolé mais merci quand même

PS : j'ai commencé le Java ya deux jours alors...

[dazz_x]

OK, OK, j'y suis allé un peu fort... Mais le concept n'est pas compliqué à comprendre. L'idée c'est de se dire que dans une application de dessin, ce qu'on veut c'est dessiner. En fait, les points communs entre un rectangle, un cercle et un point sont :
-coordonnées de localisation (x,y)
-méthode jemedessine() (appellons-là draw() si tu veux bien)

Après s'être aperçu de ces points communs, on va pouvoir dire à Java --> ces objets ont des points communs. Cela est fait grâce à ce qu'on appelle une interface. Il s'agit d'un contrat passé avec Java disant que toute classe dont on dit qu'elle implémente cette interface va contenir les fameux points communs.
Une interface se déclare comme suit

Code :

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

1
2
3
4
5
6
7
 
public interface ObjetGraphique {
  // on dit que tous les Objets graphiques se dessinent
  public void draw(Graphics g);
  //on dit qu'on peut les bouger
  public void setLocation(int x, int y);
}

A partir de là, on ne peut pas créer d'ObjetGraphique puisqu'on ne peut pas instancier (ie faire de new) une interface. On crée donc un type général qui représentera ces objets et qui respecte le contrat:

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
public abstract class AbstractObjetGraphique implements ObjetGraphique{

 Point aLocation;

 public AbstractObjetGraphique(){
 aLocation=new Point();
}

 public abstract void draw(Graphics g);
 
 public abstract void setLocation(int x, int y){
  aLocation.x=x;
  aLocation.y=y; 
}
}

Jusqu'ici, tous les objets ont en commun ce qu'il y a au dessus. L'idée c'est d'hériter de cette classe en faisant par 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
16
17
18
19

public class Rectangle extends AbstractObjetGraphique {

  //membres propres au rectangle 
  int width;
  int height;
  public Rectangle(){
   super(); 
   width=100;
   height=300;
}
   //et là tu dois implémenter draw
   public void draw(Graphics g){
   g.setColor(Color.BLACK);
   g.drawRect(x, y, width, height);
}

}

Et tu peux le faire pour tous les objets graphiques que tu voudras, tant que tu as extends AbstractObjetGraphique.
Comme ça dans ton panel tu déclares:

Code :

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

1
2
 
ArrayList<ObjetGraphique> anArrayList;

tu ajoutes différents objets :

Code :

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

1
2
3
4
 
anArrayList.add( new Rectangle());
anArrayList.add( new Cercle());
anArrayList.add( new Point());

en oubliant pas de les renseigner sur leurs membres propres, leur position etc
et dans ta méthode paint :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public void paint(Graphics g){
//tu parcours ta liste (Attention JDK >= 1.5 seulement sinon il faut faire une boucle for (int i = 0;i<anArrayList.size();i++))
for (ObjetGraphique aGObj : anArrayList)
 {
  //ici, grâce à la puissance du langage, le compilateur sait que tous les GObj 
  // ont au moins une méthode draw(). De plus, a l'éxecution, chaque objet 
  // a un type propre (Rectangle, Cercle, Point, etc), et c'est donc la méthode
  // de ce type propre qui sera appelée .
  aGObj.draw(g);
 }
 
}

Voilà, j'espère avoir été un peu plus clair

Bienvenue au coeur du Langage Objet !