:: Enseignements :: ESIPE :: E3INFO :: 2011-2012 :: Programmation Objet avec Java ::

Objets, références, égalités

Exercice 1 - Point

On cherche à écrire une classe Point stockant un point graphique en coordonnées cartésiennes (appelons les x et y).

Déclarer une classe Point contenant les deux champs privés x et y.
Puis essayer le code suivant dans la méthode main de la classe Point.
```
Point p=new Point();
System.out.println(p.x+" "+p.y);
      
```
Expliquer pourquoi l'accès aux champs privés est autorisé ici.
Créer une classe TestPoint (dans un fichier TestPoint.java) et recopiez le main de Point dans la classe TestPoint.
Quel est le problème à l'exécution de la classe TestPoint? Comment peut-on le corriger ?
Pourquoi doit-on toujours déclarer les champs privés ?
Qu'est ce qu'un accesseur ?
Quels sont les acceseurs que l'on doit mettre ici ?
Ajouter un constructeur initialisant les coordonnés du point avec deux paramètres (appelons les px et py).
Quel est le problème ?
Quel est la solution ?
Modifier le constructeur précédent pour que les deux paramètres s'appellent x et y.
Quel est le problème ?
Quel est la solution ?
Écrire un autre constructeur qui prend un point en paramètre et et utilise les coordonnées de celui-ci pour initialiser le point courant.
Comment le compilateur fait-il pour savoir quel constructeur appeler ?

Exercice 2 - Test d'égalité

En utilisant la classe Point de l'exercice précédent.

      Point p1=new Point(1,2);
      Point p2=p1;
      Point p3=new Point(1,2);

      System.out.println(p1==p2);
      System.out.println(p1==p3);

Qu'affiche le code ci-dessus ? Expliquez.
Écrire dans la classe Point une méthode isSameAs() (à vous de trouver la signature exacte de la méthode) qui renvoie true si deux points ont les mêmes coordonnées.
La classe java.util.ArrayList fournit une implementation correspondant à un tableau qui s'agrandi dynamiquement, au besoin.
À quoi selon vous peut servir la méthode indexOf de cette classe?

Executez le code suivant :

     public static void main(String[] args){
       Point p1=new Point(1,2);
       Point p2=p1;
       Point p3=new Point(1,2);

       ArrayList list = new ArrayList();
       list.add(p1);
       System.out.println(list.indexOf(p2));
       System.out.println(list.indexOf(p3));
     }

Quel est le problème avec les résultats affiché sur la console.
Note : ici, le compilateur génère des warnings à la création et à l'utilisation de l'ArrayList. Nous verrons dans les prochains TD comment les éviter.

Quel méthode de Point est appelée par ArrayList.indexOf ?
Lire la doc !!!
Modifier la classe Point pour que indexOf() teste suivant les coordonées des Points et pas suivant les références.
Utiliser l'annotation @Override pour vérifier que vous avez bien écrit la signature de la méthode ajoutée à Point.
A quoi sert l'annotation @Override ?

Exercice 3 - Comment afficher un Point ?

On aimerait pouvoir afficher les caractéristiques d'un point, par le code Java suivant :

      Point point=...
      System.out.println(point);

Java sait faire cela, à condition de mettre dans la classe Point une méthode public String toString() (la définition de cette méthode est dans la classe java.lang.Object) retournant une chaîne de caractères, qu'on construit typiquement à partir des attributs de l'objet.
Rappel: en Java on peut faire un '+' entre une String et n'importe quoi, le résultat est la concatenation entre la String et le n'importe quoi vu comme une suite de caractère.

Ecrire cette méthode, pour obtenir par exemple l'affichage suivant :
```
      (x,y)
      
```
Peut-on utiliser l'annotation @Override, ici ?

Exercice 4 - Tri à bulle [à la maison]

Écrire une méthode swap qui échange les valeurs de deux cases d'un tableau. void swap(int[] array,int index1,int index2)
Écrire une méthode indexOfMin qui renvoie l'index de la valeur minimale d'un tableau.
Modifier la méthode indexOfMin en ajoutant deux index indiquant que l'on cherche l'index du minimum non pas sur tout le tableau mais sur la partie de tableau entre les deux index (le premier inclus, le deuxième exclus).
Ecrire la méthode sort qui prend un tableau d'entier en paramètre et qui trie celui-ci en utilisant pour cela les méthodes indexOfMin et swap.

Exercice 5 - Bissextile [à la maison]

Une année est dite bissextile si elle comporte un 29 février. C'est le cas de toutes les années divisibles par 4, à l'exception de celles divisibles par 100, qui ne sont bissextiles que si elles sont également divisibles par 400.

Écrivez une classe LeapYear avec une méthode isLeapYear() qui prend en paramètre un nombre entier qui est l'année à tester, et qui retourne un booléen indiquant si cette année est bissextile ou non.
Ajoutez une méthode main() à la classe, qui accepte une année en argument sur la ligne de commande et qui affiche si elle est bissextile ou non.
Écrivez une méthode showAllInTheRange() qui prend en paramètre deux années, et qui affiche à l'écran toutes les années bissextiles supérieures ou égales à la première et inférieure ou égale à la seconde.
Modifez la méthode main pour que si elle ne prend qu'un seul argument, elle se comporte comme avant, mais si on lui passe deux années, alors elle affiche à l'écran toutes les années bissextiles comprises entre ces deux valeurs.
Modifiez la méthode showAllInRange() pour qu'elle retourne un tableau d'entiers (contenant les années bissextile).

Exercice 6 - Les doubles [à la maison]

Écrivez un programme qui calcule et qui affiche les racines réelles d'un polynôme a x² + b x + c. On distinguera les différents cas selon le nombre de racines. Les valeurs de a, b et c seront de type double. Pour les transmettre à votre programme, deux solutions: soit en argument sur la ligne de commande, et vous pouvez les récupérer par Double.parseDouble(args[0]), soit sur l'entrée standard à partir d'un Scanner grâce à la méthode nextDouble(). et seront introduites par TC.lireDouble().

Écrivez toutes les fonctions qui vous semblent utiles. Voici quelques exemples pour tester :

a b c : 1 1 1
Discriminant = -3.0
Pas de racine

a b c : 1 -2 1
Discriminant = 0.0
Racine double : 1.0

a b c : 3 2 -1
Discriminant = 16.0
Racines : -1.0 et 0.3333333333333333

a b c : 0.3 0.2 -0.1
Discriminant = 0.16
Racines : -1.0000000000000002 et 0.33333333333333337

a b c : 0.03 0.02 -0.01
Discriminant = 0.0015999999999999999
Deux racines : -1.0 et 0.33333333333333337