Examen de Java

Ce document présente un examen de programmation Java portant sur plusieurs exercices. Il teste des compétences en manipulation de chaînes de caractères, détection d’erreurs dans un code donné, programmation orientée objet appliquée à un jeu simple (Tic Tac Toe), et amélioration progressive de ce jeu avec gestion d’exceptions et recherche exhaustive. Chaque exercice demande la création de classes et méthodes spécifiques, avec une attention particulière à la structure, la logique et la conformité aux consignes.

Exercice 1 Opérations sur des chaînes de caractères

Il s'agit d'écrire un programme Java avec une seule classe publique nommée GererChaine qui affiche un menu en boucle proposant cinq options à l’utilisateur, puis réalise l’opération choisie sur deux chaînes de caractères.

Le menu affiché est :

1 Concatenation de deux chaines
2 Indice de premiere occurrence d’une sous-chaine
3 Commence par une sous-chaine
4 Se termine par une sous-chaine
5 Quitter

Veuillez entrer votre choix :

Le programme doit :

• Lire un entier entre 1 et 5.
• Pour les choix 1 à 4, demander deux chaînes, puis afficher le résultat de l’opération correspondante.
• Pour le choix 5, sortir du programme.

Les méthodes de la classe String à utiliser sont :

• concat(String s)
• indexOf(String s)
• startsWith(String s)
• endsWith(String s)

Le code doit être placé dans un fichier GererChaine.java et être court.

Solution :

On crée la classe GererChaine avec une boucle while affichant le menu, puis on lit le choix. Pour les choix 1 à 4, on demande deux chaînes, puis on applique la méthode correspondante :

• Concatenation : afficher s1.concat(s2)
• Indice : afficher s1.indexOf(s2)
• Commence par : afficher s1.startsWith(s2)
• Se termine par : afficher s1.endsWith(s2)

Si le choix est 5, on sort de la boucle et termine le programme.

Réponse finale : Programme Java conforme aux consignes, utilisant les méthodes String indiquées, avec gestion correcte des entrées et sortie propre.

Exercice 2 Détection d’erreurs

Il faut écrire dans un fichier erreurs.txt les erreurs présentes dans le code donné, qui comporte deux classes : maClasse et classeMain.

Analyse des erreurs :

• Dans le constructeur maClasse(String s, int nb), la variable String ch = s; déclare une variable locale ch qui masque le champ d’instance ch. Il faut écrire this.ch = s; pour affecter le champ.
• Dans classeMain, le constructeur de maClasse est appelé avec un seul entier 4, alors que le constructeur défini attend un String et un int. Il manque un argument String.
• La méthode affiche() est statique mais accède à tabCh qui est un champ d’instance, ce qui est incorrect. Soit la méthode doit être non statique, soit tabCh doit être statique.
• Dans la boucle de la méthode affiche(), la condition est i <= tabCh.length, ce qui provoque un dépassement d’indice. Il faut i < tabCh.length.
• Dans classeMain, la méthode main n’est pas statique, elle doit être public static void main(String[] args) pour être exécutable.
• Dans classeMain, on appelle m.affiche() avant d’avoir rempli le tableau, ce qui affichera des null.
• Le commentaire indique que les éléments du tableau ne sont pas alloués, ce qui est vrai car on crée un tableau de références mais pas les chaînes individuelles.

Réponse finale : Les erreurs principales sont la mauvaise déclaration et affectation du champ ch, l’appel incorrect du constructeur, la méthode affiche() statique accédant à un champ d’instance, la condition de boucle incorrecte, et la méthode main non statique.

Exercice 3 Jeu simple

Il s’agit de développer un programme Java pour jouer au Tic Tac Toe avec l’ordinateur. Les classes doivent être dans TicTacToeTrivial.java.

1. Classe TicTacToeTrivial

Créer une classe publique contenant uniquement la méthode main qui crée une instance de la classe Jeu.

2. Classe Plateau

Créer une classe Plateau avec :

• Un champ dimension (int) pour la taille du plateau carré.
• Un tableau String[][] cases représentant les cases.
• Deux chaînes cercle = "O" et croix = "X".
• Constructeurs : Plateau(int dimPlateau) et Plateau().
• Méthodes :
• getDimension() retourne la dimension.
• viderPlateau() remplit toutes les cases avec la chaîne " ".
• afficherPlateau() affiche le plateau (code fourni).
• getCase(int ligne, int colonne) retourne la chaîne dans la case.
• plateauEstPlein() teste s’il n’y a plus de cases vides.
• caseEstVide(int ligne, int colonne) teste si la case est vide.
• deplPiece(int qui, int ligne, int colonne) place un "X" ou "O" selon qui si la case est vide et indices valides.

