POO Java Chapitre 1 Classe & Objet

Chapitre 1
Classe et Objet
Mouna Torjmen Khemakhem

Analyse d’un problème avec
l’approche OO
Exemple: Une société de location de voiture
Chaque voiture possède les caractéristiques suivantes:
• un identifiant : matricule
• un couleur: noir, gris, rouge• un couleur: noir, gris, rouge
• marque : Renault, Peugeot
• un prix de location / jour
• une description: type du carburant, nombre de portes, etc
• nombre de jours de location
C’est possible d’ajouter ou de diminuer le nombre de jours de
location et de calculer le prix total de location.
2

Identification de l’objet
Objet
Voiture
ID
Prix
Couleur
Attributs Méthodes
Couleur
Description
Nombre jours location
Augmenter nombre jours location
Diminuer nombre jours location
Calculer Prix Total Location
3

Classe et objet JAVA
Plan de construction
Une classe n'est pas un objet. Une classe est un patron d'objet.
Classe « Voiture »
Objet 1
Id: 125Tunisie160
Prix: 100 DT
Couleur: Gris
NbreJL: 10
Objet 2
Id: 653Tunisie123
Prix: 70 DT
Couleur: Rouge
NbreJL: 5
4

Classe et objet JAVA
• classe : structure d'un objet, la déclaration de l'ensemble des entités
qui composeront un objet.
•Un objet est une instanciation d'une classe objet = instance
•Une classe est composée de deux parties :•Une classe est composée de deux parties :
• Les attributs (appelés aussi données membres) : il s'agit des
données représentant l'état de l'objet
• Les méthodes (appelées aussi fonctions membres): il s'agit des
opérations applicables aux objets
5

Déclaration d’une classe
public class Voiture
{
/*Déclaration des attributs*/
/*Déclaration des méthodes*/
//commentaire sur une seule ligne
}
//commentaire sur une seule ligne
/*commentaires sur
plusieurs lignes*/
• Le nom de la classe doit commencer par une majiscule
• Exemple: CompteBancaire, AgenceVoyage
6

Déclaration des attributs
Syntaxe:
type nom_variable [=value];
int id = 0;
•Le nom de l’attribut doit commencer par une lettre miniscule
•Exemple: age, quantiteStock
7

Types de données en JAVA
• Deux grands groupes de types de données :
types primitifs
types objets (instances de classe)
•Les types de données utilisés sont :
• les nombres entiers• les nombres entiers
• les nombres réels
• les caractères et les chaînes de caractères
• les booléens
• les objets
8

int age;
boolean abonne;
age abonne sexe
•Déclaration de type primitive réservation de l’espace
mémoire.
boolean abonne;
char sexe;
age=18;
abonne=false;
sexe=‘M’;
•La valeur affectée sera stockée dans l’espace mémoire
réservé.
age
false
abonne
M
sexe
18
9

Types primitifs
• Valeur logique
boolean (true/false)
• Nombres entiers
byte (1 octet)
boolean abonne=true;
byte (1 octet)
short (2octets)
int (4 octets)
long (8 octets)
• types réels
float (4 octets)
double (8 octets).
• Caractère (un seul)
char (2 octets) 10
float prix=1.2f;
double poids=34.8d;
char sexe=‘M’;Mouna Torjmen Khemakhem

Type primitif Signification
Place occupée en
mémoire
byte Entier très court allant de -128 à +127 1 octet
short Entier court allant de -32768 à +32767 2 octets
int Entier allant de -2 147 483 648 à +2 147 483 647 4 octetsint Entier allant de -2 147 483 648 à +2 147 483 647 4 octets
long Entier long allant de -263 à +263 -1 8 octets
float Nombre réel allant de -1.4 * 10-45 à +3.4 * 1038 4 octets
double
Nombre réel double précision allant de 4.9 * 10-324
à +1.7 * 10308 8 octets
char Caractère unicode (65536 caractères possibles) 2 octets
boolean variable booléenne (valeurs : vrai ou faux) 1 octet
11

Types primitifs: initialisation par défaut
Type Valeur par défault (pour les attributs)
byte 0
short 0short 0
int 0
long 0L
float 0.0f
double 0.0d
char 'u0000'
boolean false
12

Types primitifs: déclaration des constantes (pour attributs)
•On déclare une constante avec le mot final
•Le nom de la constante doit être en majuscule.
•Si le nom est composé de plusieurs mots, on utilise "_" pour
13
•Si le nom est composé de plusieurs mots, on utilise "_" pour
la séparation des mots
final int TAILLE;
final int MAX_STOCK;
final int CAPACITE_DANS_STOCK;

