Java

Outline
Modélisation et programmation orientée objet
GSTR1 - GM1
R.J.
Printemps 2020
R.J. Modélisation et programmation orientée objet 1/55

Outline
3 Programmation Orientée Objet

4 Premiers pas en Java

Programmation Orientée Objet
Premiers pas en Java
Préambule
La Programmation Orientée Objet (POO) est un paradigme de program-

mation informatique, qui a été élaboré au début des années 1960.
La POO se base sur la définition et l’interaction entre des ”objets”. Un
objet représente une entité (une partie, une composante) de l’application
à réaliser (du problème à résoudre).
Objet, instance, classe, attribut, méthode, encapsulation, typage, poly-
morphisme, héritage, redéfinition, généricité . . . sont des notions de la
POO qu’on verra dans les prochains chapitres.

Préambule
Il existe plusieurs langages de Programmation Orientée Objet :

– – Java,
– – Python,
– – C#,
– – C++,
– – Objective-C,
– – VB.NET,
– – Ruby,
– – Perl,
– – Delphi,
– – Smalltalk,
– – PHP,
– – Vala,
– – Eiffel,
– – Ada,
– – LOGO,
– – ...
On apprendra dans ce cours le langage Java.

Pourquoi Java? (source : http://pypl.github.io/PYPL.html)

Pourquoi Java?
La particularité et l’objectif central de Java est que les applications

développées sont portables sur tous les systèmes d’exploitation, e.g.,
Microsoft Windows, Mac OS (Macintosh Operating System), UNIX,
OS/400 (Operating System/400), OpenVMS (Open Virtual Memory Sys-
tem) . . . ; on parle de la ”portabilité” des applications Java.
Ainsi par exemple, un programme Java codé sous Windows 8, peut être
compilé sous OS X Yosemite et enfin exécuté sous Debian Wheezy.


Plate-formes Java
Une plate-forme Java est un standard de plate-formes logicielles qui per-

mettent de développer et d’exécuter des programmes écrits en langage
Java indépendants de tout processeur et de tout système d’exploitation.
On retrouve comme plate-formes Java : Java Card, Java ME, Java SE,
Java EE et JavaFX.
Java Card : permet à de petites applications basées sur Java (applets)
de s’exécuter en toute sécurité sur des smart cards (cartes à puce)
comme les cartes SIM (Subscriber Identity Module) et les cartes ban-
caires.
Java Platform, Micro Edition ou Java ME (anciennement appelée J2ME)
: spécifie plusieurs différents ensembles de bibliothèques pour des com-
posantes à capacités de stockage, d’affichage, et de puissance limités.
Java ME est souvent utilisé pour développer des applications em-
barquées (lecteurs blu-ray, téléphonie mobile, automobile, domotique,
électroménager . . . ).
Plate-formes Java
Java Standard Edition ou Java SE (anciennement appelée J2SE) : c’est

l’édition principale destinée typiquement aux applications pour poste de
travail. Cette plate-forme contient outre toutes les interfaces de program-
mation (Application Programming Interface) API de base :
– – toutes les API spécialisées dans le poste client, comme Java Foun-
dation Classes (JFC), Abstract Window Toolkit (AWT) et Java2D,
– – des API d’usage général comme Java API for XML Processing
(JAXP),
– – Java DataBase Connectivity (JDBC) . . . .
Java Enterprise Edition ou Java EE (anciennement appelée J2EE) :
c’est une extension de Java SE (ajout de plusieurs API), destinée
particulièrement aux applications d’entreprises client-serveur, qui sont
développées dans une approche multi-niveaux. Elle est utilisée notam-
ment dans la création d’applications réparties, d’applications Web . . . .
Java FX Edition ou JavaFX : c’est une plate-forme qui est orientée RIA,
i.e., rich Internet application ou en français application Internet riche.

Outils de développement
Pour pouvoir développer en Java, on a besoin de :

1) Un environnement d’exécution Java (Java Runtime Environment)
JRE, qui permet l’exécution de programmes développés en Java,
2) un Environnement de Développement Intégré (EDI), ou en anglais In-
tegrated Development Environment (IDE), qui permet le développement
et la compilation d’applications Java.
On peut également utiliser un kit de développement Java (Java Devel-
opment Kit) JDK, qui est un ensemble de bibliothèques logicielles de
base du langage Java et des outils pour développer et compiler du code
source Javaa , transformé en bytecode destiné à la machine virtuelle
Javab . Le JDK inclut en réalité le JRE.
a
La compilation d’un code source Java génère un bytecode Java. Le bytecode Java
est un code intermédiaire entre le code source et le code binaire.
b
Une machine virtuelle Java (Java Virtual Machine) JVM est un ”appareil infor-
matique” fictif qui interprète du bytecode Java. L’appareil est simulé par un logiciel
spécifique à chaque plate-forme ou couple {machine , système d’exploitation} et permet
aux applications Java compilées en bytecode de produire les mêmes résultats quelle que
soit la plate-forme, tant que celle-ci est pourvue d’une JVM.
Outils de développement
Il y a plusieurs EDI qui permettent de développer en Java. On utilisera

