COURS 2

L. KADDOURI
NIT
2024
Manipulation des notions de
Classes et d’Objets avec
JAVA

L. KADDOURI
NIT
2024
 Définition d’une classe
class <NomClasse> { // le NomClasse commence par une Majuscule !
// liste des Attributs (variables d’instances)
<type> <nomAttribut> ; classe : <NomClasse>
...
// Les Attributs :
<type> <nomAttribut> ;
- attribut_1
// liste des Methodes (fonctions membres) - …
<type> <nomMethode> (<liste_Parametres>) { - attribut_n
<corps de la méthodes> ; } // Les Méthodes :
…….. - methode_1 ( )
<type> <nomMethode> (<liste_Parametres>) { - …
<corps de la méthodes> ; } - methode_1 ( )
}
 Définition d’un Attribut
<type> <nomAttribut> ;

1. primitif : Variable d’instance

byte, short, int, long, float, double, (commence tjs par une minuscule)
boolean et char Remarque :
L’attribut peut avoir une valeur
2. « type objet » : initiale :
- Classe de la Bibliothèque <type> <nomAttribut> = <valeur> ;
(Ex. String, JFrame, …)
- Classe définie dans l’application
 Définition d’une Méthode (Fonction)
<type> <NomMethode> (<liste_Parametres>) { <corps de la méthodes> }

Le nom de la méthode :
1. primitif : (commence tjs par une
byte, short, int, long, minuscule) -Déclarations de variables
float, double, boolean -Affectations
et char -Structures de contrôle
2. « type objet » : (Condition , Boucle, …)
Liste des paramètres :
le nom d’une Classe -Instanciations (créations)
<type> <param> ,
3. Le type : void d’objets
…
Dans le cas ou la -Ecriture/Lecture
<type> <param> ,
méthode ne retourne -…
pas de valeur
 Création d’une instance d’une classe (instanciation)

<NomClasse> <nomObjet> = new <constructeurClasse> (…) ;

L’appel du constructeur
de la Classe. Il a le même
Nom de la Classe Nom de l’objet
qu’on souhaite créé. Mot Clé utilisé nom que la classe
instancier C’est une pour la création 2 sortes :
- Constructeur par
référence vers
défaut SANS
l’objet en
Paramètres
mémoire
- Constructeur
paramétrique
 Accès aux attributs et Appels de méthodes d’un objet

<nomObjet>.<nomAttribut> ;

Nom de l’objet créé. Nom de l’Attribut de

(référence de l’objet) Séparés par un l’objet
POINT « . »

<nomObjet>.<nomMethode>(<listeParametresAppel>) ;

Nom de la méthode
Nom de l’objet créé. Séparés par un de l’objet avec les
(référence de l’objet) POINT « . » paramètres d’appel
éventuellement
 Exemple 1 : Définition de la classe « Chien »
class Chien { classe : Chien
// les Attributs
Propriétés
String race ;
- race
double taille ;
- taille
int age ;
- âge
String couleur ;
- couleur
// les Methodes
void manger ( ) { System.out.println ("Je mange …") ; } Comportements :
- manger ( )
void courir ( ) { System.out.println ("Je cours …") ; } - courir ( )
void dormir ( ) { System.out.println ("Je dors …") ; } - dormir ( )
- aboyer ( )
void aboyer ( ) { System.out.println ("J’aboie …") ; }
}
 REMARQUE

o la classe Chien précédente ne contient pas de méthode main.

o ce n’est pas une application.
o c’est juste une classe permettant de créer des objets qui seront
utilisés dans une application.
Exemple 1 : Test de la classe « Chien » (Méthode « main »)