Types objets
• Ce type comprend les instances de classe et les tableaux
(« arrays »)
14
• Les objets sont créés dynamiquement au moyen de
l’opérateur « new ».
Exemple: String, Voiture, Etudiant, …

String message;
message
ref
•On crée une référence sur une String
•Déclaration de type objet Réservation de l’espace mémoire pour
la référence
null
Les types références: String
objet null
ref
message=‘’Bonjour’’;
//équivalent à
message=new String(‘’Bonjour’’);
message
ref Bonjour
message=‘’Hello’’;
message
ref Bonjour
Hello
null
objet String
objet String

• Un type enveloppe est un type objet qui encapsule un type
primitif.
•A chaque type primitif est associé une classe enveloppe.
Types objets Enveloppes: wrappers
Type primitif classe enveloppeType primitif classe enveloppe
boolean java.lang.Boolean
char java.lang.Character
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
16

• Chaque classe enveloppe d'un type primitif possède une méthode
pour convertir une instance de la classe en une valeur du type
primitif associé : primitifValue().
Integer entier= new Integer( 25) ;
Types objets Enveloppes: wrappers
Integer entier= new Integer( 25) ;
int age = entier. intValue ( ) ;
• Les objets enveloppes permettent notamment de convertir une
chaîne de caractères en un entier, un réel, un booléen, etc ...
• int quantite=Integer.parseInt( "6" ) ;
• double prix=Double.parseDouble( " 6 .89 " ) ;
• boolean test= Boolean.parseBoolean( " false " ) ;
17

Conversion des types
primitifs
• Conversion implicite (automatique)
– byte -> short -> int -> long -> float -> double
// 64 bit long integer
Long myLongInteger;
// 32 bit standard integer
• Conversion explicite (Casting)
myInteger = (int) myLongInteger;
// 32 bit standard integer
int myInteger;
myLongInteger = myInteger;
18

int[] tab;
0 1 2 3 4 indices
1er indice
tab.length=5
10 20
Tableaux
int[] tab;
tab = new int[5];
tab[0] = 10; // initialiser le premier élément
tab[1] = 20; // initialiser le second élément
int[] tab = { 10, 20, 30, 40, 50}; //déclaration + initialisation
19

int[] notes={10,12,15};
notes
reference
int
12 1510
intint
•Un tableau contenant des éléments de type primitif
objet int [ ]
Tableaux
int intint
String[] animaux={‘’chat’’,’’poisson’’};
animaux
reference refref
chat
•Un tableau contenant des éléments de type objet
objet String
poisson
objet String
20

Récapitulation sur les types objets et les types primitifs
Tableaux
21

Déclaration des méthodes
Syntaxe:
Type_retour nom_methode([arguments])
{
}
•Le nom de la méthode doit commencer par un verbe
}
void afficherInfoVoiture (){
}
22

Classe voiture
public class Voiture{
int id;
char couleur;
float prix;
String description;
int nbreJourLocation;
void augmenterNbJourLocation (int nombre) {
nbreJourLocation += nombre;
}}
void diminuerNbJourLocation (int nombre) {
nbreJourLocation - = nombre;
}
void afficherInfoVoiture() {
System.out.println(id+ " " +couleur+ " " +prix+ " " +description);
}
}
23

Plan de construction
17, Rue Carthage
Création des objets
24
Classe « Voiture »
9, Rue Hannibal 23, Rue des anges
Référence 1 Référence 2
Objet 1 Objet 2
17, Rue Carthage

Notion de référence
public class Test{
public static void main(String[] args){
Voiture maVoiture;
Mémoire
maVoiture=new Voiture();
maVoiture.couleur=‘R’;
}
}
maVoiture
•Création d’une variable maVoiture de type Voiture
Stack Heap
25

public class Test{
Voiture maVoiture;
0id
0x034009
Mémoire
maVoiture =new Voiture();
}
}
maVoiture
0
0.0f
null
0
id
couleur
prix
description
nbreJourLocation
•Instanciation de la classe Voiture Création d’un objet.
•Cet objet possède une adresse de son emplacement dans la mémoire
(0x034009)
Stack Heap
'u0000’
26