dans ce cours l’EDI gratuit Eclipse.
Remarque : Eclipse supporte Java SE et Java EE.

Pourquoi Eclipse?

Téléchargement et installation des outils
1 Téléchargez et installez le JRE correspondant à

votre système d’exploitation depuis la page Web
https://www.java.com/fr/download/manual.jsp. Dans le cas par exemple
d’un Windows 64 bits, ça sera le fichier ”jre-8u241-windows-x64.exe”.
2 – – Téléchargez depuis la page Web
https://www.eclipse.org/downloads/packages/ le package ”Eclipse
IDE for Java Developers” qui correspond à votre système d’exploitation.
Dans le cas par exemple d’un Windows, ça sera le fichier ”eclipse-java-
2020-03-R-win32-x86 64.zip”,
– – décompressez où vous voudriez le fichier .zip,
– – entrez dans ce dossier et lancez ”eclipse/eclipse.exe” pour ouvrir
Eclipse,
– – créez un répertoire ”workspace”, i.e., c’est la où Eclipse enregistre
nos projets.

Notre premier programme Java
Créez un projet Java (Java Project), i.e., un répertoire, qu’on va appeler

par exemple ”TPs” :



Créez une classe Java (class) dans ce projet, i.e., un programme, qu’on
va appeler par exemple ”helloworld”, tout en cochant la case ”public
static void main(String[] args)” :




Ajouter l’instruction ”System.out.println(”Hello world!”);”, dans la

méthode main() :


Exécutez le programme et regardez donc le résultat obtenu :




Remarques
Les programmes Java sont composés d’au moins une classe, et qui doit
contenir la méthode main().
Le fichier source .java porte presque toujours le nom de la classe (c’est
obligatoire quand la classe a l’attribut public).
Le fichier bytecode Java a comme extension .class.
Toute instruction se termine toujours par le caractère point-virgule ’;’.
Java est sensible à la casse.
On peut insérer un commentaire sur une seule ligne, en le précédant de
deux caractères slash //.
On insère un commentaire multi-lignes (un commentaire long) en
l’entourant des chaı̂nes de caractères /* et */.

Les variables
Dans tout langage de programmation, dès qu’on a besoin de stocker une

information, on utilise une variable.
Pour pouvoir utiliser une variable, il faut la déclarer au préalable.
Une variable est un espace de stockage dans la mémoire qui porte un
nom, qui va servir à stocker une valeur, et qui a un type.
Selon la nature de la valeur qu’elle va stocker, la variable sera de tel ou
de tel type.

Les variables
Les types de variables qu’on peut avoir sont :

