Amine Ramadane

POO JAVA
RAPPORT DE
SYNTHESE
LPABD 2022/2023
Table des matières
1) Classes ................................................................................................................................... 2

1.1. Déclaration d’une classe Java ............................................................................................ 2

1.2. Attributs ............................................................................................................................. 2

1.3. Méthodes........................................................................................................................... 3

1.4. Conventions de nommage ................................................................................................. 4

2) Création et manipulation d'Objets ........................................................................................ 4

3) Les constructeurs................................................................................................................... 6

3.1. Définition ........................................................................................................................... 6

3.2. Constructeur par défaut : .................................................................................................. 7

3.3. Constructeur par recopie................................................................................................... 8

3.4. Règles des constructeurs ................................................................................................... 8

3.5. Initialisation des attributs .................................................................................................. 8

3.6. Surcharge des constructeurs (Plusieurs constructeurs) .................................................... 9

3.7. Utilisation du mot clé this dans un constructeur .............................................................. 9

4) Tableaux................................................................................................................................. 9

4.1. Déclaration et création des tableaux................................................................................. 9

4.2. Accès aux éléments d’un tableau : .................................................................................. 10

5) L'héritage ............................................................................................................................. 11

6) Polymorphism ...................................................................................................................... 12

7) L’abstraction ........................................................................................................................ 13

7.1. Exemple d’abstraction en Java ........................................................................................ 13

7.2. Les avantages de l’abstraction: ....................................................................................... 16

7.3. Conclusion ....................................................................................................................... 16

8) Interface .............................................................................................................................. 16

8.1. Différence entre une interface et une classe: ................................................................. 17

8.2. Interfaces multiples ......................................................................................................... 18

 1) Classes

Une classe est un type structuré de données. Elle de modéliser et décrire un ensemble des objets qui
ont des propriétés et des comportements communs. Un programme Java utilise certaines classes prédéfinies
dans la bibliothèque Java. Ces classes sont rassemblées par catégorie (packages), ces derniers doivent être
spécifiés avant leur utilisation par l’instruction import sauf pour le package java.lang qui est utilisé par défaut
et il contient les définitions des classes les plus usuelles.

1.1. Déclaration d’une classe Java

Pour déclarer une classe (un nouveau type d’objets) on utilise le mot clé class suivi du nom de la
classe. La syntaxe pour créer une classe de nom ''NomClasse'' est la suivante :

class NomClasse { // NomClasse est le nom de la classe à créer

/*

Le corps de la classe comprend :

- la définition des attributs (données membres)

- la définition des méthodes et des constructeurs.

*/

1.2. Attributs
La classe contient des attributs appelés aussi champs ou données membres, définissent l’état interne
d’un objet. Ilsqui peuvent être soient des variables (ou des constantes) de type primitifs (booléen, caractère,
entier, réel). Ces variable ne sont pas obligatoirement initialisées auquel cas elle prennent la valeur false pour
les booléen et 0 pour les autres types. Soient des références vers d'autres objets (une référence n'est pas un
objet mais elle permet de manipuler l'objet référencé). L’objet référencé est mémorisé dans une zone de
mémoire spéciale appelée TAS gérée par la machine Java. De plus, la référence n’est pas initialisée (sauf
initialisation explicite) et prend la valeur null (pour un attribut) et ne référence aucun objet. Ces attributs
correspondent aux propriétés de l'objet et doivent être déclarés avant d’être utilisés..

Syntaxe :

modificateur type nomAttribut