public class Test{
Voiture maVoiture;
0x034009
Mémoire
0idmaVoiture=new Voiture();
}
}
maVoiture
Stack Heap
•Lier l’objet créé et la variable maVoiture
maVoiture est la référence de l’objet créé
0x034009
0
0.0f
null
0
id
couleur
prix
description
nbreJourLocation
'u0000’
27

public class Test{
Voiture maVoiture;
0x034009
Mémoire
0idmaVoiture=new Voiture();
}
}
maVoiture
Stack Heap
•En utilisant la référence maVoiture on peut accéder aux attributs de l’objet
0x034009
0
0.0f
null
0
id
couleur
prix
description
nbreJourLocation
R
28

public class Test{
Voiture maVoiture=new Voiture()
maVoiture
0
R
0.0f
id
couleur
prix
description
nbreJourLocation
0x034009
0x034009
Mémoire
null
Voiture taVoiture=new Voiture();
}
}
0
nbreJourLocation
Stack Heap
0
0.0f
0
id
couleur
prix
description
nbreJourLocation
0x99f311
taVoiture
0x99f311
null
null
'u0000’
29

Les constructeurs
Pour créer un objet à partir d'une classe, on utilise l'opérateur new.
public class Test{
Voiture maVoiture;
L’opérateur new fait appel au
constructeur de la classe
class Voiture{
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)
maVoiture=new Voiture();
}
}
Voiture() {}
}
30

Les constructeurs
Constructeur par défaut
Voiture(){}
Voiture(){
id=0;
Le constructeur par défaut initialise les
attributs de la classe aux valeurs par
défaut.
id=0;
couleur=‘N’;
prix=75.5f;
}
Voiture(int id, char couleur, float prix){
this.id=id;
this.couleur=couleur;
this.prix=prix;
}
Constructeur surchargé
31

Les constructeurs
• Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera
plus créé par le compilateur
• Absence de constructeur dans la classe le compilateur crée automatiquement
un constructeur par défaut implicite
• La plateforme java différencie entre les différents constructeurs déclarés au• 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.
Voiture (int id) {
this.id=id
}
Voiture (int id) {
this.id=id*2
}
Erreur de compilation
32

Les constructeurs
Quel constructeur va choisir Java lors de création de l’objet ?
class Voiture{
int id;
char couleur;
float prix;
String description;
int nbreJourLocation; Utilisation:int nbreJourLocation;
Voiture() {}
Voiture(int id) {
this.id=id;
}
Voiture(int id, char couleur) {
this(id);
this.couleur=couleur;
}
}
Voiture v1=new Voiture();
Voiture v1=new Voiture(122);
Voiture v1=new Voiture(122, ‘N’);
Utilisation:
33

Le mot clé this
Pour manipuler un attribut de l’objet courant:
this.couleur
•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
this.couleur
Pour manipuler une méthode de la super-classe :
this.ajouterVoiture (100)
Pour faire appel au constructeur de l’objet courant:
this()
34