– – byte : peut contenir un nombre entier (positif ou négatif) codé sur 1
octet,
– – short : peut contenir un nombre entier (positif ou négatif) codé sur 2
octets,
– – int : peut contenir un nombre entier (positif ou négatif) codé sur 4
octets,
– – long : peut contenir un nombre entier (positif ou négatif) codé sur 8
octets,
– – float : peut contenir un nombre réel (positif ou négatif) codé sur 4
octets,
– – double : peut contenir un nombre réel (positif ou négatif) codé sur 8
octets,
– – boolean : ne peut contenir que true ou false,
– – char : peut contenir un caractère,
– – String : peut contenir une chaı̂ne de caractères (notons bien que
String commence par un S majuscule).

Les variables
Voici des exemples de déclaration et d’initialisation de variables :

– – byte cumul;
cumul = -7;
– – short annee;
annee = 2015;
– – int superficie;
superficie = 710850;
– – long personnes;
personnes = 5140300600L; /*Notons bien qu’on doit ajouter un ”L” à la
fin du nombre.*/
– – float somme;
somme = 100.0f; /*Notons bien qu’on doit ajouter un ”f” à la fin du nom-
bre. Notons bien aussi qu’on n’utilise pas la virgule, mais plutôt le point.
Notons bien finalement qu’on écrit ”.0” à la fin du nombre, dans le cas
où celui ci est ”rond”.*/
– – double rapport;
rapport = -0.666666666666666666666666666666666666666666667;

Les variables
– – boolean decision;
decision = true;
– – char reponse;
reponse = ’N’; /*Notons bien que le caractère est entouré
d’apostrophes.*/
– – String texte; /*La variable texte peut aussi être déclarée avec : String
texte = new String();.*/
texte = ”Bonjour”; /*Notons bien que la chaı̂ne de caractères est entouré
de guillemets.*/

Les variables
Remarques :
– – On peut déclarer et initialiser une ou plusieurs variables d’un seul
coup.
Exemple :
float coefficient1 = 0.5f , coefficient2 = 0.3f , coefficient3 = 0.2f;
– – Il est possible de déclarer des expressions numériques en
hexadécimal, en utilisant le préfixe ”0x” ; comme il est possible d’utiliser
la notation binaire, en utilisant le préfixe ”0b”.
Exemples :
int valeur1 = 0x1F;//valeur1 vaut 31.
int valeur2 = 0b11111111; //valeur2 vaut 255.

Les variables
Notez bien qu’on peut formater les valeurs de types numériques avec un
séparateur, qui est le caractère tiret bas (underscore, tiret du 8), ce qui
peut s’avérer être très pratique quand on a de grands nombres qui sont
difficiles à lire.
Exemples :
int nombre1 = 1 000 000 000;
double nombre2 = 1 000 000 000 000.543;
Le nombre d’underscores n’a pas d’importance. Cependant, les under-
scores doivent être placés entre deux caractères numériques, i.e., ils ne
peuvent pas être utilisés en début ou en fin de déclaration ni avant ou
après le point.
Sachez qu’il existe des règles de nommage :
– – Les noms des variables doivent commencer par une minuscule,
– – les noms des classes doivent commencer par une majuscule,
– – les noms des variables et de classes ne doivent contenir ni de car-
actères espace, ni de caractères accentués.

Les variables
En manipulant les variables, on peut faire usage des opérateurs

arithmétiques suivants :
– – + : addition (de nombres) ou concaténation (de caractères ou de
chaı̂nes de caractères),
– – - : soustraction,
– – * : multiplication,
– – / : division,
– – % : modulo,
– – ( : parenthèse ouvrante,
– – ) : parenthèse fermante.

Les variables
On peut également utiliser des expressions particulières :

