Méthode static paintComponent(Graphics g)

Résolu
caroline -  
 caroline -
svp ,j'ai besoin d'une méthode paintComponent(Graphics g) qui soit static ,c'est a dire j'appelle la méthode paintComponent(Graphics g) avec de nouveau cordonnées

4 réponses

Réponse 1 / 4
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Comme je l'ai déjà dit, je ne vois pas en quoi ce que tu veux faire peut-être lié à l'utilisation d'une méthode static !
Une méthode est static signifie qu'elle ne s'applique à aucun objet, alors que toi tu as bien un objet et en plus tu le modifies... ton problème n'est pas lié à des méthodes static !

Si tu veux dessiner ton graphe à chaque fois qu'il est modifié, tu dois appeler une méthode d'affichage après chaque modification... avec repaint peut-être ?
0
caroline
 
je t'envoie le code
0
caroline
 
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import javax.swing.*;

public class GraphingData11 extends JPanel {
final int PAD = 20;
//3 variables pour tracer la ligne de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
static int multi;static int multi1;static int k;

//la fonction factoriel
public static double factorial(int N){for (int i = 1; i <= N; i++){multi = multi*i;}return multi;}

//la fonction qui calcule le factoriel de k=1 jusqu'a 100,et la je dessine la graphe
//pour chaque k

public static double FUNCTION(){
int k=1;multi1=0;
while (k<=100){factorial(k);

//paintComponent(Graphics g) je veux appeler la méthode paintComponent(Graphics g) //chaque fois avec les nouveaux cordonné de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
// fact(k=1) c'est la variable multi1 et fact(k=2) c'est la variable multi

multi1=multi;
k=k+1;}
return 0;}

//la fonction qui dessine les points et les lignes

protected void paintComponent1(Graphics g) {
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
int w = getWidth(); // Largeur de la fenêtre
int h = getHeight(); // Hauteur de la fenêtre

// dessiner ordonnée.
g2.draw(new Line2D.Double(PAD, PAD, PAD, h-PAD));
// dessiner abscisse.
g2.draw(new Line2D.Double(PAD, h-PAD, w-PAD, h-PAD));

//couleur de la ligne
g2.setPaint(Color.red);
//dessiner la ligne
g2.draw(new Line2D.Double(PAD + (20*(k-1)),h - (PAD +multi1), PAD + (20*(k)), h - (PAD + multi)));
//couleur de point
g2.setPaint(Color.red);
//dessiner le point
g2.fill(new Ellipse2D.Double(PAD +(20*(k-1)),h - (PAD + multi1),2,2));

}


public static void main(String[] args) {
FUNCTION();
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new GraphingData11());
f.setSize(400,400);
f.setLocation(200,200);
f.setVisible(true);
}
}
0
Réponse 2 / 4
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Le moins que l'on puisse dire c'est que tu as une manière très étrange de concevoir ton code. Dans ton cas, il est faux de mettre static à tes variables privées, de même qu'à tes méthodes...

Je ne dis pas que mon code est parfait, mais regardes le en détail pour voir comment j'ai fait et apprendre de tes erreurs ;)

Détail important : tu voulais afficher la factorielle jusqu'à k=100, mais c'est absolument impossible, car elle prend rapidement des valeurs gigantesques.
Alors ne t'étonnes pas de ne voir s'afficher que les première valeurs de la fonction sur ta courbe, les autres sont hors cadres !
Par exemple dans ta fenêtre 400x400, 6! = 720 ne pourrait pas être affiché ! 
import java.awt.*;  
import java.awt.geom.*;  
import javax.swing.*;  

public class GraphingData11 extends JPanel 
{  
    private static final long serialVersionUID = 1L; 

//////////////////////////////////////////////////////////// 

    /** nombre de pixels utilisés comme unité d'affichage */ 
    private double unite; 
     
    /** nombre de pixels utilisés entre le bord et les axes */ 
    private double bord; 
         
    /** le dernier entier dont on a calculé la factorielle */ 
    private byte n; 
     
    /** le dernier résultat obtenu par calcul de la factorielle */ 
    private long fact; 
     
    /** true lorsqu'on a effectivement fact égal à n!, false sinon (débordement calculs) */ 
    private boolean ok;      

//////////////////////////////////////////////////////////// 

    /** 
     * @param unite la taille de l'unité horizontale  
     * @param bord l'espacement entre le bord de la fenêtre et les axes 
     */ 
    GraphingData11(double unite, double bord) 
    { 
        this.bord=bord; 
        this.unite=unite; 
    } 

//////////////////////////////////////////////////////////// 