class TestChien {
public static void main (String [ ] args) { L’argument de la
méthode « main » :
// Creation des objets de la classe “Chien” args
……………………… C’est un tableau de
// Accès aux attributs des objets créés type String
……………………..
// Appels aux méthodes des objets créés La méthode « main »
…………………….. -public
-static
} -void
}
Exemple 1 : Test de la classe « Chien » (Méthode « main »)
class TestChien {
public static void main (String [ ] args) { Référencé a l’objet créé
// Creation de l’objet “chien1”
Chien chien1 = new Chien ( ) ; L’appel au Constructeur par défaut
// Accès aux attributs de l’objet “chien1”
chien1.race = "Caniche" ; // Modification de l’attribut race de “chien1”
chien1.taille = 35.5 ; // Modification de l’attribut taille de “chien1”
chien1.age = 4 ; // Modification de l’attribut age de “chien1”
chien1.couleur = "Blanche" ; // Modification de l’attribut couleur de “chien1”
// Appels aux methodes de l’objet “chien1”
chien1.manger ( ) ; // Appel de la méthode manger de “chien1”
chien1.courir ( ) ; // Appel de la méthode courir de “chien1”
chien1.dormir ( ) ; // Appel de la méthode dormir de “chien1”
chien1.aboyer ( ) ; // Appel de la méthode aboyer de “chien1”
Exemple 1 : Mon Application pour manipuler des Chiens
APPLICATION : 2 Classes
classe : Chien classe : TestChien
Attributs : Attributs :
- race Méthode (static) :
- taille - main (String [ ] args)
- âge // Creation des objets de la
- couleur classe “Chien”
………………………
Méthodes : // Accès aux attributs des
- manger ( ) objets créés
- courir ( ) ……………………..
- dormir ( ) // Appels aux méthodes des
- aboyer ( ) objets créés
……………………..
Exemple 1 : Résultats du l’exécution de la classe TestChien
CONSOLE
Je mange …
Je cours …
Je dors …
J’aboie …

- race : Caniche
L’objet - taille : 35.5 (cm)
« chien1 » - âge : 4 (ans)
- couleur : Blache
(référence)
 Accès aux attributs et Appels de méthodes de l’objet a
l’intérieur de la classe de l’objet lui-même (this)
this.<nomAttribut> ;
this.<nomMethode>(<listeParametresAppel>) ;
class Personne {
Accès a l’attribut « age » de
String nom ; // Deux Attributs : nom et age
l’objet lui-même
int age ;
void incrementerAge ( ) // Méthode « incrementerAge ()»
{ this.age = this.age + 1 ; Appel de la méthode «
this.grandir( ) ; } grandir() » de l’objet
… lui-même
void grandir ( ) // Méthode « grandir () »
{ System.out.println ("J’ai grandi d’une année .…") ; }
}
 Accès aux attributs et Appels de méthodes de l’objet a
l’intérieur de la classe de l’objet lui-même (this)
L’utilisation de “this” n’est pas obligatoire !
Bonnes pratiques (Best Practices)
class Personne {
String nom ; // Deux Attributs : nom et age
int age ;
void incrementerAge ( ) // Méthode « incrementerAge ()»
{ age = age + 1 ;
grandir( ) ; }
…
void grandir ( ) // Méthode « grandir () »
{ System.out.println ("J’ai grandi d’une année .…") ; }
}
 Exemple 2 : Définition de la classe « Employe »
class Employe {
// les Attributs Dans certains cas, l’utilisation de “this” est
String nom ; nécessaire !
double salaire;
// les Méthodes (les accesseurs : Getters et les mutateurs : Setters)
String getNom ( ) { return this.nom ; } L’attribut et le
paramètre de la
void setNom (String nom) { this.nom=nom ; } méthode sont
identique. Pour faire la
double getSalaire ( ) { return this.salaire ; } différence, l’attribut est
précédé par « this. » :
void setSalaire (double salaire) { this.salaire=salaire ; }
}
 Exemple 2 : Test de la classe « Employe » (« main »)
class TestEmploye {
public static void main (String [ ] args) {
Employe employe = new Employe ( ) ; // Creation de l’objet “employe”

// Accès aux attributs nom et salaire et Modification de leurs valeurs

employe.setNom ("Mohamed ALI") ;
employe.setSalaire (5000) ;

// Acces aux attributs nom et salaire et affichage de leurs valeurs

System.out.println ("MON NOM : " + employe.getNom() );
System.out.println ("MON SALAIRE : " + employe.getSalaire() + " $ ");
}
}
 Exemple 2 : Résultats du l’exécution de la classe
TestEmploye
CONSOLE
MON NOM : Mohamed ALI
MON SALAIRE : 5000 $

-nom : Mohamed ALI

-salaire : 5000

L’objet
« employe »
(référence)
 Exemple 3 : Définition de la classe « Bicycle »
class Bicycle {
// Attribut avec valeurs initales
int cadence = 0;
int vitesse = 0;
int pignon = 1;
void changerCadence ( int nouvelleCadence ) { cadence = nouvelleCadence ; }
void changerPignon ( int nouveauPignon ) { pignon = nouveauPignon ; }
void augmenterVitesse ( int increment ) { vitesse = vitesse + increment ; }
void appliquerFrein ( int decrement ) { vitesse = vitesse - decrement ; }
void imprimerEtat ( ) { System.out.println
( " Cadence : « + cadence + " Vitesse : " + vitesse + " Pignon : " + pignon ) ;
}
 Exemple 3 : Test de la classe « Bicycle » (« main »)
class TestBicycle {
public static void main (String [ ] args) {
Bicycle bike1 = new Bicycle ( ) ; // Creation de l’objet bicycle : bike1
Bicycle bike2 = new Bicycle ( ) ; // Creation de l’objet bicycle : bike2
bike1 . changerCadence (50) ; // Appel des méthodes de ces objets
bike1 . augmenterVitesse (10) ; bike1 bike2
bike1 . changerPignon (2) ; - cadence : 0 - cadence : 0
- vitesse : 0 - vitesse : 0
bike1 . imprimerEtat ( ) ; - pignon : 1 - pignon : 1
bike2 . changeCadence (40) ;
bike2 . augmenterVitesse (25) ;
bike2 . changerPignon (3) ; - cadence : 50 - cadence : 40
- vitesse : 10 - vitesse : 15
bike2 . appliquerFrein (10) ; - pignon : 2 - pignon : 3
bike2 . imprimerEtat ( ) ;
}
}
 Exemple 3 : Résultats du l’exécution de la classe
TestBicycle
CONSOLE
Cadence : 50 Vitesse : 10 Pignon : 2
Cadence : 40 Vitesse : 15 Pignon : 3

L’objet L’objet
bike1 bike2
« bike1 » « bike2 »
- cadence : 50 - cadence : 40
(référence) - vitesse : 10 - vitesse : 15
(référence)
- pignon : 2 - pignon : 3
 Exemple 4 : Définition de 2 classe « Voiture » et « Moto »
class Voiture { class Moto {
// Attributs // Attributs
String nom, marque, couleur ; String nom, marque ;
// Méthodes : Setters et Getters // Méthodes : Setters et Getters
void setNom (String nom) { … } void setNom (String nom) { … }
String getNom ( ) { return … } String getNom ( ) { return … }
void setMarque (String marque) { … } void setMarque (String marque) { … }
String getMarque ( ) { return … } String getMarque ( ) {return … }
// + trois autres Méthodes // + trois autres Méthodes
void démarrer ( ) { … } void démarrer ( ) { … }
void avancer ( ) { … } void avancer ( ) { … }
void activerAirBag ( ) { … } void mettreBequille ( ) { … }
} }
 Exemple 4 : Définition de 2 classe « Voiture » et « Moto »
class Voiture { class Moto {
// Attributs // Attributs
String nom, marque ; String nom, marque ;
// Méthodes : Setters et Getters // Méthodes : Setters et Getters
void setNom (String nom) { … } void setNom (String nom) { … }
String getNom ( ) { return … } String getNom ( ) { return … }
void setMarque (String marque) { … } void setMarque (String marque) { … }
String getMarque ( ) { return … } String getMarque ( ) { return … }
// + trois autres Méthodes // + trois autres Méthodes
void démarrer ( ) { … } void démarrer ( ) { … }
void avancer ( ) { … } void avancer ( ) { … }
void activerAirBag ( ) { … } void mettreBequille ( ) { … }
} }
 Exemple 4 : Héritage « Factorisation »
classe : Véhicule
classe : Propriétés
Véhicule - nom
- marque
Hérite de Hérite de
Comportements :
- getters( )
classe : classe : - setters ( )
Voiture Moto - démarrer ( )
- avancer ( )
- Tout objet de la classe Voiture hérite les attributs (nom et marque) ainsi que les
méthodes (getters/setters , démarrer() et avancer()) de sa superclasse Véhicule.

- tout objet de la classe Moto hérite les attributs (nom et marque) ainsi que les
méthodes (getters/setters , démarrer() et avancer()) de sa superclasse Véhicule.
 Exemple 4 : « Voiture » et « Moto » Héritent de Véhicule
class Véhicule { class Voiture extends Véhicule {
// Attributs // Attributs propres à Voiture
String nom, marque ; String couleur ; …
// Méthodes propres à Voiture
// Méthodes : Setters et Getters
void setCouleur (String couleur) { … }
void setNom (String nom) { … }
String getCouleur { return …}
String getNom ( ) { return … }
void activerAirBag ( ) { … }
void setMarque (String marque) { … }
}
String getMarque ( ) { return … }
class Moto extends Véhicule {
// + deux autres Méthodes // Attributs propres à Moto
………
void démarrer ( ) { … }
// Méthodes propres à Moto
void avancer ( ) { … }
void mettreBequille ( ) { … }
}
}
 Exemple 4 : Test des Classes « Voiture », … : (« main »)
class TestVoiture {
public static void main (String [ ] args) {
Voiture maVoiture = new Voiture ( ) ; // Création de l’objet maVoiture
// Appel des méthodes héritées de la superclasse : Véhicule
maVoiture.setNom = " 407 " ;
maVoiture.setMarque = " Peugeot " ; Attributs maVoiture
hérités
maVoiture.demarrer ( ) ;
maVoiture.avancer ( ) ; - nom : 407
Méthodes - marque : Peugeot
// Appel de sa propre méthode héritées - couleur : Grise
maVoiture.setCouleur = " Grise " ;
maVoiture.activerAirBag ( ) ;
}}