– – nomVariable1 = nomVariable2 = nomVariable3 = X; est équivalente
à nomVariable1 = X; nomVariable2 = X; nomVariable3 = X; (X étant une
autre variable ou un nombre),
– – nomVariable += X; est équivalente à nomVariable = nomVariable +
X; (X étant une autre variable ou un nombre),
– – nomVariable -= X; est équivalente à nomVariable = nomVariable - X;
(X étant une autre variable ou un nombre),
– – nomVariable *= X; est équivalente à nomVariable = nomVariable * X;
– – nomVariable /= X; est équivalente à nomVariable = nomVariable / X;
– – nomVariable++; est équivalente à nomVariable = nomVariable + 1;
(c’est une incrémentation),
– – nomVariable--; est équivalente à nomVariable = nomVariable - 1;
(c’est une décrémentation).

Les variables
Attention : On ne peut faire de traitement arithmétique que sur des vari-

ables de même type, sous peine de perdre de la précision lors du calcul
ou de l’affectation.
Voici des exemples où on utilise les conversions d’ajustement (cast de
variables) :
int i = 791;
float j = (float)i; /*Conversion du type int au type float. j vaut 791.0 .*/
double k = (double)i; /*Conversion du type int au type double. k vaut
791.0 .*/
double l = 1.623;
int m = (int)l; /*Conversion du type double au type int. m vaut 1 (une
perte de précision, en ne prenant que la valeur entière du double).*/
int A = 5, B = 2;
double rapport = (double)(A / B); /*rapport vaut 2.0 . La JVM commence
par faire la division de deux int qui, donne 2, puis cast le résultat (2.0),
et fini par affecter cette valeur à la variable.*/
double rapport2 = (double)(A) / (double)(B); /*rapport vaut 2.5 .*/

Les variables
Voici des exemples de conversion nombre - chaı̂ne de caractères (dans

les deux sens) :
int i = 93; String j = new String(); j = j.valueOf(i);//j vaut ”93”.
int k = Integer.valueOf(j).intValue();//k vaut 93.
byte l = Byte.valueOf(j).byteValue();//l vaut 93.
short m = Short.valueOf(j).shortValue();//m vaut 93.
long n = Long.valueOf(j).longValue();//n vaut 93.
float o = 346.5f; String p = new String(); p = p.valueOf(o);//p vaut ”346.5”.
float q = Float.valueOf(o).floatValue();//q vaut 346.5.
double r = Double.valueOf(o).doubleValue();//r vaut 346.5.

Lecture du clavier / Affichage dans l’écran
Il y a plusieurs méthodes qui permettent de faire des lectures du clavier

et des affichages dans l’écran ; nous en verrons les plus simples.
La lecture des entrées clavier se fait via la classe Scanner, qui se trouve
dans le package java.util.
Elle dispose de méthodes qui permettent de récupérer les différents
types de données.

L’affichage des sorties écran peut se faire en utilisant les méthodes

print() et println() de l’objet out de la classe System :
– – System.out.print(”Ce texte sera affiché sans un retour à la ligne à la
fin.”);
– – System.out.println(”Ce texte sera affiché avec un retour à la ligne
automatique à la fin.”);
On affiche le contenu de la variable maVariable via :
– – System.out.print(maVariable);
– – System.out.println(maVariable);
On peut afficher du texte et le contenu de variables en les concaténant.
Exemples :
– – System.out.println(maVariable + ” est le contenu de la variable
maVariable.”);
– – System.out.println(”Le contenu de la variable maVariable est : ” +
maVariable + ”.”);
La méthode System.out.printf(format,maVariable) fait un affichage for-
maté.
Voici des Exemples :

