Bonjours,

Comme le titre l'indique il se trouve que j'éprouve quelque difficulté à coder un jeu ressemblant à pong en Java
Cela fait déjà quelque semaine que je fouille le net à la recherche de codes de jeux de pong simple en algorithme,
pour m'inspiré .etc...
Mais je coince quand il s'agit de faire le tout en orienté objet avec plusieurs classe
Je n'arrive pas à faire bouger les raquettes avec les touches du clavier pourtant j'y arrive quand le tout est coder en une seule classe coder en seule classe .

Voila si il y a quelqu'un d'assez balèze en progra Java OO et qui a un peu de temps à me consacrer
qui pour m'aider à faire bouger les raquettes et la balle à l'écran.
Je lui en serais vraiment reconnaissant merci d'avance.

Voila le code:

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FenetrePong fenetre = new FenetrePong();

	}

}

import java.awt.BorderLayout;
import java.awt.Color;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class FenetrePong extends JFrame {
	private SurfaceDuJeu surface = new SurfaceDuJeu();
	private JPanel container = new JPanel();
	private JButton bouton = new JButton("Bouton");
	
	public FenetrePong(){
		/* Attribut de la fenetre */
        this.setTitle("PONG");
        this.setSize(800,600);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
        /* Container que l'on va placer à l'intérieure de la fenêtre */
        
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
        container.add(surface,BorderLayout.CENTER);
        container.add(bouton, BorderLayout.SOUTH);
        
        this.setContentPane(container);
        this.setVisible(true);
	}

}

/**
 * 
 * @author Bigpop
 * Interface qui contient les variable du jeu pour alléger un peu l'écriture du code
 */
public interface ConstantesDuJeu {
	/* Taille de la surface de jeu */
	public final int LARGEUR_SURFACE = 640;
	public final int HAUTEUR_SURFACE = 480;
	/* Placement des pongs des joueurs */
	public final int LARGEUR_PONG = 20;
	public final int HAUTEUR_PONG = 75;
	public final int PONG_JOUEUR1_DEPART_Y = HAUTEUR_SURFACE /2- HAUTEUR_PONG /2;
	public final int PONG_JOUEUR1_X = 20;
	public final int PONG_JOUEUR2_DEPART_Y = HAUTEUR_SURFACE /2- HAUTEUR_PONG /2;
	public final int PONG_JOUEUR2_X = LARGEUR_SURFACE - 40;
	public final int INCREMENT_PONG = 2;
	/* position de la balle */
	public final int TAILLE_BALLE = 25;
	public final int BALLE_X_DEPART = LARGEUR_SURFACE / 2-TAILLE_BALLE/2;
	public final int BALLE_Y_DEPART = HAUTEUR_SURFACE / 2-TAILLE_BALLE/2;
	
}

C'est surtout dans la classe MoteurJeuPong que il reste un bon boulo à faire XD mais je susi coincé la dessus depuis quelque temps déjà.
Et j'arrive toujours pas à faire varié le positionnement de la raquette en pixel sur l'écran :s

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;


public class MoteurJeuPong implements Runnable , KeyListener, ConstantesDuJeu {
	private SurfaceDuJeu surface;
	private SurfaceDuJeu table; // Référence à la table.
	private int pongJoueur1_Y = PONG_JOUEUR1_DEPART_Y ;
	private int pongJoueur2_Y = PONG_JOUEUR2_DEPART_Y;
	private int scoreJoueur1;
	private int scoreJoueur2;
	private int balle_X; // position X de la balle
	private int balle_Y; // position Y de la balle

