Reprise du message précédent :
c'est pour ca que j'aime bien

 
Rhoooooooooo    

Ben j'ai un QI très moyen (100) alors... avant de m'engager dans quelque chose de trop compliqué, je préfère me renseigner...

Alors ?

on  est sur prog ici, entre gens intelligents, on a pas de bas de plafonds (socialistes, nordiste, chomistes ou moderateurs) pour mordre a tes trolls de base sans creativité ni panache

Bonjour,
 
Je vais devoir m'autoformer à Java et Struts pour un futur projet, bon j'ai pas trop d'appréhensions étant donné que j'ai pas mal bossé sous Zend Framework et php5 , ça devrait déja me faciliter les choses
 
Ceci dit, qu'est ce que vous me conseilleriez comme outils (editeurs & co) pour commencer ?

une corde

C'est si nul/compliqué que ça?

Masklinn a préféré démissionner plutôt que de continuer à en faire.
Maintenant il fait du PHP4 en freelance...

Si c'est struts 1, c'est encore plus nul que ça

Non

Moi qui pensais prendre autant voir plus de plaisir qu'avec Zend Framework, espérons que ceci n'est qu'un gros troll
Pour  struts ça sera surement la toute dernière version, c'est un projet qui débute.

J'en serais pas aussi sûr que toi, Struts 2 est très différent de Struts 1 et il y a encore des gens qui partent sur Struts 1.
 
Après tant mieux si c'est pas le cas, Struts 2 est moins pire que Struts 1. C'est néanmoins pas la panacée non plus

en IDE ben t'as Eclipse ou Netbeans en gratuit, et IntelliJ en payant qui sont très bien...

Mais est-ce que nous pouvons prendre Eclipse en payant???  

 
oui, je te le vends si tu veux
 
[spoiler]sinon, il y a a myEclipse si tu veux vraiment payer

Il faut faire tourné le pays...

 
AH MAIS CEST CELUI QUI CROIT QU'UN IDE CA VEUT DIRE "Infirmier diplômé d'État"
 

j'ai une NPE 3 fois sur 4 (c'est aleatoire en plus ) avec ce code :
 

/** classe GameWindow, etend un JFrame
 * crée et gere la fenetre de jeu
 * @extends JFrame
 * @author tomas
 * @version 0.01
 */
public class GameWindow extends JFrame{
    
    /* constante finale pour recuperer la largeur par defaut de la fenetre */
    public static final int DEFAULTWIDTH = 800;
    
    /* constante finale pour recuperer la hauteur par defaut de la fenetre */
    public static final int DEFAULTHEIGHT = 600;
    
    /* constante finale pour recuperer le nombre d'images par seconde par defaut de la fenetre */
    public static final int DEFAULTFPS = 60;
    
    /* Timer qui gere la vitesse de rafraichissement de la fenetre */
    private Timer refresh = null;
    
    private Personnage joueur;
    
    /** Constructeur de la fenetre de jeu
     * @param width Largeur de la fenetre
     * @param height Hauteur de la fenetre
     * @param fps Nombre de frames par secondes
     */
    public GameWindow(int width, int height, int fps){
        /* appele le constructeur par defaut de la classe mere */
        super();
        
        /* definit les dimensions de la fenetre */
        this.setSize(width, height);
        
        /* definit la visibilité de la fenetre */
        this.setVisible(true);
        
        /* creation des joueurs */
        this.joueur = new Personnage(800, 200, 0);
        //this.joueurs[1] = new Personnage(300, 300, 1);
        
        /* demarre le timer de rafraichissement */
        this.refresh = new Timer(1000 / fps,  new ActionListener() {
                public void actionPerformed(ActionEvent evt) {
                    /* lorsque le timer sonne, on demande explicitement un rafraichissement */
                    repaint();
                }
            }
        );
        
        /* on precise au timer qu'il doit se repeter */
        this.refresh.setRepeats(true);
        
        /* et on le demarre */
        this.refresh.start();
    }
    
    /** PSVM, point d'entrée du programme     * 
     * @param args Parametres de ligne de commande
     */
    public static void main(String[] args) {
        /* on instancie un nouveau GameWindow avec les hauteur, largeur, et fps par defaut */
        new GameWindow(GameWindow.DEFAULTWIDTH, GameWindow.DEFAULTHEIGHT, GameWindow.DEFAULTFPS);
    }
    
    /** Surcharge de la methode paint de JFrame
     * avec cast de l'objet Graphics en Graphics2D
     * @param g Objet Graphics sur lequel dessiner le jeu
     */
    @Override public void paint(Graphics g){
        /* cast de l'objet Graphics en Graphics2D */
        Graphics2D g2d = (Graphics2D)g;
        
        /* dessin des personnages */
        this.joueur.draw(g2d);
        
        //this.joueurs[1].draw(g2d);
        this.joueur.move(Personnage.GAUCHE);
        
    }
    
}

 
à la ligne ou je fais  
 

 
g2d qui merde ?

c'est pas les parametres qui sont null à la ligne ou pète la NPE. en l'occurence ça ne peut être que "joueur".

oui, mais j'instancie bien joueur :
 

 
et d'ailleurs, il est bien affiché à l'ecran, mais la NPE ne se produit qu'une fois ou deux, alors qu'elle le devrait 60 fois par secondes,  
 
