FORMATION JAVA -
RÉSUMÉ DE L’ORIENTÉ OBJET
01/06/2016
Programmer objet en Java
• créer une classe
• manipuler un objet
• abstraction
• encapsulation
• héritage
• interface
• package
2
Les classes: Structure
• les attributs : ce sont des variables qui caractérisent l'objet (aussi
appelées variables d'instance)
– possèdent un type et un nom
• les méthodes : ce sont des procédures/fonctions qui permettent de
manipuler l'objet. Les paramètres de ces méthodes sont passés par
valeur, sauf pour les tableaux et objets (par référence)
– possèdent un nom
– optionnellement, prennent un ou plusiseurs paramètres en entrée
– optionnellement, retournent une valeur d'un type donné
3
Les classes: définition
• Définition des attributs :
– la syntaxe est celle de la définition d’une variable
Type nomAttribut;
• Définition des méthodes :
– La syntaxe est celle de la définition de fonctions
en C++
TypeRetour nomFonction (TypeArg1 nomArg1,…){
//le code
}
4
Les classes: exemple
class Point
{
// attributs
private int _abscisse;
private int _ordonnee;
// méthodes
public Point() { _abscisse = 0; _ordonnee = 0; }
public int getAbscisse() { return _abscisse; }
public int getOrdonnee() { return _ordonnee; }
public void setCoordonnees(int abscisse, int ordonnee)
{
_abscisse = abscisse;
_ordonnee = ordonnee;
}
}
5
Les spécificateurs d'accès
• Il est possible de préciser l’accès aux différents attributs et
méthodes :
– <aucun>: l ’attribut ou la méthode est accessible par toutes
les classes du package auquel la classe de l ’attribut appartient
– private : seules les méthodes de la classe dans lequel cet
attribut ou méthode est défini y ont accès
– protected : l ’attribut ou la méthode est accessible à travers
la classe dans lequel il/elle est définie ainsi que dans toute
classe dérivée
– public : l ’attribut ou la méthode est accessible à partir de
n ’importe quelle classe
6
Les méthodes/variables de classe
• appelés aussi méthodes/variables 'statiques'
• partagées entre toutes les instances de la classe
• déclarées à l'aide du mot-clef « static »
• les variables de classe:
– partagées entre toutes les instances de la classe
– accessibles par l’intermédiaire du nom de la classe ou à travers un objet de cette
classe
• les méthodes de classe:
– sont exécutées en dehors du contexte d'un objet de la classe
– accessibles par l’intermédiaire du nom de la classe (ou également à travers le nom
d ’un objet)
– ne peuvent manipuler que les variables de classes et leurs paramètres
7
Constructeurs
• un constructeur:
– est une méthode d'initialisation qui porte le nom de la classe
– il est en en règle générale défini comme "public" !
– il peut recevoir des arguments en paramètre
– il ne retourne aucune valeur (du moins pas explicitement)
– il est appelé automatiquement à chaque fois que l'opérateur new
est utilisé pour créer une nouvelle instance de la classe
• il peut y avoir plusieurs constructeurs pour une
même classe (surcharge)
• Si aucune méthode constructeur n'est spécifiée
dans la classe:
– Java crée automatiquement un "constructeur par défaut"
– le constructeur par défaut initialise les attributs de l'objet à leurs
valeurs par défaut (zéro, null, ou false suivant leurs types) 8
Constructeurs (II)
• les attributs de l'objet peuvent être initialisés
par le constructeur.
• par défaut, si rien n'est précisé, les attributs
sont initialisés à :
– zéro pour les types numériques
– false pour les booléens.
– null pour les références.
9
Understanding constructors-cont
On utilise this pour faire reference a un autre constructeur de la meme classe avec d’autre
arguments
public class Play {
String name;
Play(String input) {
name = input;
}
Play() {
this(“toy");
}
public static void main(String args[]) {
Play p1 = new Play("digger");
Play p2 = new Play();
}
}
Note: obligation que ca soit la premiere instruction
Understanding constructors-cont
• Les constructeurs utilisent super pour appeler la
constructeur de la classe mère (peut être avec arguments)
public class SuperClassDemo {
SuperClassDemo() {}
}
class Child extends SuperClassDemo {
Child() {
super();
//some special initialization
}
}
Note: comme pour “this” ca doit etre la première instruction
L’instanciation
• L'opérateur new :
– alloue la mémoire nécessaire à la création d'un nouvel objet de la classe
spécifiée
– crée ("instancie") un nouvel objet de la classe spécifiée
– appelle le constructeur adéquat sur l'objet créé
– retourne une référence sur l'objet créé
• Exemple:
// Déclaration d’une variable de type Point (une référence)
Point monPoint;
// instanciation d'un nouvel objet Point, et affectation de la
// référence correspondante à la variable monPoint
monPoint = new Point();
12
Manipulation d’une instance
• L’accès aux membres publics d’une instance
en dehors des méthodes de la classe se fait
par la notation pointée (‘ . ’)
• Les membres privés ne sont accessibles qu ’à
partir du code des méthodes de la classe
– Point monPoint=new Point();
[Link](0,0);
13
Les références
• Ce sont des pointeurs sur des instances de
classes. Un objet est donc un pointeur implicite.
• Ce sont aussi des pointeurs sur des tableaux
alloués dynamiquement.
• La mémoire allouée à un objet est libérée
automatiquement au passage du garbage
collector si cet objet n’est plus référencé.
• On peut comparer des références : '==', '!=',
'instanceof'
14
Les références: le mot-clef this
• C'est une référence sur l'objet courant.
• Permet de manipuler explicitement des
méthodes et attributs de l'instance courante.
• Évite les conflits de noms avec les paramètres
et variables locales.
15
Les classes: Exemple avec this
class Point {
// attributs
private int abscisse;
private int ordonnee;
// méthodes
public int getAbscisse() { return abscisse; }
public int getOrdonnee() { return ordonnee; }
public void setCoordonnees(int abscisse, int ordonnee) {
[Link] = abscisse;
[Link] = ordonnee;
}
}
16
L’utilisation d’une instance
• L’accès aux membres public d’une instance se
fait par la notation pointée.
• Les membres privés ne sont accessibles que
dans le code de la classe en utilisant leur nom
:
– Point monPoint=new Point();
[Link](0,0);
17
STATIC
• Une seule copie pour toutes les instances
• Peut etre accéder via le nom de la classe
• L’accés en dehors de la classe se fait de la
manière
[Link]
[Link]()
Ou travers un objet instance de la classe
Static
• Supposons que tous le personnel a le même
salaire , comment gérer ce cas?
• A faire et tester avec 2 personnels
Travaux Pratiques - TP1
• Création d’une classe qui modélise une agence bancaire
– La classe s ’appelle Agence
– elle possède les variables d’instance suivantes:
• numero: numéro d'agence (entier int)
• nom: nom de l'agence (chaîne de caractères String)
• adresse: adresse de l'agence (chaîne de caractères String)
– elle possède des méthodes permettant de:
• créer/lister/supprimer des clients et des comptes
• établir le total des intérêts versés aux clients
• Etablir la liste des classes du modèle, ainsi que leurs méthodes et
attributs
20
Travaux Pratiques – TP 2.1
• Création d’une classe qui modélise un compte courant
– La classe s ’appelle Compte
– elle possède les variables d’instance suivantes:
• numero: numéro de compte (entier int)
• nom: nom du titulaire du compte (chaîne de caractères String)
• solde: solde du compte (nombre décimal, double)
– Elle implémente les méthodes d ’instance
suivantes:
• un constructeur avec les paramètres: numCompte, nomTitulaire, apportInitial
• int getNumero()
• void crediter(double montant)
• void debiter(double montant)
• double getSolde()
21
Travaux Pratiques – TP 2.1 (2)
• Écrire un programme principal de test
– La classe s ’appelle Main et possède la méthode
suivante:
• public static void main(String[] args)
– Coder les opérations suivant au sein de la
méthode main():
• instancier un nouveau compte en lui affectant un numéro et un solde initial
• effectuer une opération de crédit sur ce compte,
• effectuer une opération de débit,
• et afficher le numéro du compte et le solde à l'écran
22
La composition
• Un attribut d’une classe peut être une
instance d’une autre classe.
• L’instance référencée devra être créée
explicitement par la classe container (au
travers du constructeur par exemple).
23
La composition: exemple
• Une classe Segment peut être construite par
composition avec des objets de la classe
Point.
24
L'héritage
• Mot-clef extends.
• Java ne permet que l’héritage simple (une
seule classe parent).
25
Héritage: possibilités de spécialisation de
la classe dérivée
• ajout de nouvelles variables d'instance/de classe
• redéfinition de variables existantes:
– ne "remplacent" pas les variables de la classe parente, mais les "masquent"
partiellement (voir diapo suivante)
• ajout de nouvelles méthodes:
– Les méthodes de la classe dérivée peuvent accéder aux champs public et
protected de la classe parent
• redéfinition de méthodes de la classe parente:
– possibilité de redéfinir/spécialiser le comportement de la classe dérivée
– redéfinition du code de méthodes de la superclasse:
• obligation de conserver la "signature" de la méthode existante:
– nombre, ordre, et type des paramètres
– type de la valeur de retour
– type des exceptions levées 26
Héritage: accès à la classe parent
• Les méthodes de la classe dérivée peuvent accéder aux
champs public et protected de la classe parent
• Le mot-clef super représente la classe parent et permet de
lever les ambiguïtés
– notamment sur le nom de variables portant le même nom et définies dans les
2 classes:
• x: la variable x définie dans la classe dérivée
• super.x: la variable x définie dans la classe parente
– mais aussi pour différencier l'appel de méthodes définies dans la classe
parente et redéfinies dans la classe dérivée:
• super() : le constructeur du parent
• f(): la méthode f(à de la classe dérivée
• super.f(): la méthode f() du parent
27
L’héritage: le mot-clef final
• appliqué à une classe, interdit la création de
classes dérivées
• appliqué à un attribut, empêche la
modification de sa valeur (constante)
• appliqué à une méthode, empêche la
redéfinition de celle-ci dans les classes
dérivées
28
Héritage: exemple
class Point3D extends Point
{ // définition d ’attributs supplémentaires
private int altitude;
// spécialisation
public Point3D()
{
super();
[Link] = 0;
}
public Point3D(int x, int y, int z)
{ super(x,y);
altitude = z;
}
// une nouvelle méthode
public int getAltitude() { return altitude; }
// redéfinition de la méthode setCoordonnees()
public void setCoordonnees(int x, int y, int z);
{ [Link](x, y);
altitude = z;
}
}
29
Travaux Pratiques – TP 2.2
• Dériver à partir de la classe Compte les classes suivantes:
– CompteEpargne
– CompteFidélité
• Modifier le programme de test de façon à:
– créer un compte épargne et un compte fidélité
– effectuer des opérations sur ces comptes
– afficher les informations sur ces comptes: numéro, solde, et taux d'intérêt
30
Les classes abstraites
• Mot-clef abstract
– Applicable à des méthodes ou des classes
• une classe abstraite n'est pas instanciable (on ne peut
pas créer d ’objets de cette classe)
– si une classe comporte au moins une méthode qualifiée
de abstract, la classe elle-même devra être déclarée
abstract
– on peut déclarer une classe abstract même si elle ne
comporte aucune méthode abstraite, afin d ’empêcher
l ’instanciation de cette classe
• une méthode abstraite ne contient pas de code
– on fait suivre la déclaration de la méthode d ’un point-
virgule
31
La Classe Object
• Toute classe Java est une sous-classe de la
superclasse Object
• Toute classe Java hérite donc des méthodes
et attributs de Object
• A la construction d'une classe, le
constructeur de la superclasse Object est
automatiquement appelé (appel implicite à
super()).
32
Les méthodes d'Object
• Object implémente les méthodes :
– toString() : chargée de fournir une représentation « lisible »
de l ’ état de l ’objet.
– equals() : permet de tester l'égalité entre 2 objets (renvoie
un booléen).
– getClass() : permet d'accéder au type de la classe de l'objet
courant.
– clone(): permet de réaliser une copie conforme de l'objet
courant.
• crée une nouvelle instance de l ’objet source, et copie membre par
membre les attributs de l ’objet source dans l ’objet cible (la copie)
33
Compatibilité entre classes
• Une référence sur un objet peut référencer
tout objet de n'importe laquelle des sous-
classes de cet objet
• Il est possible d ’interpréter (cast) une
référence vers une instance d ’une classe
comme une référence vers une instance
d’une de ses sous-classes
S alarié
n om
in t c alc u lerS alaire()
Personnel Cadre
in t c alc u lerS alaire() n b P ers o n n e s E n c a d ré es
in t c alc u lerS alaire() 34
Travaux Pratiques – TP 2.3
• Utilisation de la méthode toString():
– Modifier le programme de test:
• afficher le résultat de l'appel à la méthode toString()
pour l'objet Compte
– Redéfinir la méthode toString() pour donner des
informations plus pertinentes: numéro de
compte, solde, nom du titulaire
– Tester la nouvelle fonctionnalité
35
Les interfaces: Introduction
• La notion d ’héritage multiple n ’existe pas en
Java pour les classes
• Elle est contournée à travers la notion
d ’interface
• Une classe ne peut hériter des fonctionnalités
que d ’un seul parent, mais peut implémenter
plusieurs interfaces / comportements
• Une interface peut, elle, étendre plusieurs
interfaces (héritage multiple)
36
Les interfaces: Présentation
Objet brique
getPrix
setNombre
Interface produit
getPrix
Objet sable
getPrix
setMasse
37
Les interfaces: Syntaxe
• Création :
interface Drawable // pour 1 objet graphique ‘ dessinable ’
{
public void draw(); // signatures des méthodes
}
• Utilisation :
class Circle extends Shape implements Drawable
{
// implémentation des méthodes définies par Drawable
public void draw() { … }
}
• Héritage d ’interfaces
interface Texturable extends Drawable
{ // Texturable hérite de, et étend, Drawable }
38
Les packages: Présentation
• Un package est un espace de nommage.
• C’est un regroupement de classes et
d’interface logiquement liées.
• Ils jouent un rôle important dans la
structuration des applications.
• Les packages ont des implications strictes sur
le stockage physique des classes.
39
Les packages: Nommage
• Les noms de packages sont construits en utilisant une notation
pointée.
• Il n’y a pas de hiérarchie entre les packages eux-mêmes. En
particulier, pas de visibilité entre java.x.a et java.x.b .
• Convention :
• préfixe java. pour le noyau du langage
• préfixe javax. pour les extensions de Sun
• préfixe basé sur le nom de domaine du producteur pour toutes les autres
classes :
– [Link]
– [Link]
40
Les packages: Visibilité
• Par défaut, une classe n’est accessible que
par les classes du package auquel elle
appartient.
• Seules les classes déclarées public sont
accessibles de n'importe quelle classe.
41
Les packages: Importation
• Pour utiliser une classe d’un autre package, il
faut, par défaut, utiliser le nom complet.
• L’instruction import permet d’accéder aux
classes du package spécifié simplement par le
nom. C’est un artifice utilisé au niveau de la
compilation :
import [Link];
class MyApplet extends Applet {..
import [Link].*;
class MyApplet extends Applet {... 42
Les packages: Stockage physique
• Le nom du package doit apparaître au
début du fichier source :
– package [Link]
• Le source .java et la classe compilée
doivent être dans un répertoire défini par
la règle suivante :
– prendre le nom de package, remplacer les . par des /
43
Questions
Est ce que ca compile?
class Animal {
Animal(String name) { }
}
class Horse extends Animal {
Horse() {
super();
}}
Questions
class Top {
public Top(String s) { [Link]("B"); } }
public class Bottom2 extends Top {
public Bottom2(String s) { [Link]("D"); }
public static void main(String [] args) { new Bottom2("C");
}}
What is the result?
A. BD
B. DB
C. BDC
D. DBC
E. Compilation fails.
Question
Est-ce que ca compile?
package certification;
public class Parent {
protected int x = 9;
}
In another file:
package other;
import [Link];
class Child extends Parent {
public void testIt() {
[Link]("x is " + x);
}}
Question
Est ce que ca compile?
public class Pencil {
public String color = “red”;
public int length;
public float diameter;
private float price;
public static long nextID = 0;
public void setPrice (float newPrice) {
price = newPrice;
}
}
public class CreatePencil {
public static void main (String args[]){
Pencil p1 = new Pencil();
[Link] = 0.5f;
}
}
Non-access Member Modifiers-cont
public class Pencil {
public String color = “red”;
public int length;
public float diameter;
private float price;
public static long nextID = 0;
public void setPrice (float newPrice) {
price = newPrice;
}
}
public class CreatePencil {
public static void main (String args[]){
Pencil p1 = new Pencil();
[Link]++;
[Link]([Link]);
//Result1?
Pencil p2 = new Pencil();
[Link]++;
[Link]([Link]);
//Result2?
[Link]([Link]);
//Result3?
}
}
Questions
Can we have abstract class without any abstract
method?
Can abstract class be instantiated?
JAR
• Il est possible de créer une enveloppe qui va contenir tous
les fichiers d'une application Java ou une portion de cette
application dans un fichier .jar (Java archive). Ceci inclus :
– l'arborescence des packages,
– les fichiers .class,
– les fichiers de ressources (images, configuration, ...),
• Un fichier .jar est physiquement une archive de type Zip qui
contient tous ces éléments.
• L'outil jar fourni avec le jdk permet de manipuler les fichiers
jar.
TP
• Créer un jar avec les fichiers .class dont vous
disposés
jar cvf [Link] [Link] [Link]
Classement java
Qui utilise java
• Three billion devices run Java
3,000,000,000,000
• Statistiques 2013
JAVA LE BIEN AIME
Et SUN?
Acquisition par ORACLE
Acheté par oracle en 2010 pour la modique somme de
7.4 billion dollars
7,400,000,000 $
TP classe abstraite + polymorphisme
• La classe Animal est abstraite et déclare uniquement une méthode
abstraite nommée action, sans paramètre et qui ne retourne rien.
• La classe Chien hérite de Animal et définit la méthode action qui écrit à
l'écran "J'aboie".
• La classe Chat hérite de Animal et définit la méthode action qui écrit à
l'écran "Je miaule".
• La classe EssaiChat contient trois champs statiques :
– un champ statique pour un attribut de type [Link] qui est
initialisé dès sa définition
– une méthode statique nommée tirage sans paramètre qui retourne
un Animal qui a une chance sur deux d'être un Chat et une chance
sur deux d'être un Chien.
– une méthode main qui utilise la méthode tirage et invoque la
méthode action sur l'animal obtenu par cette méthode
Solution
QUESTIONS?