Java MAN INFRES 1A _#5A3B26

Programmation Java - bases
Programmation objet avec Java (1)
Christelle Urtado & Sylvain Vauttier
Janvier 2013
Objectifs du cours et organisation
 Séances de Cours / TD
 Cours 3 séances = 9 heures
 TD 4 séances = 12 heures (Abderrahman Mokni)
 Connaissance et pratique simple du langage
 (Re)voir les concepts de base de la programmation par
objet et leur mise en œuvre dans le langage Java,
 (Re)voir les concepts de base de la programmation en
langage Java : mots-clés / structures de contrôle /
exceptions
 (Re)voir (utiliser) les bibliothèques de classes utiles.
1
Repères
Plan
1970
1980
1990
Introduction
- la maturité de l’objet ?
- « Write once, run everywhere »
( Classes / Attributs /
Méthodes / Objets)
Langage C++ - B. Stroutstrup
AT&T Bell Labs
Construction et
destruction
Compléments objet
(Héritage et visibilité)
2010
Langage Java - J. Gosling
Sun Microsystems
Notions de base
Paquetages et rapide
panorama de l’API
2000
- du C avec des objets
- un efficace « pot-pourri »
Langage C - D. Ritchie - Bell Labs
- le langage créé pour écrire UNIX
- rapide et bas niveau (pointeurs, mémoire)
- initialement pas normalisé et peu portable
Langage Pascal - N. Wirth - ETH Zurich
- typage statique fort
- programation structurée : goto
- « Algorithms + Data Structures = Programs »
Historique des principales versions
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 1996, JDK 1.0
 1997, JDK 1.1
 refonte du modèle des IHM , JavaBeans, RMI
 1998, J2SE 1.2
 réflexion, nouvelle API pour les IHM (Swing),
compilation juste à temps, structures de données
standards (Collections)
 2004, J2SE 5.0
 types génériques, annotations, conversions
automatiques type primitif ↔ classe enveloppe
(autoboxing
/
unboxing),
enumérations,
amélioration des boucles for, spécialisation
covariante des types de retour des méthodes
 2011, Java SE 7 : version courante
 possible de mettre des String dans switch
2
Plan
Qu’est-ce qu’un programme autonome
Java ?
 Programme autonome vs applet
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 Un ensemble de classes qui définissent chacune
 des données (ses attributs),
attributs
 et des fonctionnalités (ses méthodes).
thodes
 Une de ces classes contient
principal c-à-d la méthode main.
le
programme
 Le code de chacune de ces classes est écrit dans
un fichier qui porte le même nom que la classe
suivi de l’extension .java
 Lorsque le programme devient conséquent, les
classes sont « rangées » dans des paquetages.
paquetages
 Le code peut utiliser des fonctionnalités :
 que vous avez décrites dans d’autres classes,
 qui existent déjà dans les classes de l’API
