doc - Limsi

DUT Informatique S3 - Programmation Java
Jean-Claude MARTIN - MARTIN@LIMSI.fr
Cours 3 : Encapsulation et tests
Plan . Divers
. Paquetages : intérêt, utilisation des packages existants, créer un
package
. Encapsulation : principe et intérêts
. Visibilité et accessibilité des classes, attributs et méthodes
. Test jUnit : junit.org Divers . Tester 1 classe à la fois : d'abord client, puis CompteCourant, ...
. noms de variables commençant par une minuscule
. toString () => à quoi cela sert ? est-ce obligatoire ?
. indenter
. attribut initialisés à des valeurs par défaut, pas les variables
locales
. numClient, numCompte => utiliser plutot "numero" dans toutes les
classes
. NullPointerException => à expliquer en amphi Paquetages Définition : un paquetage ("package" en anglais) est un regroupement de
classes qui ont une fonction similaire ; par exemple classes permettant de
gérer les entrées-sorties (java.io). Intérêt : ......................................................... Utilisation d'un paquetage existant Cf javadocs Pour utiliser une classe qui est dans un package donné, il faut :
- Soit ...
- Soit ... Exception : La classe System est dans le paquetage java.lang
Pourquoi peux-t'on tout de meme l'utiliser ? .............. import java.io.* ; class ExPaquetageExistant { public static void main (String arg[]) { System.out.println ("Exemple d'utilisation d'un paquetage
existant");
System.out.println ("2 puissance 3 = " + Math.pow (2,3));
System.out.println ("Affichage du dossier ");
File f = new File (".");
String dossier [] = f.list (); // enhanced for loop
for (String s : dossier) {
System.out.println ("-- " + s);
}
}
} Spécifier un paquetage pour une nouvelle classe Mettre en début de fichier
package nom ; Mettre la source dans un dossier nom
Encapsulation Pourquoi protéger les attributs des classes ? ...................... L'encapsulation consiste à permettre à un utilisateur d'utiliser un objet
sans qu'il ne se soucie des détails internes. Un objet sert alors de
conteneur / capsule pour regrouper et protéger l'accès aux attributs et aux
méthodes. Capsule = protection + entrées contrôlées dans la capsule
Schéma d'une capsule L'encapsulation permet de cacher certains attributs des objets. Pour
accéder à ces attributs, un programmeur est alors obligé de passer par des
méthodes qui peuvent alors contrôler les accès. Visibilité / accessibilité d'une classe . class C (par défaut)
o cette classe est accessible depuis toutes les autres classes de
ce paquetage
. public class C :
o cette classe est accessible depuis toutes les autres classes Visibilité / accessibilité des attributs et des méthodes . public : accessible par tous les objets
. private : accessible seulement par cette classe (et les classes
imbriquées)
. protected : accessible par cette classe et les sous-classes
. par défaut : accessible aux classes du même package Accesseurs Pour permettre tout de même d'accéder à des attributs que l'on a mis en
private, il faut ajouter des méthodes qui permettent d'y accéder : ce sont
des accesseurs : getX () => récupérer la valeur de l'attribut
setX(val) => donner une valeur à l'attribut Exemple : classe Action, mot de passe pour accéder au solde, affichage des
opérations, ... CLASSE ENCAPSULEE: Action class Action {
private double montant = 100; void setMontant (double val) {
if (val > 10 * montant) {
System.out.println ("Tentative de magouille ?");
}
else
montant = val ;
} double getMontant () {
return montant ;
}
}
CLASSE QUI EST MAINTENANT OBLIGEE DE PASSER PAR LES ACCESSEURS POUR ACCEDER
AUX ATTRIBUTS DE Action :
class Magouille {
public static void main (String args[]) {
// On recupere un ensemble d'action
Action a = new Action ();
System.out.println ("Montant initial : " + a.getMontant()); // Modifier le montant (personne ne s'en apercoit !)
a.setMontant(10000) ; // On sauvegarde ces objets dans les fichiers
System.out.println ("Montant apres magouille : " +
a.getMontant()); }
} Tests jUnit junit.org
http://www.jmdoudoux.fr/java/dejae/chap011.htm
http://www-igm.univ-mlv.fr/~dr/XPOSE2003/JUnit_tour/ JUnit est un framework open source pour réaliser des tests unitaires sur du
code Java. Le principal intérêt est de s'assurer que le code répond
toujours au besoin même après d'éventuelles modifications. Le but est d'automatiser les tests. Ceux ci sont exprimés dans des classes
sous la forme de cas de tests avec leurs résultats attendus. JUnit exécute
ces tests et les comparent avec ces résultats. Spécification de la librairie dans Eclipse (cf doc Eclipse) Avec Junit, l'unité de tests est une classe dédiée qui regroupe des cas de
tests. Ces cas de tests exécutent les tâches suivantes :
. création d'une instance de la classe et de tout autre objet nécessaire
aux tests
. appel de la méthode à tester avec les paramètres du cas de test
. comparaison du résultat obtenu avec le résultat attendu : en cas
d'échec, une exception est levée Il faut compléter la classe générée selon les besoins : par exemple,
ajouter un attribut qui va contenir une instance de la classe à tester,
ajouter l'instanciation de cette classe dans la méthode setUp() et libérer
cette instance dans la méthode tearDown().
Il faut ajouter les traitements nécessaires dans les méthodes testXXX() en
utilisant l'API de JUnit. Exemple d'encapsulation: concevoir un jeu de test avec Junit. On n'a pas vu
le code (qui n'existe peut-être pas encore) on écrit un test seulement en
fonction de la spécification. La classe « Argent » spécification La classe Argent représente une somme d'argent dans une monnaie déterminée. Elle contient
un constructeur (avec un montant et le nom d'une monnaie il fabrique
l'objet qui représente la somme d'argent),
deux accesseurs (accès au montant et à la monnaie)
et une méthode ajoute qui permet de créer la somme d'argent résultant de
l'ajout à la somme d'argent courante, une autre somme de la même monnaie.
Deux sommes d'argent sont identiques si elles représentent le même
montant dans la même monnaie. Les prototypes sont les suivants:
public Argent(double d, String s);
public double montant();
public String monnaie();
public Argent ajoute(Argent a);
La classe de test d' « Argent » import junit.framework.TestCase;
public class ArgentTest extends TestCase { Argent huitEuros, deuxEuros; public ArgentTest(String name) {
super(name);
} protected void setUp() throws Exception {
super.setUp();
huitEuros= new Argent(8,"euros");
deuxEuros= new Argent(2, "euros");
} public final void testAjoute() {
Argent attendu=new Argent(10, "euros");
Argent resultat= huitEuros.ajoute(deuxEuros);
assertEquals(attendu.montant(), resultat.montant());
assertEquals(attendu.monnaie(), resultat.monnaie());
assertEquals(attendu, resultat);
}
} La classe « Argent » conception public class Argent { private double montant;
private String monnaie;
public Argent(double d, String s){
montant=d;
monnaie=s;
}
public double montant(){
return montant;
}
public String monnaie(){
return monnaie;
}
public Argent ajoute(Argent a){
return new Argent( montant()+a.montant(), monnaie());
}
}