Applets java

D'accord j'ai fait une applet pour qu'en fait quand on tape sur les flèches du clavier le programme réagit, j'ai pas trouvé comment faire autrement, est-ce qu'une fenetre simple JFrame est capable de modifier ce qu'elle affiche quand on tape sur les flèches du clavier ? j'ai essayé mais j'ai pas réussi

Oui, les mécanismes de Listener du awt sont les mêmes pour les JFrame et les applets. La grosse différence entre les deux est architecturale (page html vs programme Java). Du coup tu devras modifier ton point d'entrée, la méthode init() d'une applet devenant un main classique avec création et affichage de la JFrame. Mais en terme de fonctionnalités la JFrame peux faire tout ce que l'applet fait, mais peux faire bien plus, notamment la manipulation de fichiers sur le système.

En faisant une simple conversion copier/coller ça donne ceci :

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;

public class Jeu extends JFrame
{
    /*** L'affichage ***/
    int cote = 2, x = 30, y = 30;
    int[][] jeu = new int[cote][cote];
    
    // JButton bouton = new JButton("Recommencer");
    
    public Jeu()
    {
        setSize(180, 120);
        Color myColor = new Color(130, 157, 251);
        setBackground(myColor);
        
        addKeyListener(new KeyDown());
    }
    
    @Override
    public void paint(Graphics g)
    {
        for (int i = 0; i < cote; i++ )
            for (int j = 0; j < cote; j++ )
            {
                g.drawString("" + jeu[i][j], x, y);
                x += 100;
                if (j == (cote - 1))
                {
                    x = 30;
                    y += 50;
                }
            }
        x = 30;
        y = 30;
    }
    
    private class KeyDown implements KeyListener
    {
        @Override
        public void keyTyped(KeyEvent e) { }
        
        @Override
        public void keyReleased(KeyEvent e)
        {
            switch (e.getKeyCode())
            {
                case KeyEvent.VK_LEFT :
                    jeu[0][0]++ ;
                    break;
                case KeyEvent.VK_RIGHT :
                    jeu[0][1]++ ;
                    break;
                case KeyEvent.VK_UP :
                    jeu[1][0]++ ;
                    break;
                case KeyEvent.VK_DOWN :
                    jeu[1][1]++ ;
                    break;
            }
            
            repaint();
        }
        
        @Override
        public void keyPressed(KeyEvent e) { }
    }
    