 ▪ modificateur : un spécificateur d’accès.
▪ nomAttribut : le nom de l’attribut (le nom de la variable).
▪ type : le type de l’attribut. Il est de type primitif (char, byte, short, int, long, float,
double, boolean) ou un nom d’une classe.

Exemple :

class NomClasse {

private double x ; // nom de l’attribut : x, le type : double ; le modificateur : private

public NomClasse A ; // nom de l’attribut : A, le type : NomClasse ; le modificateur : public

1.3. Méthodes
La classe contient aussi des méthodes appelées aussi fonctions membres ou comportement
définissent l’ensemble d’opérations applicables à l’objet (les objets sont manipulés avec les appels de ces
méthodes). Une méthode est soit : Une fonction ou une procédure : Une fonction est un sous-programme
retournant une valeur, une procédure n'en retourne pas. Fonctions et procédures peuvent avoir des
paramètres composés de données de type primitif et/ou de références d'objets. Lors de la définition, ces
paramètres sont appelés paramètres formels. Soit un constructeur avec ou sans paramètres : Un
constructeur est une méthode spéciale portant le nom de la classe et ayant pour but d'initialiser (on dit
construire) l'objet. Le constructeur est appelé lors de l'instanciation de l'objet. Le constructeur utilisé est
déterminé par le nombre et les types de ces paramètres précisés lors de l'instanciation de l'objet. Si une
classe ne définit aucun constructeur, un constructeur par défaut (constructeur sans paramètre) est
automatiquement défini. Dans le cas contraire, le constructeur par défaut n’est pas défini (sauf définition
explicite).

Syntaxe :

modificateur typeRetour nomMethode ( listeParamètres ) {

// corps de la méthode : les instructions décrivant la méthode

modificateur : un spécificateur d’accès.

nomMethode : le nom de la méthode

 listeParamètres : la liste (éventuellement vide) des paramètres (arguments). On spécifie les types et
les noms des informations qu’on souhaite passer à la méthode lors de son appel.

typeRetour : c’est le type de la valeur qui sera retournée par la méthode après son appel. Si la
méthode ne fournit aucun résultat, alors typeRetour est remplacé par le mot clé void. Dans le cas où
la méthode retourne une valeur, la valeur retournée par la fonction doit être spécifiée dans le corps
de la méthode par l’instruction de retour:

return expression;

ou

return; // possible uniquement pour une fonction de type void

1.4. Conventions de nommage

Une classe commence toujours par une majuscule. Si la classe est un mot composé, la première
Lettre du mot composé est en majuscules. Exemple Moteur, MoteurAvion
Un attribut commence toujours par une minuscule. Si l'attribut est un mot composé, la première
Lettre du mot composé est en majuscules. Exemple : tableau, unTableau. Une constante est
Toujours en majuscules.
Une méthode commence toujours par une minuscule. Si la méthode est un mot composé, la
Première lettre du mot composé est en majuscules.

2) Création et manipulation d'Objets

Syntaxe de déclaration:

NomClasse idObjet1, idObjet2, … ;

NomDeClasse : désigne le nom de la class.

idObjet1, idObjet2, … : désignent les noms des variables de type '' NomClasse '' qui sont des variables
pour référencer un objet de type cette classe. Aucun objet n’est créé, ils sont seulement déclarés,
ils vallent ''null'' et ne peuvent être utilisés. Après la déclaration d’un objet, il faut réserver un
emplacement mémoire pour stocker l’état interne de l’objet correspondant. La création doit être
demandée explicitement dans le programme en faisant appel à l’opérateur « new » qui permet
de réserver de la place mémoire pour stocker l’objet et initialiser les attributs.

Syntaxe :

nomClasse idObjet;

idObjet = new nomClasse();

Les deux expressions peuvent être remplacées par : NomClasse idObjet = new NomClasse();
 Exemple:

public class Rectangle{

int longueur;
int largeur;
int x;
int y;
public static void main (String args[]) {
Rectangle rectangle1; /* déclare une référence sur l’objet rectangleR1 */
rectangle1 = new Rectangle(); /* création de l’objet rectangleR1 */
// rectangle R1 est une instance de la classe Rectangle
/**
* Les deux expressions peuvent être remplacées par :
* Rectangle rectangleR1 = new Rectangle();
*/
}
}

Initialisation par défaut :

La création d’un objet entraîne toujours une initialisation par défaut de tous les attributs de l’objet.
Cette garanti d’initialisation par défaut ne s’applique pas aux variables locales (variables déclarée dans un
bloc: par exemple les variables locales d’une méthode).

Accès aux attributs :

Une fois l’objet est créé, on peut accéder à ses attributs (données membres) en indiquant le nom de
l’objet suivi par un point, suivi par le nom de l’attribut comme suit :

nomObjet.nomAttibut

nomObjet : nom de la référence à l’objet (nom de l’objet)

nomAttribut : nom de la donnée membre (nom de l’attribut).

Accès aux méthodes: appels des méthodes

- 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 indiquant le nom de l’objet suivi d’un point, suivi
du nom de la méthode et de sa liste d’arguments:
 nomObjet.nomMethode(listeArguments).

- nomObjet : nom de l’objet

- nomMethode : nom de la méthode.

- listeArguments : liste des arguments

class Classe1 {
double x;
boolean b;
void init(double x1, boolean b1){
x = x1;
b = b1;
}
}
class Classe1App {
public static void main (String args[]) {
// crée un objet de référence obj (crée un objet : obj)
Classe1 obj = new Classe1();

obj.b = true; // affecte true à l’attribut b de l’objet obj.

obj.x = 2.3; // affecte le réel 2.3 à l’attribut x de l’objet obj.
obj. init(0,false); // affecte 0 à l'attribut x et false à l'attribut y de l’objet obj
}
}

3) Les constructeurs