Solution : Les constructeurs initialisent dimension et le tableau cases. viderPlateau() remplit le tableau avec " ". deplPiece() vérifie les bornes et la vacuité avant de placer la pièce.

3. Classe Jeu

Créer une classe Jeu avec :

• Constantes pour les états du jeu (HUMAIN_GAGNE=0, EGALITE=1, DOUTEUX=2, ORDINATEUR_GAGNE=3) et joueurs (HUMAIN=4, ORDINATEUR=5, PERSONNE=6).
• Champs : BufferedReader stdin pour entrée, Plateau plateau.
• Constructeurs Jeu(int dimPlateau) et Jeu().
• Méthodes :
• rejouerUnePartie(String message) : vide le plateau, l’affiche, puis appelle actionsEffectuees(HUMAIN).
• actionsEffectuees(int aQuiLeTour) : boucle infinie alternant les tours humain et ordinateur :
• Si tour humain : appelle humainJouerCoup(), teste si humain gagne (estCeGagne(plateau.cercle)), ou match nul (plateauEstPlein()), sinon passe au tour ordinateur.
• Si tour ordinateur : appelle ordinateurJouerCoup(), teste si ordinateur gagne (estCeGagne(plateau.croix)), ou match nul, sinon passe au tour humain.
• Après chaque coup, affiche le plateau.
• En sortie de boucle, appelle rejouerUnePartie() pour recommencer.
• estCeGagne(String piece) : teste toutes les lignes, colonnes, et diagonales pour un alignement complet de la pièce donnée.
• humainJouerCoup() : demande au joueur de saisir ligne et colonne, vérifie la validité et la vacuité, rejoue la saisie tant que le coup est illégal, puis joue le coup.
• ordinateurJouerCoup() : parcours le plateau en double boucle, joue sur la première case vide trouvée.

Solution : Implémenter les méthodes conformément aux descriptions, en respectant les constantes et la logique de jeu. La méthode estCeGagne() doit parcourir lignes, colonnes, diagonales et vérifier un alignement complet.

Réponse finale : Jeu fonctionnel avec alternance des tours, détection de victoire ou égalité, et saisie contrôlée.

Exercice 4 Jeu normal et bête

Il s'agit d'améliorer la structure objet du jeu précédent, en introduisant une hiérarchie de classes plus riche, gestion d’exceptions, et séparation claire des responsabilités.

1. Classe TicTacToeBete

Créer une classe publique contenant uniquement la méthode main qui crée une instance de la classe Jeu.

2. Classes Piece, Croix, Cercle, PieceVide

Créer une classe abstraite Piece avec une méthode abstraite getPiece() retournant une chaîne.

Créer trois classes non publiques héritant de Piece :

• Cercle : constructeur initialise laPiece = "O", getPiece() retourne laPiece.
• Croix : constructeur initialise laPiece = "X", getPiece() retourne laPiece.
• PieceVide : constructeur initialise laPiece = " ", getPiece() retourne laPiece.

3. Classe CoupOptimal

Classe finale avec trois champs int ligne, colonne, val et deux constructeurs :

• CoupOptimal(int v, int lig, int col)
• CoupOptimal(int v)

4. Classe TTTIllegalAccessException

Hérite de Exception, contient un constructeur avec un String qui appelle le constructeur mère avec ce paramètre.

5. Classe Plateau

Champs :

• int dimension
• Piece[][] cases
• int[][] grille
• Jeu jeu

Méthodes :

• Constructeurs Plateau(int dimPlateau, Jeu j) et Plateau(Jeu j) initialisent champs, puis appellent viderGrille() et viderPlateau().
• getDimension() retourne la dimension.
• viderPlateau() remplit cases avec des objets PieceVide, puis vide la grille.
• afficherPlateau() affiche le plateau (similaire à l’exercice précédent).
• getCase(int ligne, int colonne) retourne l’objet Piece à la position.
• deplPiece(int qui, int ligne, int colonne) vérifie que les indices sont valides et que la case est vide, puis remplit cases et grille en fonction de qui (utiliser constantes HUMAIN et ORDINATEUR de Joueur).
• viderGrille() remplit grille avec la constante PERSONNE de Joueur.
• grilleEstPleine() teste si la grille est pleine.
• getCellule(int ligne, int colonne) retourne l’entier dans grille.
• setCellule(Object appelant, int valeur, int ligne, int colonne) modifie grille à la position donnée si appelant instanceof Joueur, sinon lance TTTIllegalAccessException.
• celluleEstVide(int ligne, int colonne) teste si la cellule est égale à PERSONNE.

6. Classe abstraite Joueur

Constantes :

• HUMAIN = 0
• ORDINATEUR = 1
• PERSONNE = 2

Champs protégés :