import java.util.Scanner;/*Import de la classe Scanner.*/
public class monprogramme {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(”Entrez votre login : \n”);/*Affichage dans l’écran. La
classe System se trouve dans le package java.lang ; il est importé au-
tomatiquement par Java.*/
String entree1 = sc.nextLine();/*Lecture d’une chaı̂ne de caractères. No-
tons bien qu’il faudra cliquer dans la console afin de pouvoir y saisir par
la suite.*/
System.out.println(”Bonjour ” + entree1);/*Affichage dans l’écran.*/
System.out.println(”Veuillez saisir un premier nombre entier : ”);
byte entree2 = sc.nextByte();/*Lecture d’un nombre entier de type byte.*/
System.out.println(”Veuillez saisir un deuxième nombre entier : ”);
short entree3 = sc.nextShort();/*Lecture d’un nombre entier de type
short.*/
System.out.println(”Veuillez saisir un troisième nombre entier : ”);
int entree4 = sc.nextInt();/*Lecture d’un nombre entier de type int.*/

System.out.println(”Veuillez saisir un quatrième nombre entier : ”);
long entree5 = sc.nextLong();/*Lecture d’un nombre entier de type long.*/
System.out.println(”Vous avez saisi les nombres entiers suivants : ” + entree2
+ ” ” + entree3 + ” ” + entree4 + ” ” + entree5);
System.out.println(”Veuillez saisir un premier nombre réel : ”);
float entree6 = sc.nextFloat();/*Lecture d’un nombre réel de type float. Atten-
tion : la saisie se fait avec la virgule, et non avec le point.*/
System.out.println(”Veuillez saisir un deuxième nombre réel : ”);
double entree7 = sc.nextDouble();/*Lecture d’un nombre réel de type double.
Attention : la saisie se fait avec la virgule, et non avec le point.*/
System.out.println(”Vous avez saisi les nombres réels suivants : ” + entree6 +
” ” + entree7);
System.out.println(”Veuillez saisir un booléen : ”);
boolean entree8 = sc.nextBoolean();/*Lecture du booléen true ou false.*/
System.out.println(”Veuillez saisir un caractère : ”);
char entree9 = sc.next().charAt(0);/*Lecture d’un caractère.*/
System.out.println(”Vous avez saisi le booléen et le caractère suivants : ” +
entree8 + ” ” + entree9);}}
STOP : Si on veut lire une chaı̂ne de caractères après avoir lu aupar-

avant un entier ou un réel ou un booléen ou un caractère, il faudra
impérativement faire sc.nextLine(); ma variable = sc.nextLine();.
Remarques :
– – \n permet de faire un retour à la ligne.
– – \t permet de faire une tabulation.
– – Il faut ”échapper” un guillemet, i.e., le précéder du caractère antislash
\, pour pouvoir l’afficher dans la sortie standard.
Exemple :
System.out.println(”Bonjour \”ENSA de Tetouan\”!” );/*Affiche à l’écran
Bonjour ”ENSA de Tetouan”!.*/

Les structures conditionnelles – Préambule
Une structure conditionnelle est un mécanisme qui permet de ne faire

exécuter une instruction ou un bloc d’instructions que lorsqu’une condi-
tion sera remplie ou pas.
On peut mettre en place une structure conditionnelle en faisant appel à
if . . . else, ou à switch . . . case, ou en utilisant une ternaire.

Les structures conditionnelles – Opérateurs de test
Les conditions testées font appel à des opérateurs de test.

On aura donc des expressions du genre :
– – valeur1 == valeur2 : Vaut true si les deux valeurs numériques ou
booléennes sont égales, false sinon,
– – Valeur1 != valeur2 : Vaut true si les deux valeurs numériques ou
booléennes sont différentes, false sinon,
– – valeur1 < valeur2 : Vaut true si valeur1 est strictement inférieure à
valeur2, false sinon (les deux étant des valeurs numériques),
– – valeur1 <= valeur2 : Vaut true si valeur1 est inférieure ou égale à
– – valeur1 > valeur2 : Vaut true si valeur1 est strictement supérieure à
– – valeur1 >= valeur2 : Vaut true si valeur1 est supérieure ou égale à
valeur2, false sinon (les deux étant des valeurs numériques).
Notez bien que les opérateurs de test == , != , < , <= , > et >= peuvent
s’utiliser aussi avec des variables de type char.

Les structures conditionnelles – Opérateurs logiques
On peut combiner plusieurs conditions à travers les opérateurs logiques