Les attributs static
Attribut d’instance:
Chaque instance de la classe possède
ses propres valeurs d’attributs.
Class Etudiant{
String nom;
Etudiant [class]
String nom;
Etudiant(String nom){
this.nom=nom;
}
}
Etudiant [instance]
Etudiant etud1 = new Etudiant (“Ahmed");
Etudiant etud2 = new Etudiant (“Marwa");
nom
Ahmed
Etudiant [instance]
nom
Marwa
35

Attribut d’instance:
Class Etudiant{
String nom;
Utilisation
Les attributs d’instance sont appelés avec le nom de l’instance
class Test{
public static void main(String[] args){String nom;
this.nom=nom;
}
}
Etudiant etudiant=new Etudiant();
System.out.println(etudiant.nom);
}
}
36

Attribut de classe:
•n'appartient pas à une instance particulière, il
appartient à la classe.
•est partagé par toutes les instances de la classe
Etudiant [class]
0
nbrEtudiants
Class Etudiant{
String nom;
123
Etudiant [instance]
Etudiant [instance]
Etudiant [instance]
String nom;
static int nbrEtudiants;
this.nom=nom;
nbrEtudiants++;
}
}
Etudiant etud1 = new Etudiant (“Ahmed");
Etudiant etud2 = new Etudiant (“Marwa");
Etudiant etud3 = new Etudiant (“Fatma");
nom
Ahmed
nom
Marwa
nom
Fatma
37

Variable de classe:
Utilisation
Les attributs static sont appelés avec le nom de la classe
class Etudiant{
String nom;String nom;
static int nbrEtudiants;
this.nom=nom;
nbrEtudiants++;
}
}
class Test{
System.out.println(Etudiant.nbrEtudiants);
}
}
38

Les méthodes static
•Le comportement d’une méthode statique ne dépend pas de la valeur des
attributs d'instance
class MaClassMath{
static int min(int a , int b){
Utilisation:
L'appel à une méthode statique se fait en
utilisant le nom de la classe.static int min(int a , int b){
if(a<b){
return a;
}else{
return b;
}
}
}
class Test {
public static void main ( String [] args ){
int x = MaClassMath.min (21 ,4);
}
}
utilisant le nom de la classe.
39

Les méthodes static
Puisque les méthodes static appartiennent à la classe, elles ne
peuvent en aucun cas accéder aux attributs d'instances qui
appartiennent aux instances de la classe.
•Les méthodes d’instances accèdent aux attributs d’instance et méthodes
d’instance
•Les méthodes d’instances accèdent aux attributs de classe (static) et méthodes de
classe (static)
• Les méthodes de classe (static) accèdent aux attributs de classe (static) et
méthodes de classe (static)
• Les méthodes de classe (static) n’accèdent pas aux attributs de d’instance et
méthodes d’instance
• Dans une méthode static on ne peut pas utiliser this 40

Classe principale
public static void main (String [] args){
}
41

Passage de paramètres
Les types primitifs: passage de paramètres par valeur
La transmission des arguments de type simple est
uniquement par valeur: les arguments ne peuvent pas
être modifiés par la méthode appelée.
Les types objets : passage de paramètres par adresse
Le passage des objets en paramètre d’une méthode est
par adresse: si la méthode modifie l'objet, il sera donc
toujours modifié après l'appel à cette méthode.
42

Passage de paramètres
class Rectangle {
int longueur;
int largeur;
void changeInt (int n) {n =22; }
void changeObj (Rectangle r) {r.longueur=40; }
}
class TestRectangle {class TestRectangle {
public static void main (String[] args){
Rectangle r = new Rectangle () ;
// Essayer de modifier un entier
int ent = 11 ;
r.changeInt(ent) ; // passage de paramètre par valeur
System.out.println("valeur entière : "+ent); // Affiche ?
// Essayer de modifier le contenu d’un objet
r.longueur = 25 ;
r.changeObj (r) ; // passage de paramètre par adresse
System.out.println(" valeur dans l’objet : " +r.longueur); // Affiche ?
}
}
43

Surcharge
•Une classe peut contenir des méthodes de même nom,
avec des arguments différents
•On dit que la méthode est surchargée.
class Affiche {
void print (int i) { System.out.println ("entier = "+i); }
void print (float f) { System.out.println ("réel = "+f); }
44
void print (float f) { System.out.println ("réel = "+f); }
void print (String s) { System.out.println ("chaîne de caractères =" +s); }
}
class TestAffiche {
public static void main (String []args){
Affiche a = new Affiche() ;
a.print(4.2f); // Affiche ?
a.print("hello"); // Affiche ?
a.print(4); // Affiche ?
}
}

La méthode toString
La méthode toString définie dans la classe Object renvoie le nom de la classe de
l'objet concerné suivi de l'adresse de cet objet.
Conversion d’un objet en String : méthode toString().
Quand la méthode toString est redéfinie, elle renvoie une chaîne de caractères
servant à décrire l'objet concerné.
class Voiture{
int id;
servant à décrire l'objet concerné. int id;
char couleur;
float prix;
String description;
int nbreJourLocation;
public String toString() {
return id+ " " +
couleur + " " +
prix + " " +
description + " " +
nbreJourLocation;
}
}
45

Exemple
class Rectangle {
int longueur;
int largeur;
Rectangle (){
this. longueur = 0 ; this. largeur = 0 ;
}
void allongerRect (int lg) {
// accès à l’attribut « longueur » à partir de l’intérieur de la classe Rectangle
46
// accès à l’attribut « longueur » à partir de l’intérieur de la classe Rectangle
longueur=longueur+lg; }
void augmenterRect () {
// accès à la méthode « allonger Rect(int lg) » à partir de l’intérieur de la classe
Rectangle
allongerRect(2); }
void affiche() {System.out.println("longueur= "+longueur+ " ; largeur =" +
largeur); }
int getLongueur () {return (longueur);}
int getLargeur () {return (largeur);}
}Mouna Torjmen Khemakhem

Exemple
class TestRectangle {
Rectangle r1 ;
r1 = new Rectangle() ; // initialiser par défaut : longueur=?, largeur=?
// invocation de la méthode « affiche » à partir d’une autre classe
r1.affiche(); // Affiche longueur=?; largeur=?
// accès aux attributs, de la classe Rectangle, à partir d’une autre classe
47
// accès aux attributs, de la classe Rectangle, à partir d’une autre classe
r1.longueur = 20; r1. largeur = 10;
// invocation des méthodes, de la classe Rectangle, à partir de l’extérieure
int larg = r1.getLargeur();
System.out.println(" largeur="+larg); // Affiche largeur =?
System.out.println(" longueur="+r1.getLongueur ()); // Affiche longueur = ?
r1.augmenterRect();
r1.affiche(); //Affiche longueur=? ; largeur=?
}
}

Exemple
class Rectangle {
static int compte= 0 ;
int id, longueur, largeur ;
Rectangle () {
compte=compte+1 ; id= compte; longueur=20 ; largeur=10 ;}
}
public class TestRectangle {
public static void main(String[] args) {
48
public static void main(String[] args) {
Rectangle r1, r2 ;
r1 = new Rectangle();
r2 = new Rectangle();
System.out.println ("compte avec nom de la classe= "+Rectangle.compte); // Affiche compte =?
System.out.println ("compte avec instance r1= "+ r1.compte); // Affiche compte = ?
System.out.println ("compte avec instance r2= "+ r2.compte); // Affiche compte = ?
System.out.println ("id="+r1.id); // Affiche id = ?
System.out.println ("id="+r2.id); // Affiche id = ?
}
}

Exemple
class MathTool {
final static double PI=3.14 ;
static double getPI (){return PI ;}
static double diametre (double rayon) {return(2*PI*rayon);}
static double power (double x){return(x*x) ;}
}
class TestTest{
49
class TestTest{
public static void main(String []args){
// method1
double i = MathTool.power(6) ;
System.out.println("i=" +i); // Affiche i= ?
// method2
MathTool tool = new MathTool() ;
double i = tool.power(6) ;
System.out.println("i=" +i); // Affiche i= ?
}
}

Exemple
class Rectangle {
int longueur; int largeur; String nom;
Rectangle (){ // premier constructeur
longueur = 20; // peut s’écrire : this. longueur = 20
largeur = 10; // peut s’écrire : this. largeur = 10
}
Rectangle (String nom){ // second constructeur
this.nom =nom+nom; }
Rectangle (int longueur, int largeur, String nom){ // troisième constructeur
50
Rectangle (int longueur, int largeur, String nom){ // troisième constructeur
this (nom); // appel du second constructeur
this.longueur = longueur; this.largeur = largeur; }
void affiche () {
System.out.println("longueur= "+longueur+" ; largeur= "+largeur+" ; nom= "+nom);
} }
class TestRectangle {
Rectangle r1 = new Rectangle (5, 3, "REC"); // appel du troisième constructeur
r1.affiche(); // affiche longueur = ?; largeur = ? ; nom = ?
}
}

Employe
class Employe{
public Compte compte;
public void setCompte(Compte compte) {
this.compte=compte;
}
public Compte getCompte() {
return compte;
}
Les associations
Compte
1
1
Mapping
}
}
class Compte{
public Employe employe;
public void setEmploye(Employe employe) {
this.employe=employe;
}
public Employe getEmploye() {
return empl;oye
}
} 51

Les associations
Employe
*
Mapping
class Employe{
public Societe societe
public void setSociete(Societe
societe) {
this.societe=societe;
}
public Compte getSociete() {
return societe;
Societe
*
1
Mapping
return societe;
}
}
class Societe{
public Employe[] employes;
public void setEmployes(Employe[]
employes) {
}
public Employe[] getEmployes() {
return empl;oyes
}
} 52

Les associations
Employe
*
Mapping
class Employe{
public Projet[] projets;
public void setProjets(Projet[]
projets) {
this.projets=projets;
}
public Projet[] getProjets() {
return projets;
projet
*
*
Mapping
return projets;
}
}
class Projets{
public Employe[] employes;
public void setEmployes(Employe[]
employes) {
}
public Employe[] getEmployes() {
return empl;oyes
}
} 53

POO Java Chapitre 1 Classe & Objet

Contenu connexe

Tendances

Similaire à POO Java Chapitre 1 Classe & Objet

Plus de Mouna Torjmen

Dernier

POO Java Chapitre 1 Classe & Objet