	public MoteurJeuPong(SurfaceDuJeu surfaceJeu) {
		surface = surfaceJeu;
		Thread travailleur = new Thread(this);
		travailleur.start();
	}
	public void keyPressed(KeyEvent ke) {

		if(haut){
			if(pongJoueur1_Y > 0)
				pongJoueur1_Y -=INCREMENT_PONG;
		}
		if(bas){
			if(pongJoueur1_Y < HAUTEUR_SURFACE - HAUTEUR_PONG/2)
				pongJoueur1_Y +=INCREMENT_PONG;
		}
		surface.positionnerPongJoueur1_Y(pongJoueur1_Y);
	}
	public void keyReleased(KeyEvent ke){
		switch(ke.getKeyCode()){
		case KeyEvent.VK_DOWN:
			bas=false;
			break;
		case KeyEvent.VK_UP:
			haut=false;
			break;
		case KeyEvent.VK_A:
			haut2=false;
			break;
		case KeyEvent.VK_Q:
			bas2=false;
			break;
		}
	}
	public void terminerJeu(){
		System.exit(0);
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub

	}
	@Override
	public void keyTyped(KeyEvent e) {
		// TODO Auto-generated method stub

	}

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;


public class SurfaceDuJeu extends JPanel implements ConstantesDuJeu{
	/* Definition des pongs du joueur 1 et 2 on les places à la position de départ
	 * le milieu de la surface de jeu remarque on ne donne pas la position en X ici vu que elle est
	 * définie dans les Constantes du jeu et que celle ci ne varie jamais*/
	private int pongJoueur1_Y = PONG_JOUEUR1_DEPART_Y ;
	private int pongJoueur2_Y = PONG_JOUEUR2_DEPART_Y;
	/* position de la balle */
	private int balle_X = BALLE_X_DEPART;
	private int balle_Y = BALLE_Y_DEPART;
	SurfaceDuJeu(){
		MoteurJeuPong moteurJeu = new MoteurJeuPong(this);
		addkeylistener(moteurJeu);
	}
	/**
	 * Méthode qui va dessiner une surface de jeu ansi que ses éléments
	 * @param g
	 */
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		/* Surface de jeu*/
		g.setColor(Color.BLACK);
		g.fillRect(0, 0, LARGEUR_SURFACE, HAUTEUR_SURFACE);
		/* Pongs */
		g.setColor(Color.WHITE);
		/**
		 * On creé les deux raquettes avec leurs positions et leurs formes
		 */
		g.fillRect(PONG_JOUEUR1_X, pongJoueur1_Y, LARGEUR_PONG, HAUTEUR_PONG);
		g.fillRect(PONG_JOUEUR2_X, pongJoueur2_Y, LARGEUR_PONG, HAUTEUR_PONG);
		/* Balle */
		g.fillOval(balle_X, balle_Y, TAILLE_BALLE, TAILLE_BALLE);
	}
	/* Affecte sa position courante à la pong du joueur 1 */
	public void positionnerPongJoueur1_Y(int y) {
		this.pongJoueur1_Y = y;
		repaint();
	}
	/*Retourne la position courante de la pong du joueur 1*/
	public int coordonnéePongJoueur1_Y() {
		return pongJoueur1_Y;
	}
	/* Affecte sa position courante à la pong du joueur 1 */
	public void positionnerPongJoueur2_Y(int y) {
		this.pongJoueur2_Y = y;
		repaint();
	}
	/*Retourne la position courante de la pong du joueur 1*/
	public int coordonnéePongJoueur2_Y() {
		return pongJoueur2_Y;
	}


	// Positionne la balle
	public void positionnerBalle(int x, int y) {
		balle_X = x;
		balle_Y = y;
		repaint();
	}
}

Voila merci

Personne n'a su m'aider
J'ai finalement décidé de bouger les raquettes avec la souris , j'ai pompé un code sur le net et l'ai intégré a mon projet.
Voila je poste juste au cas ou ça pourrait aider quelqu'un à faire quelque chose.
Je ne fait du java que depuis 3 mois donc soyez indulgent avec mon code .

package be.ephec.moteur;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.io.Serializable;

import be.ephec.main.ConstantesDuJeu;



public class MoteurJeuPong implements Runnable, ConstantesDuJeu , KeyListener, MouseMotionListener, Serializable{
	private SurfaceDuJeu surface;
	private int pongJoueur1_Y = PONG_JOUEUR1_DEPART_Y ;
	private int pongJoueur2_Y = PONG_JOUEUR2_DEPART_Y;
	private int scoreJoueur1;
	private int scoreJoueur2;
	private int balle_X; // position X de la balle
	private int balle_Y; // position Y de la balle
	private boolean backX, backY;
	private int vitesse = 1;
	private boolean balleServie = false;
	public MoteurJeuPong(SurfaceDuJeu surfaceJeu){
		surface = surfaceJeu;
		Thread travailleur = new Thread(this);
		travailleur.start();
	}
	public MoteurJeuPong() {
		// TODO Auto-generated constructor stub
	}
	public void mouseMoved(MouseEvent événement) {
		int souris_Y = événement.getY();
		// Si la souris est au-dessus de la raquette du joueur1
		// et que la raquette n'a pas dépassé le haut de la
		// table, la déplace vers le haut ;
		// sinon, la déplace vers le bas.
		if (souris_Y < pongJoueur1_Y && pongJoueur1_Y > HAUT_TABLE) {
			pongJoueur1_Y -= INCREMENT_PONG;
		} else if (pongJoueur1_Y < BAS_TABLE - HAUTEUR_PONG) {
			pongJoueur1_Y += INCREMENT_PONG;
		}
		// Affecte la nouvelle position de la raquette
		surface.positionnerPongJoueur1_Y(pongJoueur1_Y);
	}
	public void keyReleased(KeyEvent événement) {}
	public void keyTyped(KeyEvent événement) {}
	public void terminerJeu(){
		System.exit(0);
	}

