Expose groupe 2..

Java et la programmation Orientée Objet
1
SOMMAIRE...........................................................................................................................................................1
DEDICACE...........................................................................................................................................................................3
REMERCIEMENTS...............................................................................................................................................................4
..........................................................................................................................................................................................5
LISTE DES TABLEAUX ET FIGURES .......................................................................................................................................5
INTRODUCTION..................................................................................................................................................................6
PARTIE A : THEORIE............................................................................................................................................................7
I. Introduction au langage JAVA.....................................................................................................................................7
1. Compilation............................................................................................................................................................7
2. Interprétation.........................................................................................................................................................8
II. Programmation orientée objet ...................................................................................................................................9
1. Initiation à la programmation orientée objet ..........................................................................................................9
1.1) Notion de classe..............................................................................................................................................9
a) Définition........................................................................................................................................................9
b) Les membres de la classe..............................................................................................................................11
c) Déclaration d’une variable d’instance ...........................................................................................................12
1.2) Notion d’objet...............................................................................................................................................13
a) Création des objets .......................................................................................................................................13
b) Gestion des objets ........................................................................................................................................14
1.3) Notion d’encapsulage ...................................................................................................................................14
1.4) Notion de polymorphisme ............................................................................................................................15
1.5) Notion d’héritage..........................................................................................................................................17
a) Généralités ...................................................................................................................................................17
b) Intérêt et utilisation ......................................................................................................................................17
c) Syntaxe de l’héritage.....................................................................................................................................18
1.6) Notion de méthode.......................................................................................................................................18
a) Définitions ....................................................................................................................................................18
b) Classification des méthodes..........................................................................................................................19
c) Déclaration d’une méthode ..........................................................................................................................20
1.7) Notion de référencement..............................................................................................................................23
a) Accéder aux données membres d’un objet....................................................................................................24
b) Accéder aux méthodes d’un objet.................................................................................................................24
c) Le mot clé « This » ........................................................................................................................................24
2. Présentation de la structure de base d’un programme JAVA .................................................................................25
2.1 Structure générale d’un programme JAVA.......................................................................................................25
SOMMAIRE

2
2.2) Affichage d’un message à l’écran ...................................................................................................................26
2.3) Variables.......................................................................................................................................................26
2.4) Commentaires ................................................................................................................................................29
PARTIE B : CAS PRATIQUE.................................................................................................................................................30
I. Description littérale..................................................................................................................................................30
II. Présentation du code ...............................................................................................................................................30
1. Présentation des différentes notions abordées dans notre exposé .......................................................................30
1.1) Les classes.....................................................................................................................................................30
1.2) Un objet........................................................................................................................................................31
1.3) L’encapsulation.............................................................................................................................................31
1.4) Le polymorphisme ........................................................................................................................................31
1.5) L’héritage......................................................................................................................................................32
1.6) La méthode...................................................................................................................................................32
1.7) Un référencement.........................................................................................................................................32
2. Le code proprement dit ........................................................................................................................................32
III. Execution du programme .....................................................................................................................................35
CONCLUSION ...................................................................................................................................................................36

3
A
Tous les élevés Ingénieurs de conception appartenant à la promotion 2024 de
Génie Civil et urbanisme de l’ENSPY
DEDICACE

4
Avant tout, nous remercions le créateur de l’univers, qui nous a donné l’espace, le temps et l’état qui nous a
permis d’effectuer ce travail. Par la suite, nous nous retournons vers toutes les personnes qui nous ont participé
pour l’élaboration de cet exposé. Il s’agit de :
 Nos parents qui ont su toujours se montrer présent.
 Pr. Remy Magloire ETOUA, directeur de l’école nationale supérieure polytechnique de YAOUNDE (ENSPY)
pour son bon sens de gestion tête de cette institution.
 Pr. MANJIA Marcelline chef de département du génie civil à l’école nationale supérieure polytechnique de
YAOUNDE.
 Ing. ENYEGUE Germain, enseignant et encadreur en informatique pour sa
Disponibilité dans l’apport de son expertise pour la rédaction de cet exposé.
 Nous, étudiants du groupe 5 pour l’apport et la participation de tout un chacun.
 Tous les étudiants de génie civil de la promotion 2023, ainsi que ceux qu’on a omis de citer.
REMERCIEMENTS

5
PARTIE A :
Figure1 : Interprétation du langage java (page 9)
Figure2 : Création d’objet (page 13)
Figure3 : Affichage d’un message a l’écran (page 26)
Tableau1 : Variable de type entier (page 27)
Tableau2 : Variable de type réel (page 27)
Tableau3 : Variable de type caractère (page 28)
Tableau4 : variable de type booléen (page 28)
Figure4 : Implémentation d’une variable (page 28)
Figure5 : Illustration des commentaires en java (page 29)
LISTE DES TABLEAUX ET FIGURES

