Académique Documents
Professionnel Documents
Culture Documents
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
Java et la programmation Orientée Objet
1
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
2
DEDICACE
A
Tous les élevés Ingénieurs de conception appartenant à la promotion 2024 de
Génie Civil et urbanisme de l’ENSPY
3
REMERCIEMENTS
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 :
4
LISTE DES TABLEAUX ET FIGURES
PARTIE A :
Figure1 : Interprétation du langage java (page 9)
5
INTRODUCTION
6
PARTIE A : THEORIE
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
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.
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
7
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
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
8
Figure 1 : interprétation du langage java
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.
• 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.
9
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 :
10
{ ”corps de la classe”}
Exemple
11
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 ().
Exemple
12
private int x;
private int y;
static int dim = 2 ;
}
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 :
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) ;
13
Exemple :
Point p1 = new Point(1,4) ;
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)
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
14
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.
15
-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 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.
-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
16
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).
a) Généralités
b) Intérêt et utilisation
UTILISATION
Pour son utilisation en analyse oriente objet : on regroupe dans une
classe ce qui est commun à plusieurs classes
c) Syntaxe de l’héritage
a) Définitions
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é),
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 :
- Les arguments sont facultatifs, mais s'il n'y a pas d'arguments, les
parenthèses doivent rester présentes ;
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 :
Un argument peut être : une constante, une variable, une expression, une
autre méthode retournant une valeur
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 ();
Nom_du_handle.Nom_de_la_donnee_membre = valeur ;
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,…)
class Michel
{
Int age ;
Char sexe[16] ;
Void DefineMichelAge(int age)
{
This.age=age;
}
}
L’entête:
- 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 corps:
2.3) Variables
LONG -9 223 372 036 854 755 9 223 372 036 854 755
807
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.
Le type « booléen »
types Valeur possible
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 :
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é
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 :
La classe Entryapp
Elle a été créée pour le test de notre application.
Sa syntaxe est la suivante :
1.2) Un objet
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
1.5) L’héritage
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 :
1.7) Un référencement
//constructeur
public rectangle(){
this.setLongueur(0);
this.setLargeur(0);
}
La classe « carre »
public Carre(){
super();
}
public Carre(float cote){
super(cote, cote);
}
//redefinition de perimetre
//redefinition de surface
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;
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(continuer);
}
Y
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
?