TD 1 - Ma première class d'objets - Le jeu de dominos

Préparation

Ouvrir un terminal. Créez au moyen de la commande mkdir un répertoire (par exemple Prog_Imp2) pour placer les fichiers que vous écrirez au cours des TD. Créez ensuite, à l'intérieur de ce répertoire, un répertoire TD1 pour stocker les programmes de ce premier TD. Placez-vous dans le répertoire TD1 au moyen de la commande cd.
Les semaines suivantes, il faudra veiller à créer un répertoire pour chaque nouveau TD.

dominos

Le jeu de dominos

Pour créer notre première class d'objets, nous allons utiliser les dominos. Comme tous les objets, les dominos possèdent les caractéristiques pouvant être valuées.

Chaque domino est porteur de deux marques qui représentent les nombres de 0 à 6,
Le zéro (0) est nommé ¨blanc¨ et les autres valeurs sont dénommées de ¨un¨ à ¨six¨

Nous allons commencer par définir une classe d'objet que nous nommerons naturellement Domino

Exercice 1: Création de la classe Domino

Pour cette première classe, vous recopierez le code ci-dessous en téléchargant le fichier domino.java.

/** Classe représentant un domino avec ses 2 marques. */

class Domino {
	// Attributs
	
        int	m1; // marque 1
	int	m2; // marque 2
	
        /**
	 * Le constructeur de domino avec ses 2 marques en paramètres.
	 * @param vm1 première marque
	 * @param vm2 seconde marque
	 */
	
        public Domino(int vm1, int vm2) {
		// Instructions d'initialisation du domino en cours de construction
	
        	this.m1 = vm1; // marque 1
		this.m2 = vm2; // marque 2
	}
}

Exercice 2: Tests de la classe Domino

Pour ces tests, vous commencerez par créer la class MainDominos contenant un point de lancement d'application Java ainsi qu'une première méthode de test.

/**
 * Classe pour le lancement de l'application Java sur le jeu de dominos.
 */
class MainDominos {

	/** Méthode main */
	public static void main(String[] args) {
		test1(); // Lancer le test 1
		test2(); // Lancer le test 2
	}

	/** Méthode de test 1 */
	public static void test1() {
            // à remplir
	}

	/** Méthode de test 2 */
	public static void test2() {
            // à remplir
	}
}

Réaliser ces différents tests en complétant la méthode test1() au fur et à mesure.

Instanciez ces trois dominos (3,4); (1,1) et (2,5) dans les variables référencées d1, d2 et d3. Compilez votre programme et exécutez-le.

Modifiez la méthode test1() pour qu'elle affiche les trois dominos d1, d2 et d3 de la manière suivant:
```
(3,4) (1,1) (2,5)
```
c'est à dire sans aller à la ligne et avec un espace avant chaque domino. Pour cela, écrivez une nouvelle méthode capable d'écrire un domino précédé d'un espace dans une chaîne, soit
```
public static String dominoToString(Domino d)
```
Compilez et testez votre programme.
Ecrivez la méthode estDouble qui teste si un domino est un double en renvoyant une valeur booléenne adéquate. Proposez la signature de la méthode avant de l'écrire.
Testez ensuite vos trois dominos un affichant à l'ecran ceux qui ne sont pas doubles de la manière suivante:
```
Le domino (x,y) n'est pas un double.
```
Ecrivez la méthode valeur qui calcule la valeur d'un domino en faisant la somme de ces deux marques. Proposez la signature de la méthode avant de l'écrire.
Testez ensuite vos trois dominos un affichant à l'ecran leurs valeurs:
```
Le domino (x,y) a une valeur v.
```
Ecrivez la méthode plusGrandDomino qui compare deux dominos et renvoie la valeur entière +1 si le premier est plus grand, 0 s'ils sont égaux et -1 dans le dernier cas. Proposez la signature de la méthode avant de l'écrire.
Testez ensuite vos trois dominos un affichant celui qui est le plus grand
```
Le domino (x,y) est plus grand que (x2,y2) et (x3,y3).
```
La qualité plus grand que est vraie pour un domino dont la valeur est strictement plus grande ou égale qu'un autre.

Exercice 3: Un jeu de dominos normal

Nous allons maintenant générer un jeu de dominos. Pour se faire, nous allons créerons tous les dominos d'un jeu normal de dominos, c'est à dire l'ensemble des dominos dont les marques sont de "blanc" à "six" et sans que deux dominos ne portent des marques identiques de quelque sens qu'on les regarde. Par example, le domino (3,4) est le même que le domino (4,3) et il ne doit apparaître qu'une seule fois dans le jeu.

Instanciez un jeu normal de dominos dans une méthode statique test2() de la class MainDominos. Pour cela, vous commencerez par déclarer, dans test2(), une variable locale représentant un tableau de dominos. Puis vous y initialiserez le jeu en invoquant une méthode ad-hoc qui retourne un tableau de dominos rempli avec un jeu normal.

Modifiez test2() pour qu'elle affiche ensuite le jeu de dominos. Pour cela, écrivez une nouvelle méthode capable un tableau de domino précédé du nombre total de dominos qu'il contient, soit
```
 public static StringsetDominosToString(Domino[] setDominos)
```
Compilez et testez votre programme.

Exercice 4: Le jeu de dominos généralisé

On généralise la notion de jeu de dominos de sorte qu'un jeu de dominos soit maintenant défini par une valeur de sa marque maximale. Par example, le jeu de domino de marque maximale 4 comporte tous les dominos dont les marques sont de "blanc" à "quatre".

Créez une méthode test3(int marqueMax) qui admet cette fois un paramètre marqueMax et construit puis affiche le jeu de domino correspondant. (Vous commencerez par formaliser le nombre de dominos d'un jeu en fonction de sa marque maximale.)

Combien de dominos un jeu de marque maximale 10 contient-il? Calculez-le et vérifiez-le avec votre programme.

Dernière mise à jour : 28/01/2013

Pour tout commentaire : thang [arobase] ibisc [point] fr