    /** initialise le calcul de la factorielle */ 
    private void initFactorielle() 
    { 
        n=0; 
        fact=1; 
        ok=true; 
    } 
     
    /** calcule une nouvelle itération de la factorielle */ 
    private void incrFactorielle() 
    { 
        n++; 
        long fact2 = fact*n; 
        ok = ok && fact2>=fact; 
        fact=fact2; 
    } 
     
    /** @return true si le calcul est fiable, false si on a eu débordement de calculs */ 
    private boolean okFactorielle() 
    { 
        return ok; 
    } 

//////////////////////////////////////////////////////////// 

    /** dessin du graphe */ 
    public void paint(Graphics g) 
    {  
        Graphics2D g2 = (Graphics2D) g;     
        int w = getWidth(); // Largeur de la fenêtre  
        int h = getHeight(); // Hauteur de la fenêtre  
       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);  
     
        // dessiner les axes 
        g2.setPaint(Color.blue); 
        g2.draw(new Line2D.Double(bord,bord,bord,h-bord)); 
        g2.draw(new Line2D.Double(bord,h-bord,w-bord,h-bord)); 
         
        double unite2 = Math.sqrt(unite); // epaisseur des ellipses 

        g2.setPaint(Color.red); 
        for (initFactorielle(); okFactorielle() && fact<h-bord; incrFactorielle())  
        {         
            g2.draw(new Line2D.Double(bord+unite*n, h-(bord+fact), bord + unite*(n+1), h-(bord+fact))); 
            g2.fill(new Ellipse2D.Double(bord+unite*n, h-(bord+fact+unite2/2), unite2, unite2));  
        } 
    }  

//////////////////////////////////////////////////////////// 

    /** Affichage de la fenêtre */ 
    public static void main(String[] args) 
    {  
        JFrame jf = new JFrame(); 
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        jf.setSize(400,800); 
        jf.setVisible(true); 

        jf.add(new GraphingData11(40,10));  
    }  
}

La confiance n'exclut pas le contrôle
0
caroline
 
merci , mais se n'est pas ce que je veux,je ne veux pas une boucle qui calcule de 1 jusqu'à 100
mais a chaque k en on fait la mise a jour de la fenêtre
0
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Je ne vois pas ce que ça change, ici à chaque k (n chez moi), la fenêtre a été mise à jour pour dessiner le nouveau point...
De plus de 1 à 100, oublie ! Tu ne dépasseras jamais 20, à partir de 21 tu débordes...
0
caroline
 
oui j'ai compris pour le débordement je vais changer mon code
0
caroline
 
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import javax.swing.*;

public class GraphingData11 extends JPanel {
final int PAD = 20;
static double multi=1;static double multi1;
static int k;
static long t0;
static long t1;
//3 variables pour tracer la ligne de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
//la fonction factoriel
public static double factorial(int N){
multi=1;
for (int i = 1; i <= N; i++){multi = multi*i;}
System.out.println(multi);
return multi;}

//la fonction qui calcule le factoriel de k=1 jusqu'a 100,et la je dessine la graphe
//pour chaque k

public static double FUNCTION(){
int k=1;multi1=0;
while (k<=100){factorial(k);

//paintComponent(Graphics g) je veux appeler la méthode paintComponent(Graphics g) //chaque fois avec les nouveaux cordonné de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
// fact(k=1) c'est la variable multi1 et fact(k=2) c'est la variable multi

//pour attendre un petit moment puis calculer factoriel de k
////////////////////////////////////////////
t0 = System.currentTimeMillis();
do{t1 = System.currentTimeMillis();}while (t1 - t0 < 10000);
///////////////////////////////////////



multi1=multi;
k=k+1;}
return 0;}

//la fonction qui dessine les points et les lignes

protected void paintComponent1(Graphics g) {
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
int w = getWidth(); // Largeur de la fenêtre
int h = getHeight(); // Hauteur de la fenêtre

// dessiner ordonnée.
g2.draw(new Line2D.Double(PAD, PAD, PAD, h-PAD));
// dessiner abscisse.
g2.draw(new Line2D.Double(PAD, h-PAD, w-PAD, h-PAD));

//couleur de la ligne
g2.setPaint(Color.red);
//dessiner la ligne
g2.draw(new Line2D.Double(PAD + (20*(k-1)),h - (PAD +multi1), PAD + (20*(k)), h - (PAD + multi)));
//couleur de point
g2.setPaint(Color.red);
//dessiner le point
g2.fill(new Ellipse2D.Double(PAD +(20*(k-1)),h - (PAD + multi1),2,2));

}


public static void main(String[] args) {
FUNCTION();
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new GraphingData11());
f.setSize(400,400);
f.setLocation(200,200);
f.setVisible(true);
}
}
0
Réponse 3 / 4
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
J'ai plutôt repris mon code, parce que je n'étais pas si loin que ça de ce que tu voulais.... Enfin, si j'ai bien compris ce que tu voulais ^^

