Programmation Orienté Objet

Introduction au Langage de Programmation

JAVA Standard Edition
Dr. HAJJI TARIK
Département de Mathématiques et Informatique
t.hajji@umi.ac.ma

ENSAM
2019-2020
 Descriptif POO
• Programmation orientée objet Java
– Présentation générale du langage Java
– Syntaxe et compilation
– Machine virtuelle et environnement d'exécution
– Types de base, types tableaux, références et affectation
– Structures de contrôle (conditionnelles et boucles)
• Concepts de base de l’approche objet
– Objets et classes
– Encapsulation
– Héritage
– Abstraction et interfaces
– Polymorphisme
• Gestion des exceptions
• Les entrées sorties en Java
– Structures de données en java : les collections
• Interfaces graphiques et gestion des événements
 Sommaire

A. Les bases de java

B. Les constructeurs
C. Généralités sur les structures lexicales de Java
D. Héritage
E. La gestion des Exceptions
F. Complément
G. Introduction aux Interfaces graphiques
 Séance 1: Les bases de java

• I. Généralités sur les objets

• II. Les bases à connaître
• III. Mon premier programme en Java
• IV. Les classes en Java
• V. Création et manipulation d’Objets
• VI. Notion de portée et de durée de vie des
objets
• VII. Champs de classe
 Introduction Générale: L’évolution
Programmation séquentielle
Programmation parallèle
Programmation dynamique
Programmation distribuée
Programmation orienté objet Classes
Structures
de
données La
portabilité
Variables

Typage de données
 Ch I. JAVA: les bases

I. Généralités sur les objets

• Un objet est une variable améliorée: il stocke les
données, mais on peut effectuer des requêtes sur cet
objet (on demande à l’objet de faire des opérations
sur lui-même), en envoyant un message à cet objet.
• Chaque objet à son espace mémoire
• Chaque objet a un type précis: c’est-à-dire chaque
objet est une instance (variable) d’une class (type)

Un programme JAVA est ensemble d’objets qui

s’envoient des messages.
II. Les bases à connaître
• Java est un langage orienté objet: l'entité de
base de tout code Java est la classe
• Sa syntaxe est proche du langage C
• Il est fourni avec le JDK (Java Developpment
Kit)
– Outils de développement
– Ensemble de paquetages très riches et très variés
• Portable grâce à l’exécution par une machine
virtuelle
• En Java, tout se trouve dans une classe.
– Il ne peut y avoir de déclarations ou de code en
dehors du corps d'une classe.
• La classe elle même ne contient pas
directement du code.
– Elle contient des déclarations de variables
globales, que l'on appelle des ``attributs'',
– et des méthodes (équivalents à des fonctions).
• Le code se trouve exclusivement dans le corps
des méthodes, mais ces dernières peuvent
aussi contenir des déclarations de variables
locales (visibles uniquement dans le corps de la
méthode).
III. Mon premier programme en Java

Considérons le code source du programme qui affiche à

l’écran Mon premier programme Java

// Fichier source MonPremProg.java