API Java.
Plan
Introduction
Comment exécuter
autonome Java ?
un
programme
Fichier de byte code
(pseudo code)
Fichier de code Java
Compilateur
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
MaClasse.java
javac
MaClasse.class
Machine virtuelle Java
(JVM)
java
Autres fichiers
de pseudo-code
(Héritage et visibilité)
$ javac MaClasse.java
$ java MaClasse
3
Classes
Plan
Introduction
Notions de base
import java.util.*;
public class ProgPpal
{
private Vector lesFigures;
public static void main (String args [])
{
lesFigures = new Vector ();
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
}
Carre monCarre = new Carre (10);
System.out.println("Mon Carré possède un côté de : ",
monCarre.getCote (), "cm.");
lesFigures.addElement (mon Carre);
}
public class Carre
{
private float cote;
Paquetages et rapide
panorama de l’API
une classe
public Carre (float leCote)
{
cote = leCote;
}
public float getCote ()
{
return (cote);
}
Compléments objet
(Héritage et visibilité)
}
public float calculeSurface ()
{
return (cote * cote);
}
Attributs
Plan
Introduction
Notions de base
import java.util.*;
public class ProgPpal
{
private Vector lesFigures;
public static void main (String args [])
{
lesFigures = new Vector ();
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
}
Carre monCarre = new Carre (10);
System.out.println("Mon Carré possède un côté de : ",
monCarre.getCote (), "cm.");
lesFigures.addElement (mon Carre);
}
public class Carre
{
private float cote;
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
public Carre (float leCote)
{
cote = leCote;
}
public float getCote ()
{
return (cote);
}
un attribut
}
public float calculeSurface ()
{
return (cote * cote);
}
4
Méthodes
Plan
Introduction
Notions de base
import java.util.*;
public class ProgPpal
{
private Vector lesFigures;
public static void main (String args [])
{
lesFigures = new Vector ();
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
}
Carre monCarre = new Carre (10);
System.out.println("Mon Carré possède un côté de : ",
monCarre.getCote (), "cm.");
lesFigures.addElement (mon Carre);
}
public class Carre
{
private float cote;
Paquetages et rapide
panorama de l’API
public Carre (float leCote)
{
cote = leCote;
}
public float getCote ()
{
return (cote);
}
Compléments objet
(Héritage et visibilité)
une méthode
}
public float calculeSurface ()
{
return (cote * cote);
}
Objets
Plan
Introduction
Notions de base
import java.util.*;
public class ProgPpal
{
private Vector lesFigures;
public static void main (String args [])
{
lesFigures = new Vector ();
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
}
Carre monCarre = new Carre (10);
System.out.println("Mon Carré possède un côté de : ",
monCarre.getCote (), "cm.");
lesFigures.addElement (monCarre);
}
public class Carre
{
private float cote;
Paquetages et rapide
panorama de l’API
public Carre (float leCote)
{
cote = leCote;
}
public float getCote ()
{
return (cote);
}
Compléments objet
(Héritage et visibilité)
un objet
}
public float calculeSurface ()
{
return (cote * cote);
}
5
Objets : création
Plan
Carre monCarre = new Carre (10);
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paramètres du constructeur
Type de l’objet
(Nom de la classe)
Opérateur new
Nom de la variable dans
laquelle est stocké l’objet
Nom du constructeur
(le même que celui de la classe)
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
Attributs et méthodes : définition
Plan
 Définition d’un attribut dans une classe
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
private float cote;
Spécificateur d’accès
Type
Nom
private Vector lesFigures;
 Définition d’une méthode dans une classe
public float calculeSurface ()
{
return (cote * cote);
}
Modificateurs
Type de retour
Liste de paramètres
(couples « type nom »
séparés par des virgules)
Nom
Bloc de code
(dont les spécificateurs
d’accès)
public Carre (float leCote)
{
cote = leCote;
}
6
Attributs et méthodes : utilisation
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
 Accès à un attribut (pour lire sa valeur ou lui
affecter une valeur) ou exécution d’une méthode
 Etant donné un objet (référencé par une
variable, retourné par une méthode), on utilise
« . ».
System.out.println("Mon Carré possède un côté de : ",
monCarre.getCote (), "cm.");
 A l’intérieur des méthodes de sa classe, on peut
se passer de désigner l’objet.
cote = leCote;
(Héritage et visibilité)
Méthodes : surdéfinition (1)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
 Dans une même classe, il peut y avoir plusieurs
méthodes de même nom, pourvu qu'elles diffèrent
en nombre et/ou type de paramètres (signature).
 On parle de surdé
surdéfinition (overloading).
 Le choix de la méthode à exécuter est fonction