J'ai juste transformé mon main pour en faire une méthode qui appelle plusieurs fois le calcul de la factorielle (en incrémentant la valeur maximale) et en laissant passer un peu de temps entre deux repaint()... 

import java.awt.*; 
import java.awt.geom.*; 
import java.util.Scanner;

import javax.swing.*; 

public class GraphingData11 extends JPanel
{ 
    private static final long serialVersionUID = 1L;

////////////////////////////////////////////////////////////
    
    /** nombre de pixels utilisés comme unité d'affichage */
    private double unite;
    
    /** nombre de pixels utilisés entre le bord et les axes */
    private double bord;
        
    /** le dernier entier dont on a calculé la factorielle */
    private byte n;
    
    /** la dernière valeur maximale de n */
    private byte m;
    
    /** le dernier résultat obtenu par calcul de la factorielle */
    private long fact;
    
    /** true lorsqu'on a effectivement fact égal à n!, false sinon (débordement calculs) */
    private boolean ok; 
    

////////////////////////////////////////////////////////////
    
    /**    
     * @param unite
     * @param bord
     */
    GraphingData11(double unite, double bord)
    {
        m=0;
        this.bord=bord;
        this.unite=unite;
    }

////////////////////////////////////////////////////////////
    
    /** initialise le calcul de la factorielle */
    private void initFactorielle()
    {
        n=0;
        fact=1;
        ok=true;
    }
    
    /** calcule une nouvelle itération de la factorielle */
    private void incrFactorielle()
    {
        n++;
        long fact2 = fact*n;
        ok = ok && fact2>=fact;
        fact=fact2;
    }
    
    /** @return true si le calcul est fiable, false si on a eu débordement de calculs */
    private boolean okFactorielle()
    {
        return ok;
    }

////////////////////////////////////////////////////////////
    
    /** dessin du graphe */
    public void paint(Graphics g)
    { 
        Graphics2D g2 = (Graphics2D) g;    
        int w = getWidth(); // Largeur de la fenêtre 
        int h = getHeight(); // Hauteur de la fenêtre 
        
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON); 
        
        g2.setPaint(Color.blue);
        g2.draw(new Line2D.Double(bord,bord,bord,h-bord));
        g2.draw(new Line2D.Double(bord,h-bord,w-bord,h-bord));
        
        double unite2 = Math.sqrt(unite); // epaisseur de l'ellipse
        
        for (initFactorielle(); n<m && fact<h && okFactorielle(); incrFactorielle())
        {
            g2.setPaint(Color.red);
            g2.draw(new Line2D.Double(bord+unite*n, h-(bord+fact), bord + unite*(n+1), h-(bord+fact)));
            g2.fill(new Ellipse2D.Double(bord+unite*n, h-(bord+fact+unite2/2), unite2, unite2)); 
        }
    } 
    
    /** Boucle qui affiche successivement les résultats */
    public void executer(int mMax,long delay)
    {
        JFrame jf = new JFrame();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setSize(400,800); 
        jf.setVisible(true);        
        jf.add(this);
        for (m=1; m<mMax; m++)
        {
            long t = System.currentTimeMillis()+delay; 
            while (System.currentTimeMillis()<t); 
            jf.repaint();
        }
    }
    
////////////////////////////////////////////////////////////
    
    /** Affichage de la fenêtre */
    public static void main(String[] args)
    { 
        new GraphingData11(40,10).executer(10,500);
    } 
}
0
caroline
 
merci beaucoup et dsl pour dérangement mais se n'est pas se que je veux
0
caroline
 
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import javax.swing.*;