3.1. Définition
Le constructeur est une méthode particulière qui permet de créer (instancier) les objets. Il porte le
même nom que la classe et n’a pas de type retour. Il peut contenir des instructions à exécuter pendant la
création des objets, en particulier, il contient des instructions pour l’initialisation des attributs. Par
conséquent la création de l’objet et son initialisation peuvent être unifiées. Quand une classe possède un
constructeur, Java l’appel automatiquement à toute création d’objet avant qu’il ne puisse être utilisé. Chaque
classe peut avoir un ou plusieurs constructeurs qui servent à créer les instances et initialiser leurs états. Pour
créer une instance d’une classe, on utilise l’opérateur new avec l’un des constructeurs de la classe.

Exemple :

public class Point {

 private int x; // abscisse: variable d’instance
private int y; // ordonnée: variable d’instance

public Point(int x, int y) { // Constructeur qui remplace la méthode initialise()

/*
* x désigne la valeur passé en argument alors que this.x désigne l’attribut x
*/
this.x = x;
/*
* y désigne la valeur passé en argument alors que this.y désigne l’attribut y
*/
this.y = y;
}

public void affiche() {

System.out.println(" abscisse : " + x + " ordonnée : " + y);
}
}

public class PointApp {

public static void main(String args[]) {
Point pA = new Point(1, 1); // création et initialisation de l’objet pA
pA.affiche();
Point pB = new Point(2, 3); // création et initialisation de l’objet pB
pB.affiche();
}
}

L’instruction Point pA=new Point(1,1); appelle le constructeur Point() définie dans la classe Point
pour créer l’objet pA. L’exécution du code du constructeur Point() permet d’initialiser les attributs de l’objet
pA.

3.2. Constructeur par défaut :

Si la classe ne déclare pas explicitement un constructeur, alors un constructeur par défaut sera
automatiquement ajouté par le compilateur Java. Ce constructeurs sert à :

• Allouer l’espace mémoire nécessaire pour stocker les données de l’objet

• Crée une référence sur cet espace mémoire
• Initialise les attributs par défaut (voir initialisation par défaut) :
 Cependant Le constructeur par défaut ne peut être utilisé pour l’instanciation des objets que lorsque
la classe ne possède pas explicitement un constructeur.

3.3. Constructeur par recopie

Le constructeur d’une classe peut posséder un unique paramètre qui est une référence à un objet de
la classe appelé constructeur par recopie. Ce cas est très utilisé car bien souvent, dans un programme, on
veut dupliquer un objet (afin, par exemple, de travailler sur sa copie et de garder une sauvegarde). Le
constructeur par recopie peut être déclaré de la manière suivante :

public NomClasse(NomClasse);

Pour dupliquer l’objet a dans un objet b, le programmeur écrira simplement :

NomClasse objest1 = new NomClasse(objet2);

3.4. Règles des constructeurs

Un constructeur :

• porte le même nom que la classe.

• ne doit figurer devant son nom aucun type de retour, même void.
• peut disposer d’un nombre quelconque d’arguments (éventuellement aucun).
• il doit être appelé à chaque création, lorsque la classe au moins comporte un constructeur.
• il ne peut pas être appelé de la même manière que les autres méthodes. Par exemple :
a.Point (2,3) n'est pas valide car Point() est un constructeur et non pas une méthode
classique.
• Lorsque la classe ne comporte pas de constructeur, un constructeur par défaut sera
automatiquement ajouté par Java pour créer les objets.
• Si un constructeur est déclaré private, dans ce cas il ne pourra pas être utilisé, à l’extérieur
de la classe, pour instancier les objets.