6
Le langage Java est un langage généraliste de programmation synthétisant les
principaux langages existants lors de sa création en 1985 par Sun Microsystems. Il
permet une programmation orientée-objet, modulaire et reprend une syntaxe très
proche de celle du langage C. Outre son orientation objet, le langage Java a l’avantage
d’être modulaire, rigoureux et portable. Une telle observation soulève une
préoccupation essentiellement capitale, celle de la programmation orientée objet dans le
cas du langage Java qui a toujours été un outil incontournable pour le développement de
plus en plus croissant de ce langage de programmation. Ce qui nous amène à nous
questionner sur quelques points entre autres, le concept de programmation orientée
objet en Java et la structure de base d’un programme Java. Le présent document sera
subdivisé en trois parties : tout d'abord nous expliquerons le fonctionnement du langage
Java, ensuite nous nous attaquerons a la programmation orientée objet en Java
proprement dit en abordant les notions de classes, d’objets, d’encapsulation, de
polymorphisme, d’héritage, de méthode et de référencement ; et enfin nous
présenterons la structure de base d’un programme Java.
INTRODUCTION

7
PARTIE A : THEORIE
I. Introduction au langage JAVA
Java est un langage interprété, ce qui signifie qu’un programme compilé n’est pas
directement exécutable par le système d’exploitation mais il doit être interprété par un
autre programme, qu’on appelle interpréteur.
1. Compilation
Compiler en informatique désigne le procédé de traduction d'un programme écrit et
lisible par un humain, en un programme exécutable par un ordinateur. De façon plus
globale, il s'agit de la transformation d'un programme écrit en code source en un
programme transcrit en code cible ou binaire.
La compilation en java s'effectue grâce à des compilateurs Java comme par exemple :
 JAVAC: qui est un compilateur java de SUN Microsystem livrée avec le JDK (Java
Development Kit)
 ECJ (Eclipse Compiler for Java): c'est le compilateur Java intégré à l'environnement de
développement intégré Eclipse
 GCJ (Gnu Compiler For Java) inclus dans le Gnu Compiler Collection (GCC) qui génère du
code machine grâce au back-end de GCC.
Exemple de compilation avec la commande Javac
Pour ce cas La compilation s’effectue par la commande javac suivie d’un ou plusieurs nom
de fichiers contenant le code source de classes Java. Par exemple: javac MyProg.java
compile la classe MyProg dont le code source est situé dans le fichier MyProg.java. La
compilation nécessite souvent la précision de certains paramètres pour s’effectuer
correctement, notamment lorsque le code source fait référence à certaines classes situées
dans d’autres répertoires que celui du code compilé. Il faut alors ajouter l’option-classpath
suivie des répertoires (séparés par ";" sous Windows et ":" sous Unix) des classes

8
référencées. Par exemple : javac -classpath /prog/exos1;/cours MyProg.java compilera le
fichier MyProg.java si celui-ci fait référence à d’autres classes situées dans les répertoires
/prog/exos1 et /cours. Le résultat de cette compilation est un fichier nommé MyProg.class
contenant le bytecode correspondant au code source compilé. Ce fichier est créé par défaut
dans le répertoire où la compilation s’est produite. Il est cependant fortement souhaitable
de ne pas mélanger les fichiers contenant le code source et ceux contenant le bytecode. Un
répertoire de destination où sera créé le fichier MyProg.class peut être précisé par l’option-
d, par exemple: javac -d /prog/exos1 -classpath /cours MyProg.java .
2. Interprétation
Interpréter en informatique c'est analyser, traduire et exécuter les programmes écrits
dans un langage informatique. L'exécution nécessite ainsi de disposer non seulement d'un
programme, mais aussi de l'interprète correspondant.
Apres compilation du code source on obtient le byte code ou code a bytes qui est un code
intermédiaire entre les instructions machines et le code source qui n'est pas directement
exécutable. Ce dernier ne peut être exécuté qu’à l’aide de l’interpréteur. L’exécution se fait
par la commande java suivie du nom de la classe à exécuter (sans l’extension .class). Comme
lors de la compilation, il se peut que des classes d’autres répertoires soient nécessaires. Il faut
alors utiliser l’option-classpath comme dans l’exemple qui suit : java -classpath
/prog/exos1:/cours MyProg .
RECAPITULATIF GENERALE

9
Figure 1 : interprétation du langage java
II. Programmation orientée objet
1. Initiation à la programmation orientée objet
1.1) Notion de classe
a) Définition
Une classe est un modèle de définition pour des objets ayant le même ensemble
d’attributs, et le même ensemble d’opérations.
Une classe doit définir:
• Les données ou attributs associés aux objets de la classe
• Les opérations ou méthodes qui peuvent être effectuées par les objets.
En programmation orientée objet, la déclaration d'une classe regroupe des
membres, méthodes et propriétés (attributs) communs à un ensemble d'objets.