:
– – && : ET logique,
valeur1 && valeur2 : Vaut true si les deux valeurs booléennes sont true,
false sinon,
– – || : OU logique,
valeur1 || valeur2 : Vaut true si au moins une des deux valeurs
booléennes est true, false sinon.
On peut également utiliser l’opérateur NON logique : !,
!valeur1 : Vaut true si valeur1 est false, et vaut false si valeur1 est true.

Les structures conditionnelles – if . . . else
Syntaxe d’utilisation 1 :
if(valeurBooleenne) instruction V ; else instruction F ;
Syntaxe d’utilisation 2 :
if(valeurBooleenne)
{
instruction V 1 ;
..
.
instruction V N ;
}
else
{
instruction F 1 ;
..
.
instruction F M ;
};
Si la valeur booléenne est true, alors l’instruction ou le bloc d’instructions qui suit
la structure if est exécuté(e) ; sinon l’instruction ou le bloc d’instructions qui suit
la structure else est exécuté(e).
Les structures conditionnelles – if . . . else
On peut imbriquer des tests if, via la structure else if.

Syntaxe d’utilisation :
if(commandedecontrole1)
{
commandesA
/∗ Exécution si succès de commandedecontrole1. ∗/
}
else if(commandedecontrole2)
{
commandesB
/∗ Exécution si échec de commandedecontrole1, et succès
après de commandedecontrole2. ∗/
}
else
{
commandesC
/∗ Exécution si échec de commandedecontrole1 et échec
après de commandedecontrole2. ∗/
};

Les structures conditionnelles – switch . . . case
switch(nomvariable)
{
case valeur1 :
instruction 11 ;
.
.
.
instruction 1N ;
break;
.
.
.
case valeurP :
instruction P1;
.
.
.
instruction PM ;
break;
default :
instruction D1 ;
.
.
.
instruction DK ;
}

Les structures conditionnelles – switch . . . case
Si nomvariable vaut valeur1 alors l’instruction ou le bloc d’instruction qui

suit valeur1 sera exécuté(e).
..
.
Si nomvariable vaut valeurP alors l’instruction ou le bloc d’instruction qui
suit valeurP sera exécuté(e).
Si nomvariable ne vaut aucune des précédentes valeurs testées alors
l’instruction ou le bloc d’instruction qui suit default sera exécuté(e).
Notez bien que l’instruction break, permet de sortir du switch.

Les structures conditionnelles – Les ternaires
Une ternaire est une structure conditionnelle qui est très simple et rapide
à écrire. Les ternaires sont très utiles pour raccourcir les codes. De plus,
elles permettent de renvoyer une valeur.
Syntaxe :
expression analysée ?
valeur retournée si expression analysée vaut true :
valeur retournée si expression analysée vaut false ;
Exemple :
Scanner sc = new Scanner(System.in);
System.out.println(”Veuillez saisir une première valeur : ”);
int A = sc.nextInt();
System.out.println(”Veuillez saisir une deuxième valeur : ”);
int B = sc.nextInt();
System.out.println(”La plus petite valeur saisie est : ” + ((A <= B) ? A :
B));
int max = ((A >= B) ? A : B);/*max contient la plus grande valeur saisie.*/

Les boucles – Préambule
Une boucle est un mécanisme qui permet de répéter l’exécution d’une

instruction ou d’un bloc d’instructions tant qu’une condition sera remplie.
On peut mettre en place une boucle en faisant appel à while, ou à do
. . . while, ou à for.

Les boucles – while
while(condition) {
instructions;
}
On évalue la condition ; et en cas de succès, on fera un tour de
boucle. Tant que la condition sera satisfaite (vraie), on répétera le bloc
d’instructions.
Exemple :
int i=1; // initialisation
while(i<=10) {
System.out.println(i);
i++; // incrémentation
}

Les boucles – do . . . while
do {
instructions;
} while(condition);
Le test est effectué après le bloc d’instructions, i.e., la boucle est
exécutée au moins une fois peu importe la condition.
Exemple :
int i=1; // initialisation
do {
System.out.println(i);
i++; // incrémentation
} while(i<=10);

