Programmation Orientée Objet

en Java
 Une brève histoire de Java

Inventé par Sun 1990s: répondre à 5 objectifs

utiliser une méthodologie orientée objet,
permettre à un même programme d'être exécuté sur
plusieurs systèmes d'exploitation différents,
pouvoir utiliser de manière native les réseaux
informatiques,
pouvoir exécuter du code distant de manière sûre,
être facile à utiliser et posséder les points forts des
langages de programmation orientés objet comme le
C++.
2
 Java
Langage orienté objet
Notions de classes, héritage, …
Beaucoup d’outils disponibles (packages)
JDK (Java Development Kit)
Historique
Sun Microsystems
1991: conception d'un langage indépendant du
hardware
1994: browser de HotJava, applets
1996: Microsoft et Netscape commencent à
soutenir
1998: l‘édition Java 2: plus stable, énorme librairie

3
 Java c'est quoi ?

Java est un environnement de programmation objet développé par Sun,

adapté à la distribution d'applications sur Internet.

4 éléments :
Java est un langage de programmation objet
Une machine virtuelle
Des bibliothèques de classes ou des packages : API Application
Programming Interface (2500 classes dans Java 1.4)
Ensemble d'outils : java, javac, jdb javadoc, jar, ...

execution compilation debugger documentation archivage

4
 Les outils pour Java
Le Java Development Kit de Sun (incluant une
machine virtuelle Java), disponible sur www.sun.com
Outils
java : JVM, interpréteur pour les programmes java
javac : Compilateur Java
appletviewer : JVM pour l'exécution des applets
jar : Création et manipulation d 'archive java
javadoc : Générateur de documentation Java au format HTML
javap : désassembleur de classes Java compilées
jdb : débogueur Java en ligne de commande
javah : génère le header C ou C++ pour créer un pont compatible entre
java et C/C++

5
 Java : principe fondateur de sa portabilité
"write once, run everywhere"

6
 Langages compilés et limitations
Légende
Indépendant de la
fichier machine

source du Dépendant de la
machine
programme

Compilation

Exécutable ExécutableExécutable Exécutable Exécutable

Unix Linux Windows MacOS PalmOS

Architecture 1 Architecture 2 Architecture 3 Architecture 4

Risc 6000 Intel x86 Mac G5 Intel xScale

7
 Portabilité
Notion de portabilité
Capacité d'un programme à être indépendant du
système d'exploitation et de l'architecture machine

Impossible !
Programme
portable

Unix Linux Windows

Architecture 1 Architecture 2
Risc 6000 Intel x86

8
 Java et la portabilité
Solution proposée:
Construire une machine virtuelle:
joue le rôle de plateforme virtuelle
dépendante de l'architecture machine et du SE
opère un langage machine virtuel indépendant de
l'architecture réelle et du SE réel

Code source Java

Programme Java

Machine virtuelle

SE / Architecture
9
 Pseudo-Langage interprété
Schéma du principe Java

fichier source du
programme

Compilation Programme
portable !
Programme Java

Machine Machine
Machine virtuelle Machine virtuelle Machine virtuelle
virtuelle virtuelle

Unix Linux Windows MacOS PalmOS

Architecture 1 Architecture 2 Architecture 3 Architecture 4

Risc 6000 Intel x86 Mac G5 Intel xScale

10
 Compilation en Java → bytecode

En Java, le code source n’est pas traduit

directement dans le langage de l’ordinateur
Il est d’abord traduit dans un langage appelé
« bytecode », langage d’une machine virtuelle
(JVM ; Java Virtual Machine) définie par Sun
Ce langage est indépendant de l’ordinateur
qui va exécuter le programme

11
 La compilation fournit du bytecode
Programme Java
Programme source
PremiereAppli.java

Compilateur: javac

Programme en bytecode, compilateur

indépendant de l'ordinateur

Bytecode
PremiereAppli.class
12
 Java Virtual Machine
Les systèmes qui veulent pouvoir exécuter un
programme Java doivent fournir une JVM
A l'heure actuelle, tous les systèmes ont une
JVM (Linux, Windows, MacOs,…)
Il existe aussi depuis peu quelques JVM « en
dur », sous forme de processeurs dont le
langage natif est le bytecode ; elles sont
rarement utilisées (en raison de la portabilité)

13
 Le bytecode peut être exécuté par
n'importe quelle JVM

Bytecode:
PremierAppli.class

JVM sous Lunix JVM sous MacOs

JVM sous Windows

Si un système possède une JVM, il peut exécuter

tous les fichiers .class compilés sur n'importe
quel autre système
14
 Le bytecode peut être exécuté
par n'importe quelle JVM

Fichiers Fichiers JVM Linux

.java .class

Compilateur Java
JVM Windows

15
 Avantages de la JVM pour