3.5. Initialisation des attributs

On distingue 3 types d’initialisation des attributs :

1) Initialisation par défaut : les champs d’un objet sont toujours initialisés par défaut. Boolean
(False) ; char (caractère de code nul) ; int, byte, short, int long (0) ; float, double (0.f ou 0.)
et class (Null)
2) Initialisation explicite des champs d’un objet : Un attribut peut être initialisé explicitement
pendant sa déclaration. Par exemple :

public class Point {

 private int x = 7;
private int y;
}

3) Initialisation par le constructeur

On peut aussi initialiser les attributs lors de l’exécution des instructions du corps du constructeur.

Exemple du constructeur Point(int,int): Point pA=new Point(8,12); . D’une manière générale, la

création d’un objet entraîne toujours, par ordre chronologique, les opérations suivantes :

• l’initialisation par défaut de tous les champs de l’objet.

• l’initialisation explicite lors de la déclaration du champ.
• l’exécution des instructions du corps du constructeur

3.6. Surcharge des constructeurs (Plusieurs constructeurs)

Une classe peut avoir plusieurs constructeurs. Comme le nom du constructeur est identique au nom
de la classe, il s’agit de la surcharge donc même nom (celui de la classe) mais types et/ou nombre de
paramètres différents.

3.7. Utilisation du mot clé this dans un constructeur

Il est possible d’appeler, au sein d’un constructeur, un autre constructeur de la même classe en
utilisant l’instruction this (arguments) ; où arguments désigne les arguments du constructeur appelé. Cette
instruction doit être la première instruction.

4) Tableaux

4.1. Déclaration et création des tableaux

Les tableaux sont considérés comme des objets. Ils sont manipulés par des références : les variables
de type tableau contiennent des références aux tableaux. Ils sont créés par l’opérateur new: allocation
dynamique par new. Les éléments du tableau peuvent être d’un type primitif ou d’un type objet. La création
des tableaux s’effectue en deux étapes : 1. Déclaration : cette étape détermine seulement le type des
éléments du tableau. 2. Création et dimensionnement : on détermine la taille du tableau (c’est-à-dire le
nombre d’éléments) pendant la création (instanciation) et non pendant les déclaration.

Déclaration :

La déclaration d’une référence à un tableau précise le type des éléments du tableau. Elle s’effectue
par l’une des syntaxes suivantes :

type[] id ; ou type id[] ;

 Cette dernière forme permet de mélanger des tableaux et des variables de même de type.

type : précise le type des éléments du tableau.

id : est une référence à un tableau.

int [] a, tab1, b; // a, tabNotes et b sont tous des références à des tableaux de type int.

double a, tab1[ ], b; // mélange de tableaux et de variables de même de type.

En java la taille des tableaux n’est pas fixée à la déclaration. Elle est fixée quand l’objet tableau sera
effectivement créé snon cela provoque une erreur à la compilation

Création :

La création des tableaux s’effectue avec l’opérateur new en précisant sa taille.

int [] tab; // déclaration que « tab » est une référence à un tableau d’entiers

/**
* création effective de l’objet tableau et fixation de sa taille Dans cet
* exemple on a créé un tableau de 5 éléments de type int.
*/
tab = new int[5];

Déclaration et création :

int [] tab = new int[5];

La création d’un tableau par l’opérateur new:

• Alloue la mémoire en fonction du type et de la taille.

• Initialise, par défaut, chaque élément du tableau à 0 ou à false ou à null, suivant le type de base du
tableau.

4.2. Accès aux éléments d’un tableau :

Soit tab un tableau. On accède à l’élément d’indice i, pour 0 à i (tab.length – 1), du tableau tab en
écrivant tab[i].

int tab[] = new int[8]; // crée un tableau, nommé tab, de type int et de taille 8
int e1=tab[4] ; // accès au 5éme élément du tableau tab (élément d’indice 4)
/**
 * tentative d’accès hors bornes, en effet les indices du tableau sont compris entre 0
* et 7. L’exécution produit le message ArrayIndexOutOfBoundsException
*/
int e2 = tab[8];

5) L'héritage