• int gameNum = 0
• Plateau plateau
• Jeu jeu

Constructeur Joueur(Plateau pl, Jeu j).

Méthodes abstraites :

• choisirCoup(int cote) retourne un CoupOptimal.
• jouerCoup().

Méthode non abstraite :

• simulerDeplPiece(int cote, int ligne, int colonne) appelle plateau.setCellule().

7. Classe Ordinateur

Hérite de Joueur, redéfinit :

• choisirCoup() : renvoie un CoupOptimal avec valeur DOUTEUX et position de la première case libre du plateau (testée avec celluleEstVide()).
• jouerCoup() : appelle choisirCoup(), puis deplPiece() pour jouer.

8. Classe Humain

Hérite de Joueur, redéfinit :

• choisirCoup() : ne fait rien, retourne null.
• jouerCoup() : identique à humainJouerCoup() de l’exercice précédent, demande une saisie valide et joue le coup.

9. Classe Jeu

Constantes :

• HUMAIN_GAGNE = 0
• EGALITE = 1
• DOUTEUX = 2
• ORDINATEUR_GAGNE = 3

Champs :

• Plateau plateau
• Joueur humain, ordinateur
• Piece typeCercle = new Cercle()
• Piece typeCroix = new Croix()
• Piece typePieceHumain, typePieceOrdinateur

Méthodes :

• Constructeurs initialisent les champs, appellent viderPlateau() et rejouerUnePartie().
• getTypePieceHumain() et getTypePieceOrdinateur() retournent les pièces respectives.
• rejouerUnePartie(String message, boolean ordinCommence) : similaire à l’exercice précédent, mais distingue si l’ordinateur commence ou non.
• actionsEffectuees(Joueur aQuiLeTour) : analogue à l’exercice précédent, mais avec gestion que le gagnant commence la partie suivante, et en utilisant grilleEstPleine() au lieu de plateauEstPlein().
• estCeGagne(int cote) : analogue à l’exercice précédent, utilise getCellule() au lieu de getCase().

Exercice 5 Jeu par recherche exhaustive (optionnel)

Amélioration de l’algorithme de jeu par recherche exhaustive pour les coups de l’ordinateur. Les classes sont dans TicTacToeSimpleIntelligent.java.

1. Méthode valeurPosition()

Ajoutée à la classe Jeu, elle renvoie :

• ORDINATEUR_GAGNE si l’ordinateur a gagné.
• HUMAIN_GAGNE si l’humain a gagné.
• EGALITE si la grille est pleine.
• DOUTEUX sinon.

Utilise estCeGagne() et grilleEstPleine().

2. Méthode simulerDeplPiece()

Signature : public void simulerDeplPiece(int cote, int ligne, int colonne) throws TTTIllegalAccessException.

Appelle simplement setCellule() de Plateau.

3. Méthode choisirCoup()

Effectue :

• Test d’arrêt avec valeurPosition().
• Simulation récursive :
• Appel de simulerDeplPiece().
• Appel récursif de choisirCoup() pour l’adversaire.
• Annulation de la simulation en remettant la case à vide.

4. Méthode choisirCoup() (suite)

Implémente la recherche exhaustive pour choisir le meilleur coup possible.

Méthode - Techniques récompensées et erreurs sanctionnées

Ce sujet valorise :

• La maîtrise de la programmation orientée objet en Java, avec gestion correcte des classes, héritage, abstractions, et exceptions.
• La capacité à respecter strictement les consignes, notamment en ce qui concerne les signatures des méthodes, les constantes et la structure des classes.
• La rigueur dans la gestion des entrées utilisateur, avec validation et boucles de reprise en cas d’erreur.
• La compréhension et l’implémentation d’algorithmes simples pour le jeu Tic Tac Toe, incluant la détection de victoire, égalité, et la gestion des tours.
• La capacité à améliorer progressivement un programme, en introduisant des concepts avancés comme la recherche exhaustive et la simulation de coups.

Les erreurs les plus pénalisées sont :

• Ignorer les consignes sur la visibilité des classes et méthodes (par exemple, classes non publiques quand demandé).
• Ne pas respecter les signatures exactes des méthodes.
• Confondre variables locales et champs d’instance, notamment dans les constructeurs.
• Oublier la validation des indices et la gestion des cas limites (dépassement de tableau).
• Ne pas gérer correctement les exceptions, ou ne pas lever les exceptions demandées.
• Ne pas utiliser les constantes définies, ou utiliser des valeurs magiques.
• Ne pas respecter la logique de jeu, notamment dans la détection de victoire ou dans l’alternance des tours.

Enfin, ce sujet récompense une présentation claire du code, avec des méthodes courtes, bien nommées, et une structure cohérente facilitant la maintenance et l’évolution.