pas un probleme de threads ?
 
       

peut etre que le timer demande un rafraichissement, et donc utilise this.joueur alors qu'il n'a pas encore eu le temps d'etre crée ?
 
Personnage implemente une interface a moi, mais n'est pas un thread ou autre

quoique, personage demarre un timer statique à la premiere instanciation

C'est quoi l'intérêt du super s'il n'a pas de paramètres ?

ha bah oui, aucun
 
l'habitude sans doute

essaye de faire que ta classe fasse une composition de frame au lieu d'en hériter (en gros crée un membre JFrame frame; et enlève l'héritage de JFrame)...c'est pas une super bonne pratique d'hériter d'un truc aussi énorme que JFrame
 
je suis pas certain (faudrait demander à nraynaud), mais le fait que t'appelles repaint dans le constructeur de l'objet c'est pas forcément top (il peut ne pas avoir fini d'etre initialisé)...essaye en sortant le timer du constructeur et en en faisant une méthode séparée que tu appelles après avoir appelé le constructeur ...

si, l'interêt c'est de rendre le truc explicite.
 
et le prob c'est que tu fais setVisible() avant d'instancier Personnage, et donc ta methode paint() pète avant que Perso soit instancié... en gros en appelant setVisible() a la fin de ton constructeur ça devrait aller mieux.

 
mais comment je surcharge paint dans ce cas ?
 
Merci pour les infos sur le setvisible et autres j'essayes

je comprends pas très bien pourquoi tu surcharges paint()...
 
quand t'appelles update(Graphics g) sur ta frame, elle va appeler automatiquement paint() sur elle même et sur tous les composants qui lui sont associés...
 
donc si ton joueur a déjà été ajouté à la hiérarchie de composants, il va se refresh au passage...
 
y'a quoi dans ta méthode joueur.draw() ?

ha oui, je ne l'avais pas vu comme ca
 
effectivement ca devrait marcher
 
joueur.draw() prend en param en graphics 2d, et affiche une buffered image sur le graphics 2d, donc dans la jframe

t'as un getGraphics() sur la Jframe, donc t'es pas obligé de la surcharger pour l'obtenir...

ok

J'ai pas le droit de faire ça :
 

vlivre.addElement(new Livre(titre[i], reference[i]));

addElement c'est une méthode de Java, ça demande un objet.

faut poster plus de code, tu donnes rien là :  
 

• de quel type est vlivre (on dirait un Vector, tu confirmes ? Si oui utilises une ArrayList à la place, Vector est déprécié)
• quel est le constructeur de Livre ?
• que vaut i
• quels sont les contenus des tableaux titre et reference ?
• quel est le msg d'erreur ?

Désolé pour le manque de détails.
 

• vlivre est bien un vecteur.

Je ne peux pas utiliser ArrayList, c'est explicitement demandé dans le TP d'utiliser des vecteurs (si je pouvais savoir pourquoi il vaut mieux utiliser ArrayList que Vector, je suis prenneur).
 

• Constructeur de livre :

public Livre (String titre, int reference) {
        this.titre = titre;
        this.reference = reference;
}

• i varie de 0 à la taille du vecteur livre.

• Titre = strings, références = int

• Message d'erreur (enfin, warning plutôt) : unchecked call to addElement(E) as a member of the raw type java.util.Vector.

Vector est une collection datant de Java 1.0, ArrayList fait partie du framework Collections introduit dans Java 1.2. Les différences principales sont que l'interface de List/ArrayList est moins grande (Vector a été rétroffité pour implémenter List, ce qui veut dire qu'il a pas mal de paire de méthodes ayant le même rôle mais des noms différents, donc ArrayList a une interface plus simple, plus propre, et uniforme avec le reste des Collections); et que Vector est une collection synchronisée (avec des locks toussa), ArrayList (et les classes du framework Collection en général) ne sont pas nativement thread-safe, mais le deviennent par composition (avec Collections#synchronizedList, Collections#synchronizedMap ou Collections#synchronizedSet, et les versions Sorted correspondantes), donc avant Java 1.6 Vector a tendance à avoir des perfs inférieures à ArrayList.

Parce que tu ne files pas de type générique à ton vector: utilises Vector<Livre> plutôt que Vector, et vas lire l'introduction sur les generics.

 
Merci pour l'explication
 

 
Vector<Livre>
Jamais vu comme notation, je dois l'utiliser à quel endroit ?
 
L'intro sur les generics, c'est bien celle là : http://java.sun.com/j2se/1.5.0/doc [...] erics.html ?

Partout.

http://java.sun.com/docs/books/tut [...] erics.html
 
La page que tu as trouvée est également intéressante (et à lire), mais c'est pas une intro.

Donc ça je laisse :
Vector vlivre = new Vector();
 
Mais ça par exemple :
vlivre.addElement(new Livre(titre[i], reference[i]));
 
devient :
Vector<vlivre>.addElement(new Livre(titre[i], reference[i]));
 

 
L'intérêt c'est de connaitre son type ou il y a plus que ça ?

C'est l'inverse. Comme indiqué dans la doc.

Lis la doc, c'est marqué dedans