10
Les attributs représentent l'état des objets et les méthodes représentent
leur comportement.
Une classe apparaît donc comme un moule ou une usine à partir de laquelle il est
possible de créer des objets ; c'est en quelque sorte une « boîte à outils » qui
permet de fabriquer un objet. On parle alors d'un objet en tant qu'instance d'une
classe (création d'un objet ayant les propriétés de la classe).
Il existe aussi des classes abstraites signalées par le modificateur abstract ; elles
ne peuvent pas être déclarées static ou private ou final et ne peuvent pas être
instanciées. Elles sont souvent utilisées pour faire de la factorisation de code en ne
donnant qu’une implémentation partielle ou pour interdire l’instanciation d’une
classe. Une sous classe d’une classe abstraite sera aussi abstraite si elle ne définit
pas toutes les méthodes abstraites dont elle hérite. Il est nécessaire alors de créer
une classe concrète (non abstraite) qui l’étende (en fournissant un corps de
méthode) et de l’instancier.
Syntaxe de définition :
 public ou private// portée( cf notion d’encapsulation)
 abstract // classe abstraite, impossibilité à être instanciée
 final // impossibilité à être dérivé (changé dans la suite du programme)
 class ”nom de la classe”
 Public class - extends ”nom de la super-classe” /* précision de la classe
mère, spécification de la super-classe (cf. notion d’héritage)*/
 implements ”nom d’interface” //implémentation d’une interface

11
 { ”corps de la classe”}
Exemple
public class Point{ }
b) Les membres de la classe
Membre : élément définissant les propriétés structurelles ou
fonctionnelles des instances (objet) d’une classe : variable d’instance,
variable de classe, constructeur, méthode d’instance, méthode de classe,
classe imbriquée, destructeur. Le membre peut prendre 3 valeurs :
private, public ou protected.
Variable d’instance : (ou attribut ou variable membre), définit une
propriété structurelle ou relationnelle (par opposition à fonctionnelle ou
comportementale) des instances d’une classe, sert à la matérialisation des
relations de composition et d’association mises en évidence pendant
l’´étape de conception.
Champs : membres permettant de stocker des valeurs de type de
base ou des objets ; le mot clé static indique que le champ est statique
sinon il est dit non statique ; après quoi suit le type du champ (type de base
ou nom du champ) puis son nom et une éventuelle initialisation.
(visibilité) (Static) type de champ nom de champ (=initialisation)

12
c) Déclaration d’une variable d’instance
Lors de la création d’une classe, nous avons affaire à deux types de variable ;
les variables de classe et les variables d’instance.
 La variable de classe n’est en rapport avec aucun objet, elle ne dépend d’aucun
objet. Le plus souvent, elle n’est pas modifiée au cours de l’exécution du
programme. Elle est souvent accessible dans la classe directement par son nom
et dans d’autres classes par point. Dimension () ou bien par la méthode statique
appelée par point. Quelle dimension ().
 La variable d’instance qui sert à représenter l’objet informatiquement. Ainsi, il est
possible de représenter les objets réels par un ensemble de données de bases.
Ceci s’appelle l’agrégation qui est la méthode la plus utilise pour créer des objets
simples.
 private — protected — public — package // portée
 static // il s’agit d’une variable de classe
 final // la variable ne pourra être affectée qu’une seule fois
 transient /* la variable ne doit pas être prise en compte
lorsqu’une instance de la classe doit être sauvée sur disque */
 volatile // empêche certaines optimisations du compilateur
 type et nom de la variable suivi d’un point virgule
Exemple
public class Point {

13
private int x;
private int y;
static int dim = 2 ;
}
1.2) Notion d’objet
Un objet est une instance d’une classe, qui est l’outil fondamental de programmation
en java ; En d’autres termes un objet est une variable conforme à un type, qui est une
classe.
On a le schéma suivant :
Figure 2 : création d’objet
a) Création des objets
L’instanciation est le mécanisme qui crée des objets à partir (de la Spécification) d’une
classe. Elle se fait grâce à l'opérateur new suivi de la classe à instancier et des parenthèses
contenant les paramètres du constructeur. La première étape pour créer de nouveaux
objets est de créer une nouvelle classe de façons particulière.
Syntaxe d’instanciation :
Nom_de _la_classe NomDeLobjet = new Nom_de _la_classe (attribut de l’objet pris
dans le constructeur) ;
Classe Instanciation Naissance
des objets

14
Exemple :
Point p1 = new Point(1,4) ;
b) Gestion des objets
Ils le font en s’échangent des messages. La réponse à la réception d’un message par
un objet est appelée une méthode. On dira donc qu’une méthode est la mise en œuvre du
message : elle décrit la réponse qui doit être donnée au message. (cf notion de methodes)
1.3) Notion d’encapsulage
L'encapsulation est une manière de définir une classe de telle sorte que ses attributs ne
puissent pas être directement manipulés de l‘extérieur de la classe, mais seulement
indirectement par l'intermédiaire des méthodes.
Un des avantages de cette approche est la possibilité de redéfinir la représentation
interne des attributs, sans que cela affecte la manipulation externe d'un objet de cette
classe.
L'encapsulation facilite donc la mise à jour des applications. On peut en voir l'intérêt dans
un projet de développement réalisé par plusieurs développeurs (ce qui est généralement le
cas en entreprise). Chaque développeur est responsable d'une partie du projet. Si les classes
dont il est le responsable sont proprement encapsulées, il pourra modifier par la suite leurs
représentations internes, sans que cela perturbe le travail des autres développeurs du
projet susceptibles d'utiliser ces classes.
Pour faire une encapsulation, il suffit de déclarer « private » les données à encapsuler et
de définir des méthodes permettant de les lire et de les modifier : on appelle ces méthodes
« getter » (pour la lecture) et « setter » (pour la modification).Chacune ayant une fonction
précise dont :
 Getter : méthode « public » permettant de définir la manière de lecture d’un attribut
privé. Son type de retour est celui de la donnée retournée et son nom est souvent
composé de « get » et du nom de l’attribut qu’elle retourne.
 Setter : méthode « public » permettant de définir la manière de modification d’une
donnée. Souvent, elle ne retourne rien (« void ») et prend un paramètre du même