Internet
Grâce à sa portabilité, le bytecode d'une classe peut être chargé
depuis une machine distante du réseau, et exécutée par une
JVM locale
La JVM fait de nombreuses vérifications sur le bytecode avant
son exécution pour s’assurer qu’il ne va effectuer aucune action
dangereuse
La JVM apporte donc
– de la souplesse pour le chargement du code à exécuter
– mais aussi de la sécurité pour l'exécution de ce code
Les vérifications effectuées sur le bytecode et l'étape
d'interprétation de ce bytecode (dans le langage natif du
processeur) ralentissent l'exécution des classes Java

Les techniques « Just In Time (JIT) » ou

« Hotspot » réduisent ce problème : elles permettent de ne traduire
qu'une seule fois en code natif et à la volée les instructions qui
sont exécutées

16
 Applications indépendantes
et applets

Java permet de développer deux sortes de

programmes:
Applets exécutées dans l’environnement/JVM d’un
navigateur Web et chargées par une page HTML
Applications indépendantes avec ou sans interface graphique

17
 Applet
Objet de la classe Java Applet, référencé dans
une page Web (écrite dans le langage HTML)
Le lancement d'une applet se fait quand la partie
de la page Web qui référence l'applet est affichée
par le client Web

18
 Exemple de page Web qui
contient une applet
<HTML>
<HEAD>
<TITLE> Une applet </TITLE>
</HEAD>
<BODY>
<H2> Exécution d’une applet </H2>
<APPLET code="HelloApplet.class"
width=500 Dimensions de l'emplacement
réservé à l'affichage de l'applet
height=300>
Votre navigateur ne peut exécuter une applet
</APPLET>
</BODY>
</HTML>

19
 import java.awt.Graphics;
import java.applet.Applet;
public class HelloApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world", 50, 25);
} Zone où commencera
} l'affichage : x = 50 pixels,
y = 25 pixels

Représente l’emplacement
de la page Web où l’applet
20 s’affichera
 Étapes pour l’exécution d’une
applet

1. Demande chargement page

Web qui contient une applet
Client Serveur
HTTP 2. Chargement de la page Web HTTP
de la classe de l’applet

Exécution de l’applet
Dans la JVM du client

21
 Remarques

Le navigateur a sa propre machine virtuelle

Un programme Java spécial démarré par le
navigateur va lancer certaines méthodes de la
classe Applet : init(), start(), stop(), destroy(),
paint()
init() est exécuté seulement quand l’applet
est lancée pour la première fois
paint() dessine l'applet dans la page Web
22
 Exécution de l’applet

Soit:
A partir du navigateur
A partir de l’appletviewer
Javac HelloApplet.java ->
HelloApplet.class
Appletviewer HelloApplet.html

23
 Utilité des applets

Les applets permettent de faire des pages

Web plus riches (grâce aux possibilités
offertes par Java)
La page Web peut contenir
– des animations ou des mises en forme complexes
pour mettre en valeur certaines informations
– des résultats de calculs complexes
– des informations « dynamiques » (pas connues au
moment où la page Web statique est créée)
trouvées en interrogeant une base de données

24
 Applications :la console vs G.U.I

L’utilisateur fournit des infos au clavier

Programme à interface sous forme de lignes de texte. Le
console programme décide du séquencement
des opérations. L’opérateur est sollicité
au moment voulu.

Programme à interface L’interaction programme-opérateur se

graphique : GUI fait essentiellement via des composants
(Graphical User Interface) graphiques. C’est la programmation
évènementielle :le programme réagit à
des évènements provoqués par l’utilisa-
teur.

25
 Application indépendante

Exécution de la classe de lancement de l’application