des paramètres passés à l'appel.
 Ce choix est réalisé de façon statique (c-à-d à la
compilation).
Compléments objet
(Héritage et visibilité)
7
Méthodes : surdéfinition (1)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
public class Point
{
private int x,y;
public class Carre
{
private Point centre;
private int cote;
public Point (int abs, int ord)
{
x = abs;
y = ord;
}
public Carre (int leCote)
{
cote = leCote;
centre = new Point (0,0);
}
public int getX() {return (x);}
public int getY() {return (y);}
}
public void deplace (Point nouveauCentre)
{
centre = nouveauCentre;
}
public void deplace (int deltaX, int deltaY)
{
centre = new Point (centre.getX() + deltaX, centre.getY() + deltaY);
}
}
public class ProgPpal
{
public static void main (String args[])
{
Carre monCarre = new Carre (10);
monCarre.deplace (new Point (5, 4);
monCarre.deplace (8, 10);
}
}
Construction d’objets
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
public Carre (float leCote)
{
cote = leCote;
}
…
Carre monCarre = new Carre (10);
…
 Le constructeur est une méthode d’initialisation
 de même nom que la classe,
 sans type de retour (explicite),
 qui se déclenche automatiquement lors du new
(instanciation d’un objet).
 Pour une même classe :
 il peut y avoir plusieurs constructeurs qui diffèrent
par leurs paramètres (surdéfinition).
 il existe un constructeur « vide » sans paramètre par
défaut (qui cesse d’exister dès que vous écrivez un
autre constructeur).
8
Destruction d'objets (1)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
 Java
propose
un
mécanisme
qui
détruit
automatiquement les objets devenus inutiles : le
ramasse-miettes (garbage collector).
 Il collecte, pour les détruire, les objets qui ne
sont plus référencés.
 Il détruit les objets de façon asynchrone.
 Il fonctionne en permanence dans un thread de
faible priorité.
 Il est basé sur le principe du compteur de
références.
Compléments objet
(Héritage et visibilité)
Destruction d'objets (2)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
 Ainsi, le programmeur n'a pas à détruire
explicitement les objets, importante source
d'erreurs dans d’autres langages :
 fuites de mémoire (memory leaks),
 références pendantes (pending references).
 Mais, seuls les objets non référencés peuvent
être collectés.
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
9
Paquetages
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
 Lorsqu’on a défini de nombreuses classes, il est utile
d’en faire des sous-ensembles thématiques. Pour cela,
on les « range » dans des paquetages.
 Si aucun paquetage n'est précisé pour une classe,
celle-ci est intégré dans le paquetage anonyme
(unnamed).
 A chaque paquetage Java correspond un répertoire du
système de fichiers.
Paquetages et rapide
panorama de l’API
 Arborescence de fichiers 
paquetages et sous-paquetages
Compléments objet
 Exemple : Les classes de java.lang sont dans le
répertoire java/lang/.
(Héritage et visibilité)
Décomposition
en
 Un paquetage est aussi un espace de nommage
(permettant d’assurer l’unicité des noms de classes).
 Convention :
fr.mines-ales.lgi2p.monPaquetage.MaClasse
Utilisation des paquetages
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 Pour utiliser une classe située dans un paquetage, il y a deux
possibilités :
 Indiquer le nom du paquetage avant celui de la classe,
java.util.Vector monVecteur;
 Utiliser
le
raccourci
import java.util.Vector;
Vector monVecteur;
lexical
import.
import java.util.*;
Vector monVecteur;
 Comment ranger une classe dans un paquetage :
 créer un répertoire qui porte le nom monPaquetage
 pour chacune des classes qu’on souhaite ranger dans le
paquetage, ajouter en début de fichier :
package monPaquetage;
 Il faut, en outre, indiquer le chemin de recherche au
compilateur et à la JVM.
CLASSPATH = .:<répertoire père de monPaquetage>
10
Les paquetages de l’API
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
 Java contient plusieurs centaines de classes
constituant son API (Application Programming
Interface).
 Liste des paquetages les plus utilisés :
 java.lang : chaînes de caractères, interaction
avec l'OS, threads
 java.util : structures de données classiques
 java.io : entrées / sorties
Paquetages et rapide
panorama de l’API
 java.net : sockets, URL
 java.applet
Compléments objet
 java.awt et javax.swing : fenêtres, boutons,
événements souris
(Héritage et visibilité)
 java.rmi : (Remote Method Invocation) pour
réaliser des applications distribuées
Héritage (1)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
 L’héritage est un mécanisme qui permet de
« factoriser » des éléments de définitions de
classes (attributs / méthodes).
 On parle de super-classe et de sous-classe.
EtreVivant
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
Personne
Etudiant
Employé
 La relation d’héritage permet de définir un ordre
partiel entre les classes allant de la plus
générique (en haut) à la plus spécifique (en bas).
 En Java, le graphe de toutes les classes reliées
par la relation d’héritage est un arbre de racine
Object.
11
Héritage (2)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
p1
p2
p3
public class Personne
{
private String nom;
private Date dateNaissance;
public void prendDesLoisirs ()
{
...
}
}
public class Employe extends Personne
{
private float salaire;
public void travaille ()
{
...
}
}
puclic class Etudiant extends Personne
{
private int numeroEtudiant;
public void etudie ()
{
...
}
}
Personne p1 = new Personne ();
Personne p2 = new Personne ();
Personne p3 = new Personne ();
Employe emp1 = new Employe ();
Employe emp2 = new Employe ();
Etudiant et1 = new Etudiant ();
Etudiant et2 = new Etudiant ();
Etudiant et3 = new Etudiant ();
Etudiant et4 = new Etudiant ();
et4
emp1
et1
et3
emp2
et2
Spécialisation:
Etudiant < Personne
Etudiant
Personne
est
une
spécialisation
de
Inclusion covariante des extensions:
ext (Etudiant) ⊂ ext (Personne)
Tout Etudiant
Personne
est
(a
fortiori)
une
Inclusion contravariante des intensions:
int (Personne) ⊂ int (Etudiant)
Les Etudiants possèdent toutes les
caractéristiques (méthodes et attributs)
des Personnes.
Visibilité (1)
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 Il existe 4 modes d’accès aux attributs et aux méthodes d’une
classe, correspondant à 3 spécificateurs d’accès.
 Un attribut ou une méthode d’un objet peuvent être :
 visibles pour les instances de toutes les classes d'une
application. En d'autres termes, ils peuvent être utilisés dans
l'écriture de toute méthode qui manipule cet objet. L’attribut
ou la méthode sont dits « publiques ».
- Mot réservé : public
 visibles uniquement pour les instances de sa classe. En
d'autres termes, ils ne peuvent être utilisés pour manipuler
cet objet que depuis une méthode définie dans la classe dont
l’objet est une instance. Il sont alors dits privés (à la classe
d’objets).
- Mot réservé : private
- Attention : Les méthodes d’une sous-classe n’ont pas accès aux
propriétés privées de ses super classes.
12
Visibilité (2)
Plan
Notions de base
 visibles pour les instances des classes de son paquetage ou de
ses sous-classes. En d’autres termes, ils peuvent être utilisés
dans l’écriture d’une méthode d'une classe quelconque
appartenant au même paquetage ou d’une méthode d'une
sous-classe (qui peut ne pas appartenir au même paquetage).
Ils sont « protégés ».
Construction et
destruction
 visibles pour les instances des classes de son paquetage. En
d’autres termes, ils peuvent être utilisés dans l’écriture d’une
méthode d'une classe quelconque appartenant au même
paquetage . On l'appelle ce type d ’accès « friendly ».
Introduction
( Classes / Attributs /
Méthodes / Objets)
- Mot réservé : protected
- Pas de mot réservé.
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 NB : La visibilité s’applique aussi aux classes et aux
interfaces. Une classe ou une interface peut être :
 publique c-à-d accessible partout où son paquetage l'est,
 ou « friendly » c-à-d accessible seulement au sein de son
paquetage.
Visibilité (3)
Plan
Introduction
Notions de base
public class Parallelepipede
{
private int longueur = 0;
private int largeur = 0;
public int profondeur = 0;
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
}
public void affiche ()
{
System.out.println("Longueur= " + longueur +
" Largeur = " + largeur +
" Profondeur = " + profondeur);
}
public class ProgPpal
{
public static void main(String args[])
{
Parallelepipede p1 = new Parallelepipede ();
p1.longueur = 5;
// invalide
p1.profondeur = 4;
// OK
p1.affiche ();
// OK
}
}
13
Visibilité et encapsulation
Plan
Introduction
Notions de base
( Classes / Attributs /
Méthodes / Objets)
Construction et
destruction
Paquetages et rapide
panorama de l’API
Compléments objet
(Héritage et visibilité)
 Pour
respecter
les
principes
de
bonne
programmation objet, il faudrait toujours que :
 les attributs ne soient pas visibles,
- Les attributs ne doivent pouvoir être lus ou
modifiés que par l'intermédiaire de méthodes
prenant en charge les vérifications et effets de
bord éventuels (accesseur get... et modifieur
set...).
 les méthodes "utilitaires" ne soient pas visibles,
 seules les fonctionnalités de l'objet, destinées à
être utilisées par d'autres objets soient visibles.
14