15
type que la donnée à modifier. Son nom se compose de la mention « set » et du nom
de l’attribut concerné.
Autrement dit, l’encapsulation permet de définir des niveaux de visibilité des éléments
de la classe. Ces niveaux de visibilité définissent les droits d’accès aux données selon que
l’on y accède par une méthode de la classe elle-même, d’une classe héritière, ou bien d’une
classe quelconque. Il existe quatre niveaux de visibilité :
 Visibilité par défaut : aucun modificateur de visibilité n’est indiqué.
 Visibilité protégée : l’accès aux données est réservé aux fonctions des classes
héritières, c’est-à-dire par les fonctions membres de la classe et des classes dérivées.
Ainsi, Un attribut ou une méthode déclarée “protected” est accessible uniquement
aux classes d’un package et à ses sous-classes même si elles sont définies dans un
package différent.
 Visibilité privée : l’accès aux données est limité aux méthodes de la classe elle-même.
Il s’agit du niveau de protection des données le plus élevé
 Visibilité publique : les fonctions de toutes les classes peuvent accéder aux données
ou aux méthodes d’une classe définie avec le niveau de visibilité « public ». Il s’agit du
plus bas niveau de protection.
NB: Une classe est encapsulée, si tous ses attributs sont privés.
1.4) Notion de polymorphisme
Le nom de polymorphisme vient du grec « polúmorphos » qui signifie « qui
peut prendre plusieurs formes ». Cette caractéristique est un des concepts
essentiels de la programmation orientée objet. Dans java il veut simplement dire
qu’une classe peut prendre plusieurs formes et c’est d’autant plus vrai avec les
classes qui héritent d’une classe supérieure. Il peut aussi être vu comme la
capacité de choisir dynamiquement la méthode qui correspond au type réel de
l’objet.
On distingue généralement trois types de polymorphisme :
-Le polymorphisme ad hoc (également surcharge ou en anglais overloading).
-Le polymorphisme paramétrique (également généricité ou en anglais template).

16
-Le polymorphisme d'héritage (également redéfinition, spécialisation ou en anglais
overriding).
 Le polymorphisme ad hoc
Le polymorphisme ad hoc permet d'avoir des fonctions de même nom, avec
des fonctionnalités similaires, dans des classes sans aucun rapport entre elles (si
ce n'est bien sûr d'être des filles de la classe objet). Par exemple, la classe
complexe, la classe image et la classe lien peuvent avoir chacune une fonction
"afficher". Cela permettra de ne pas avoir à se soucier du type de l'objet que l'on
a si on souhaite l'afficher à l'écran.
Le polymorphisme ad hoc permet ainsi de définir des opérateurs dont
l'utilisation sera différente selon le type des paramètres qui leur sont passés. Il
est donc possible par exemple de surcharger l'opérateur + et de lui faire réaliser
des actions différentes selon qu'il s'agisse d'une opération entre deux entiers
(addition) ou entre deux chaînes de caractères (concaténation).
 Le polymorphisme paramétrique
Le polymorphisme paramétrique, appelé généricité, représente la possibilité
de définir plusieurs fonctions de même nom mais possédant des paramètres
différents (en nombre et/ou en type). Le polymorphisme paramétrique rend
ainsi possible le choix automatique de la bonne méthode à adopter en fonction
du type de donnée passé en paramètre.
Ainsi, on peut par exemple définir plusieurs méthodes homonymes addition
() effectuant une somme de valeurs.
-La méthode int addition (int, int) pourra retourner la somme de deux entiers
-La méthode float addition (float, float) pourra retourner la somme de deux flottants
-La méthode char addition (char, char) pourra définir au gré de l'auteur la
somme de deux caractères, etc

17
 Le polymorphisme d'héritage
La possibilité de redéfinir une méthode dans des classes héritant
d'une classe de base s'appelle la spécialisation. Il est alors possible
d'appeler la méthode d'un objet sans se soucier de son type intrinsèque
: il s'agit du polymorphisme d'héritage. Ceci permet de faire abstraction
des détails des classes spécialisées d'une famille d'objet, en les masquant
par une interface commune (qui est la classe de base).
1.5) Notion d’héritage
a) Généralités
Un autre concept important du POO est celui d’héritage. Le concept
d’héritage constitue l’un des fondements de la programmation orientée objet.
Il est notamment à l’origine des possibilités de réutilisation des composants
logiciels que sont les classes. En effet il permet de définir une nouvelle classe
dite classe dérivée, à partir d’une classe existante dite classe de base. Cette
nouvelle classe hérite d’emblée des fonctionnalités de la classe de base
(champs et méthodes) qu’elle pourra modifier ou compléter à volonté, sans
qu’il soit nécessaire de remettre en question la classe de base.
Cette technique permet donc de développer de nouveaux outils en se
fondant sur un certain acquis, ce qui justifie le terme d’héritage. Comme on
peut s’y attendre, il sera possible de développer à partir d’une classe de base,
autant de classes dérivées qu’on desire.de même une classe dérivée pourra à
son tour servir de classe de base pour une nouvelle classe dérivée.
b) Intérêt et utilisation

18
 INTERET
Le concept d’héritage a comme vision descendante : la possibilité de
reprendre intégralement tout ce qui a déjà été fait et de pouvoir l’enrichir.
Et comme vision ascendante : la possibilité de regrouper en un seul
endroit ce qui est commun a plusieurs.
 UTILISATION
