Types Abstraits.

Slides:



Advertisements
Présentations similaires
La programmation orientée objet avec Java L3-MIAGE Plan
Advertisements

Spécialisation/généralisation Héritage Polymorphisme
Le mécanisme des exceptions
SI3 MAM3 Hydro Nathan Cohen Igor Litovsky Christophe Papazian
Introduction à la Programmation Orientée Objet Retour sur les principaux concepts SI3 MAM3 Hydro Nathan Cohen
La classe String Attention ce n’est pas un type de base. Il s'agit d'une classe défini dans l’API Java (Dans le package java.lang) String s="aaa"; // s.
Cours n° 8 Conception et Programmation à Objets
Approfondissement du langage
(Classes prédéfinies – API Java)
Programmer en JAVA par Tama
JAV - TD 6 Structures de données JAVA
Tarak Chaari, Stéphane Frénot, Frédérique Laforest, Frédéric Le-Mouël JAV1 JAV – TD 5 Lhéritage en Java.
Test dans les objets DESS Andrés Farias –
1 Le mécanisme des exceptions Qu'est-ce qu'une exception? Comment définir et signaler des exceptions? Comment récupérer des exceptions?
26/05/071 Présentation de JUnit Partie 2 NICOLAS BOUSSEKEYT CNAM
Programmation par Objets et Java
Principes de programmation (suite)
Tests Programmation par contrats
Récursivité.
JavaBeans Réalise par: EL KHADRAOUY TARIK AOUTIL SAFOWAN.
Les méthodes en java Une méthode est un regroupement d’instructions ayant pour but de faire un traitement bien précis. Une méthode pour être utilisée.
POO-L3 H. Fauconnier1 Tableau et héritage Y[] yA=new Y[3]; X[] xA=yA; //ok xA[0]=new Y(); xA[1]=new X(); //non xA[1]=new Z(); //non Object XX[]int[] YZY[]Z[]
Premier cours (23 septembre). Cours programmation- orientée objet en Java Licence dinformatique Hugues Fauconnier
Chapitre VII Généricité. POO-L3 H. Fauconnier2 Chapitre VII 1. Principes généraux 2. Types génériques imbriqués 3. Méthodes génériques 4. Types paramètres.
1 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Résumé du cours précédent.
Master 1 SIGLIS Java Lecteur Stéphane Tallard Chapitre 5 – Héritage, Interfaces et Listes génériques.
Structures de données IFT Abder Alikacem Gestion des exceptions Département dinformatique et de génie logiciel Édition Septembre 2009.
Programme de baccalauréat en informatique Programmation Orientée Objets IFT Thierry EUDE Module 7 : Classes et fonctions paramétrables Département.
66 Utilisation des classes et des objets. 6-2 Objectifs A la fin de ce cours, vous serez capables de : Créer de nouvelles classes à laide de Eclipse Utiliser.
Introduction au paradigme orienté-objet (suite)
Contrôle de types Les types en programmation Expressions de types Un contrôleur de types Equivalence de types Conversions de types Généricité.
1 IFT 6800 Atelier en Technologies dinformation Le langage de programmation Java chapitre 3 : Classes et Objects.
LIFI-Java 2004 Séance du Jeudi 9 sept. Cours 1. La notion de langage Décrire une tâche à effectuer –programme Écrire à un haut niveau –facile pour lutilisateur.
Chapitre 9 Les sous-programmes.
Types de données abstrait et mécanismes d'encapsulation
Partie II Sémantique.
Cours 8 (18 novembre 2011) exceptions. héritagePOO-L3 H. Fauconnier2 Tableau et héritage Y[] yA=new Y[3]; X[] xA=yA; //ok xA[0]=new Y(); xA[1]=new X();
Java, les objets : tout de suite ! Rassembler, grouper les objets
Structures de données IFT-2000
Structures de données IFT-10541
99 Réutilisation du code grâce à l'héritage. 9-2 Objectifs À la fin de ce cours, vous serez capables de : Définir l'héritage Utiliser l'héritage pour.
Les assertions en Java.
27/02/2006L3 MIAGE - GLO ADA1 Les Paquetages Permettent d’encapsuler un groupe d’entités logiquement reliées. Comme toute unité de programme, le paquetage.
Objectifs À la fin de ce cours, vous serez capables de :
JavaScript Nécessaire Web.
LES PILES ET FILES.
Packages et Types De la Spécification Formelle A l'implémentation Ada.
LIFI-Java 2004 Séance du Mercredi 22 sept. Cours 3.
Propriétés. Propriétés ► Les propriétés peuvent être visibles dans les environnements de scripts ► Les propriétés peuvent être accédées par programmation.
Page de garde Design by Contract en C++ Maîtrise d’informatique Février 2002.
Cours 61 6 La sécurité, Portée, Visibilité Programmer avec sécurité.
Factory Design Patterns. Contents Factory patterns: principesFactory patterns: principes The Factory Method patternThe Factory Method pattern The Abstract.
Cours 9 Exceptions (fin) Généricité. POO-L3 H. Fauconnier2 Chaînage d'exceptions  Une exception peut être causée par une autre.  il peut être utile.
11/04/ L'héritage Cours 7 Cours 7.
Algorithmique et programmation (1)‏
Programmation objet La base.
Variables et accès en Java. Déclaration des variables final transient static private Printer hp; transient => ne doivent pas être sérialisées volatile.
Cours 7 Classes locales Clonage Divers: tableaux.
Créer des packages.
Tutorat en bio-informatique
Les classes présenté par: RAHMOUNE RIME / ZEKRI SELMA.
Schéma de conception Factory Method Exemple Sylvain Giroux.
Cours du 5 novembre.
Cours 4 (14 octobre) Héritage. Chapitre III Héritage.
6ième Classe (Mercredi, 17 novembre) CSI2572
Introduction à la programmation objet avec java
Héritage Conception par Objet et programmation Java
1 Cpt JAVA : Eclipse (bis) Debogage. 2 Code à tester public class siecle { int t; public siecle() { super(); t=1; } static public boolean vrai() { return(false);
Transcription de la présentation:

Types Abstraits

Définition une spécification mathématique de « abstrait » un ensemble de données l'ensemble des opérations qu'elles peuvent effectuer. « abstrait » un cahier des charges qu'une structure de données doit ensuite implémenter. spécifications des opérations les préconditions pour l'utilisation des opérations. les constructeurs (permettent de créer un objet du type) les observateurs (fonction donne des informations sur l'état de l'objet) les transformateurs (permettent de modifier les objets et leur contenu)

Type abstrait et réalisation Type abstrait : Stack Spécification Données Opérations Axiomes implémentation Java interface StackType Assertions Exception Java ArrayStack implements StackType LinkedListStack implements StackType

Type abstrait : pile structure STACK ( item) declare CREATE() : stack PUSH (item, stack) : stack POP ( stack ) : stack TOP ( stack ) : item ISEMPTY ( stack ) : boolean for all S : stack, i : item let ISEMPTY ( CREATE() ) == true ISEMPTY ( ADD(i,S) ) == false POP ( CREATE() ) == error // isEmpty(s) == false POP ( PUSH(i,S) ) == S TOP ( CREATE() ) = error // isEmpty(s) == false TOP ( PUSH(i,S) ) == i end end STACK

Traduction en Java public interface StackType { // pas de spécification du constructeur boolean isEmpty() ; void top() throws StackException ; Object pop() throws StackException ; void push(Object item); // ne se trouve pas dans la spécification // formelle donnée int getSize() ; }

Pour une pile de taille bornée Pas dans la spécification formelle, mais lié à l’implémentation public interface BoundedStackType extends StackType { int getCapacity() ; boolean isFull() ; }

Modification de StackType public interface StackType { // pas de spécification du constructeur boolean isEmpty() ; void top() throws StackException ; Object pop() throws StackException ; void push(Object item) throws StackException ; // ne se trouve pas dans la spécification // formelle donnée int getSize() ; }

une implémentation possible public class ArrayStack implements BoundedStackType { private Object[] stack_ ; int capacity_; int top_; public ArrayStack(int capacity) { stack_ = new Object[capacity]; capacity_ = capacity; top_ = -1; } public int getCapacity() { return capacity_; public int getSize() { return top_ + 1; …

public class ArrayStack implements BoundedStackType { … public boolean isEmpty() { return top_ == -1; } public boolean isFull() { return getSize() == getCapacity(); public void pop() throws StackException { if(isEmpty()) throw new StackException("pile vide"); top_ = top_ - 1; public void push(Object item) throws StackException { if(isFull()) throw new StackException("pile pleine"); top_ = top_ + 1; stack_[top_] = item; public Object top() throws StackException { return stack_[top_];

Un des principes guidant la refactorisation

Programmation par contrats Relation entre une classe et ses clients Un accord formel (contrat) définissant les droits et devoirs de chaque partie Objectif Assurer la conformité entre les spécifications et l’implémentation Inclure des éléments de la spécification dans l’implémentation comme telle Assertion Une propriété sur les valeurs des éléments d’un programme Ex.: argument doit être positif Expression booléenne

Préconditions et postconditions Spécification sémantique des méthodes Précondition Les propriétés qui doivent être vérifiées avant l’appel d’une méthode Postcondition Les propriétés qui doivent être vérifiées lorsque la méthode se termine

Exemple : la classe Stack public class Stack { private Object[] _stack; private int _topIndex; private int _capacity; public Stack(int capacity) { super(); SetCapacity (capacity); _stack = new int[ getCapacity()]; _topIndex = -1; }

Méthodes utilitaires de la classe Stack public int getSize() { return this.getTopIndex() + 1; } protected boolean isFull() { return this.getSize() == this.getCapacity(); public boolean isEmpty() { return this.getSize() == 0;

Précondition & postcondition public int top() { // precondition : la pile ne doit pas être vide assert !isEmpty() : "Stack is empty"; return _stack[getTopIndex()]; }

Précondition & postcondition public void pop() { // precondition : la pile ne doit pas être vide assert !isEmpty() : "Stack is empty"; int oldNum = getTopIndex(); setTopIndex(getTopIndex() - 1); // postcondition : // la pile ne doit pas être pleine; // le pointeur vers le sommet a été décrémenté de 1 assert getTopIndex() == oldNum - 1 && !isFull() : "problem with counter"; return top; }

Précondition & postcondition public void push(int element) { // precondition : la pile ne doit pas être pleine assert getSize() < getCapacity() : "stack is full"; int oldNum = getTopIndex(); setTopIndex(getTopIndex() + 1); _stack[getTopIndex()] = element; // postcondition : // la pile ne doit pas être vide; // le sommet de la pile correspond à l'élément ajouté // le nombre d'éléments a été incrémenté de 1 assert getTopIndex() == oldNum + 1 && _stack[getTopIndex()] == element && !isEmpty() : "problem with counter"; }

Qu’est-ce qu’un contrat ? Les préconditions lient le client Définissent les conditions pour lesquelles une invocation de la méthode est légitime Si les préconditions ne sont pas remplies, le comportement de la méthode et de la classe est indéterminé Valeur rendue invalide, Boucle infinie, fin anormale… Les postconditions lient la classe Les conditions qui sont garanties lorsque la méthode rend son résultat ou se termine si aucun résultat n’est rendu

Et si un contrat n’est pas respecté… Si les préconditions ne sont pas remplies, le comportement de la méthode et de la classe est indéterminé Valeur rendue invalide, Boucle infinie, fin anormale… Avantage des préconditions Simplification de la programmation Une des sources importantes de complexité vérification si les données transmises satisfont les contraintes requises pour un traitement adéquat Vérifications redondantes Diminuent l’efficacité Pollution conceptuelle du logiciel Diminution de la simplicité du système Augmentation du risque d’erreurs Entrave des qualités comme l’extensibilité, la compréhensibilité et la maintenabilité Le code des méthodes pop et top n’ont pas besoin de vérifier si la pile est vide (underflow) Le code de la méthode push n’a pas besoin de vérifier si la pile est pleine (overflow) Approche recommandée Utiliser systématiquement les préconditions et programmer en supposant que les préconditions sont respectées Les préconditions et postconditions déterminent clairement qui a la responsabilité de vérifier si certaines conditions s’appliquent - approche plus rigoureuse

Jusqu’à quel point faut-il faire confiance aux clients ? Il faut faire confiance aux clients que l’on connaît Si on a un contrôle sur les clients On peut définir des préconditions strictes pour simplifier le code Dans le cas contraire, Rendre les préconditions moins strictes Et gérer explicitement les erreurs (exceptions) Et si les deux cas sont possibles Approche : encapsuler l’objet Par héritage Par encapsulation

Encapsuler la pile par héritage public class ProtectedStack extends Stack { public ProtectedStack(int capacity) { super(capacity); } public int top() throws StackException { if (isEmpty()) throw new StackException("Stack is empty"); return super.top(); public int pop() throws StackException { return super.pop(); public void push(int element) throws StackException { if (getNum() < getCapacity()) throw new StackException("stack is full"); super.push(element);

Encapsuler la pile par indirection public class EncapsulatedStack { private Stack stack; public FilteredStack(int capacity) { stack = new Stack(capacity); } public int top() throws StackException { if (stack.isEmpty()) throw new StackException("Stack is empty"); return stack.top(); public int pop() throws StackException { return stack.pop(); public void push(int element) throws StackException { if (isFull()) throw new StackException("stack is full"); stack.push(element);

Invariants de classe Propriétés globales pour toutes les instances d’une classe qui doivent être préservées par toutes les méthodes Sur les variables d’instance d’une classe 0 < = num <= capacity Relations sémantiques entre les fonctions d’une classe Relations sémantiques entre des fonctions et des attributs isEmpty rend vrai <==> num = 0 Un invariant de classe doit être vérifié Après la création d’une instance Avant et après l’invocation de toute méthode publique de la classe Les méthodes « internes » ne sont pas contraintes à maintenir la validité de l’invariant de classe

/** * Class invariant */ private boolean inv() { return (num >= 0 && num < capacity); } public Stack(int capacity) { // l’invariant de classe ne doit pas être vérifié ici setCapacity (capacity); _stack = new Object[_capacity]; setTopIndex(-1); assert inv() : "Class invariant failure"; public Object top() throws StackException { // precondition : la pile ne doit pas être vide assert !isEmpty() : "Stack is empty"; int top = _stack[getTopIndex()]; return top;

public void push(Object element) throws StackException { // precondition : la pile ne doit pas être pleine assert inv() : "Class invariant failure"; assert getSize() < getCapacity() : "stack is full"; int oldNum = getTopIndex(); setTopIndex(getTopIndex() + 1); _stack[getTopIndex()] = element; // postcondition : // la pile ne doit pas être vide; // le sommet de la pile correspond à l'élément ajouté // le nombre d'éléments a été incrémenté de 1 assert getTopIndex() == oldNum + 1 && _stack[getTopIndex()] == element && !isEmpty() : "problem with counter"; }

Invariant de boucle Une propriété entre les variables qui est vraie lorsque le contrôle entre dans la boucle à chaque exécution du corps de la boucle à la sortie de la boucle

Quotient entier ( 10 quotient 3 = 3) public static int quotient( int n, int d) { int q = 0, r = n; assert n == q * d + r : "loop invariant before entering loop"; while (r >= d) { assert n == q * d + r : "loop invariant before performing body"; r = r - d; q = q + 1; assert n == q * d + r : "loop invariant after performing body"; } assert r < d && n == q * d + r : "loop invariant after the loop"; return q;

Assertion en Java Disponible à partir de J2SE 1.4 assert booleanExpression; assert booleanExpression : errorMessage; public int pop() { // precondition assert !isEmpty() : "Stack is empty"; return stack[--num]; } java -ea:com.javacourses.tests... -da:com.javacourses.ui.phone MyClass ea : enable assertions da : disable assertions Sans arguments : toutes les classes sauf les classes systèmes Un packaqe et ses sous-package Au niveau d’une classe http://java.sun.com/developer/technicalArticles/JavaLP/assertions/index.html To enable assertions at various granularities, use the -enableassertions, or -ea, switch. To disable assertions at various granularities, use the -disableassertions, or -da, switch. You specify the granularity with the arguments that you provide to the switch: no arguments    Enables or disables assertions in all classes except system classes. packageName...    Enables or disables assertions in the named package and any subpackages. ...    Enables or disables assertions in the unnamed package in the current working directory. className    Enables or disables assertions in the named class

Types génériques en Java Si la spécification exige que tous les objets dans la pile doivent être du même type public interface GenericStackType<T> { T top() throws StackException ; void push(T item) throws StackException ; void pop() throws StackException ; boolean isEmpty() ; }

Types génériques en Java public class GenericStack<T> implements GenericStackType<T>{ private T[] stack ; private int num; private int capacity; public boolean isEmpty() { ... } public void pop() throws StackException { ... } public void push(T item) throws StackException { ... } public T top() throws StackException { ... } public int getSize() { ... } }

Configuration dans Eclipse Pour activer les assertions Choisir au moins la version 1.4 de Java Passer « –ea » en arguments à la machine virtuelle