Programmation orientée objet

TP 2

Un peu plus sur les objets

Introduction aux exceptions

Introduction aux tests unitaires

• Un package Java est un ensemble de types (classe, interfaces, énumérations, ...)
• Par convention, le nom d'un package commence par une minuscule et est souvent un nom de domaine inversé (be.ac.ulb.code) pour éviter les conflits.
• Par exemple, les classes fondamentales se trouvent dans java.lang (importé par défaut), les classes d’entrée/sortie se trouvent dans java.io, ...
• A la première ligne d'un fichier, il faut préciser le package concerné (sinon il sera dans le package par défaut) :

package nomDuPackage;

Pour utiliser des types d'un package dans un fichier d'un autre package, on peut :

• Importer tous les types d'un package au début du fichier :

import tp1.*; // Comparable à using namespace std; en C++

• Importer un type contenu dans un package au début du fichier :

import tp1.Date;

• Utiliser le nom complet à chaque fois :

tp1.Date date = new tp1.Date(12,11,09);

• L’encapsulation est un concept OO qui consiste à protéger l’information contenue dans un objet.
• En Java, les attributs et méthodes peuvent être :
  • public : accessibles de partout (intérieur, extérieur)
  • private : accessibles seulement à l’intérieur de la classe
  • private-package (par défaut si on ne précise rien) : accessibles à l’intérieur de la classe et à l’intérieur d’un package.
  • protected : voir plus loin
• Une classe doit être le vigile de l'intégrité de ses objets. Pour ce faire, on va généralement déclarer tous ses attributs en private et gérer leur intégrité via des accesseurs. Attention, il ne faut faire des accesseurs que si c’est nécessaire.

• Les niveaux de protection pour une classe sont:
  • public : la classe peut être vue par tout le monde
  • private-package : la classe n'est vue qu'à l'intérieur de son package
• Il ne peut y avoir au maximum qu'une classe publique par fichier .java.

• Un attribut ou une méthode statique se réfère à une classe et non à une instance particulière.
• Exemples :
  • Math.PI : pas besoin d'instancier un objet de type Math
  • Math.max(int i, int j)
  • static void main(String[] args) : méthode dans laquelle on va créer les premiers objets
• Une méthode statique dans une classe ne peut accéder qu'aux méthodes statiques de cette classe (et des autres).

public Date {
    [...]
    private static int[] daysInMonths =
        new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
    public static int daysInMonth(int month, int year) {
        return daysInMonths[month-1]
            + (isLeapYear(year) && month == 2 ? 1 : 0);
    }
}

Pour que ça marche, il faut que isLeapYear soit défini comme méthode statique.

Pour appeler une méthode statique depuis une autre classe :

int daysInFeb12 = Date.daysInMonth(2, 2012);

• Les objets sont toujours utilisés par références.
• Une instance = un new.

Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);

• En Java, quand quelque chose se passe mal, une exception peut être déclenchée :
  • Une condition d’exécution anormale a été détectée par la machine virtuelle (division par zéro, dépassement de tableau, …)
  • Une exception a été lancée par une méthode via l’instruction throw
  • Une exception asynchrone a été déclenchée (voir plus loin)
• Une exception est un objet d’une classe ou d’une sous classe de la classe Throwable. Par exemple un objet de type Exception.
• http://java.sun.com/docs/books/jls/third_edition/html/exceptions.html

• On peut attraper (catch) une exception en Java à l’aide de l’instruction try catch
• Exemple :

try {
    // code pouvant déclencher une exception
    // si un exception se déclenche,
    // on saute dans le bloc catch
} catch (Exceptioneption e) {
    // gestion de l’exception
    // par exemple :
    System.out.println(e.getMessage());
}

• L’instruction try catch finally permet d’exécuter du code qu’une exception ait été déclenchée ou non.
• Exemple :

try {
    // code pouvant déclencher une exception
    // si un exception se déclenche,
    // on saute dans le bloc catch
} catch (Exception e) {
    // gestion de l’exception
} finally {
    // code exécuté de toute faireçon
}

• Exception unchecked :
  • Error (plutôt hardware):
    • Erreurs qui peuvent arriver à beaucoup d’endroits. Diffile ou impossible à réparer. (division par zero, sortir d’un tableau, ...)
  • RuntimeException (plutôt software)
    • Exceptions qui ne devraient pas arriver comme un pointeur nul mais qui pourraient arriver tellement souvent que les gérer serait fastidieux.
• Exceptions checked :
  • Toutes les autres exceptions.

• L’instruction throw permet de déclencher une exception et sortir de la méthode courante.
• Les méthodes qui peuvent déclencher une exception checked doivent le déclarer dans leur signature via le mot clé throws. Et donc le code qui appelle ces méthodes doivent attraper cette exception checked.
• Exemple :

public void aMethod() throws Exception {
    [...]
    if(somethingHappens()) {
         throw new Exception("Boumshanka ! An interception !");
    }
    [...]
}

• Tests manuels :
  • Essayer un ou deux appels dans main
  • Regarder à la main les résultats
• Tests unitaires :
  • Formaliser et automatiser les prodécures de test
  • Au niveau d'une fonction, voire d'une classe (une unité)
  • Idéalement, un outil exécute l'ensemble des tests régulièrement
• Avantages :
  • Les tests peuvent être refaits à chaque modification
  • Permet de vérifier qu'on ne "casse" rien

import static org.junit.Assert.*;
import org.junit.Test;

public class DateTest {
    @Test
    public void testIncrementSimple() {
        Date d = new Date(1,1,2012);
        d.increment();
        assertEquals(d.getDay(), 2);
        assertEquals(d.getMonth(), 1);
        assertEquals(d.getYear(), 2012);
    }
}

@Test(expected=RuntimeException.class)
public void testConstructorInvalidMonth(){
    new Date(1,-1,2012);
}

Attention :

Program testing can be used to show the presence of bugs, but never to show their absence!

—Edsger W. Dijkstra