Pour son utilisation en analyse oriente objet : on regroupe dans une
classe ce qui est commun à plusieurs classes
Lors de sa réutilisation : la classe de base étant définie, on peut la
reprendre intégralement pour construire la classe dérivée
c) Syntaxe de l’héritage
Pour sa syntaxe elle est simple et est la suivante :
Protection classe « classe dérivée » extends « classe_de_base » {/*ect * /}
Où le terme protection est le droit d’accès attribués au niveau de la classe.
Publics ou néant.
1.6) Notion de méthode
a) Définitions
On appelle fonction un sous-programme qui permet d'effectuer un ensemble
d'instructions par simple appel de la fonction dans le corps du programme
principal. Les fonctions permettent d'exécuter dans plusieurs parties du
programme une série d'instructions, cela permet une simplicité du code et
donc une taille de programme minimale. D'autre part, une fonction peut faire
appel à elle-même, on parle alors de fonction récursive (il ne faut pas oublier
de mettre une condition de sortie au risque sinon de ne pas pouvoir arrêter le
programme...).
Une méthode est une fonction faisant partie d'une classe. Elle permet
d'effectuer des traitements sur (ou avec) les données membres des objets.

19
Puisqu'en Java on ne manipule que des classes, il n'y aura formellement que
des méthodes, même si on pourra parler de fonction pour des méthodes static
qui ne manipulent aucune des données membres.
b) Classification des méthodes
Il existe différents types de méthodes :
 Les constructeurs appelés à la création de l'objet, soit :
Le constructeur par défaut appelé par défaut lors de la création d'un objet,
(offert par défaut lors de la compilation s'il n'y a pas de constructeur déclaré),
Le constructeur par recopie (ou constructeur de copie) appelé lors de la
création de l'objet, du passage d'un objet par référence,
Le(s) constructeur(s) paramétrique appelé(s) si la signature correspond à
celle du constructeur ;
 Le destructeur appelé à la suppression de l'objet, explicitement
ou bien implicitement dans le cadre d'un langage à ramasse-
miettes ;
 Les méthodes abstraites qui sont des méthodes sans code —
leur existence dans une classe suffit à déclarer qu'une classe est
abstraite et contraint à introduire des classes filles pour les
implémenter et les exploiter ;  Les accesseurs (Get) et les
mutateurs (Set):
Les accesseurs permettent de récupérer la valeur de données membres
privées sans y accéder directement de l'extérieur ; ils sécurisent donc l'attribut
en restreignant sa modification,

20
Les mutateurs permettent de modifier l'état de données membres tout en
vérifiant si la valeur que l'on veut donner à la donnée membre respecte les
normes de celle-ci ou diverses règles de cohérence. Leur détournement pour
modifier en cascade d'autres états du programme pouvant être source de
bogues ou de perte de maintenabilité.
c) Déclaration d’une méthode
Avant d'être utilisée, une méthode doit être définie car pour l'appeler
dans une classe il faut que le compilateur la connaisse, c'est-à-dire qu'il
connaisse son nom, ses arguments et les instructions qu'elle contient. La
définition d'une méthode s'appelle "déclaration". La déclaration d'une fonction
se fait selon la syntaxe suivante :
TypeDeRetour nomDeLaMethode(Type1 argument1, Type2 argument2) {
Liste d’instructions}
Remarque :
- Type de retour représente le type de valeur que la méthode va
retourner, cela peut-être un type primitif, une classe, ou alors le
mot-clé void si la méthode ne retourne aucune valeur.
- Le nom de la méthode suit les mêmes règles que les noms de
variables : il doit être écrit en minuscule, sauf pour les initiales de
chaque nouveau mot
- Un nom de méthode peut comporter des chiffres, mais pas pour
le premier caractère ;
- Le nom de la méthode est sensible à la casse (différence entre les
minuscules et majuscules) ;
- Les arguments sont facultatifs, mais s'il n'y a pas d'arguments, les
parenthèses doivent rester présentes ;

21
Une fois cette étape franchie, votre méthode ne s'exécutera pas tant que
l'on ne fait pas appel à elle quelque part dans la classe !
 Appel de méthode :
Pour exécuter une méthode, il suffit de faire appel à elle en écrivant
l'objet auquel elle s'applique (celui qui contient les données), le nom de la
méthode (en respectant la casse), suivie de ses arguments entre parenthèse :
objet.nomDeLaMethode(argument1,argument2);
Remarque :
- Si vous exécutez une méthode sur l'objet courant (this), c'est à
dire que vous utilisez dans une classe, une méthode de la même
classe, alors il est inutile de préciser que this est l'objet auquel
s'applique la méthode.
- Le point-virgule signifie la fin d'une instruction pour distinguer les
différents blocs d'instructions
- Si jamais vous avez défini des arguments dans la déclaration de la
méthode, il faudra veiller à les inclure lors de l'appel de la
méthode (le même nombre d'arguments séparés par des virgules
!), mais sans avoir à préciser leur type.
 Les arguments d'une méthode :
Il est possible de passer des arguments (appelés aussi paramètres) à une
méthode, c'est-à-dire lui fournir une valeur ou le nom d'une variable afin que la
méthode puisse effectuer des opérations sur ces arguments ou bien grâce à ces
arguments.

22
Le passage d'arguments à une méthode se fait au moyen d'une liste
d'arguments (séparés par des virgules) entre parenthèses suivant
immédiatement le nom de la méthode.
Le nombre et le type d'arguments dans la déclaration, le prototype et dans
l'appel doit correspondre, au risque, sinon, de générer une erreur lors de la
compilation...
Un argument peut être : une constante, une variable, une expression, une
autre méthode retournant une valeur
 Renvoi d'une valeur par une méthode :
La méthode peut renvoyer une valeur (et donc se terminer) grâce au mot-
clé return. Lorsque l'instruction return est rencontrée, la méthode évalue la
valeur qui la suit, puis la renvoie au programme appelant (classe à partir de
laquelle la méthode a été appelée).
Une méthode peut contenir plusieurs instructions return, ce sera toutefois
la première instruction return rencontrée qui provoquera la fin de l'exécution
de la méthode et le renvoi de la valeur qui la suit.
- La syntaxe de l'instruction return :
return valeurDeRetour;
Le type de valeur retourné doit correspondre à celui qui a été précisé
dans la définition - La surcharge de méthode :
Un des apports les plus intéressants de la conception objet, est la
possibilité d'appeler plusieurs méthodes avec le même nom, à condition que
leurs arguments diffèrent (en type et/ou en nombre).
Ce principe est appelé surcharge de méthode. Il permet de donner le
même nom à des méthodes comportant des paramètres différents et simplifie

23
donc l'écriture de méthodes sémantiquement similaires sur des paramètres de
types différents.
En effet, une méthode est déterminée par ce que l'on appelle sa
signature, c'est-à-dire : sa classe d'appartenance, son nom, ses paramètres
Il est ainsi possible de définir une méthode réalisant la même opération
sur des variables différentes en nombre ou en type :
int somme (int p1, int p2) {
Return p1+p2;
}
int somme (int p1, int p2, int p3) {
Return p1+p2+p3;
}
double somme (double p1, double p2)
{Return p1+p2 ;}
1.7) Notion de référencement
Une référence est une adresse mémoire désignant un objet ou un tableau
dans le tas. On appelle type référence en java, les types des objets et des
tableaux ; alors que les types primitifs sont un petit nombre de types prédéfini
tels que les types entiers signés (byte, int...); les types caractères non signés
(char); booléen (boolean); types à virgule flottante (float, double). Les valeurs
des types primitifs existent sans qu’ils n’y aient besoin de les créer. Tandis que
celles du type référence doivent être créé (on créera par exemple un tableau
ou des objets). Une valeur du type référence est une référence, une adresse. Il
est donc possible d’identifier chaque objet par un nom grâce à une référence.
Le concept de référence est très proche de celui des « pointeurs » en langage
C/C++, il est toutefois beaucoup plus simple à comprendre et à mettre en
œuvre.

24
Pour créer une référence d’objet, il suffit de faire précéder le nom que
l’on donne à un objet par le nom de la classe que l’on instancie; par exemple
une référence de l’objet Michel, instance de la classe Personne, peut être défini
de la manière suivante :
Personne Michel;
La référence Toto ne pointe pour l’instant vers aucun objet. Pour ce faire,
il suffit de l’initialiser, c’est-à-dire en réalité de lui affecter le résultat de la
création de l’objet renvoyé par l’opérateur new. Avec l’exemple précédent cela
pourrait s’écrire de la façon suivante :
Personne Michel;
Michel = new personne ();
a) Accéder aux données membres d’un objet
L’accès aux données membres d’un objet se fait grâce au nom de la
référence vers l’objet, suivi d’un point puis du nom de la donnée membre. Par
exemple :
Nom_du_handle.Nom_de_la_donnee_membre = valeur ;
b) Accéder aux méthodes d’un objet
L’accès aux méthodes d’un objet se fait comme pour l’accès aux données
membres, c’est-à-dire par un point. La méthode est suivie de parenthèses,
contenant les paramètres, s’il y’en a. L’accès à une fonction membre se fait de
la manière suivante:
Nom_du_handle.Nom_donnee_fonction_membre (paramètre1,
paramètre2,…)
c) Le mot clé « This »
Le mot clé « this » permet de désigner l’objet dans lequel on se trouve,

25
c’est-à-dire que lorsqu’on désire faire référence dans une fonction membre à
l’objet dans lequel elle se trouve, on utilise « this ».
Ainsi lorsqu’on désire accéder à une donnée membre d’un objet à
partir d’une fonction membre du même objet, il suffit de faire précéder le nom
de la donnée membre par « this ». Par exemple :
class Michel
{
Int age ;
Char sexe[16] ;
Void DefineMichelAge(int age)
{
This.age=age;
}
}
2. Présentation de la structure de base d’un programme JAVA
2.1 Structure générale d’un programme JAVA
Un programme Java est constitué comme suit :
 L’entête:
C’est le début du programme il comprend entre autres :
- Le nom du package: Pour définir un package en java; il faut utiliser le mot clé
package suivi du nom de votre package. Cette définition doit être la première
ligne du code effectif de votre fichier. Par exemple: package hello.
- Le nom des importations de bibliothèques, par exemple : import java.i.o.*
(ici on va importer toutes les classes dans la bibliothèque java.i.o ainsi que
toutes les méthodes de cette bibliothèque), import java.util.Scanner (ici on
importe juste la classe Scanner qui se retrouve dans la bibliothèque java.util),
etc.
 Le corps:

26
Qui constitue le lieu où le code sera saisit. Il comprend entre autres les
variables ; les fonctions (généralement appelées méthodes en java) ; classe
secondaire qui commence généralement avec <<public class>> ; les attributs de
la classe; etc.
2.2) Affichage d’un message à l’écran
Pour afficher un message à l'écran, on utilise la fonction System.out.print( ).
Par exemple, le code ci-après affiche hello world! .
Figure3 : affichage d’un message à l’écran
En effet, la ligne System.out.print ("hello world!"); signifie :
 La méthode print( ) va écrire hello world! en utilisant l'objet out de la classe
System
 . System : ceci correspond à l'appel d'une classe qui s'appelle «System » C’est
une classe utilitaire qui permet surtout d'utiliser l'entrée et la sortie standard.
 . out: objet de la classe*Système*qui gère la sortie standard.
 . print: méthode qui écrit dans la console de la chaîne passée en paramètre
2.3) Variables
On appelle Variable un espace de stockage pour un résultat. En java il existe
9types de variable différentes qui se répartissent en 4 catégories :
-> 4types « nombres entiers »
-> 2 types « nombres réels »

27
-> 2 types « caractères »
-> 1 type « logique »
 Les 4 types « nombres entiers »
Ils sont présentés dans le tableau suivant :
types Valeur la plus petite Valeur la plus grande
BYTE -128 127
SHORT -32 768 32 767
INT -2 147 483 648 2 147 483 647
LONG -9 223 372 036 854 755 9 223 372 036 854 755
807


     Tableau 1 : type entier

 Les 2 types « nombres réels »
Types Valeur la plus petite Valeur la plus grande
FLOAT 1.4e-45 3.4e38
DOUBLE 5e-324 1.7e308
Tableau 2 : variable de type réelle
Ici il est bien de noté de le FLOAT est généralement suffisant et précis alors le
type DOUBLE est utilisé pour les hautes précisions comme le calcul scientifique.
 Les 2 types « caractères »

28
Types peut contenir
CHAR Un seul caractère
STRING Une chaine de caractère
Tableau 3 : variable de type caractère
 Le type « booléen »
types Valeur possible
BOOLEAN True or false
Tableau 4 : variable de type booléen
ILLUSTRATION DE DECLARATION D’UNE VARIABLE
Le programme Java ci-dessous déclare une variable nommée « nombre », lui
donne la valeur 2021 puis l’affiche à l’écran.
Figure 4: Implémentation d'une variable.
En effet, en java avant d’utiliser une variable il faut la déclarer : c’est ce

29
qui est en fait à la ligne 6 du programme ci-dessus. Déclarer une variable
consiste à définir son type. Par exemple le type int utilisé précédemment
indique la variable nombre ne pourra contenir que des nombres entiers. Dans
un programme, la déclaration des variables se fait toujours au début du
programme (après la deuxième accolade).
2.4) Commentaires
Afin de rendre le code source de nos programmes plus lisible, il est possible d’y
ajouter des commentaires. Les commentaires sont des notes personnelles
écrites par le programmeur et qui sont totalement ignorées par le compilateur
lors de l’exécution du programme. Dans un programme en java, les
commentaires sur plusieurs lignes commencent par /*et se termine par les
caractères*/ , et les commentaires sur une seule ligne commencent par //
suivi du commentaire: il est alors affiché en vert dans ECLIPSE. Une fois
commenté, le programme est plus agréable à lire.
Prenons l'exemple du programme précèdent à commenter :
Figure 5: illustration des commentaires en java

30
PARTIE B : CAS PRATIQUE
I. Description littérale
 Problème à résoudre :
Le but de notre programme est la gestion des terrains c’est-à-dire pour un
terrain de forme bien connu (rectangle ou carré) nous calculons le périmètre
du terrain ainsi que sa surface.
 Données d’entrées
- La longueur et la largeur du terrain pour un terrain rectangulaire
- Le côté du terrain pour un terrain carré
 Données attendus en sortie
Le périmètre et la surface du terrain
II. Présentation du code
1. Présentation des différentes notions abordées dans notre exposé
1.1) Les classes
 La classe Rectangle
