Programmation Objet en JAVA Mise à Niveau

Slides:



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

SI3 MAM3 Hydro Nathan Cohen Igor Litovsky Christophe Papazian
Introduction à la programmation objet Langage Java
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.
Approfondissement du langage
(Classes prédéfinies – API Java)
Introduction à Java - les paquetages -
C.
JAV - TD 6 Structures de données JAVA
TD 1 IJA Introduction Objet, méthode, attribut Classe, instance
Programmation Orientée Objet (POO)
Leçon 3 : Héritage IUP 2 Génie Informatique
Introduction à la POO: Les classes vs les objets
Principes de programmation (suite)
Programmation orientée objet
Introduction à la programmation (420-PK2-SL) cours 12 Gestion des applications Technologie de linformation (LEA.BW)
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.
Langage Oriente Objet Cours 4.
Principes de programmation (suite)
Introduction au paradigme objet Concepts importants surcharge (overload) redéfinition (override) Définition d’une classe Définition des attributs.
© 2007 P. Van Roy. All rights reserved. FSAB1402: Informatique 2 Le Langage Java et les Exceptions Peter Van Roy Département dIngénierie Informatique,
Les Classes les structures en C (struct) regroupent des variables : structuration de l'analyse mais problèmes de cohérence problèmes de sécurité d'accès.
77 Utilisation des classes (suite). 7-2 Objectifs A la fin de ce cours, vous serez capables de : Définir des méthodes surchargées dans une classe Fournir.
Classes abstraites et Interfaces
POO : Objets et classes (Rappels)
1 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Résumé du cours précédent.
Langage Oriente Objet Cours 2.
Master 1 SIGLIS Java Lecteur Stéphane Tallard Chapitre 5 – Héritage, Interfaces et Listes génériques.
Structures de données IFT-2000
Structures de données IFT-10541
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 à la programmation objet Langage Java
Introduction à la Programmation Orientée Objet Retour sur les principaux concepts SI3 MAM3 Hydro Nathan Cohen
Introduction au paradigme orienté-objet (suite)
Programmation concurrente
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.
Types de données abstrait et mécanismes d'encapsulation
Cours 4 Héritage (suite).
COURS DE PROGRAMMATION ORIENTEE OBJET :
Leçon 1 : notion dobjet IUP Génie Informatique Besançon Méthode et Outils pour la Programmation Françoise Greffier Université de Franche-Comté.
4 Introduction des objets. Les chaînes et tableaux
LIFI-Java 2004 Séance du Mercredi 22 sept. Cours 3.
La notion de type revisitée en POO
Cours 61 6 La sécurité, Portée, Visibilité Programmer avec sécurité.
11/04/ L'héritage Cours 7 Cours 7.
Programmation objet La base.
© 2005 P. Van Roy. All rights reserved. FSAB1402: Informatique 2 Le Langage Java Peter Van Roy Département d’Ingénierie Informatique, UCL
Tutorat en bio-informatique
5ième Classe (Mercredi, 19 octobre) Prog CSI2572.
Tutorat en bio-informatique Le 14 novembre Au programme… Les objets –Propriétés (attributs) –Constructeurs –Méthodes.
Réaliser par: Sadok Amel Cheboui hassiba
Master 1 SIGLIS Java Lecteur Stéphane Tallard Chapitre 3 – Classes et objets en Java Master 1 SIGLIS1 Java Lecteur - Chapitre 3 Classes et objets en Java.
Strings et Tableaux en Java
PHP objet Jérôme CUTRONA 10:13:27 Programmation Web
Les classes présenté par: RAHMOUNE RIME / ZEKRI SELMA.
Les classes et les objets Les données finales class A { … private final int n = 20 ; // la valeur de n est définie dans sa déclaration … } class A { public.
Cours du 5 novembre.
IUT du Limousin L.U.P Michel Vergnaud Programmation Objet - Java.
Les classes Introduction aux Langages Orientés Objets
Cours 4 (14 octobre) Héritage. Chapitre III Héritage.
Introduction à la programmation objet avec java
Héritage Conception par Objet et programmation Java
Langage de Programmation Orientée Objet : C++
Conception de Programmes - IUT de Paris - 1ère année Les classes Introduction Déclaration d’une classe Utilisation d’une classe Définition des.
Transcription de la présentation:

Programmation Objet en JAVA Mise à Niveau Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS) allauzen@limsi.fr Ce cours reprend en partie le matériel pédagogique mis au point par Claude Barras et Frédéric Vernier et s'inspire du cours de Philippe Genoud (INRIA)