L’héritage est un concept important de la programmation orientée objet (POO). C’est le mécanisme
en java par lequel une classe est autorisée à hériter des fonctionnalités (champs et méthodes) d’une autre
classe.

Terminologie importante :

• Sous-classe (classe fille) – la classe qui hérite d’une autre classe

• Superclasse (classe mère) – la classe héritée

Pour hériter d’une autre classe, utilisez le mot clé extend.

Exemple :

Dans l’exemple ci-dessous, la classe Student(sous-classe) hérite des attributs et des méthodes de la
classe Person(superclasse):

class Person {

protected String name = "Alex";

 public void getName() {
System.out.println("My name is "+ name);

public class Student extends Person {

private String cours = "Java";

public static void main(String[] args) {

// Créer un objet st

Student st = new Student();

st.getName();

System.out.println(st.name + " " + st.cours);

Sortie:

My name is Alex
Alex Java

6) Polymorphism

Le polymorphisme est la capacité d’un objet à prendre plusieurs formes. L’utilisation la plus courante
du polymorphisme dans la POO se produit lorsqu’une référence de classe mère est utilisée pour faire
référence à un objet de classe fille.

L’héritage nous permet d’hériter des attributs et des méthodes d’une autre classe. Le
polymorphisme utilise ces méthodes pour effectuer différentes tâches. Cela nous permet d’effectuer une
seule action de différentes manières.

Par exemple, pensez à une superclasse appelée Animal qui a une méthode appelée cri(). Les sous-
classes d’animaux peuvent être des vaches, des chats, des chiens, des oiseaux, et ils ont également leur
propre implémentation d’un cri (la vache meugle et le chat miaule, etc.) :

class Animal {
public void cri() {
 System.out.println("Le cri d'animaux");
}
}

class Chat extends Animal {

public void cri() {
System.out.println("meow, meow");
}
}

class Chien extends Animal {

public void cri() {
System.out.println("ouah, ouah");
}
}

Nous pouvons maintenant créer des objets Chat et Chien et appeler la méthode cri() sur les deux:

Sortie:

Le cri d'animaux

meow, meow

ouah, ouah

7) L’abstraction

L’abstraction est l’un des concepts clés dans les langages de programmation orientée objet (POO).
Son objectif principal est de gérer la complexité en masquant les détails inutiles à l’utilisateur. Cela permet à
l’utilisateur d’implémenter une logique plus complexe sans comprendre ni même penser à toute la
complexité cachée.

7.1. Exemple d’abstraction en Java

Pour donner un exemple d’abstraction, nous allons créer une super-classe appelée « Forme » et deux
sous-classes – « Rectangle » et « Cercle ». Les deux sous-classes ont des propriétés communes à partager,
comme la couleur. Il existe une différence majeure entre le rectangle et le cercle à savoir: la surface, la
largeur, la taille et le rayon …
 Commençons par créer la superclasse Forme. Notez l’utilisation du mot clé « abstract » dans la
définition de la classe. Ceci marque la classe comme abstraite, ce qui signifie qu’elle ne peut pas être
instanciée directement. Nous définissons deux méthodes appelées surface() et toString() en tant que
méthode abstraite. De cette façon, vous laissez l’implémentation de ces méthodes aux sous-classe de la
classe Forme.

abstract class Forme {

String coleur;

// Méthodes abstraites
abstract double surface();
public abstract String toString();

// Classe abstraite peut avoir un constructeur

public Forme(String coleur) {
System.out.println("Constructeur de la classe Forme est appelé");
this.coleur = coleur;
}

// Méthode concrète
public String getColeur() {
return coleur;
}
}
 La classe « Cercle » hérite toutes les propriétés de la classe mére « Forme », mais doit fournir sa
propre implémentation pour la méthode surface() et toString(). Dans ce cas, nous multiplions la valeur de π
par le carré de son rayon, et on défini un message spécifique dans la classe Cercle avec la méthode toString().

class Cercle extends Forme

{
double rayon;

public Cercle(String coleur, double rayon) {

// appel du constructeur de la classe Forme

super(coleur);
System.out.println("Constructeur de la classe Cercle est appelé");
this.rayon = rayon;
}

@Override
double surface() {
return Math.PI * Math.pow(rayon, 2);
}

@Override
public String toString() {
return "La couleur de la cercle est " + super.coleur +
" et la surface est : " + surface();
}
}

La classe « Rectangle » a également sa propre implémentation de la méthode surface() et toString().

Dans ce cas, il suffit de multiplier longueur par largeur. Ainsi un message spécifique dans la classe Rectangle
avec la méthode toString().

class Rectangle extends Forme{

double longueur;
double largeur;

public Rectangle(String coleur, double longueur, double largeur) {

// appel du constructeur de la classe Forme
super(coleur);
System.out.println("Constructeur de la classe Rectangle est appelé");
this.longueur = longueur;
this.largeur = largeur;
}

@Override
double surface() {
return longueur * largeur;
}

@Override
public String toString() {
return "La couleur de la rectangle est " + super.coleur + " et la surface est : " + surface();
}
}
 Voici une classe de test qui contient la méthode main() pour tester tous les parties de notre
programme:

public class Test

{
public static void main(String[] args)
{
Forme f1 = new Cercle("Bleu", 3.2);
Forme f2 = new Rectangle("Rouge", 3, 6);

System.out.println(f1.toString());
System.out.println(f2.toString());
}
}

La sortie est comme suite:

Constructeur de la classe Forme est appelé

Constructeur de la classe Cercle est appelé
Constructeur de la classe Forme est appelé
Constructeur de la classe Rectangle est appelé
La couleur de la cercle est Bleu et la surface est : 32.169908772759484
La couleur de la rectangle est Rouge et la surface est : 18.0

7.2. Les avantages de l’abstraction:

• Réduire la complexité.
• Évite la duplication de code et augmente la possibilité de réutilisation.
• Aide à renforcer la sécurité d’une application ou d’un programme car seuls les détails importants
sont fournis à l’utilisateur.

7.3. Conclusion
L’abstraction est un concept général que vous pouvez trouver dans le monde réel ainsi que dans les
langages POO. Tous les objets du monde réel, comme votre voiture, ou votre maison, masquant les détails
internes fournissent une abstraction.

Ces abstractions facilitent beaucoup la gestion de la complexité en les divisant en petites parties.
Dans le meilleur des cas, vous pouvez les utiliser sans comprendre comment ils fournissent les
fonctionnalités. Et cela vous aide à diviser la complexité de votre logiciel en parties contrôlable.

8) Interface

Comme une classe, une interface peut avoir des méthodes et des variables, mais les méthodes
déclarées dans une interface sont par défaut abstraites (uniquement la signature de méthode, pas de corps).
 8.1. Différence entre une interface et une classe:
• Une interface peut contenir un nombre illimité de méthodes.
• Vous ne pouvez pas instancier une interface.
• Une interface ne contient aucun constructeur.
• Toutes les méthodes d’une interface sont abstraites.
• Une interface ne peut pas contenir des champs. Les seuls champs pouvant apparaître dans une
interface doivent être déclarés à la fois static et final.
• Une interface n’est pas héritée par une classe, elle est implémentée par une classe.
• Une interface peut étendre plusieurs interfaces.

Exemple :

interface MyInterface {
public void a(); // méthode d'interface (n'a pas de corps)
public void b();
public void c();
}

Pour accéder aux méthodes dans l’interface, l’interface doit être implémentée par une autre classe
avec le mot-clé « implements ». Le corps de la méthode dans l’interface est fourni par la classe qui
implémente cette interface :

class MaClasse implements MyInterface {

public void a() {
// Le corps de la méthode est fourni ici
System.out.println("La méthode a.");
}
public void b() {
System.out.println("La méthode b.");
}
public void c() {
System.out.println("La méthode c.");
}
}

class ClassMain {
public static void main(String[] args) {
MaClasse obj = new MaClasse();
obj.a();
obj.b();
obj.c();
}
}

Sortie:

La méthode a.
La méthode b.
La méthode c.
 8.2. Interfaces multiples
Pour implémenter plusieurs interfaces, séparez-les par une virgule :

interface Interface1 {
public void methode1();
}

interface Interface2 {
public void methode2();
}

class MaClasse implements Interface1, Interface2 {

public void methode1() {
System.out.println("La méthode 1.");
}

public void methode2() {

System.out.println("La méthode 2.");
}
}

class ClassMain {
public static void main(String[] args) {
MaClasse obj = new MaClasse();
obj.methode1();
obj.methode2();
}
}