UniversityLibHub Documents

Examen de Java

1/13
100%
Rendu du PDF...
Page 1 sur 13Lecteur de document UniversityLib

Examen de Java

Programming · exam

Browse all programmation documents

Examen de Java

Institut d’(cid:19)Electronique Fondamentale

Universit(cid:19)e de Paris Sud

Modalit(cid:19)es

  • Dur(cid:19)ee : 4 heures
  • Tous les documents sont autoris(cid:19)es.
  • Les sources java r(cid:19)epondant (cid:18)a chaque exercice, et seulement les sources seront

obligatoirement copi(cid:19)es dans le r(cid:19)epertoire examjava0304 (tout en minuscules)

cr(cid:19)e(cid:19)e (cid:18)a la racine de votre compte.

Nota Bene

Sauf mention contraire explicite, les diverses classes (cid:18)a cr(cid:19)eer seront non publiques (plus

pr(cid:19)ecis(cid:19)ement sans modi(cid:12)cateur de visibilit(cid:19)e devant), non statiques et non abstraites.

Exercice 1 Op(cid:19)erations sur des cha^(cid:16)nes de caract(cid:18)eres

(cid:19)Ecrire un programme java, contenant une seule classe publique nomm(cid:19)ee GererChaine

qui a(cid:14)che en boucle le menu textuel suivant (cid:18)a l’utilisateur :

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 :