Elle a été créée pour définir un rectangle dont les caractéristiques sont sa
longueur et sa largeur. Sa syntaxe est la suivante :
Public class rectangle {
…….
………..
………….
}
 La classe Carre
Elle a été créée pour définir un carré de caractéristique son côté. Cette classe
héritera de la classe Rectangle
Sa syntaxe est la suivante :

31
Public class Carre extends rectangle {
………………..
…………………….
………………………
}
 La classe Entryapp
Elle a été créée pour le test de notre application.
Sa syntaxe est la suivante :
public class Entryapp {
………………………………
………………
}
1.2) Un objet
A la 24eme ligne de la classe « Entryapp » nous avons définit l’objet « terrain »
de type « Rectangle ». Ici, il est représenté par la longueur et la largeur du
rectangle.
Sa syntaxe est :
Rectangle terrain =new Rectangle (longueur, largeur) ;
1.3) L’encapsulation
Dans notre code, nous avons voulu protéger les informations relatives à chaque
forme (rectangle ; carré). C’est-à-dire que les données ne pourront pas être
modifiées depuis l’extérieur. Pour le rectangle on a par exemple :
Private float longueur;
Private float largeur;
1.4) Le polymorphisme

32
Dans notre programme, un exemple de polymorphisme est la méthode
« afficher » qui permet d’afficher un message à l’utilisateur. un exemple dans
notre programme est :
System.out.print ("le perimetre de votre terrain est : ");
1.5) L’héritage
Dans notre programme la notion d’héritage a été représentée dans la classe
« Carre ». En effet, la classe a hérité de la classe « Rectangle ». La syntaxe est :
public class Carre extends rectangle {
public Carre() {
super();
}
}
1.6) La méthode
Il s’agit en fait il s’agit des fonctions et procédures en java. Dans notre cas, la
procédure « info » en est un exemple :
public void info () {
System.out.print("le perimetre de votre terrain est : ");
System.out.println(this.perimetre());
System.out.print("la surface de votre terrain est : ");
System.out.println(this.surface());
}
1.7) Un référencement
Dans notre programme, un exemple de référencement est lorsqu’on fait appel
à la méthode « périmètre » pour faire appel à des données (longueur ; largeur)
qui sont privées. Exemple :
public rectangle (float longueur, float largeur) {
this.setLongueur(longueur);
this.setLargeur(largeur);
}
2. Le code proprement dit

