Programmation Objet en JAVA Mise à Niveau Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS) [email protected]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)
31
Embed
Programmation Objet en JAVA Mise à Niveau Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS) [email protected] Ce cours reprend en partie le matériel.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
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 ? »
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
public class etudiant { String nom; int promo, note; String traiterExam(String enonce) {…}}
public class prof { String nom; 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;
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);
}Après 1:??Après 2:??
Passage par valeur -1
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 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);
}
var @ val
a #55 3
b #57 4
a #55 4
b #57 3
Appel de la méthode :
Passage par valeur -2
var @ val
aObjet #0 #a
bObjet #1 #b
x #2 3
y #3 4
var @ val
a #78 #a
b #79 #b
a #78 #b
b #79 #a
Appel de la méthode :
public static void echange(int a , int b) {int tmp = a ;a = b;b = tmp;
}public static void echange(Integer a, Integer b) {
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);
}
Mais pourquoi ?
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) {
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
import java.awt.*;public class CercleNul {
private Point centre; private float rayon;private Color color;
public Point getCentre() {
public float getRayon() {return rayon;
System.out.println(c1.getCentre());}
}
CercleNul c1 = new CercleNul();
/* construction par défaut */public static void main( String[] args) {}
}
return centre;
•
• 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) { nom = 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"; promo = 0;}
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.