et qui attend un entier (entre 1 et () entr(cid:19)e par l’utilisateur. Pour un choix entre 1 et

4, le programme demande ensuite (cid:18)a l’utilisateur d’entrer les deux cha^(cid:16)nes de l’op(cid:19)eration

(cid:18)a e(cid:11)ectuer, puis a(cid:14)che le r(cid:19)esultat de l’op(cid:19)eration. Si le choix 5 est entr(cid:19)e, on sort du

programme.

On pourra se servir des m(cid:19)ethodes suivantes de la classe String :

1

2

| Examen de Java

String concat(String s), int indexOf(String s),

boolean startsWith(String s),

boolean endsWith(String s).

Le code fourni doit ^etre court et doit ^etre obligatoirement plac(cid:19)e dans le (cid:12)chier

source GererChaine.java.

Exercice 2 D(cid:19)etection d’erreurs

Ecrire, dans le (cid:12)chier erreurs.txt les di(cid:11)(cid:19)erentes erreurs qui vous semblent ^etre contenues

dans le code suivant :

class maClasse {

String ch = null;

String[] tabCh;

maClasse(String s, int nb) {

String ch = s;

tabCh = new String[nb];

}

public void remplirIdentique(String s) {

for(int i = 0; i < tabCh.length; i++)

tabCh[i] = s;

}

public static void affiche() {

// Pas i <= mais i < tabCh.length

for(int i = 0; i <= tabCh.length; i++)

System.out.print(tabCh[i] + " ");

}

}

public class classeMain {

public void main(String args[]) {

maClasse m = new maClasse(4);

// Il n’y a qu’un tableau de pointeurs, les differents

//

m.affiche();

m.remplirIdentique("Le soleil est bleu");

// La methode affiche est statique

m.affiche();

elts de tabCh ne sont pas alloues

}

}

Exercice 3. Jeu simple

Jeu de Tic/Tac/Toe

3

L’objet des exercices qui suivent est de d(cid:19)evelopper un programme pour jouer au Tic

Tac Toe avec l’ordinateur.

Exercice 3 Jeu simple

Les classes cr(cid:19)ees pour cet exercice seront toutes mises dans un (cid:12)chier obligatoirement

nomm(cid:19)e TicTacToeTrivial.java.

1. Cr(cid:19)eer une classe publique TicTacToeTrivial servant juste (cid:18)a contenir la m(cid:19)ethode

main(...). Elle contiendra juste une instruction : la cr(cid:19)eation d’une nouvelle classe

Jeu, d(cid:19)ecrite ci-dessous.

2. Cr(cid:19)eer une classe Plateau, dont le squelette est le suivant :

class Plateau {

private int

private String[][] cases;

String cercle = new String("O");

String croix = new String("X");

dimension; // Cas plus simple de plateaux carres

// cases "physiques" du plateau materiel

// Constructeurs

public Plateau(int dimPlateau) {...}

public Plateau() {...}

// Acesseur

public int getDimension() {...}

// Vider le plateau

public void viderPlateau() {...}

// Affichage du plateau

public void afficherPlateau()

{

System.out.print("\n |");

for(int i = 0; i < dimension; i++)

System.out.print(i+"|");

System.out.println("");

for(int i = 0; i < dimension; i++)

System.out.print("--");

System.out.println("---");

for(int i = 0; i < dimension; i++) {

System.out.print(i+" |");

Advertisement

for(int j = 0; j < dimension; j++)

System.out.print(cases[i][j] + "|");

System.out.println("");

for(int j = 0; j < dimension; j++)

4

| Examen de Java

System.out.print("--");

System.out.println("---");

}

System.out.println("");

}

// Renvoyer la piece qui se trouve a la case specifiee

public String getCase(int ligne, int colonne) {...}

// Le plateau est-il plein ?

public boolean plateauEstPlein() {...}

// La case est-elle vide ?

public boolean caseEstVide(int ligne, int colonne) {...}

// Jouer un coup, dont on teste la legalite

public boolean deplPiece(int qui, int ligne, int colonne) {...}

}// class Plateau

Les di(cid:11)(cid:19)erentes m(cid:19)ethodes (toutes tr(cid:18)es courtes) de Plateau doivent r(cid:19)ealiser les

op(cid:19)erations suivantes :

  • Les constructeurs devront initialiser les di(cid:11)(cid:19)erents champs.
  • getDimension() renvoie la dimension du plateau (la valeur du champ nomm(cid:19)e

dimension).

  • viderPlateau() met toutes les cases du plateau (les (cid:19)el(cid:19)ements du tableau

cases) (cid:18)a la cha^(cid:16)ne " ".

  • afficherPlateau(), est fournie.
  • getCase(int ligne, int colonne) renvoie l’(cid:19)el(cid:19)ement du tableau cases

situ(cid:19)e en ligne ligne et colonne colonne.

  • plateauEstPlein() teste s’il existe au moins une case du tableau cases

qui est libre (c.(cid:18)a.d. (cid:19)egale (cid:18)a " ").

  • caseEstVide(int ligne, int colonne) teste si l’(cid:19)el(cid:19)ement du tableau

cases situ(cid:19)e en ligne ligne et colonne colonne est (cid:19)egal (cid:18)a " ".

  • deplPiece(int qui, int ligne, int colonne) met la cha^(cid:16)ne croix

ou la cha^(cid:16)ne cercle (cid:18)a la ligne ligne et (cid:18)a la colonne colonne du tableau

cases, en testant que les entiers ligne et colonne sont compris entre 0 et

dimension et que la case correspondante est vide.

3. Cr(cid:19)eer une classe Jeu, dont le squelette est le suivant :

class Jeu {

// qui gagne

public static final int HUMAIN_GAGNE

public static final int EGALITE

= 0;

= 1;

Exercice 3. Jeu simple

5

= 2;

public static final int DOUTEUX

public static final int ORDINATEUR_GAGNE = 3;

// Joueurs

public static final int HUMAIN

public static final int ORDINATEUR

public static final int PERSONNE

= 4;

= 5;

= 6;

BufferedReader stdin;

Plateau

plateau;

// flux d’entree

// le plateau de jeu

// Constructeurs

public Jeu(int dimPlateau) {...}

public Jeu() {...}

// Si le jeu est fini, recommencer une partie

public void rejouerUnePartie(String message) {...}

// Ordonnancement de partie :

// - l’humain joue

// - on teste si l’humain a gagne

// - on teste si le match est nul

// - l’ordinateur joue

// - on teste si l’ordinateur a gagne

// - on teste si le match est nul

public void actionsEffectuees(int aQuiLeTour) {...}

// renvoie true si "piece" a gagne (ou "piece" est "X", les

//

croix, ou bien "O", les ronds

boolean estCeGagne(String piece) {...}

// Selectionner le prochain coup a jouer par l’utilisateur

public void humainJouerCoup() {...}

// Selectionner le prochain coup a jouer par l’ordinateur

public void ordinateurJouerCoup() {...}

}// class Jeu

Les di(cid:11)(cid:19)erentes m(cid:19)ethodes de Jeu doivent r(cid:19)ealiser les op(cid:19)erations suivantes :

  • Les constructeurs devront initialiser les di(cid:11)(cid:19)erents champs.
  • rejouerUnePartie(String message) : on recommence (cid:18)a jouer une par-

tie. Plus pr(cid:19)ecis(cid:19)ement, on vide le plateau, puis on l’a(cid:14)che (en appelant les

m(cid:19)ethodes viderPlateau() et afficherPlateau() de Plateau ; ensuite,

on appelle la m(cid:19)ethode actionsEffectuees() d’ordonnancement d’une par-

tie, d(cid:19)ecrite ci-dessous, en sp(cid:19)eci(cid:12)ant que c’est (cid:18)a l’humain de jouer (l’ordinateur

est sympathique).

6

| Examen de Java

  • actionsEffectuees(int aQuiLeTour) contient une boucle in(cid:12)nie, au

sein de laquelle on teste si c’est au tour de l’humain ou de l’ordinateur (si

aQuiLeTour (cid:19)egal HUMAIN ou ORDINATEUR)

  • Si c’est au tour de l’humain, on appelle la m(cid:19)ethode humainJouerCoup(),

puis on teste si l’humain a gagn(cid:19)e (appel de la m(cid:19)ethode estCeGagne()

avec plateau.cercle en param(cid:18)etre), auquel cas on sort de la boucle

in(cid:12)nie (au moyen d’un break), puis on teste si le match est nul (au moyen

de la m(cid:19)ethode plateauEstPlein() de la classe Plateau), auquel cas

on sort de la boucle in(cid:12)nie, puis on met la variable aQuiLeTour (cid:18)a la

constante ORDINATEUR (c’est alors (cid:18)a lui de jouer).

Advertisement

  • Si c’est au tour de l’ordinateur, on appelle ordinateurJouerCoup(),

puis on teste si l’ordinateur a gagn(cid:19)e (appel de la m(cid:19)ethode estCeGagne()

avec plateau.croix en param(cid:18)etre), auquel cas on sort de la boucle

in(cid:12)nie (au moyen d’un break), puis on teste si le match est nul (au moyen

de la m(cid:19)ethode plateauEstPlein() de la classe Plateau), auquel cas

on sort de la boucle in(cid:12)nie, puis on met la variable aQuiLeTour (cid:18)a HUMAIN

(c’est alors (cid:18)a lui de jouer).

  • Apr(cid:18)es le test sur aQuiLeTour, on a(cid:14)che le plateau (au moyen de la

m(cid:19)ethode afficherPlateau() de la classe Plateau.

  • en dehors de la boucle in(cid:12)nie, on place un appel (cid:18)a rejouerUnePartie().
  • estCeGagne(String piece) scrute les lignes, les colonnes et les deux di-

agonales du tableau cases de la classe Tableau a(cid:12)n de savoir s’il y a un

alignement de pi(cid:18)eces identiques, toutes (cid:19)egales (cid:18)a l’argument piece. Si c’est le

cas, la m(cid:19)ethode renvoie true, sinon, elle renvoie false.

  • humainJouerCoup() fait jouer l’utilisateur ; la m(cid:19)ethode doit tester si le coup

entr(cid:19)e est l(cid:19)egal, c’est-(cid:18)a-dire si les entiers num(cid:19)ero de ligne et de colonne entr(cid:19)es

au clavier sont bien compris entre 0 et dimension (la dimension du plateau)

; ensuite, le coup est jou(cid:19)e par appel de la m(cid:19)ethode deplPiece() de la classe

Plateau. Tant que le coup n’est pas l(cid:19)egal, la m(cid:19)ethode doit redemander une

saisie (cid:18)a l’utilisateur.

  • ordinateurJouerCoup() fait jouer l’ordinateur de mani(cid:18)ere stupide : on

scrute les lignes et les colonnes une double boucle for() et si la m(cid:19)ethode

caseEstVide() renvoie true, on appelle deplPiece().

Exercice 4 Jeu normal et b^ete

Il s’agit ici de ra(cid:14)ner (ou plut^ot de rendre moins barbare) la structure d’objets

pr(cid:19)ec(cid:19)edente, tout en gardant la m^eme simplicit(cid:19)e (ou plut^ot stupidit(cid:19)e) algorithmique.

Les classes cr(cid:19)ees pour cet exercice seront toutes mises dans un (cid:12)chier obligatoire-

ment nomm(cid:19)e TicTacToeBete.java. Les classes suivantes devront ^etre cr(cid:19)ees :

Exercice 4. Jeu normal et b^ete

7

class Jeu

class TTTIllegalAccessException

extends Exception

class Plateau

abstract class Joueur

class Ordinateur extends

Joueur

class Humain extends Joueur

final class CoupOptimal

abstract class Piece

class Cercle extends Piece

class Croix extends Piece

class PieceVide extends Piece

reponsable de

Classe

d’une partie

Exception propre du jeu

l’ordonnancement

pour

utilitaire

Classe

l’utilisateur

Classe abstraite d’un joueur

Incarnation (electronique) d’un ordinateur

l’interface

avec

Incarnation d’un joueur

Classe representant le coup optimal selec-

tionne

Classe abstraite repr(cid:19)esentant une pi(cid:18)ece du

jeu

Pi(cid:18)ece de forme circulaire ("les ronds")

Pi(cid:18)ece cruciforme ("les croix")

Repr(cid:19)esentant une pi(cid:18)ece vide

1. Cr(cid:19)eer une classe publique TicTacToeBete servant juste (cid:18)a contenir la m(cid:19)ethode

la cr(cid:19)eation d’une nouvelle

main(...). Elle contiendra juste une instruction :

classe Jeu, d(cid:19)ecrite ci-dessous.

2. Cr(cid:19)er une classe abstraite Piece et trois classes non publiques (non abstraites)

Croix, Cercle et PieceVide h(cid:19)eritant de Piece. Le squelette de ces classes est

le suivant :

abstract class Piece {

abstract public String getPiece();

}

class Cercle extends Piece {

String laPiece;

// Constructeur

public Cercle() {...}

// Accesseur

public String getPiece() {...}

}// class Cercle

class Croix extends Piece {

String laPiece;

// Constructeur

public Croix() {...}

// Accesseur

public String getPiece() {...}

}// class Croix

class PieceVide extends Piece {

8

| Examen de Java

String laPiece;

// Constructeur

public PieceVide() {...}

// Accesseur

public String getPiece() {...}

}// class PieceVide

Le code (cid:18)a cr(cid:19)eer (cid:19)etant particuli(cid:18)erement trivial, il n’y a pas besoin d’explications

suppl(cid:19)ementaire sur chaque m(cid:19)ethode.

3. Cr(cid:19)eer une classe CoupOptimal, repr(cid:19)esentant le coup optimal (cid:18)a jouer par l’ordinateur,

dont le squelette est le suivant :

final class CoupOptimal

{

int ligne;

Advertisement

int colonne;

int val;

// Constructeurs

public CoupOptimal(int v, int lig, int col) {...}

public CoupOptimal(int v) {...}

}

Le code (cid:18)a cr(cid:19)eer (cid:19)etant particuli(cid:18)erement trivial, il n’y a pas besoin d’explications

suppl(cid:19)ementaire sur chaque m(cid:19)ethode.

4. Cr(cid:19)eer une classe TTTIllegalAccessException h(cid:19)eritant de Exception et ne

contenant qu’un constructeur admettant un unique argument de type String qui

appelle le constructeur de la classe m(cid:18)ere en lui passant son param(cid:18)etre.

5. Cr(cid:19)eer une classe Plateau, dont le squelette est le suivant :

private int

private Piece[][]

private int[][]

private Jeu

dimension; // Cas plus simple de plateaux carres

cases;

grille;

jeu;

// cases "physiques" du plateau materiel

// grille "immaterielle" pour coups reels ou simules

// Constructeurs

public Plateau(int dimPlateau, Jeu j) {...}

public Plateau(Jeu j) {...}

// Accesseur

public int getDimension() {...}

// Vide cases puis appelle viderGrille()

public void viderPlateau() {...}

// Affichage

public void afficherPlateau() {...}

Exercice 4. Jeu normal et b^ete

9

// Accesseur

public Piece getCase(int ligne, int colonne) {...}

// Jouer un coup, dont on teste la legalite

public boolean deplPiece(int qui, int ligne, int colonne) {...}

// Vide la grille

public void viderGrille() {...}

// Teste si la grille est pleine

public boolean grilleEstPleine() {...}

// Accesseur

public int getCellule(int ligne, int colonne) {...}

// fixe un elt de grille avec test sur l’appelant

public void setCellule(Object appelant, int valeur,

int ligne, int colonne)

throws TTTIllegalAccessException {...}

// Teste si une cellule de grille est vide

public boolean celluleEstVide(int ligne, int colonne) {...}

Les di(cid:11)(cid:19)erentes m(cid:19)ethodes (toutes tr(cid:18)es courtes) de Plateau doivent r(cid:19)ealiser les

op(cid:19)erations suivantes :

  • Les constructeurs devront initialiser les di(cid:11)(cid:19)erents champs, puis vider la grille

et vider le plateau (appel des m(cid:19)ethodes correspondantes)

  • getDimension() renvoie la dimension du plateau (la valeur du champ nomm(cid:19)e

dimension).

  • viderPlateau() met une pi(cid:18)ece vide (voir la classe PieceVide) dans toutes

les cases du plateau, puis vide la grille.

  • afficherPlateau(), ne varie pas par rapport (cid:18)a la version de l’exercice

pr(cid:19)ec(cid:19)edent.

  • getCase(int ligne, int colonne) renvoie l’(cid:19)el(cid:19)ement du tableau cases

situ(cid:19)e en ligne ligne et colonne colonne.

  • deplPiece(int qui, int ligne, int colonne) teste que les entiers

ligne et colonne sont compris entre 0 et dimension et que la case corre-

spondante est vide. Remplit ensuite grille et cases de mani(cid:18)ere ad(cid:19)equate.

On se servira des constantes HUMAIN et ORDINATEUR de la classe Joueur.

  • viderGrille() vide la grille en se servant de la constante PERSONNE de la

classe Joueur.

  • grilleEstPleine() teste si la grille est pleine.
  • getCellule(int ligne, int colonne) renvoie l’(cid:19)el(cid:19)ement d(cid:19)esir(cid:19)e du tableau

grille.

10

| Examen de Java

  • setCellule(Object appelant, int valeur, int ligne, int colonne)

throws TTTIllegalAccessException (cid:12)xe l’(cid:19)el(cid:19)ement sp(cid:19)eci(cid:12)(cid:19)e du tableau

grille (cid:18)a valeur en testant ((cid:18)a l’aide de instanceof) que la r(cid:19)ef(cid:19)erence

de l’objet appelant (apss(cid:19)e en premier param(cid:18)etre) est bien une instance de

la classe Joueur. Si ce n’est pas le cas, on l(cid:18)eve une exception de type

TTTIllegalAccessException.

  • celluleEstVide(int ligne, int colonne) teste si l’(cid:19)el(cid:19)ement sp(cid:19)eci(cid:12)(cid:19)e

de grille est vide (se servir de la constante PERSONNE de la classe Joueur).

6. Cr(cid:19)eer une classe abstraite Joueur dont le squelette est le suivant

abstract class Joueur {

public static final int HUMAIN

= 0;

public static final int ORDINATEUR = 1;

= 2;

public static final int PERSONNE

protected int

protected Plateau

protected Jeu

gameNum = 0;

plateau;

jeu;

// Constructeur

Joueur(Plateau pl, Jeu j) {...}

// Methodes abstraites

public abstract CoupOptimal choisirCoup(int cote);

public abstract void jouerCoup();

// Simulation d’un coup (sert pour les recherches optimales)

public void simulerDeplPiece(int cote, int ligne, int colonne)

throws TTTIllegalAccessException {...}

}

La seule m(cid:19)ethode de non abstraite de Joueur r(cid:19)ealise un appel (cid:18)a la m(cid:19)ethode

setCellule() de la classe Plateau.

7. Cr(cid:19)eer une classe Ordinateur h(cid:19)eritant de Joueur qui red(cid:19)e(cid:12)nit les m(cid:19)ethodes ab-

Advertisement

straites de Joueur :

  • La m(cid:19)ethode choisirCoup() choisit un coup sens(cid:19)e ^etre optimal ; ici encore, on

se bornera (cid:18)a renvoyer un CoupOptimal correspondant (cid:18)a la premi(cid:18)ere case libre

du plateau (test(cid:19)e au moyen de celluleEstVide() de la classe Plateau).

On pourra mettre comme premier argument du constructeur de CoupOptimal

la constante DOUTEUX de la classe Jeu.

  • La m(cid:19)ethode jouerCoup() appelle la m(cid:19)ethode choisirCoup() (phase de

r(cid:19)eflexion), puis appelle la m(cid:19)ethode deplPiece() de la classe Plateau (phase

de passage (cid:18)a l’acte).

Exercice 4. Jeu normal et b^ete

11

8. Cr(cid:19)eer une classe Humain h(cid:19)eritant de Joueur qui red(cid:19)e(cid:12)nit les m(cid:19)ethodes abstraites

de Joueur :

  • La m(cid:19)ethode choisirCoup() ne fait rien (la phase de r(cid:19)eflexion est cens(cid:19)ee se

passer dans la t^ete de l’utilisateur), elle renvoie juste null.

  • La m(cid:19)ethode jouerCoup() fait jouer l’utilisateur ; elle est identique (cid:18)a la

m(cid:19)ethode humainJouerCoup() de l’exercice pr(cid:19)ec(cid:19)edent ; elle doit tester si

le coup entr(cid:19)e est l(cid:19)egal, c’est-(cid:18)a-dire si les entiers num(cid:19)ero de ligne et de colonne

entr(cid:19)es au clavier sont bien compris entre 0 et dimension (la dimension du

plateau) ; ensuite, le coup est jou(cid:19)e par appel de la m(cid:19)ethode deplPiece() de la

classe Plateau. Tant que le coup n’est pas l(cid:19)egal, la m(cid:19)ethode doit redemander

une saisie (cid:18)a l’utilisateur.

9. Cr(cid:19)eer une classe Jeu

class Jeu

{

= 0;

public static final int HUMAIN_GAGNE

= 1;

public static final int EGALITE

public static final int DOUTEUX

= 2;

public static final int ORDINATEUR_GAGNE = 3;

Plateau plateau;

Joueur humain, ordinateur;

Piece

Croix

Cercle typeCercle = new Cercle();

typePieceHumain, typePieceOrdinateur;

typeCroix = new Croix();

// Constructeurs

public Jeu(int dimPlateau) {...}

public Jeu() {...}

// Accesseurs

public Piece getTypePieceHumain() {...}

public Piece getTypePieceOrdinateur() {...}

// Si le jeu est fini, recommencer une partie

public void rejouerUnePartie(String message, boolean ordinCommence) {...}

// Ordonnancement de partie :

public void actionsEffectuees(Joueur aQuiLeTour) {...}

// A-t-on gagne ?

boolean estCeGagne(int cote) {...}

}// class Jeu

Les di(cid:11)(cid:19)erentes m(cid:19)ethodes doivent r(cid:19)ealiser les op(cid:19)erations suivantes :

  • Les constructeurs devront initialiser les di(cid:11)(cid:19)erents champs en cr(cid:19)eant des objets

12

| Examen de Java

si n(cid:19)ecessaire, puis appeler la m(cid:19)ethode viderPlateau() de la classe Plateau

et en(cid:12)n appeler la m(cid:19)ethode rejouerUnePartie().

  • rejouerUnePartie(String message, boolean ordinCommence) ; cette

m(cid:19)ethode est tr(cid:18)es analogue (cid:18)a celle de l’exercice pr(cid:19)ec(cid:19)edent, (cid:18)a part qu’il faut ici

distinguer le cas o(cid:18)u l’ordinateur commence (variable ordinCommence (cid:19)egale (cid:18)a

true) de celui o(cid:18)u l’humain commence.

  • actionsEffectuees(int aQuiLeTour) est tr(cid:18)es analogue (cid:18)a celle de l’exercice

pr(cid:19)ec(cid:19)edent ; il faut en plus g(cid:19)erer le fait que celui qui gagne la partie a com-

mence (cid:18)a jouer pour la partie suivante. Il faut faire en outre les deux adap-

le param(cid:18)etre de la m(cid:19)ethode n’est plus un int mais une

tations suivantes :

r(cid:19)ef(cid:19)erence de type Joueur ; on se servira donc de l’op(cid:19)erateur instanceof ;

en outre l’appel (cid:18)a plateauEstPlein() doit ^etre remplac(cid:19)e par un appel (cid:18)a

grilleEstPleine().

  • estCeGagne(String piece) est tr(cid:18)es analogue (cid:18)a celle de l’exercice pr(cid:19)ec(cid:19)edent.

Il faut faire l’adaptation suivante :

par un appel (cid:18)a getCellule().

l’appel (cid:18)a getCase() doit ^etre remplac(cid:19)e

Exercice 5 Jeu par recherche exhaustive

Cet exercice est optionnel, et n’est (cid:18)a faire que lorsque les deux pr(cid:19)ec(cid:19)edents ont (cid:19)et(cid:19)e

r(cid:19)ealis(cid:19)es.

Il s’agit ici de ra(cid:14)ner un peu l’algorithme utilis(cid:19)e en utilisant une recherche exhaustive

pour les coups jou(cid:19)es par l’ordinateur.

Les classes cr(cid:19)ees pour cet exercice seront toutes mises dans un (cid:12)chier obligatoirement

nomm(cid:19)e TicTacToeSimpleIntelliegent.java.

Les adaptations (cid:18)a r(cid:19)ealiser sont les suivantes

1. Ajouter une m(cid:19)ethode valeurPosition() (cid:18)a la classe Jeu qui renvoie ORDINATEUR GAGNE

si l’ordinateur a gagn(cid:19)e, HUMAIN GAGNE si l’humain a gagn(cid:19)e, sinon EGALITE si

la grille est pleine, sinon DOUTEUX. Cette m(cid:19)ethode est utilis(cid:19)ee pour la simula-

tion des coups par l’ordinateur. On se servira des m(cid:19)ethodes estCeGagne() et

grilleEstPleine() de Plateau.

2. Cr(cid:19)eer une m(cid:19)ethode simulerDeplPiece() de signature : public void simulerDeplPiece(int

cote, int ligne, int colonne) throws TTTIllegalAccessException

qui appelle juste la m(cid:19)ethode setCellule() de la classe Plateau.

3. La m(cid:19)ethode choisirCoup() doit r(cid:19)ealiser les actions suivantes :

  • Test d’arr^et ; on teste par appel de le m(cid:19)ethode valeurPosition() de la

classe Jeu.

  • Simulation r(cid:19)ecursive de jeu :
  • appel de simulerDeplPiece()

Exercice 5. Jeu par recherche exhaustive

13

  • appel de choisirCoup() avec en param(cid:18)etre l’adversaire
  • appel de simulerDeplPiece() avec en premier param(cid:18)etre la constante

PERSONNE a(cid:12)n d’annuler la simulation

4. la m(cid:19)ethode choisirCoup()