33
 La classe « Rectangle »
public class rectangle {
/*classe permettant de representer un rectangle
* proprietes
* longueur
* largeur
* methodes
* surface retourne la surface du rectangle
* perimetre retourne le perimetre du rectangle
*/
private float longueur;
private float largeur;
//constructeur
public rectangle(){
this.setLongueur(0);
this.setLargeur(0);
}
public rectangle(float longueur, float largeur){
this.setLongueur(longueur);
this.setLargeur(largeur);
}
//definition des setters
public void setLongueur (float longueur){
this.longueur = longueur;
}
public void setLargeur(float largeur){
this.largeur = largeur;
}
//definition des getters
public float getLongueur(){
return this.longueur;
}
public float getlargeur () {
return this.largeur;
}
//definition de la methode perimetre
public float perimetre(){
return 2*(this.getLongueur() + this.getLargeur());
}
public float surface(){
return this.getLargeur()*this.getLongueur();
}
public void info(){

34
}
}
 La classe « carre »
public class Carre extends rectangle {
// classe carre heritant de la classe rectangle
public Carre(){
super();
}
public Carre(float cote){
super(cote, cote);
}
//redefinition de perimetre
public float perimetre(){
return super.getLargeur()*4;
}
//redefinition de surface
public float surface(){
return super.getLargeur()*super.getLargeur();
}
public void info(){
}
}
 La classe « Entryapp »
