POO Java - · Licence (DMI/FST Limoges) (TOB) 1 POO Java Programmation Orientée Objet en Java M. Ould Braham

Licence (DMI/FST Limoges) (TOB) 1

POO Java

Programmation Orientée Objet en Java

M. Ould Braham


Contenu du cours (18h, 12 Séances)

C

Les bases du langage La Modélisation objet La gestion des E/S (flux | fichiers)

L

Les composants graphiques La gestion des conteneurs La gestion des événements

La gestion des threads (processus)

L

Introduction aux applets


Contenu du TD (21h, 14 séances)

C

Series de TD sur les thèmes abordés en cours afin de les expliciter


Contenu du TP (21h, 14 séances)

C

TP sur les séries vus en TD et éventuellement séries de TP complémentaires


Les bases du langage Java 0. Analogie programmation Objet/programmation

classique 1. Classe et objet java 2. Héritage 3. Classe et méthode abstraite 4. Interface 5. Paquetage 6. Exception 7.Composant réutilisable de base


0. Analogie programmation Objet/programmation classique Analogie programmation

Forme générale d'un programme classique

Procedure proc1(..) { ....}

Fonction fonc1(..) {....}

Procedure Principale

{//Variables

// Instructions

// appel proc1

// appel fonc1

// appel proc/fonc bibliothèques

}

Forme générale d'une application objet

Objet

{ // attributs

// methode (...) { ... } proc| fonc

}

Objet Principal

{//Objets référencés

// Instructions

// appel méthode d'Objet

// appel méthode d'objets bibliothèques

}



Rem: les sous/prog peuvent être appelés par d'autres sous/prog

Compilation

cc princ.c -o princ

Exécution

princ

Fonctionnement système

L'exécution du prog. principal se fait en demandant au système de créer un processus qui exécutera le main de ce programme exec(princ,args)

e

Rem: Un objet peut faire référence à un autre objet

Compilation

javac princ.java

Exécution

java princ

Fonctionnement système

L'exécution d'un objet principal se fait en demandant à la machine java de créer un thread dont la méthode run exécutera le main de cet objet.



• Programmation classique • Programmation Objet

Prog. Principal

Sous-Prog

Objet

Principal

Objets référencés


0. Analogie programmation Objet/programmation classique Analogie Syntaxe

• Programmation Java• import java.util.*;• class Classe { ... }• main (String args[ ]) {int argc= args.length; ... }• String chaine;• Classe objet = new

Classe(...);• objet.methode( parametres);• System.out.println( chaine );

• Programmation C• # include <...>• struct enrgt { ... } ;• main (int argc, char

*argv[]) { ...}• char *chaine;• struct enrgt enr;

• methode( enr, parametres);• printf(« %s\n »,chaine);


0. Analogie programmation Objet/programmation classique Analogie Syntaxe

• Programmation Java• int [ ] vect; • int vect[ ];• int vect[ ] = new

int[10];• Thread• structures

algorithmiques: if, do { } while, for,

switch { }

• Programmation C• int vect [ ];

• int vect[10];

• processus et thread• les mêmes


0. Analogie programmation Objet/programmation classique

Principaux paquetages du langage java par ordre alphabétique

java.applet // gestion des applets java.awt // Gestion des composants graphiques java.io // Gestion des entrées/sorties java.lang // Eléments de base du langage java.util // utilitaires et structures de données