Les boucles – for
for(initialisation ; condition ; instruction pour faire sortir)
{
instruction(s);
}
On utilise généralement for quand on connait au préalable le nombre de
répétition de la boucle.
Exemple :
int i;
for(i=1;i<=10;i++) System.out.println(i);

Exercice
Faites un programme qui permet de convertir des devises étrangères en

Dirhams Marocains et inversement, en utilisant les taux de change suivants :
1 Dollar Américain = 9.81 Dirhams Marocains,
1 Dollar Canadien = 6.84 Dirhams Marocains,
1 Euro = 10.55 Dirhams Marocains,
1 Livre Britannique = 11.44 Dirhams Marocains,
1 Franc Suisse = 9.95 Dirhams Marocains,
100 Yens Japonais = 8.84 Dirhams Marocains,
1 Riyal Saoudien = 2.61 Dirhams Marocains.
L’utilisateur spécifie la devise étrangère, le sens de conversion et la valeur
à convertir, pour avoir finalement le résultat désiré. L’utilisateur pourra faire
autant de conversions qu’il voudra.

Java

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java

Transféré par

Droits d'auteur :

Formats disponibles

Outline

Modélisation et programmation orientée objet

R.J. Modélisation et programmation orientée objet 1/55

3 Programmation Orientée Objet

R.J. Modélisation et programmation orientée objet 2/55

La Programmation Orientée Objet (POO) est un paradigme de program-

R.J. Modélisation et programmation orientée objet 3/55

Il existe plusieurs langages de Programmation Orientée Objet :

R.J. Modélisation et programmation orientée objet 4/55

Pourquoi Java? (source : http://pypl.github.io/PYPL.html)

R.J. Modélisation et programmation orientée objet 5/55

La particularité et l’objectif central de Java est que les applications

R.J. Modélisation et programmation orientée objet 6/55

Premiers pas en Java

R.J. Modélisation et programmation orientée objet 7/55

Une plate-forme Java est un standard de plate-formes logicielles qui per-

Java Standard Edition ou Java SE (anciennement appelée J2SE) : c’est

R.J. Modélisation et programmation orientée objet 9/55

Pour pouvoir développer en Java, on a besoin de :

Il y a plusieurs EDI qui permettent de développer en Java. On utilisera

R.J. Modélisation et programmation orientée objet 11/55

R.J. Modélisation et programmation orientée objet 12/55

Téléchargement et installation des outils

1 Téléchargez et installez le JRE correspondant à

R.J. Modélisation et programmation orientée objet 13/55

Notre premier programme Java

Créez un projet Java (Java Project), i.e., un répertoire, qu’on va appeler

R.J. Modélisation et programmation orientée objet 14/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 15/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 16/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 17/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 18/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 19/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 20/55

Notre premier programme Java

Ajouter l’instruction ”System.out.println(”Hello world!”);”, dans la

R.J. Modélisation et programmation orientée objet 21/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 22/55

Notre premier programme Java

Exécutez le programme et regardez donc le résultat obtenu :

R.J. Modélisation et programmation orientée objet 23/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 24/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 25/55

Notre premier programme Java

R.J. Modélisation et programmation orientée objet 26/55

R.J. Modélisation et programmation orientée objet 27/55

Dans tout langage de programmation, dès qu’on a besoin de stocker une

R.J. Modélisation et programmation orientée objet 28/55

Les types de variables qu’on peut avoir sont :

R.J. Modélisation et programmation orientée objet 29/55

Voici des exemples de déclaration et d’initialisation de variables :

R.J. Modélisation et programmation orientée objet 30/55

R.J. Modélisation et programmation orientée objet 31/55

R.J. Modélisation et programmation orientée objet 32/55

int entree4 = sc.nextInt();/Lecture d’un nombre entier de type int./