public class MonPremProg {
// déclaration de données globales
//définition des méthodes
public static void main(String args[]) {
// déclaration des données locales;
System.out.println(" Mon premier programme
Java " );
}
}
• De manière générale, dans tout programme autonome
destiné à être exécuté doit contenir une méthode
particulière nommée main() définie de la manière
suivante:
public static void main(String args[]) {
/* corps de la méthode */
}
• Le paramètre args de la méthode main() est un tableau
d’objets de type String. Il n’est pas utilisé mais, il est
exigé par le compilateur Java.
• La classe contenant la méthode main() doit
obligatoirement être public afin que la machine virtuelle
y accès. Dans l’exemple, le contenu de la classe
MonPremProg est réduit à la définition d’une méthode
main().
• Un fichier source peut contenir
plusieurs classes mais une seule doit
être public(ici PremProg).
• Le nom du fichier source est identique
au nom de la classe publique qu'il
contient, suivi du suffixe .java, dans
l’exemple MonPremProg.java
Compilation
• La compilation d’un programme Java ne traduit
pas directement le code source en fichier
exécutable.
• Elle traduit d’abord le code source en un code
intermédiaire appelé « bytecode ».
• C’est le bytecode qui sera ensuite exécuté par
une machine virtuelle (JVM ; Java Virtual
Machine).
• Ceci permet de rendre le code indépendant de
la machine qui va exécuter le programme.
• Sun fournit le compilateur javac avec le JDK. Dans notre
exemple on exécute:
javac MonPremProg.java

• Cette compilation crée un fichier nommé

«MonPremProg.class» qui contient le bytecode

• On peut désigner le fichier à compiler par un chemin

absolu ou relatif : javac home/user2/MonPremProg.java
• Si un système possède une JVM il peut exécuter
tous les bytecodes (fichiers .class) compilés sur
n’importe qu’el autre système (c’est la notion de
la portabilité de java).
 Exécution du bytecode
• Le bytecode doit être exécuté par une JVM.
• Cette JVM n'existe pas ; elle est simulée par un
programme qui:
– lit les instructions (en bytecode) du programme
.class,
– les traduit dans le langage machine relatif à la
machine sur laquelle il sera exécuté.
– lance leur exécution
Exécution avec java

• Pour compiler il suffit d’utiliser la commande javac:

javac MonPremProg.java

• Il suffira d’utiliser la commande:

java MonPremProg

qui interprète le bytecode de la méthode main() de la

classe MonPremProg
L’exécution du programme MonPremProg affiche à l’écran,
comme résultat, la chaîne de caractères:
Mon premier programme Java,
grâce à l’instruction:
System.out.println(" Mon premier programme Java ");

Dans le programme, une ligne qui commence avec

// est un commentaire jusqu’à la fin de la ligne
Une ligne qui commence avec
/* est un commentaire qui peut être étalé sur
plusieurs lignes, et doit terminer avec */
III. Les classes en Java
• Une classe décrit un ensemble d’objets qui partagent
des caractéristiques communes.
• On définit une classe pour représenter un problème au
lieu d’utiliser un type de données pour représenter
une unité de stockage dans l’ordinateur.
• On utilise les classes exactement de la même manière
que les types de données prédéfinies.
• On peut créer des variables (objets ou instance) d’un
type particulier.
Pour créer un nouveau type d’objets on utilise le mot clé
class.
Le canevas de base pour définir un nouveau type de nom
NomDuType est la suivante:

class NomDuType {
/* Corps de la classe: instructions de définitions
des méthodes et des champs */
}
Dans la définition de la classe (corps de la classe),
on met deux types d’éléments:

- des données membres de la classe (appelées

champs) qui sont des objets de n’importe
quel type.
- des fonctions membres de la classe
(appelées méthodes).
Exemple:
UnTest est une classe (un nouveau type) qui a
3 champs : float, int et boolean.

class UnTest {
float x;
int i;
boolean b;
}
Définition des méthodes
La définition de base d’une méthode ressemble à la
définition d’une fonction en C.
typeRetour nomMethode (/* Liste des parametres
*/) {
/* corps de la méthode */
}
- nomMethode est le nom de la méthode
- Liste de paramètre (arguments de la méthode) donne
les types et les noms des informations qu’on souhaite
passer à la méthode lors de son appel.
- typeRetour est le type de la valeur qui est retournée
par la méthode après son appel. Si la méthode ne
fourni aucun résultat, alors typeRetour est remplacé
par le mot clé void.
• Le mode de passage des paramètres dans les méthodes
dépend de la nature des paramètres :
– par référence pour les objets
– par copie pour les types primitifs

Exemple
class C {
void methode1(int i){
i+=12;
}
void methode2() {
int i = 3;
methode1(i);
System.out.println("i=" + i); // i=3
}
}
IV. Création et manipulation d’Objets

Une fois la classe est définie, on peut créer des objets de la

même manière que la déclaration des types primitif:

Considérons la classe ClasseTest

class ClasseTest {
// corps de la classe ClasseTest
}

l’instruction:

ClasseTest a; // déclare a comme objet (variable) de type

ClasseTest
Attention:
- La déclaration d’une variable de type primitif
réserve un emplacement mémoire pour stocker la
variable
- La déclaration d’un objet de type A, ne réserve pas
une place mémoire pour un objet de type A, mais
seulement un emplacement pour une référence à
un objet de type A.
 les objets sont manipulés avec des références.
Exemple classique de la télécommande et la Télé.
Télé = objet
Télécommande = référence.

Objet
Référence
Télécommande Tél
é
- Pour modifier l’objet (par exemple augmenter
le son, …) on utilise la référence (la
télécommande).

- Avoir une référence ne veut pas dire avoir

l’objet (on peut avoir la télécommande sans
avoir la télé).
L’emplacement pour l’objet doit être demandé
explicitement dans le programme en faisant appel à
l’opérateur new.
L’expression new NomClasse créée un emplacement pour
un objet de type NomClasse.

class NomClasse {
/* Corps de la classe */
}

NomClasse a = new NomClasse();

En générale:
1. Chaque objet met ses données membres dans sa
propre zone mémoire.
2. Les données membres ne sont partagées entre les
objets.
Exemple 1:
class UnTest {
float x;
int i;
boolean b;
}

UnTest data = new UnTest(); // créer un objet data

Exemple 2:
Supposons qu’on veut avoir une chaîne de caractères
alors on crée une référence sur String:
String s;
Ici on a créé la référence mais pas l’objet. Pour créer
l’objet, il faut initialiser la référence s.
String s=new String ("cours Java");
ou
String s;
s = new String ("cours Java");

Ou tout simplement ( C’est un cas particulier en Java

pour les objets string) par:
String s= " cours Java "
Accès aux données membres
Exemple 1:
class UnTest {
float x;
int i;
boolean b;
}
UnTest data = new UnTest(); // créer un objet data
Maintenant l’objet dont la référence data existe. Pour
accéder à une donnée membre on indique le nom de
la référence à l’objet suivi par un point, suivi par le
nom du membre dans l’objet de la manière suivante:
data.i=2; // affecte 2 au membre i
data.b=true; // affecte true au membre b
data.x=1.2f; // affecte 1.2 au membre x.
Appels des méthodes
• Les méthodes ne peuvent être créer que comme
des composante d’une classe.
• Une méthode ne peut être appelée que pour un
objet.
• L’appel d’une méthode pour un objet se réalise
en nommant l’objet suivi d’un point suivi du
nom de la méthode et de sa liste d’arguments:
nomObjet.nomMethode(arg1, ….).
où
nomObjet: nom de la référence à l’objet
nomMethode: nom de la méthode.
Exemple: soit f () une méthode qui ne prend aucun
paramètre et qui retourne une valeur de type int.
Alors si on a une référence à un objet appelé a pour
lequel f() peut être appelée, on peut écrire: int x = a.f()

class UnTest {
float x;
int i;
boolean b;
int f() {
return 10;
}
}

UnTest a = new UnTest(); // créer un objet a;

int x = a.f(); // affecte à x la valeur retournée par f
Cas particulier des types primitifs
Les types primitifs ont un traitement particulier:
1. on n’utilise pas new,
2. les variables (non les références) sont créées au moment de
leurs déclaration.

------------------------------------------------------------------------------
Type | Taille | Classe Wrapper |
--------- |--------------------------------|--------------------------------- |
boolean | | Boolean |
char | 16 bits, Unicode | Character |
byte | 8 bits | Byte |
short | 16 bits | Short |
int | 32 bits | Integer |
long | 64 bits | Long |
float | 32 bits IEEE 754 | Float |
double | 64 bits IEEE 754 | Double |
void | | Void |
On peut traiter les type primitif comme des objet
en utilisant les classe wrapper qui leurs sont
associées.

Exemple:
char c=‘x’; // type primitif directement déclaré
Character car = new Character(c); // classe
wrapper
ou
Character car = new Character (‘x’);
Remarque :
Quand une donnée d’un type primitif est membre d’une
classe on est assuré qu’elle a une valeur par défaut
même si on ne l’initialise pas:
----------------------------------------------------------------
Type primitifs | Valeur par défaut |
---------------------------- |----------------------------------- |
boolean | false |
char | ‘\u0000’ (null) |
byte | (byte)0 |
short | (short)0 |
int | 0 |
long | 0L |
float | 0.0f |
double | 0.0d |
-----------------------------------------------------------------
Attention: Cette garanti d’initialisation par
défaut ne s’applique pas aux variables
locales (définition d’une fonction
(méthode)).