import java.util.Scanner;
public class Entryapp {
public static void main(String[] args){
Scanner lire = new Scanner(System.in);
float longueur = 0;
float largeur = 0;
float cote = 0;
int terrainType = 0;
int accepter = 2;
boolean continuer = true;

35
System.out.println("Bienvennu dans notre programme de gestion
des terrains");
do{
System.out.println("quelle est la forme de votre
terrain");
System.out.println("1: rectangle");
System.out.println("2: carre");
while(terrainType != 1 || terrainType != 2){
terrainType = lire.nextInt();
if (terrainType == 1){
System.out.println("entrer une longueur pour
votre terrain: ");
longueur = lire.nextFloat();
System.out.println("entrer une largeur pour
votre terrain: ");
largeur = lire.nextFloat();
rectangle terrain = new rectangle(longueur,
largeur);
terrain.info();
}
else if (terrainType == 2){
System.out.println("entrer une longueur de
cote pour votre terrain: ");
cote = lire.nextFloat();
Carre terrain = new Carre(cote);
terrain.info();
}
else{
System.out.println("choix de terrain non
disponnible");
}
}
while(accepter != 1 || accepter != 0){
System.out.println("voulez vous continuer?");
System.out.println("0: sortir");
System.out.println("1: continuer");
accepter = lire.nextInt();
if (accepter == 0){
continuer = false;
}
else if (accepter == 1){
continuer = true;
}
else{
System.out.println("Choix indisponible");
}
}
}while(continuer);
}
}
III. Execution du programme

36
Après exécution du programme, on a par exemple pour un terrain rectangulaire de longueur
12m et de largeur 10m, le résultat suivant :
Bienvenu dans notre programme de gestion des terrains
quelle est la forme de votre terrain
1: rectangle
2: carre
1
entrer une longueur pour votre terrain:
12
entrer une largeur pour votre terrain:
10
le perimetre de votre terrain est : 44.0
la surface de votre terrain est : 120.0

37
Au terme de cet exposé qui visait à présenter le langage java et la
programmation orientée objet, nous avons d’une part introduit le java à travers
les notions de compilation et d'implémentation; et d’autre part, nous avons
présenté la structure d'un programme java en abordant les notions de classe,
objet, méthode, encapsulage, etc. Nous constatons que le langage de
programmation Java présente des caractéristiques très intéressantes qui en
font une plate-forme de développement et d’innovation très captivante pour
les programmeurs car, ce langage a beaucoup évolué de par sa structuration
des données en général, et est devenu un langage de programmation très
puissant permettant de presque tout faire. Cependant, dans l’objectif de mieux
appréhender l’importance si capitale de la structuration des données sous Java,
ne pouvons-nous pas écrire un unique programme illustrant toutes ces notions
?
CONCLUSION
Y

Expose groupe 2..

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Expose groupe 2..

Ähnlich wie Expose groupe 2.. (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Expose groupe 2..