Introduction à la P.O.O Programmation fonctionnelle Des fonctions et leurs résultats Programmation impérative ou procédurale Des ordres (éventuellement avec des fonctions) Algorithmes + Structures de données = Programmes Programmation Orientée Objet (POO) Un programme est divisé en plusieurs modules (objets) indépendants. Les modules sont chargés en mémoire à l’exécution. Le concepteur fait évoluer ses modules en parallèle et ensemble. Méthodes + Données = Objet Les modules sont typés comme des int et des float Le type de module est aussi important que le module lui-même Le type d'un objet est sa classe

Les principes de la POO Permettre la description d'un problème à l'aide de termes liés au problème et non à la machine : par l'identification et la définition des concepts et des objets, par la mise en oeuvre de leurs interactions Tout est objet. Il contient ses données (attributs), et possède une interface (méthodes publiques) permettant de lui adresser des requêtes (ou des messages) Un programme est un ensemble d'objets qui communiquent entre eux (envoi de message). Chaque objet est construit à partir d'autres objets et possède sa mémoire propre. Un objet a un type. Il est l'instance d'une classe. Les objets d'un même type peuvent recevoir les mêmes messages. La distinction la plus importante entre objets de classes différentes est « quels messages peut-on lui envoyer ? »

package dir1.dir2.mypackage; Le package Un package = regroupement cohérent de classes. import java.util.*;// invoque toutes les classes //du package import java.util.ArrayList; //uniquement 1 classe Pour constituer un package : L'utilisation se fait soit via import soit comme ceci : Mettre toutes les classes d'un même package dans un même répertoire -> mypackage Attention aux noms utilisés. package dir1.dir2.mypackage; Indique le chemin pour trouver les fichiers .class à partir du CLASSPATH package mypackage; public class MyClass{...} mypackage.MyClass m = new mypackage.MyClass();

