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+" |");
Publicité
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).
Publicité
- 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;
Publicité
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-
Publicité
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()