Rem: Toute la documentation sur Java (Packages, Classes, Interfaces, Méthodes, etc. se trouve sur le site de sun à consulter et à marquer impérativement:java.sun.com/j2se.1.5.0/docs/api/


1. Classe et objet java

Variable et méthode d'instance

[import java.lang.*; ] // importation paquetage par défautclass Rectangle [extends Object] // héritage par défaut{ double largeur, hauteur; // variables ou attributs

double perimetre() // méthodes { return(2*(largeur+hauteur)); } double surface() { return(largeur*hauteur); } double diagonale() { return(Math.sqrt(largeur*largeur+hauteur*hauteur));} void doubler() { largeur*=2; hauteur=*2; }}



Constructeur

class Rectangle { double largeur, hauteur; // variables ou attributs

Rectangle (double initL, double initH) // constructeur { largeur=initL; hauteur=initH; }

:}

Rem: Le constructeur porte le même nom que la classe



Constructeur

class Cercle{ static final double pi=3.14; // constante double diametre; Cercle (double intD) // constructeur { diametre=intD; } double perimetre() // méthode { return (pi*diametre); } double surface() { return (pi*(diametre/2) *(diametre/2)); }

:}Rem: Si aucun constructeur n'est défini java crée un constructeur qui n'initialise

rien.



Création d'instance et assignationCercle c1; // déclaration d'un cercleRectangle r1;c1= new Cercle(4); // instanciation d'un cercler1= new Rectangle(4,3);

Invocation de méthode double p=c1.perimetre();

double d=r1.diagonale();



programme de test (Objet principal)class Test{ public static void main (String args[]) { Cercle c1=new Cercle(4); // lien de référence à c1 Rectangle r1=new Rectangle(4,3); System.out.println(« Perimetre du cercle: » + c1.perimetre()); System.out.println(« Diagonale du Rectangle: » + r1.diagonale()); }}Rem: La classe Test (Objet principal) sera sauvegardé dans le fichier

Test.java



Compilation/Exécution

Le programme ( objet principal) sera compilé avecjavac Test.java // compilateur java, création de Test.classLe programme sera exéuté avecjava Test // interpréteur java, exécution de Test.class


1. Classe et objet java Déclaration de plusieurs constructeurs (surcharge)class Rectangle{ : Rectangle (double csgX, double csgY, double cidX, double cidY) // 2ème constructeur { largeur=Math.abs(cidX-csgX) ; hauteur=Math.abs(cidY-csgY) ; }

:}//utilisation de différents constructeursRectangle r1=new Rectangle(4,3);Rectangle r2=new Rectangle(1,1,5,4);


1. Classe et objet java Surcharge de méthodeclass Rectangle{ : void doubler( boolean dL, boolean dH) { if (dL) largeur*=2; if (dH) hauteur*=2; }

:}//utilisation de différentes méthodesr1.doubler(); // double la largeur et la hauteur de r1r2.doubler(false,true); // double uniquement la hauteur de r2



Remarque: Le compilateur examine les types de paramètres et leur nombre afin de

déterminer le bon constructeur ou la bonne méthode à invoquer. Destruction d'objetLa gestion de mémoire (garbage collection) permet de récupérer la

place occupée par les objets créés et non référencés, elle se fait automatiquement.

La méthode finalize() est invoquée pour fermer explicitement les canaux (fichiers) ouverts par un objet avant de le détruire.



Variable de classeLes variables de classe sont déclarées static elles ne sont pas créées

dans les instances de classe mais dans la classe seulement.Généralement elles correspondent à des variables de travail ou des

constantes.Exemple: static final double pi=3.14;

Il peut y avoir aussi des méthodes de classe la plus connue est la méthode principale public static void main(...){ ..} de toute classe exécutable (principale).


1. Classe et objet java Visibilité des variables d'instance et des variables de

classeLes variables d'instance sont accessibles depuis toutes les

méthodes de la classe sans être préfixée et depuis l'extérieur en étant préfixé du nom de l'objet.

Il est possible de cacher des variables d'instance pour l'extérieur grâce au modificateur private (limite l’accès à la classe) et protected (limite l’accés au paquetage courant et aux classes dérivées appartenant à d'autres paquetages). Le défaut de modificateur limite l’accés au paquetage courant. Par défaut le paquetage courant correspond au répertoire courant.

Les variables de classe sont accessibles depuis l'extérieur en les préfixant du nom de la classe.

Exemple: Cercle.pi


1. Classe et objet java Méthode de classeUne méthode de classe est destinée à agir sur la classe plutôt que sur

ses instances, elle est aussi précédée de static.class Rectangle{ static double echelle=1.0; // variable de classe

: static void modifEchelle( double e) // méthode de classe { echelle=e;}

:}// exemple d'utilisationRectangle.modifEchelle(2.0);System.out.println(« Echelle utilisée : »+Rectangle.echelle);


1. Classe et objet java Référence, copie et égalitéRectangle r1= new Rectangle(4,3);Rectangle r2=r1; // r1 et r2 pointent le même objet (r1==r2)Rectangle r3=r1.clone(); // copie de r1 (r3 !=r1), methode de Objectr1.equals(r3) // est vrai, il y a égalité des attributsReprésentation schématique

largeur=4hauteur=3

r1

r2

largeur=4hauteur=3

r3


1. Classe et objet java Types simples et classes enveloppesLes types simples: boolean,char, int, long, float, double, ...Les valeurs des variables de ces types ne sont pas des objets. Il arrive que

certaines méthodes ne traitent que des objets, exemple méthodes de la classe java.util.Vector (vecteur d’objets).

Les classes enveloppes permettent d'encapsuler un type simple dans un objet. Ces classes sont: Boolean, Character, Double, Float, Integer, Long, ...

Leurs constructeurs prennent comme paramètre une valeur du type à encapsuler.

Exemple: boolean b=true; int i=256; Boolean objB= new Boolean(b); Integer objI= new Integer(i);


1. Classe et objet java Types simples et classes enveloppes Chaque classe enveloppe fournit une méthode pour extraire la

valeur simple de l'objet enveloppe.boolean b1= objB.booleanValue(); // méthode de la classe Booleanint i1 = objI.intValue(); // méthode de la classe Integer Exemple d'utilisation, classe Vector (séquence d'objets)Vector v= new Vector();v.addElement( new Integer(5)); // méthode de la classe Vectorv.addElement( new Integer(10));v.addElement( new Integer(15));int dernier=(v.lastElement()).intValue(); // méthode de la classe Vector


2. Héritage Définition de sous-classeclass Carre extends Rectangle // héritage{ Carre( double initC) // Constructeur de Carre { super (initC,initC); } double cote() { return (this.largeur);}} L'héritage permet de conserver certaines caractéristiques d'une

classe et de faire bénéficier une autre (héritière) sans avoir à tout redéfinir.

La sous-classe Carre (héritière) étend (spécialise) la super classe Rectangle

Le désignateur super désigne le constructeur de la super classe ici Rectangle.

Le désignateur this désigne une instance de la sous-classe Carre.


2. Héritage // Test de la sous-classe Carreclass TestCarre{ public static void main (String args[]) { Carre c=new Carre(4); System.out.println(« Cote du Carré: » +c.cote()); System.out.println(« Périmètre du Carre: »+c.perimetre()); System.out.println(« Cote du Carré (largeur): » +c.largeur); }}Rem1 : La méthode perimetre() est celle héritée de RectangleRem2: La classe parente englobe la classe héritière, un carre est un

rectangle ayant la largeur égale à la hauteur.Rem3: L’accès à largeur est possible car il n’est pas private


2. Héritage Assignation, sous-classe et redéfinitionUne variable Rectangle peut recevoir un objet d'une sous-classe de

Rectangle, exemple un Carre, l’inverse n’est pas autorisé.Rectangle r1,c1;r1= new Rectangle(4,3);c1= new Carre(5);Comme c1 est un Rectangle on ne peut lui appliquer que les

méthodes de Rectangle.double c=c1.cote(); //erreur à la compil. car c1 est un rectangle

Par contre si une méthode est redéfinie dans cette sous-classe (Carre), c'est cette méthode qui est utilisée.


2. Héritage Assignation, sous-classe et redéfinitionExemple : class Carre extends Rectangle { Carre( double initC) // Constructeur de Carre { super(initC,initC); } double cote() { return (this.largeur);} double perimetre() // redéfinition { return (largeur*4);} } // Exemple d'utilisation double p=c1.perimetre(); //C'est perimetre de Carre qui est utilisé

Rem: Lors de l'exécution du programme contenant cette instruction c'est le principe de liaison dynamique qui permet de faire ce choix de la méthode du Carré.


2. Héritage Assignation et compatibilité de typeCarre c;c= new Rectangle(4,4); // non autoriséou Carre c;Rectangle r;r= new Carre(4); c=r ; // non permis, même si r est instancié Carrec=(Carre)r ; // il faut d’abord convertir r en Carre

Rem: Le compilateur java vérifie bien que r est un Carre, sinon il signale une erreur. Ici la déclaration prime sur l'instanciation.


2. Héritage Constructeur de sous-classeSi la première instruction d'un constructeur de sous-classe n'est pas

super(…), un appel super() est automatiquement ajouté avant la première instruction. Dans ce cas il faut qu'un constructeur sans paramètre existe dans la super classe.

class Parallelepipede extends Rectangle{ double profondeur; Parallelepipede (double x, double y, double z ) // Constructeur { super(x,y); profondeur=z; } double volume() { return (surface()*profondeur);} // surface de Rectangle}


2. Héritage Hiérarchie des classesEn java toutes les classes ont pour origine la classe Object (Racine).

Une classe ne peut hériter (extends) que d'une seule classe (héritage simple), d'où l'arbre d'héritage exemple:

Object

Cercle

Rectangle

Carre

Parallelepipede


3. Classe et méthode abstraite Les classes abstraites sont des classes dont certaines

méthodes dites abstraites n'ont pas de corps (au moins une). Une classe abstraite n'est pas instanciable. Si une sous-classe d'une classe abstraite redéfinit toutes les méthodes abstraites de celle ci, elle devient concrète (instanciable) sinon elle reste abstraite.

A l'inverse des classes abstraites, les classes finales se situent en bas de la hiérarchie des classes, elles ne peuvent pas être étendues. Une classe peut ne pas être finale mais déclarer ses méthodes comme finales, il est alors interdit de les redéfinir.


3. Classe et méthode abstraite Exemple: abstract class Forme{ static final double pi=3.14; abstract double perimetre(); abstract double surface();}class Rectangle extends Forme{ ...............}class Cercle extends Forme{ ...............}

Rem: La classe abstraite est très utile dans la modélisation de l'architecture des applications objet.


4. Interface Une interface est similaire à une classe abstraite totale,

puisqu'elle déclare un ensemble de méthodes sans corps ( abstraites par défaut) et de constantes. On ne peut pas instancier une interface. Par contre l'interface définit un type, on peut déclarer des variables et/ou des paramètres de type interface.

Une classe peut indiquer dans sa définition qu'elle implante (implements) une ou plusieurs interfaces. Elle s'engage à fournir une définition pour toutes les méthodes de la ou des interfaces.

Une interface peut hériter d'une ou plusieurs autres interfaces (héritage multiple). Les interfaces forment une hiérarchie différente de celle des classes.


4. Interface Exemple :interface IForme{ static final double pi=3.14;}interface Courbe extends IForme // héritage entre interfaces{ double perimetre(); void doubler();}interface Surface extends IForme{ double surface();}class Rectangle extends Forme implements Courbe,Surface{ ...............} // les méthodes des interfaces en publicclass Cercle extends Forme implements Courbe,Surface{ ...............} // ajouter la méthode doubler()


4. Interface Hierarchies d’interfaces et de classes:

IForme

Courbe Surface

Forme

Rectangle Cercle

Implements

extends


4. Interfaceclass TestInterface{ public static void main (String args[]) { Courbe co1, co2; // interfaces Surface s1,s2; Rectangle r = new rectangle (4,3); Cercle c = new Cercle(4); co1=r ; // variable interface reçoit objet s1=r ; co2=c; s2=c; System.out.println(« Surface du rectangle: »+ r.surface()); System.out.println(« Surface du rectangle: »+ s1.surface()); System.out.println(« Surface du cercle: »+ s2.surface()); System.out.println(« Périmètre du cercle: »+ co2.perimetre()); System.out.println(« Périmètre du rectangle: »+ co1.perimetre()); }}


5. Paquetage Un paquetage permet de regrouper physiquement des

classes et/ou des interfaces concernant le même domaine dans un répertoire particulier ayant le même nom que le paquetage (bibliothèque). Le paquetage définit un système de nommage (nom_paquetage.nom_element)

Pour mettre une classe dans un paquetage commencer la description de la classe en spécifiant le nom du paquetage destination par:package nom_paquetage;

Pour importer le contenu d'un paquetage dans une classe ajouter au debut de la description de la classeimport nom_paquetage.*;


5. Paquetage problèmes de visibilitéL'attribut private limite la visibilité à la classe. L'attribut

protected limite la visibilité à toute classe appartenant au même paquetage et à toute sous-classe même appartenant à un autre paquetage. L'attribut public étend la visibilité à tous les paquetages.

Rem: Le répertoire du paquetage par défaut est le répertoire courant. Les classes devant appartenir à un autre paquetage (autre répertoire) doivent être compilées et exécutées en ajoutant les options: (-classpath, -d). (Une Serie de TP est prévue pour tester cela)


5. Paquetage Compilationjavac [-classpath ~/repertoire_recherche

-d ~/repertoire_destination] Classe.java Exécutionjava [-classpath ~/repertoire_recherche/:.] ClassePrincipale

Rem: Lors de la compilation de la 1ère classe du paquetage (package paquetage), un repertoire paquetage est automatiquement créé dans le repertoire destination.


5. Paquetage Schéma de visibilté

Package1 Package2

Class A private AttA1 protected AttA2 AttA3 public AttA4 [ methodes A ] // tous les attributs de A

Class B : [ mehodes B] // tous sauf AttA1

Class C extends A : [ mehodes C] // tous sauf AttA1

Class B' : [ mehodes B'] // seulement AttA4

Class C' extends A : [ mehodes C'] // Att2 et Att4


6. Exception On peut définir sa propre exception en créant une classe

qui hérite de la classe Exception. Le constructeur de cette classe indique ce qu'il y a lieu de faire lorsque cette exception est soulevée.

Pour soulever cette exception dans une méthode, il faut ajouter throws cette exception dans la déclaration de cette méthode et throw une instanciation de cette exception lorsque les conditions de soulevement sont réunies.

Le traitement de l'exception permet d'éviter à cette exception d'être traitée par le système d'exécution qui arrêtera éventuellement le programme ( exemple division par zéro).


6. ExceptionL'exécution d'une méthode soulevant une exception doit

être exécutée dans un bloc try. Les instructions try {..} + catch(..) {} + éventuellement finally {..} permettent de contrôler les instructions du bloc try. Les instructions pouvant soulever des exceptions prédéfinies (exple IOException) doivent être exécutées dans un bloc try.

L'ordre d'exécution des instructions liées au traitement de l'exception est le suivant:instructions du constructeur de l'exceptioninstructions du bloc catch s'il n'est pas videinstructions du bloc finally s'il est précisé

(Une Serie de TD et une de TP sont prévues pour tester cela)


7. Composant réutilisable de base La séquence ( classe Java.util.Vector) Une séquence est une collection ordonnée d'objets, chaque objet

possède une position. Opérations de manipulation de séquenceVector(); // Constructeur crée une séquence videvoid addElement(Object ob); // ajoute un elet en finvoid insertElement( Object ob, int index); // ajoute un elet à indexboolean removeElement(Object ob); // enlève la 1ère occur. de obvoid removeElementAt(int index); // enlève l'elet à indexvoid removeAllElements(); // vide la séquencevoid setElementAt( Object ob, int index); // remplace l'elet en index


7. Composant réutilisable de base La séquence ( classe Java.util.Vector) Opérations d'interrogationint size(); // nbr d'elets boolean isEmpty();Object firstElement();Object lastElement();Object elementAt(int index);boolean contains(Object ob);int indexOf(Object ob); // -1 si inexistantint indexOf(Object ob, int index)); // position de ob à partir de indexint lastIndexOf(Object ob); // position de la dernière occur. de ob Rem: Il est possible de définir la capacité initiale de la séquence

ainsi que l'incrément d'extension lorsqu'elle se remplit.

Documents

POO Java - · Licence (DMI/FST Limoges) (TOB) 1 POO Java Programmation Orientée Objet en Java M. Ould Braham