    public static void main(String[] args)
    {
        Jeu jeu = new Jeu();
        jeu.setVisible(true);
        jeu.setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

Remarque : ça fonctionne, mais avec des bugs d'affichage. D'une part parce que ta première ligne de chiffres est cachée par la barre de menus (avec les boutons réduire/agrandir/fermer la fenêtre), d'autre part parce que tu écris les chiffres les uns aux dessus des autres sans effacer au préalable le chiffre du dessous (les applets le font toutes seules mais pas ici).

En corrigeant ces quelques bugs d'affichage ça donne ça :

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;

public class Jeu extends JFrame
{
    /*** L'affichage ***/
    int cote = 2, x = 30, y = 30;
    int[][] jeu = new int[cote][cote];
    Color myColor = new Color(130, 157, 251);
    
    // JButton bouton = new JButton("Recommencer");
        
    public Jeu()
    {
        setSize(180+8, 120+31);
        addKeyListener(new KeyDown());
    }
    
    @Override
    public void paint(Graphics g)
    {
        super.paint(g);
        
        g.setColor(myColor);
        g.fillRect(0, 0, getWidth(), getHeight());

        g.setColor(Color.BLACK);
        for (int i = 0; i < cote; i++ )
            for (int j = 0; j < cote; j++ )
            {
                g.drawString("" + jeu[i][j], x+8, y+31);
                x += 100;
                if (j == (cote - 1))
                {
                    x = 30;
                    y += 50;
                }
            }
        x = 30;
        y = 30;
    }
    
    private class KeyDown implements KeyListener
    {
        @Override
        public void keyTyped(KeyEvent e)
        {
        }
        
        @Override
        public void keyReleased(KeyEvent e)
        {
            switch (e.getKeyCode())
            {
                case KeyEvent.VK_LEFT :
                    jeu[0][0]++ ;
                    break;
                case KeyEvent.VK_RIGHT :
                    jeu[0][1]++ ;
                    break;
                case KeyEvent.VK_UP :
                    jeu[1][0]++ ;
                    break;
                case KeyEvent.VK_DOWN :
                    jeu[1][1]++ ;
                    break;
            }
            
            repaint();
        }
        
        @Override
        public void keyPressed(KeyEvent e)
        {
        }
    }

    public static void main(String[] args)
    {
        Jeu jeu = new Jeu();
        jeu.setVisible(true);
        jeu.setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

Cependant, ça reste assez moche, on peut faire beaucoup mieux en trois fois rien.

import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class Jeu extends JFrame
{
    private static final long serialVersionUID = 1L;
    
    private final int cote;
    private JLabel[][] jeu;
    
    private Color myColor = new Color(130, 157, 251);
    
    // JButton bouton = new JButton("Recommencer");
    
    public Jeu(int dim)
    {
        setTitle("2048");
        getContentPane().setBackground(myColor);
        
        cote = dim;
        jeu = new JLabel[dim][dim];
        setLayout(new GridLayout(dim, dim));
        
        for (int i = 0; i < dim; i++ )
            for (int j = 0; j < dim; j++ )
            {
                jeu[i][j] = new JLabel("0", JLabel.CENTER);
                add(jeu[i][j]);
            }
        
        addKeyListener(new KeyDown());
        
        setLocationRelativeTo(null);
        setVisible(true);
        setSize(200, 200);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
    
    private void incr(int i, int j)
    {
        JLabel label = jeu[i][j];
        String text = label.getText();
        int value = Integer.parseInt(text) + 1;
        label.setText(String.valueOf(value));
    }
    
    private class KeyDown implements KeyListener
    {
        @Override
        public void keyTyped(KeyEvent e)
        {
        }
        
        @Override
        public void keyReleased(KeyEvent e)
        {
            switch (e.getKeyCode())
            {
                case KeyEvent.VK_LEFT :
                    incr(0, 0);
                    break;
                case KeyEvent.VK_RIGHT :
                    incr(0, 1);
                    break;
                case KeyEvent.VK_UP :
                    incr(1, 0);
                    break;
                case KeyEvent.VK_DOWN :
                    incr(1, 1);
                    break;
            }
        }
        
        @Override
        public void keyPressed(KeyEvent e)
        {
        }
    }
    
    public static void main(String[] args)
    {
        new Jeu(2);
    }
}

Wow ! merci beaucoup !!! =)

Ah zut je voulais mettre le programme "gauche" ici :
case KeyEvent.VK_LEFT :
gauche(jeu);
break;

Mais j'ai une erreur :
Jeu.java:67: gauche(int[][]) in Jeu cannot be applied to (javax.swing.JLabel[][])
gauche(jeu);

le programme gauche ne fait que modifier les nombre entiers du tableau :
public void gauche (int[][]){
...
}

En effet, dans le troisième code j'ai changé le type de

int[][] jeu;

en

JLabel[][] jeu;

parce que j'ai enlevé le

paint(Graphics g)

et donc tous les

g.drawString(""+jeu[i][j]

. À la place j'ai utilisé des JLabel qui permettent d'afficher automatiquement le texte avec le paint par défaut de JFrame, et comme on peut modifier la valeur dans les JLable, le tableau d'entier ferait doublon...

Ainsi j'ai modifié

jeu[0][0]++;

par

incr(0,0);

où la méthode

incr

permet de récupérer la valeur du JLabel, l'augmenter de 1 et mettre la nouvelle valeur dans le JLabel, et la modification est directement affiché sans rien faire de plus.

Pour faire pareil mais avec n'importe quelle opération tu peux utiliser ces deux méthodes :

private int getValue(int i, int j)
{
    JLabel label = jeu[i][j];
    String text = label.getText();
    return Integer.parseInt(text);
}

private void setValue(int i, int j, int value)
{
    JLabel label = jeu[i][j];
    String text = String.valueOf(value);
    label.setText(text );
}

Une opération que tu aurais fait avant comme ceci

jeu[a][b] = jeu[c][d] + jeu[e][f]

devient donc

setValue(a, b, getValue(c, d) + getValue(e, f));

c'est plus propre.

Déjà, ne masque pas l'exception avec ton System.out.println("test");
Pour pouvoir corriger l'erreur il faut savoir ce qu'elle est. Fais donc plutôt :

/**
 * @param jeu tableau à enregistrer dans le fichier
 * @return true si le tableau a bien été enregistré, false en cas d'erreur
 */
public static boolean enregistrer(int[][] jeu)
{
    try
    {
        EnregistreurFichier sauv = new EnregistreurFichier(); 
        sauv.choisirFichier("partie.txt") ; 
        sauv.enregistrerTableau(jeu);
        return true;
    }
    catch (Exception e)
    {
        e.printStackTrace(); // affichage de l'exception
        return false;
    }
}

Ensuite, pour t'aider il me faudra le code de EnregistreurFichier pour savoir où tu t'es trompé.
Sur le forum mets ton code avec les balises

<code java>ton code</code>

cela permettra de mieux le voir, avec les indentations, les couleurs, et surtout les numéros de lignes.
En effet l'exception va dire en gros "erreur ligne 5" (par exemple) il faut donc que je puisse en regardant ton code savoir à quoi correspond la ligne 5...

Super ça marche merci !
Par contre je comprends pas à quoi servent les @Overides dans la classe KeyDown

Et aussi le "super.paint(g)"

Bonsoir,

Tes deux questions concernent l'héritage, qui est une notion fondamentale en conception objet.
Alors je ne vais pas te faire un cours de programmation orientée objet et du coup tu ne comprendras peut-être toujours pas à quoi ça sert mais au cas où voici les réponses "courtes" :

@Override ne change rien au programme, c'est une annotation qui permet de s'assurer que la méthode est bien une redéfinition.

Dans ton code tu as une classe Jeu extends JFrame, la classe JFrame définit une méthode paint(Graphics), mettre @Override est une sécurité dans le développement parce qu'en la mettant dans la classe Jeu je suis sûr que cette méthode est bien la méthode paint définie par JFrame, et non une surcharge. En effet si je me trompais dans le nom de la méthode, ou dans le type des paramètres ou le type de retour, la méthode "paint" que j'aurais défini ne serait plus celle utilisée par JFrame et n'aurait donc rien à voir avec la rafraîchissement de la fenêtre. Mais comme j'ai mis @Override j'aurais une erreur à la compilation qui m'indiquera que ce n'est pas la méthode redéfinie à laquelle je pensais.

Exemple :

@Override // compile
public void paint(Graphics g)

@Override // ne compile pas
public void paint()

Par extension, depuis Java 6, on peut également utiliser @Override sur les méthodes définies par les interfaces comme c'est le cas avec les KeyListener. Pour un développeur averti cela permet de tout de suite voir quelles méthodes sont obligatoires (car imposées par l'interface) et lesquelles sont spécifiques à la classe (et éventuellement modifiables).

Remarque :
@Override peut être supprimée sans influence sur le code, c'est juste un outil de développement.

Ensuite, passons à super.paint(g) qui est un peu plus important.
Dans la hierarchie de classe on ça :

java.lang.Object
    java.awt.Component
        java.awt.Container
            java.awt.Window
                java.awt.Frame
                    javax.swing.JFrame
                        Jeu

Cela signifie donc que Jeu extends JFrame, JFrame extends Frame, Frame extends Window, etc.
La méthode paint(Graphics) est définie par Component, en haut de la hiérarchie de classe, cela signifie que toutes les classes filles en dessous l'on soit réutilisé tel quel, soit apporté des modifications. Mais si on apporte des modifications à une méthode héritée, il ne faut pas tout écraser son comportement, mais rappeler les spécificités de la classe mère, il faut que ce soit additif.

En faisant super.paint(g) dans la classe Jeu, cela appelle la méthode paint(g) de la classe JFrame, qui va elle même faire un super.paint(g) pour appeller la méthode de Frame etc. ce qui permet de dessiner toute la JFrame comme il faut, et une fois la JFrame bien dessinées on fait les modifications spécifiques à Jeu.

Mettre super.paint(g) est donc très important pour avoir une JFrame correcte. Si on ne mets pas super.paint(g) cela signifie que l'on définit une méthode paint comme si c'était un Component. On supprime donc toutes les particularités apportées par Component, Container, Window, etc. Dans les premier et deuxième codes que j'ai donné pour adapter ton Applet ça ne changerait pas grand chose, car finalement tu fais tout le dessin dans paint, tu t'en sers donc comme un Component sans tirer profit des spécificités d'une JFrame. En revanche dans le troisième code j'avais fortement utilisé la JFrame, tellement bien que je n'avais plus du tout de méthode paint ! En effet je laisse faire la classe JFrame pour dessiner la fenêtre. Ce qui signifie que si je devais redéfinir la méthode paint pour ce troisième code, il serait indispensable de mettre un super.paint(g) sans quoi plus rien ne s'afficherai correctement car toute la méthode paint de JFrame (qui me fait actuellement tout mon affichage) ne fonctionnerai plus car remplacé par la nouvelle méthode paint.

En règle générale (même si ce n'est pas toujours vrai) il faudrait donc avoir un super.nomDeLaMethode pour toutes les méthodes surchargées, celles ci étant annotées @Override pour faciliter le développement.

D'accord j'ai compris un peu l'idée, merci !