	public void run() {
		while (true) {
			try {
				Thread.sleep(5);
			} catch (InterruptedException exception) {
				exception.printStackTrace();
			}
			if(balleServie){
				/**
				 * Mouvement de la balle et collisions
				 */
				if(balle_X < 1){
					backX = false;
					positionDépartBalle2();
					afficherScoreJ2();
				}
				/* gére un rebond sur la raquette de joueur1 */
				if(balle_X < PONG_JOUEUR1_X+LARGEUR_PONG/2 && balle_Y>pongJoueur1_Y-HAUTEUR_PONG/2-TAILLE_BALLE && balle_Y<pongJoueur1_Y+HAUTEUR_PONG/2+TAILLE_BALLE){
					backX = false;
				}
				if(balle_X > LARGEUR_SURFACE - TAILLE_BALLE){
					backX = true;
					positionDépartBalle1();
					afficherScoreJ1();
				}
				if(balle_X > PONG_JOUEUR2_X-LARGEUR_PONG/2-TAILLE_BALLE/2 && balle_Y>pongJoueur2_Y-HAUTEUR_PONG/2-TAILLE_BALLE&& balle_Y < pongJoueur2_Y+HAUTEUR_PONG/2+TAILLE_BALLE){
					backX = true;
				}
				if(balle_Y < 1){
					backY = false;
				}
				if(balle_Y > HAUTEUR_SURFACE-TAILLE_BALLE){
					backY = true;
				}

				if(!backX){
					++balle_X;
				}
				else{
					--balle_X;
				}
				if(!backY){
					++balle_Y;
					/* Algo pour l'ordinateur il suit la balle */
					pongJoueur2_Y++;
				}
				else{
					--balle_Y;
					/* Algo pour l'ordinateur il suit la balle */
					pongJoueur2_Y--;
				}
				surface.positionnerPongJoueur2_Y(pongJoueur2_Y);
				surface.positionnerBalle(balle_X,balle_Y);
				afficherScore();
			}//fin if
		} // Fin du while
	}// Fin de run()
	public void positionDépartBalle1(){
		balle_X = PONG_JOUEUR1_X;
		balle_Y = pongJoueur1_Y;
		surface.positionnerBalle(balle_X, balle_Y);
		balleServie = true;
	}
	public void positionDépartBalle2(){
		balle_X = PONG_JOUEUR2_X;
		balle_Y = pongJoueur2_Y;
		surface.positionnerBalle(balle_X, balle_Y);
	}
	/* Incrémente et affiche le score pour chaque coup gagnant */
	private void afficherScoreJ1() {
		scoreJoueur1++;
		surface.dessinerScoreJ1(" "+scoreJoueur1);
	}
	private void afficherScoreJ2() {
		scoreJoueur2++;
		surface.dessinerScoreJ2(" "+scoreJoueur2);
	}
	private void afficherScore() {
		if (scoreJoueur1 == SCORE_GAGNANT) {
			balleServie = false;
		} 
		else if (scoreJoueur2 == SCORE_GAGNANT) {
			balleServie = false;
		}
		else if(scoreJoueur1 < SCORE_GAGNANT && scoreJoueur2 < SCORE_GAGNANT){
		}
	}
	@Override
	public void mouseDragged(MouseEvent arg0) {
		// TODO Auto-generated method stub

	}
	@Override
	public void keyPressed(KeyEvent arg0) {
		// TODO Auto-generated method stub

	}
}