(dite classe principale ; main en anglais) ;
java lance l’interprétation du code de la
méthode main() d’une classe bien déterminée
Exemple:
public class HelloWorld { public static void
main(String[] args) { System.out.println("Hello
World!"); } }

26
 Structure d’une application
Placer une classe
dans un fichier source
Placer les méthodes
Fichier source dans une classe
Placer les instructions
Fichier de classes
dans les méthodes
Méthode 1
instructions
Méthode 2
instructions

27
 Mise en œuvre

28
 Architecture générale d’un programme Java

Programme source Java = ensemble de fichiers

« .java »

Chaque fichier « .java » contient une ou plusieurs

définitions de classes

Au plus une définition de classe public par fichier

« .java » avec nom du fichier = nom de la classe
publique

29
 Structures d’un programme en Java

30
 Structures d’un programme en Java

31
 Comment développer une
application?
Deux façons d’écrire des programmes Java:
En écrivant le code dans un simple éditeur de texte
Compilation et exécution du code en ligne de commande DOS

En utilisant un environnement de développement (IDE)

Eclipse
Netbeans (http://www.netbeans.com)
Borland JBuilder (http://www.borland.com/jbuilder)
IBM WebSphere Studio
(http://www.ibm.com/software/awdtools)
Sun ONE Studio (http://wwws.sun.com/software/sundev)
Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)
… Crimson Editor
32
 Les outils Java

33
 Une première application
Application HelloWorld
Créer un fichier texte : HelloWorld.java
Règle de bonne pratique : 1 classe par fichier et 1 fichier
par classe
public class HelloWorld La première ligne du programme doit être la
{ déclaration de la classe

public static void main (String[]args) Tout programme doit contenir une méthode
{ main qui porte la signature ci-contre
System.out.println("Hello the World");
Écrire à l’écran “Hello the World”
}
} Fermer les accolades

• Compiler le programme : javac HelloWorld.java

• Le compilateur génère le bytecode dans le fichier : HelloWorld.class
• Exécuter l’application : java HelloWorld
• « Hello the World » s’affiche à l’écran
34
 Syntaxe de Java
Le code est écrit dans des blocs :
délimités par { }
qui peuvent être imbriqués
Les commentaires :
Sur une seule ligne : // mon commentaire
Sur plusieurs lignes : /* */
Les constantes sont définies avec le mot clé final :
leur valeur ne peut pas être modifiée: final double
pi=3.14 ;
Types primitifs: int, long, float, double, char, String,
boolean,..

35
 Types Primitifs de Java

36
 Initialisation

37
 Types de données primitifs

Explication:
byte : codé sur 8 bits 28 valeurs (–27) to (27–1) = -128 à 127
int : codé sur 32 bits 232 valeurs (–231) to (231–1)
Déclaration et initialisation :
int int x=12;
short short x= 32; (short x=33000; // Hors limite)
long long x= 200L; // Nombre accolé à un L
byte byte x=012; // Nombre commençant avec un 0
double double x=23.2323;
float float x= 23.233F; // Nombre accolé à un F
char char c=‘a’; char c=‘\u0061’; char c=(char)97;
boolean boolean b=true;

38
 Conversion
Vérification de typage utilise toujours le type apparent
cast
(nom d’une classe) expression

Conversion implicite des valeurs d’un type en un autre

Seulement pour les types primitifs

Ordre croissant de généralité

byte -> short -> int -> long -> float -> double
i=l illegal
l=i legal
int = char legal
char = int illegal

39
 Conversions de types

40
 Conversions de types

41
 Opérateurs

42
 Opérateurs

43
 Condition et test
Une condition correspond à vrai ou faux
E.g. (age < 50)
Tester une condition:
if condition A; else B;
si condition est satisfaite, alors on fait A;
sinon, on fait B
E.g. if (age < 65)
System.out.println("jeune");
else
System.out.println("vieux");

44
Attention: Attention:
un ; après le for( ), itère sur la condition, et ‘somme’ ‘i’ n’est déclarée ici qu’à
ne sera incrémentée qu’une seule fois l’intérieur de la boucle for

Boucle
Pour traiter beaucoup de données en série Schéma d’exécution
Schémas
somme=0;
Boucle for
int somme = 0;
for (int i = 0; i<10; i++) somme = somme + i; i=0;
Boucle while
int somme = 0; i<10?
int i = 0; oui
while (i<10) { somme = somme + i; non somme=somme+i;
i++; i++;
}
Que font ces deux boucles?

i: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

somme: 0 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, sortie

45
 Schéma d’exécution
Boucle somme=0;

do A while (condition) i=15;

Faire A au moins une fois
Tester la condition pour savoir s’il faut refaire A
i<10?
int somme = 0;
oui
int i = 15;
while (i<10) { somme = somme + i; non somme=somme+i;
i++; i++;
}
somme = 0
Schéma d’exécution
int somme = 0; somme=0;
int i = 15;
do { somme = somme + i; i=15;
i++;
} somme=somme+i;
while (i<10) i++;

somme = 15 i<10? oui

46 non
 Les tableaux en Java

47
 Les tableaux
On peut définir un tableau sur tous les types java ( types
primitifs, classes, interfaces, tableaux ).

Syntaxe de définition d'un tableau :

type [ ] nom;

Un tableau est un objet qui contient un attribut indiquant sa taille

: « length »

int [ ] tab = new int[50];

System.out.println("Taille du tableau " + tab.length );

48
 Attention:
Array a.length
Array list a.size()
Tableau String a.length()

Pour stocker une série de données de même nature

Déclaration
int [] nombre; // une série de valeurs int dans le tableau nommé nombre
String [][] etiquette; // un tableau à deux dimensions de valeurs String
Création
nombre = new int[10]; // crée les cases nombre[0] à nombre[9]
etiquette = new String[3][5]; // crée etiquette[0][0] à etiquette[2][4]
int[] primes = {1, 2, 3, 5, 7, 7+4}; // déclare, crée de la bonne taille et initialise
Utilisation
nombre[0] = 4;
for (int i=1; i<nombre.length; i++) nombre[i]=nombre[i]+1;
etiquette[2][3] = "un texte";
String texte = etiquette[2][3];

49
 Tableaux : Déclaration

50
 Tableaux : Dimensionnement

51
 Tableaux : Initialisation

52
 Tableaux en Java : Synthèse

53
 Tableaux multidimensionnel

54
 Précision sur « system.out. »

55
 Mise en forme

56
Les classes en Java
 Architecture générale d’un
programme Java

Programme source Java = ensemble de fichiers

« .java »
Chaque fichier « .java » contient une ou plusieurs
définitions de classes
Au plus une définition de classe public par fichier
« .java » avec nom du fichier = nom de la classe
publique
public class NomDeClasse
Si plus d’une classe dans un fichier .java, javac
génère des fichiers .class séparés pour chaque
58 classe
 2 classes dans 2 fichiers
/* Modélise un point de coordonnées x, y */
public class Point {
private int x, y;
public Point(int x1, int y1) {
x = x1; y = y1;
Fichier Point.java
}
public int getx(){return x;}
public double distance(Point p) {
return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
} Fichier TestPoint.java ● C'est la méthode
interprétée lors de
/* Pour tester la classe Point */
public class TestPoint { l'exécution, l'entrée.
public static void main(String[] args) { ● Elle est static : ne

nécessite pas de création

Point p1 = new Point(1, 2);
int abs = p1.getx( ); d'objet pour être invoquable
Point p2 = new Point(5, 1);
System.out.println("Distance : " + p1.distance(p2));//Afficher sur la sortie standard

}
}
59
 Classes en Java
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de
l'ensemble des entités qui composeront un objet.

Un objet est donc « issu » d'une classe, c'est le produit qui sort d'un moule.
En réalité on dit qu'un objet est une instanciation d'une classe
objet = instance

Une classe est composée de deux parties :

•Les attributs (parfois appelés données membres) : il s'agit des

données représentant l'état de l'objet

•Les méthodes (parfois appelées fonctions membres): il s'agit des

opérations applicables aux objets

60
 Structure d'une classe
• Chaque classe peut avoir :
– des attributs : ce sont des variables déclarées dans le corps de la
classe
– des méthodes : c'est le comportement de la classe, les
fonctionnalités qu'elle propose
• La méthode comporte une signature :
– visibilité (public, protected, private ou defaut)
– type de retour (void pour indiquer qu'il n'y a pas de retour)
– nom de méthode
arguments
public– class Employe{
– Levée possible d'exception (throws)
int age = 23 ; //Attribut ou membre de classe

public void poserConge(String dateDebut, String dateFin){

//Traitements réalisés par la fonctionnalité poser congé
}
}
61
 Déclaration de la classe

public class Chemise

{

/*Déclaration des attributs*/

/*Déclaration des méthodes*/

//commentaire sur une seule ligne

/*commentaires sur
plusieurs lignes*/

}
• Le fichier .java doit avoir le même nom que la classe (Chemise.java)

• Le nom de la classe doit commencer par une majiscule

Notation Camel Case. Exemple: CompteBancaire, AgenceVoyage
62
 Les constructeurs
Pour créer un objet à partir d'une classe,
on utilise l'opérateur new.

public class Test{ L’opérateur new fait appel au

constructeur de la classe
public static void main(String[] args){

Chemise maChemise; class Chemise{

maChemise=new Chemise(); Chemise () {}

} }
}

un constructeur porte le même nom que la classe dans laquelle il est défini
un constructeur n'a pas de type de retour (même pas void)

63
 Les constructeurs
Constructeur par défaut
Le constructeur par défaut initialise les
Chemise(){}
variables de la classe aux valeurs par
défaut.

Chemise(){
id=0;
couleur=‘B’
prix=10.2f;
}
Constructeur surchargé
Chemise(int id, char couleur, float prix){
this.id=id;
this.couleur=couleur;
this.prix=prix;
}
64
 Les constructeurs
L'appel de new pour créer un nouvel objet déclenche, dans
l'ordre :
L'allocation mémoire nécessaire au stockage de ce nouvel
objet et l'initialisation par défaut de ces attributs,
L'initialisation explicite des attributs, s'il y a lieu,
L'exécution d'un constructeur.
Un constructeur est une méthode d'initialisation.

public class Application

Le constructeur est ici celui
{
par défaut (pas de
public static void main(String args[])
constructeur défini dans
{
la classe Personne)
Personne jean = new Personne()
jean.setNom("Jean") ;
} }
65
 Les constructeurs
• Si vous ne créez pas un constructeur dans votre classe, le compilateur va
automatiquement vous créer un constructeur par défaut implicite

• Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera

plus créer par le compilateur

• La plateforme java différencie entre les différents constructeurs déclarés au

sein d’une même classe en se basant sur le nombre des paramètres et leurs
types.
On ne peut pas créer deux constructeurs
ayant le même nombre et types des
paramètres.

Chemise(int id) {
this.id=id
} Erreur de compilation
Chemise(int id) {
this.id=id*2
66
}
 Les constructeurs
Personne.java Définition d’un
public class Personne Constructeur. Le
{ constructeur par défaut
public String nom; (Personne() )n’existe plus.
public String prenom; Le code précédent occasionnera
public int age; une erreur
public Personne(String unNom,
String unPrenom,
int unAge) public class Application
{ {
nom=unNom; public static void main(String
prenom=unPrenom; args[])
age = unAge; {
} Personne jean = new Personne()
} jean.setNom("Jean") ;
Va donner une erreur à la compilation
} }
67
 Les constructeurs
Quel constructeur va choisir Java lorsque vous allez créer votre objet ?

class Chemise{
int id;
char couleur;
float prix;
String description;
int quantite; Utilisation:

Chemise () {} Chemise ch1=new Chemise();

Chemise(int id) { Chemise ch1=new Chemise(122);
this.id=id;
}

Chemise(int id, char couleur) { Chemise ch1=new Chemise(122, ‘B’);

this.couleur=couleur;
}
}
68
 Destructeur

le programmeur java n’a pas à s’occuper lui-même de libérer la mémoire en

supprimant les objets devenus inutiles, c’est le rôle du Garbage Collector

Le Garbage Collector est exécuté automatiquement dès que la mémoire

disponible devient inférieure à un certain seuil.

Le destructeur est une méthode spéciale qui sera appelée lorsque

l'objet sera nettoyé de la mémoire par le Garbage Collector.

Java Destructor finalize()

69
 Déclaration des variables
Syntaxe:
type nom_variable [=value];

int id = 0;

Quel nom choisir pour notre variable?

Les noms des variables sont case-sensitive

Les white space ne sont pas permis

Évitez les mots réservés de java

• Le nom de la variable doit commencer

par une lettre minuscule.
Notation Camel Case. Exemple: age, quantiteStock
70
 Déclaration des variables

Constante
•On déclare une constante avec le mot final
Exemple:
final int MAX_STOCK=100;

•Le nom de la constante doit être en majuscule.

•Si le nom est composé de plusieurs mots, on utilise _ pour la
séparation des mots
Exemple:
final int TAILLE;
final int MAX_STOCK;
final int CAPACITE_DANS_STOCK;

71
 Déclaration des variables

Les types entiers

Valeur minimale Valeur maximale Codé sur

byte - 128 127 8 bits
short - 32 768 32767 16 bits
int - 2147 483 648 2 147 483 647 32 bits
long - 922337203685477 64 bits
922337203685477 5807
5808

72
 Déclaration des variables

Les types réels

Valeur minimale Valeur maximale Codé sur

float 1.4E45 3.4028235E38 4 octets
double 4.9E3 1.7976931348623 8 octets
157E308

Exemple:
float f=1.2f
double d=34.8d

73
 Déclaration des variables

Le type caractère char

char sexe=‘M’;

Le type boolean
boolean abonne=true;

Le type chaine de caractère String

String message = ‘’Bonjour les amis’’;

74
 Déclaration des variables

Le tableaux 1er indice

0 1 2 3 4 indices
int[] tab;
tab = new int[5]; 10 20
tab[0] = 10; // initialiser le premier élément
tab[1] = 20; // initialiser le second élément tab.length=5

int[] tab = { 10, 20, 30, 40, 50}; //déclaration + initialisation

75
 Déclaration des variables

Les valeurs par défaut des variables

Type Valeur par défaut

byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char '\u0000'

boolean false
76
 Catégories des variables

Il existe deux sortes de variables :

•Une variable primitive contient des bits qui représentent sa valeur.

Exemple : int, foat , boolean.

•Une variable référence contient des bits qui indiquent comment

accéder à l'objet.
Exemple : String, Chien, Joueur,...

77
 Catégories des variables
Les variables primitives

78
 Catégories des variables
Les variables primitives

•Déclaration d’une variable primitive réservation de l’espace mémoire.

age abonne sexe

int age;
boolean abonne;
char sexe;

•La valeur affectée à la variable sera stockée dans l’espace mémoire réservé.

age abonne sexe

age=18;
abonne=false; 18 false M
sexe=‘M’;

79
 Catégories des variable
Les variables références

80
 Catégories des variables
Les variables références: String
•on crée une référence sur une String
•Lorsqu’on déclare une variable objet , on est en fait entrain de faire la réservation
de l’espace mémoire pour la référence
message objet null
String message;
ref null

message=‘’Bonjour’’; message objet String

//équivalent à
message=new String(‘’Bonjour’’); ref Bonjour

message objet String

message=‘’Hello’’; ref Bonjour

81 Hello
 Catégories des variables
Les variables références: Les tableaux
•Un tableau contenant des éléments de type primitif
notes objet int [ ]
int[] notes={10,12,15};
reference 10 12 15

int int int

•Un tableau contenant des éléments de type objet

String[] animaux={‘’chat’’,’’poisson’’};

objet String objet String

chat poisson

animaux

reference ref ref

82
 Catégories des variables
Récapitulation sur les types objets et les types primitifs

83
 Déclaration des méthodes

Syntaxe:
Type_retour nom_method([arguments])
{

Exemple:
void afficherInfoChemise (){

Le nom de la méthode doit commencer par un verbe

84
 Classe chemise
public class Chemise{
int id;
char couleur;
float prix;
String description;
int quantite;
void ajouterChemise (int nombre) {
quantite += nombre;
}

void dimunierChemise (int nombre) {

quantite - = nombre;
}

void afficherInfoChemise() {
System.out.println(id+ info);
}
}

85
 Le mot-clé this

Le mot-clé this permet de désigner l’objet courant,

this permet d'accéder aux attributs et méthodes de l’objet courant

Pour manipuler un attribut de l’objet courant:

this.couleur

Pour manipuler une méthode de la super-classe :

this.ajouterChemise (100)

Pour faire appel au constructeur de l’objet courant:

this()
86
 La classe Montre, un peu de syntaxe

class UnNomdeClasse { /* le corps */ }

• class indique la définition d'une classe nommée
Montre.
• Un nom de classe commence par une majuscule
• Le mot-clé public indique que la classe est utilisable
public class Montre { de « l'extérieur ».
/*Définissons les attributs*/
private int heure , minute ; • Les attributs sont typés (int) :
<Type> nomAttribut = valeurInit;
/* Définissons les méthodes*/
public int getHeure() { • La syntaxe générale pour définir une méthode :
return heure;
<Type retour> nomMethode (<listeparamètres>)
}
public int getMinute() { • Les noms de méthodes et attributs commencent par
return minute; une minuscule, la frontière des mot est marquée par
} une majuscule.
public void setMinute(int m) {
minute = m; • Tout ce qui est entre /* et */ est un commentaire
} (pouvant aller sur plusieurs lignes).
public void setHeure(int h) {
heure = h; • // commentaire jusqu'à la fin de la ligne
}
}
87
 Surcharge
Deux méthodes membres qui
appartiennent à la même classe
portent un identificateur identique (même nom de
fonction)
possèdent des paramètres différents

sont des méthodes surchargées

88
 Surcharge
Exemple:

Un point géométrique peut être défini par:

ses coordonnées données explicitement

Point (int i, int j) {

x=i;
y=j;
}

un autre Point

Point (Point p) {
x=p.x;
89
y=p.y;
}
 Surcharge
Exemple (suite):

des coordonnées par défaut

Point () {
x=0;
y=0;
}

Soit:
Point (int i, int j)
Point (Point p)
Point ()

90
3 méthodes portant des signatures différentes
 Surcharge
Attention:

Pas de différenciation sur le type de retour

Exemple:

int f (int v)

et

double f (int v)

ne sont pas différentiable

91
 Les attributs static

Variable d’instance:
Etudiant [class]
Chaque instance de la classe possède
ses propres valeurs des variables.

Class Etudiant{
String nom;

Etudiant(String nom){ Etudiant [instance] Etudiant [instance]

this.nom=nom; nom nom
}
Ahmed Marwa
}

Etudiant etud1 = new Etudiant (“Ahmed");

Etudiant etud2 = new Etudiant (“Marwa");
92
 Les attibuts static

Variable d’instance:
Utilisation
On invoque les variables d’instance avec le nom de l’instance

Class Etudiant{ class Test{

String nom; public static void main(String[] args){

Etudiant(String nom){ Etudiant etudiant=new Etudiant();

this.nom=nom;
} System.out.println(etudiant.nom);
} }
}

93
 Les attibuts static
Variable de classe:
•n'appartient pas à une instance particulière, elle
appartient à la classe. Etudiant [class]
•est partagée par toutes les instances de la classe
nbrEtudiants
Class Etudiant{ 0
3
2
1
String nom;
static int nbrEtudiants;
Etudiant [instance]
Etudiant(String nom){ nom Etudiant [instance]
Ahmed
this.nom=nom; nom
Fatma
nbrEtudiants++;
}
Etudiant [instance]
} nom
Marwa
Etudiant etud1 = new Etudiant (“Ahmed");
Etudiant etud2 = new Etudiant (“Marwa");
94 Etudiant etud3 = new Etudiant (“Fatma");
 Les attibuts static

Variable de classe:
Utilisation
On invoque les variables static avec le nom de la classe

class Etudiant{
String nom;
static int nbrEtudiants; class Test{
public static void main(String[] args){
Etudiant(String nom){
this.nom=nom; System.out.println(Etudiant.nbrEtudiants);
nbrEtudiants++;
} }
} }

95
 Les méthodes static

Le comportement d’une méthode statique ne dépend pas de la valeur des

variables d'instance

class MaClassMath{ Utilisation:

L'appel à une méthode statique se fait en
static int min(int a , int b){ utilisant le nom de la classe.
if(a<b){
return a;
}else{ class Test {
return b; public static void main ( String [] args ){
} int x = MaClassMath .min (21 ,4);
} }
} }

96
 Les méthodes static
Puisque les méthodes static appartiennent à la classe,
elles ne peuvent en aucun cas accéder aux variables
d'instances qui appartiennent aux instances de la classe.

•Les méthodes d’instances accèdent aux variables d’instance et méthodes d’instances

•Les méthodes d’instances accèdent aux variables de classe (static) et méthodes de
classe (static)
• Les méthodes de classe (static) accèdent aux variables de classe (static) et méthodes
de classe (static)
• Les méthodes de classe (static) n’accèdent pas aux variables de d’instance et
méthodes d’instance
• Dans une méthode static on ne peut pas utiliser this

97
 Un peu de syntaxe : construction et
communication avec un objet
Construction
Point p1 = new Point(1, 2);
Type réf allocation Constructeur, renvoie
dynamique l’adresse.

• Communication
p1.distance(p2 );

réf de la cible type du message/ params. du

message
commande/requête
int abs = p1.getx( );

98
l’objet peut répondre au message pas de params.
 Exemple
public class Personne {
public String nom;
public int anneeNaissance;
public int age() {return 2008 - anneeNaissance; }
}
class Utilisation {
public static void main(String[] args) { Déclaration de référence
Personne qui;
Création d’une instance
qui = new Personne();
qui.nom = "Pierre"; Manipulation de l’instance
qui.anneeNaissance = 1980; référée par la référence
System.out.println(qui.age());
}
qui nom: "Pierre"
}
anneeNaissance: 1980
Personne:
99 age()
 Manipulation des références
class Circle {
public double x, y; // coordonnées du centre
private double r; // rayon du cercle
public Circle(double r) {
this.r = r;
}
public Circle(double a, double b, double c) {
x = a; y = b; r = c;
}
}
// Dans une méthode, par exemple, main:
Circle c1, c2;
c1 = new Circle(2.0, 3.0, 4.0);
c2 = c1; // c2 et c1 pointent vers le même objet
c2.r = c2.r – 1; // l’objet a le rayon réduit
c1 = new Circle(2.0); // c1 point vers un autre objet, mais c2 ne change pas
c1.x = 2.0; // on modifie le deuxième objet
c2 = c1; // maintenant, c2 pointe vers le 2ième objet aussi

Que faire du premier objet?

Aucune référence ne pointe vers lui
L’objet est perdu et inutilisable
Ramasse miette (garbage collector) va récupérer l’espace occupé par l’objet
Comparaison des références
(c1 == c2): est-ce que c1 et c2 pointent vers le même objet?
100
 Illustration
c1
null
1. Cercle c1, c2; 1 c2
x: 2.0
c1 y: 3.0
2. c1 = new Cercle(2.0, 3.0, 4.0); 2 r: 4.0
c2
x: 2.0
null
c1 y: 3.0
3. c2 = c1; 3 r: 4.0
c2
null x: 2.0
c1 y: 3.0
4. c2.r = c2.r – 1; 4 r: 3.0
c2
null
x: 2.0
c1 y: 3.0
5. c1 = new Cercle(2.0); 5 r: 3.0

x: 2.0 c2
x: 0.0
c1 y: 3.0 y: 0.0
r: 3.0
6. c1.x = 2.0; 6 c2
r: 2.0

x: 2.0 x: 2.0
y: 0.0 c1 y: 3.0
r: 2.0 7. c2 = c1; 7 r: 3.0
c2
x: 2.0
101 y: 0.0
r: 2.0
 Manipulation des références
Soit l'objet suivant: Point
x y

Programme Espace des variables Espace mémoire

Point p1, p2, p3; p1 Point
p1 = new Point (1,2); 1 2
p2
p2 = new Point (3,4);
p3 = p2; p3 Point
p2 = p1; 3 4

102
 Création des objets

Plan de construction

17, Rue Carthage 9, Rue Hannibal 23, Rue des anges

Classe « Chemise »

Objet 1 Objet 2

Référence 1 Référence 2
103
 Référence d’un objet

Réellement Par analogie

Une référence nous Une adresse nous permet
permet de trouver l’objet. de trouver une maison.

En utilisant la référence, En utilisant l’adresse, on

on peut accéder aux peut envoyer une lettre à
attributs et méthodes de cette maison.
l’objet.

104
 Notion de référence

public class Test{ Mémoire

public static void main(String[] args){

Chemise maChemise;

maChemise=new Chemise();
maChemise
maChemise.couleur=‘R’;
}
}

Stack Heap
Création d’une variable maChemise de type Chemise

105
 Notion de référence

public class Test{ Mémoire

public static void main(String[] args){

0x034009
Chemise maChemise;
id 0
maChemise=new Chemise(); couleur '\u0000’

maChemise prix 0.0f

maChemise.couleur=‘R’; description null
} quantite 0
}

Stack Heap

Instanciation de la classe Chemise Création d’un objet.

Cet objet possède une adresse de son emplacement dans la mémoire (0x034009)
106
 Notion de référence

public class Test{ Mémoire

public static void main(String[] args){

0x034009
Chemise maChemise;
id 0
maChemise=new Chemise(); couleur '\u0000’

maChemise prix 0.0f

maChemise.couleur=‘R’; description null
0x034009
} quantite 0
}

Stack Heap
Lier l’objet créé et la variable maChemise
maChemise est la référence de l’objet créé
107
 Notion de référence

public class Test{ Mémoire

public static void main(String[] args){

0x034009
Chemise maChemise;
id 0
maChemise=new Chemise(); couleur R
maChemise prix 0.0f
maChemise.couleur=‘R’; description null
0x034009
} quantite 0
}

Stack Heap

En utilisant la référence maChemise, on peut accéder aux attributs de l’objet

108
 Notion de référence
Mémoire
0x034009
public class Test{
id 0
public static void main(String[] args){ maChemise couleur R
prix 0.0f
Chemise maChemise=new Chemise() 0x034009
description null
quantite 0
Chemise taChemise=new Chemise();

}
0x99f311
}
id 0
taChemise couleur '\u0000’

0x99f311 prix 0.0f

description null
quantite 0

Stack Heap
109
 Passage de paramètres

En Java, la transmission d’informations se fait toujours par valeur.

La transmission, par exemple d’un argument à une méthode ou
d’une valeur de retour se fait toujours par valeur.

Cette transmission a des conséquences totalement

A RETENIR
différentes, selon que l’on manipule des types primitifs ou
bien des types objet ( c-à-d des références).

Transmission par valeur : la méthode reçoit une copie de la

RAPPEL valeur de l’argument effectif sur laquelle elle travaille. Pas de
possibilité d’agir sur la valeur de l’argument effectif.
Transmission par référence ( par adresse): la méthode reçoit
l’adresse de l’argument effectif sur laquelle elle travaille
directement. Ici, possibilité de modifier donc la valeur de
l’argument effectif.
110
 Passage de paramètres

public class TransValeurTypePrimitif {

private double res;
public TransValeurTypePrimitif (double n) {
res = n; Argument muet.
2
}
public double add ( double p ) 10
{ p
p contient
return res += p;
4 une copie
}
public static void main(String[] args) { 3 de la valeur
de l’argument
TransValeurTypePrimitif trans = new TransValeurTypePrimitif (12);
effectif.
System.out.println ( trans.add ( 10 ) ); 10
}
1 Argument effectif.
}
111
 Passage de paramètres

public class Point {

private int x;
private int y;
public Point (int abs, int ord) { Référence à un objet de type Point
x = abs; transmise en argument d’une
y = ord; Méthode.
}
public boolean coincide ( Point p)
p
{ return ( p.x == x && p.y == y);
} 12
public static void main (String [ ] args) { 12
Point a= new Point(10,12);
Point b = new Point(12,12); b
System.out.println( a.coincide ( b ) );
10
}}
a 12
112
 Passage de paramètres
Types primitifs
Considérons la méthode suivante :
static void augmente(int i) { i=i+1;}
et un appel de cette fonction :
int j=1; augmente(j); System.out.println(j);

113
114
 Passage de paramètres
Types Références:
static void augmenteSurface(Pays p) {
p.surface=p.surface+1;}
et un appel de cette méthode :
Pays p1=new Pays();
augmenteSurface(p1);
System.out.println(p1.surface);

115
116
 Passage de paramètres en Java
Si un objet o transmet sa variable d'instance v en paramètre à
une méthode m, deux situations sont possibles :
si v est une variable primitive alors elle est passée par valeur : il
est impossible de la modifier dans m pour que v en retour
contiennent cette nouvelle valeur.
si v est un objet alors il est passé par référence: m pourra
modifier l'objet en utilisant une méthode de l'objet passé en
paramètre.
Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui
même qui est passé mais une référence sur l'objet. La référence
est bien transmise par valeur et ne peut pas être modifiée mais
l'objet peut être modifié via un message (appel d'une méthode).
Pour transmettre des arguments par référence à une méthode, il
faut les encapsuler dans un objet qui prévoit les méthodes
nécessaires pour les mises à jour.

117
 Transmission de paramètres
Exemple
public class Essai {
public static void f1 (int x) {
x=2;
}

public static void main(String [] args)

{
int i=1;
System.out.println("i=" + i);
f1(i);
System.out.println("i=" + i);
}
}
Résultat:
i=1
i=1
copie de i
public static void main(String [] args) { public static void f1 (int i) {
int i=1; i=12;
System.out.println("i=" + i); }
f1(i);
System.out.println("i=" + i);
}

118
 Transmission de paramètres
Transmission d'instance d'objet
Soit l'objet suivant
//Fichier Point.java
public class Point {
private int x, y; // coordonnées 2D du points

public Point (int a, int b) {

x=a;
y=b;
}

public static void initPoint (Point p) {

p.x=0;
p.y=0;
}
}
119
 Transmission de paramètres
Espace des variables Espace mémoire
// Ficher Point.java

public class Point {

private int x, y;
p
public Point (int a, int b) {
x=a;
y=b;
}
Point
public static void initPoint (Point p) { 1
0 2
0
p.x=0;
p.y=0;
t
}
}

// Ficher Main.java

public class Main {

public static void main (String[] args){
Point t = new Point(1,2);
System.out.println("t.x=" + t.x);
Point.initPoint(t);
System.out.println("t.x=" + t.x);
}
}

120