Exemple 1 Attributs Méthodes public class etudiant { String nom; int promo, note; String traiterExam(String enonce) {…} } public class prof { String faireSujetExam() int corrigerExam(String copie) Attributs Méthodes

Exemple 1 - suite Public class GestionDuL3 { public static void main(String[] args) { etudiant e = new etudiant(); e.nom = «Jean-Louis Ezine»; e.promo = 2; prof p = new prof(); String ennonce = « Premier exercice … »; e.note=p.corrigerExam(e.traiterExam(ennonce)); … e.nom=«Gabriel Paoli»; e.nom=«vqdfgsfkbqdlkjfgh»; e.note = -324; }

Principe d'encapsulation - Rappel Un objet = données (attributs) + algorithmes (méthodes) Principe d'encapsulation : L'accès aux données (privées) ne peut se faire que par l'intermédiaire de l'interface (méthodes publiques). Les modifications des structures de données n'affectent pas les programmes qui utilisent l'objet. Réutilisation.

Concepts Objet : en mémoire La classe est chargée une seule fois (partie static) Les instances sont chargées dynamiquement autant de fois qu’il y a d’instances dans le programme Un compteur est créé pour chaque instance A chaque fois qu’une nouvelle variable fait référence à l’instance compteur++ A chaque fois qu’une référence est perdue (sortie de boucle/bloc) compteur- - Quand (compteur==0), la JVM libère la mémoire Quand la JVM libère la mémoire d’un objet, compteur- - pour les attributs de l’instance détruite ! Si dernière référence => destruction en chaîne Si co-référence : problème !

Concepts Objet : en pratique Attention à la terminologie Classe / Instance c’est clair Objet = moins clair, pourtant c’est le terme le plus utilisé Méthode = une fonctionnalité interne / externe privée / publique Variable d'instance : Variable typée (primitif ou objet) Liée à un objet Variable de classe Partagée par toutes les instances de la classe (mot clé static) Objet = données + méthodes Programmation Objet = Définir, implémenter si besoin les types d'objet : les classes nécessaires Création d'un ensemble d’objets Mise en interaction des objets

Sondage : Manipulation des données En java : Comment sont manipulés les objets, les tableaux, les types primitifs ? Comment sont passés les paramètres des méthodes ?

Méthodes statiques : Passage des paramètres public static void echange(int a , int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; System.out.println("dedans :" + a + " " + b); public static void main(String[] args) { Integer a = new Integer(3); Integer b = new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après 1:" + x + " " + y); echange(a,b); System.out.println("Après 2:" + a + " " + b); Le passage des paramètres se fait par valeur. Les 2 méthodes echange n'ont pas la même signature : surcharge Après 1:?? Après 2:??

Passage par valeur -1 Appel de la méthode : var @ val aObjet #0 #a bObjet #1 #b x #2 3 y #3 4 public static void echange(int a , int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; System.out.println("dedans :" + a + " " + b); public static void main(String[] args) { Integer aObjet = new Integer(3); Integer bObjet= new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après 1:" + x + " " + y); echange(aObjet,bObjet); System.out.println("Après 2:" + a + " " + b); Appel de la méthode : var @ val a #55 3 b #57 4

Passage par valeur -2 Appel de la méthode : var @ val aObjet #0 #a bObjet #1 #b x #2 3 y #3 4 public static void echange(int a , int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; System.out.println("dedans :" + a + " " + b); public static void main(String[] args) { Integer aObjet = new Integer(3); Integer bObjet= new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après 1:" + x + " " + y); echange(aObjet,bObjet); System.out.println("Après 2:" + a + " " + b); Appel de la méthode : var @ val a #78 #a b #79 #b

Mais pourquoi ? > java Test Avant 2 Apres 2 Apres 0 public class Test{ public static void annule(int a ){ a = 0; } public static void annule(int tab[] ){ tab[0]=0; public static void main(String[] args) { int[] tab = { 2, 5, -1, 4, 3 }; System.out.println("Avant "+ tab[0]); annule(tab[0]); // Test.annule(tab[0]) System.out.println("Apres "+ tab[0]); annule(tab); }; > java Test Avant 2 Apres 2 Apres 0 var @ val tab #x 2 #x+1 5 #x+2 -1 ...

Exemple de classe type - 1 public class Etudiant { public String nom; public int promo; // Les constructeurs Etudiant(){ nom = « Toto »; promo = 0; } public String traiterExam( String enonce){…} public class AdminFac { public static void main(String[] args){ Etudiant et = new Etudiant(); et.nom = Robert; et.promo = 5; } Et le principe d’encapsulation ! N’importe qui peut “modifier” un étudiant comme il veut !

Exemple de classe type - 2 public class Etudiant { // les attributs sont privés private String nom; private int promo; // Les constructeurs Etudiant(String n, int p){ nom = n; promo = p; } public String traiterExam(String enonce){…} public class AdminFac { public static void main(String[] args){ Etudiant et = new Etudiant( “Robert”,5); } Comment connaître le nom d’un étudiant ? Un étudiant peut-il changer de promo ? de nom ?

Exemple de classe type - 3 public class Etudiant { // les attributs sont privés private String nom; private int promo; // Les constructeurs Etudiant(){ nom = « Toto »; promo = 0; } Etudiant(String n, int p){ nom = n; promo = p; Et tout le monde peut modifier la promo ? // L'interface : ici les // assesseurs “setter & // getter” public String getNom(){ return nom; } public int getPromo(){ return promo; public void setPromo(int p){ promo = p; // et les algo nécessaires. public String traiterExam( String enonce){…}

Définition des accès Les droits d’accès se font lors de la définiton d’une classe Sondage d’opinion : public ? private ? « friendly package access » ? protected ?

Définition des accès Dans un objet l'accès et l'utilisation d'un attribut ou d'une méthode est contrôlé : public : tout le monde peut y accéder, entre autre un utilisateur, le « client programmeur ». Définit l'interface de la classe. private : accès interne à l'objet Selon le principe d'encapsulation, les attributs doivent être « private » le « friendly package access » : public pour les classes du même package protected : public pour les classes qui héritent (nous y reviendrons plus tard) + friendly.

Droits d’accès, exemples package licence; public class Etudiant { // les attributs sont privés private String nom; public int promo; // Les constructeurs Etudiant(String n, int p){ nom = n; promo = p; } public String traiterExam(String enonce){…} private String tricherVoisin(){...}; package exam; public class Exemple { public static void main (...){ Etudiant e = new Etudiant(“Toto”,2); e.promo = 3; e.nom = “Titi”; String reponse = e.traiterExam(“...”); reponse = e.tricherVoisin(); }

Notions de Programmation OO Responsabilités Chaque objet est responsable de l'accomplissement des tâches qui lui sont associées. Les objets clients envoient des messages aux objets serveurs. Eléments « atomiques » Les éléments de base sont des objets qui sont des instances d'une classe Les propriétés génériques d'un objet sont au niveau de la classe L'état d'un objet est décrit au niveau de l‘instance Les classes sont organisées hiérarchiquement et bénéficient d'un mécanisme d'héritage automatique.

Plan Pour aujourd’hui : un sondage principe fondateur de Java classe et objet, encapsulation constructeur

Constructeurs – 1 Des méthodes permettant de construire et préparer l'objet à être utiliser : Construction et initialisation selon les souhaits du programmeur Si aucun constructeur est défini alors il existera un constructeur par défaut qui initialise les variables à leurs valeurs par défaut : NomClasse() Si une classe a un constructeur, il n'y a plus de constructeur par défaut On cependant peut définir son constructeur par défaut. Il peut y avoir plus d'un constructeur par classe avec des signatures différentes public class MaClass { /* Les attributs */ /* Les constructeurs */ public MaClass(String nom){...} public MaClass(String nom,int nb) {...} /* L'interface */ /* Les méthodes privées */ public static void main(String[] args){ /* MaClass mc=new MaClass(); * c'est interdit ! */ String n = “un nom” ; int i = 5; // par contre MaClass mc1=new MaClass(n); MaClass mc2=new MaClass(n,i); }

Par contre public class MaClass { /* Les attributs */ /* Les constructeurs */ public MaClass(String nom){...} public MaClass(String nom,int nb){...} public MaClass(){...} /* L'interface : les méthodes public */ /* Les méthodes privées */ public static void main(String[] args){ MaClass mc1=new MaClass(); * c'est possible ! */ String n = “un nom” ; int i = 5; // et aussi MaClass mc1=new MaClass(n); MaClass mc2=new MaClass(n,i); }

Constructeurs – 2 Conseil : Lors de la création d’une classe : éviter le constructeur par défaut Un constructeur doit initialiser proprement tous les attributs L’objet construit doit être prêt à l’emploi. Utiliser l’IDE. Indispensable avec le principe d'encapsulation ! L'opérateur new permet de Charger les méthodes de la classe en mémoire si c’est la première fois qu’un objet de ce type est invoqué Créer l’instance en mémoire (Réserve exactement la taille de mémoire pour les données et les initialise avec leur valeurs par défaut) Lancer le constructeur (Correspondant aux arguments donnés) Le constructeur peut appeler d’autres méthodes de l’instance (y compris d’autres constructeurs) ou de la classe.

mauvais exemple Que vaut c1.rayon ? Que vaut c1.centre ? import java.awt.*; public class CercleNul { private Point centre; private float rayon; private Color color; public Point getCentre() { return centre; } public float getRayon() { return rayon; public static void main( String[] args) { /* construction par défaut */ CercleNul c1 = new CercleNul(); System.out.println(c1.getCentre()); Que vaut c1.rayon ? Que vaut c1.centre ?

mauvais exemple - 2 : unPoint import Point;// on a besoin de la classe Point ! public class TestPoint { public static void main(String[] arg) { Point unPoint = new Point();// une variable objet unPoint.setX(10); unPoint.setY(100); System.out.println("point\n\t d'abscisse " + unPoint.getX() + "\n"+"\t et d'ordonnée "+ unPoint.getY()); } }// Fin class TestPoint

Notion de surcharge Plusieurs méthodes de même nom mais de signatures différentes (liste d'arguments + type de retour). public Etudiant(String unNom, int unePromo) { nom = unNom; promo = unePromo; } public void Etudiant(String unNom) { promo = 0; La surcharge du constructeur permet une initialisation explicite des variables d'instance. Un constructeur par défaut est un constructeur sans argument. public Etudiant() { nom = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

Auto-Référence (this) Dans une méthode, le mot-clé this fait référence à l'objet sur lequel opère la méthode. System.out.println( this ); On peut imprimer toute instance en JAVA. L'impression fait appel à la méthode toString() (héritée de Object). Dans un constructeur, le mot-clé this en début d'un constructeur désigne un autre constructeur de la même classe. public Etudiant() { this( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ); } À consommer avec modération ! Et avec le constructeur ??

Reprenons : la classe Une classe décrit, définit, implémente un type d'objet : ses attributs et ses méthodes son interface (public) et sa partie private. Elle doit être utilisable, réutilisable, évolutive : principe d'encapsulation interface bien pensée Une classe est un modèle de définition pour des objets ayant même structure (même ensemble d'attributs), même comportement (mêmes opérations, méthodes), une sémantique commune. Une classe n'est pas un objet. Un objet est l'instanciation d'une classe (et une seule), une représentation dynamique, « vivante ».

Reprenons : l'objet Un objet est l'instanciation d'une seule classe. conforme par construction au « modèle » : constructeur. Chaque objet est unique : son espace mémoire, ses attributs propres et donc son état sa référence Un objet se manipule via sa référence. Référence perdue, objet perdu. Un objet n'est pas une classe.