public class GraphingData11 extends JPanel {
final int PAD = 20;
static double multi=1;static double multi1;
static int k;
static long t0;
static long t1;
//3 variables pour tracer la ligne de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
//la fonction factoriel
public static double factorial(int N){
multi=1;
for (int i = 1; i <= N; i++){multi = multi*i;}
System.out.println(multi);
return multi;}

//la fonction qui calcule le factoriel de k=1 jusqu'a 100,et la je dessine la graphe
//pour chaque k

public static double FUNCTION(){
int k=1;multi1=0;
while (k<=100){factorial(k);

//paintComponent(Graphics g) je veux appeler la méthode paintComponent(Graphics g) //chaque fois avec les nouveaux cordonné de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2)
// fact(k=1) c'est la variable multi1 et fact(k=2) c'est la variable multi

//pour attendre un petit moment puis calculer factoriel de k
////////////////////////////////////////////
t0 = System.currentTimeMillis();
do{t1 = System.currentTimeMillis();}while (t1 - t0 < 10000);
///////////////////////////////////////

//je veux appeler repaint ici est ce que je peux faire sa je veux sa

multi1=multi;
k=k+1;}
return 0;}

//la fonction qui dessine les points et les lignes

protected void paintComponent1(Graphics g) {
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
int w = getWidth(); // Largeur de la fenêtre
int h = getHeight(); // Hauteur de la fenêtre

// dessiner ordonnée.
g2.draw(new Line2D.Double(PAD, PAD, PAD, h-PAD));
// dessiner abscisse.
g2.draw(new Line2D.Double(PAD, h-PAD, w-PAD, h-PAD));

//couleur de la ligne
g2.setPaint(Color.red);
//dessiner la ligne
g2.draw(new Line2D.Double(PAD + (20*(k-1)),h - (PAD +multi1), PAD + (20*(k)), h - (PAD + multi)));
//couleur de point
g2.setPaint(Color.red);
//dessiner le point
g2.fill(new Ellipse2D.Double(PAD +(20*(k-1)),h - (PAD + multi1),2,2));

}


public static void main(String[] args) {
FUNCTION();
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new GraphingData11());
f.setSize(400,400);
f.setLocation(200,200);
f.setVisible(true);
}
}

je veux appelr repaint dans la fonction fatoriel
et merci
0
caroline
 
je ne veux pas la boucle
for (initFactorielle(); n<m && fact<h && okFactorielle(); incrFactorielle())
la tu calcule puis tu affiche moi je veux dessiner chaque fois pour k donner et son factoriel
svp ,aide moi
0
caroline
 
je te donne un autre exemple comme le gestionnaire des taches ----->performance
tu vois le diagramme je veux mon programme faire exactement sa
0
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
En fait tu veux le même résultat (d'un point de vue visuel), mais en te servant de ce qui a déjà été dessiné auparavant, juste en rajoutant un seul point...
Le problème c'est que repaint() efface tout, je vais essayer de mettre des paramètres à repaint() ça n'effacera peut-être que la partie que l'on modifie, dans ce cas y aurait pas besoin de tout recalculer...
Mais je me répète, je n'avais jamais utilisé java.awt avant ^^
0
Réponse 4 / 4
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Je ne connais pas java.awt, et je ne sais pas trop en quoi changer ton objet nécessite que cette méthode soit static, néanmoins tu peux essayer ceci : 

public static void paintComponent(JComponent jc,Graphics g)
{
      jc.paintComponent(g);
}

Ce tour de passe-passe peut se généraliser pour transformer n'importe quelle méthode en méthode static...
-1
caroline
 
merci mais je t'explique se que je cherche
je veux que la fenêtre reste ouverte et le graphe continue a se dessiner a chaque fois que les cordonnées soit calculer
la premier étape :la fenêtre s'ouvre et il y a juste ordonnée et abscisse.
la deuxième étape:une fois la fonction factoriel calcule factoriel(k=2) alors la fenêtre affiche le graphe de (k=1,fact(k=1)=1) a (k=2,fact(k=2)=2) (la ligne) (comme il fait la mise a jour de la fenêtre et il affiche la ligne, et la fenêtre reste ouvert et une fois la fonction factoriel calcule factoriel(k=3) alors la fenêtre affiche le graphe de (k=2,fact(k=2)=2) a (k=3,fact(k=3)=6) (la ligne) ex..

et merci
0
caroline
 
sa ne marche pas , la methode que vous m'avez donner
0

Discussions similaires

Superposition de JPanel
MrMahus -
MrMahus -

1 réponse
Afficher différentes images dans un jpanel
drakahon -
drakahon -

11 réponses
positionner un JLabel dans un JPanel avec ses coordonées
ezor -
yamdjio -

1 réponse
Jpanel contentPane cannot be set to null
bibuman -
bibuman -

3 réponses