BACHELOR 2

COURS PROGRAMMATION ORIENTÉE

OBJET ET

HODABALO Lidaou
Ingénieur Infra SAP Basis
 PLAN DU COURS DE CE JOUR
Le plan du cours de ce se présente comme suit :
▪ Préparation de l’environnement de développement Java
▪ Première application Java
▪ Variables et Entrées clavier
▪ Instructions conditionnelles
▪ Instructions itératives
▪ Tableaux statiques
▪ Chaines de caractères (String)
▪ Méthodes (Fonctions)
▪ Classe et Objet
 I. Préparation de l’environnement de développement Java

Pour ce faire, nous allons avoir besoin principalement de deux logiciels :

❑ Un environnement d’exécution java (Java SE)
❑ Un IDE : Integrated Development Environment (environnement de développement
intégré) qui sera un atelier permettant de produire nos lignes de codes. En l’occurrence
nous utiliseront Eclipse
La 1ère étape consiste à télécharger ces deux logiciels :
❑ Le 1er site c’est https://www.oracle.com/ : télécharger java SE
❑ Le second site c’est https://www.eclipse.org/ : télécharger notre atelier de
développement

1. Installation de Java SE
Télécharger d’abord Java SE.
Sur le site d’Oracle vous avez différents menus que vous pouvez consulter mais vous avez
principalement le menu Resources :

➔ Cliquer sur Resources

➔ Java downloads : Une fois ici, nous avons une petite difficulté. On ne voit pas java SE.
(Vous pouvez lire les informations qui s’y trouvent pour avoir une culture plus poussée)
Pour faire simple, le Java SE, vous pouvez le télécharger sous deux formes :
o Soit on va télécharger le JRE (Java Runtime Environment) : c’est un
environnement d’exécution de type java SE permettant d’exécuter vos
 programmes java sur une plateforme de votre choix mais attention cela ne
permet pas de développer.
o Pour développer il nous faut des outils complémentaires et notamment le
compilateur java. C’est pour cela qu’il nous faut télécharger le JDK (Java
Development Kit). Le JDK inclut le JRE et tous les outils de compilation.

➔ Plus bas Nous avons des versions de java SE disponibles pour le développement,
utilisation personnelle et pour faire tourner les autres produits sous licence oracle.

o Nous allons utiliser la version Java SE Development Kit 11.0.21 soit le JDK
11.0.21
o Nous avons des versions compatibles avec Linux, macOS, Solaris, Windows.
Nous nous allons télécharger la version Windows

➔ Lancer le téléchargement :
o Vous serez redirigé pour vous connecter. Faites-le si vous avez déjà un compte
sinon inscrivez-vous et lancer le téléchargement
o Installer ensuite le JDK

2. Téléchargement d’un IDE

La deuxième étape consiste à installer un IDE (Integrated Development Environment) –
environnement de développement. Il en existe un certain nombre :
Il serait difficile pour de dire lequel d’entre eux est le meilleur car chaque développeur a ses
préférences. Parmi les 03 majeurs, nous pouvons parler :
o intelliJ : éditer par la société jetbrains. Pour les curieux, vous
pourriez le télécharger et regarder un peu.

o netbeans : cette version, il y a une petite difficulté.

A l’origine, netbeans c’était l’atelier Sun Microsystem. Lorsque Oracle a racheté Sun
Microsystem, oracle est devenu propriétaire de ce logiciel.

Le problème c’est que, oracle était déjà énormément investi au niveau de la fondation
éclipse et travaillait donc notamment sur cet atelier éclipse. Du coup depuis longtemps,
ils ont annoncé que la propriété intellectuelle allait basculer au niveau de la page
fondation software. Et donc il est passé déjà en incubation chez Apache. Il est donc
devenu un projet Apache. A long termes l’on ne sait pas ce que va devenir Netbeans.
Oracle va s’en détacher progressivement et donc oracle continuera a être contributeur
sur éclipse.

o Pour ce cours, notre préférence c’est Eclipse

➔ Cliquer sur download
➔ Vous tombez sur cette page. Vous avez deux possibilités :
o Soit, vous cliquez sur Download 64 bit, vous téléchargez puis installez puis vous
pourriez ajouter d’autres plugins (php, du C ou du C++ etc)
o Soit, vous cliquez sur l’option Download package : vous y retrouvez différentes
distributions d’Eclipse. Elles sont préchargées avec un certain nombre de
plugins.
Exemple vous avez une version orientée vers développement web java ; plus bas
une version orientée vers le développement java classique, java type desktop.
Vous avez toujours la possibilité d’ajouter par après d’autres plugins. Faire
attention en regardant la bonne version de l’OS.

➔ Nous allons télécharger la version Eclipse IDE for Enterprise Java and Web Developers.
C’est vrai que nous n’allons pas démarrer par le développement web mais il y a un
certain nombre d’éléments qui pourraient nous intéresser.
➔ Puisque ça risque de prendre un peu de temps, j’ai moi-même pré télécharger cette
version
➔ Dézipper Eclipse. On peut le mettre où on veut. Il n’y a pas d’obligation à ce qu’il soit
localisé à un endroit précis. Vous pouvez faire un raccourci sur votre bureau sinon dans
tous les cas, vous pouvez lancer l’exécutable.
➔ Eclipse démarre
➔ Une fois démarré, en gros je vais vous présenter deux concepts pour que vous soyez à
l’aise :
o 1er concept : notion de workspace : littéralement c’est un espace de travail. En
fait c’est juste un dossier. Techniquement vous mettez ce dossier où vous
souhaitez – ce dossier est un conteneur de projets et vous pouvez y mettre autant
de projet que vous le souhaitez.
 Imaginez qu’on veuille développer une application client-serveur. On aura à
créer dans le même workspace constituant le produit complet, un sous projet
client, un projet serveur et un projet pour les codes communs au client-serveur.

Dans notre cas ici, il s’agit d’une formation java et chaque projet à l’intérieur de
mon workspace constituera un TP que je vous proposerai de mettre en œuvre.

Vous pouvez changer le dossier où sera présent votre dossier workspace en

cliquant sur « Browse ». Ici nous pouvons l’appeler workspaceJava.

o Dans l’interface ouvert présenter les différents concepts :

o Cliquer ensuite sur Ok. Une interface s’ouvre. C’est une fenêtre très intéressante,
je vous conseille de lire les infos présentées. Vous y retrouverez par exemple des
tutoriaux, des exemples de projets et différentes petites choses très intéressantes.
o Mais vu que le cours nous conduira à parcourir pas mal d’info, je vais fermer le
fenêtre.
o Si vous souhaitez la rouvrir, vous allez dans le menu HELP et vous retrouverez
WELCOME.
o Montrer que le dossier est bien créé en allant à l’emplacement.

➔ 2ème concept que je voulais vous présenter : concept de perspective : En gros les
perspectives, on va les retrouver en haut et à droite :

➔ Pour comprendre ces concepts on va démarrer par un petit préalable

o Si nous allons dans le menu Help, on voit que l’on peut installer des plugins
(Install New Software) complémentaires à mon Eclipse.
o Ainsi, si nous avons internet, en cliquant sur Install New Software, on peut se
connecter et rapatrier des composants complémentaires.
o Utiliser la capture ci-dessous pour montrer la version d’éclipse que l’on a.
o Ainsi, ici nous avons Eclipse (la dernière version d’Eclipse), c’est la version
d’Eclipse que nous venons d’installer. Pour chaque version d’Eclipse, ce que
vous avez, c’est un dépôt de plugins sur internet.
o Choisissez cette version d’Eclipse. En l’ayant choisi, c’est que vous vous
connectez au dépôt « Latest Eclipse Simultaneous » la version d’Eclipse, la
dernière version que nous avons.

o Ici j’ai la liste de tous les dépôts de plugins, bien entendu ceux non encore
installés. Et donc je pourrais installer ce dont j’ai besoin.

o Il n’y a pas que des plugins relatifs au langage de programmation. On y trouve

aussi tout ce qui est connexion de votre Eclipse avec votre base de données,
Modeling – modélisation UML par exemple

o Imaginons qu’on coche tout et qu’on installe l’ensemble des plugins disponibles.
Vous auriez un super bon atelier Eclipse mais le risque c’est que quand vous
voudriez utiliser votre Eclipse, au niveau des barres de menus, des barres d’outils
ou au niveau des menus contextuels, le risque c’est que vous serez chargé avec
énormément d’éléments qui vous permettraient de lancer une multitude
 d’assistants, et du coup vous pourrez être noyé sous le nombre de propositions
qui serait fait par l’outil.

o C’est pour éviter ce risque que Eclipse a mis en place la notion de perspective
qui peut être vu comme étant un filtre. En gros, une perspective c’est un filtre
sur l’ensemble des fonctionnalités offertes par l’atelier.

o L’interface que vous voyez actuellement est liée au fait qu’en ce moment c’est
la perspective Java EE (en haut à droite) qui vous est proposée. Actuellement
notre interface est configurée pour plutôt faire du développement type java Web.

o Nous pouvons changer de perspective en choisissant le type Java classic.

▪ Cliquez sur "Open perspective"

▪ Nous nous voulons faire un développement java de type classic. Choisir
Java. Veuillez constater que les menus ont été modifiés.
▪ Cliquez sur Ok. Votre atelier se reconfigurera… A tout moment, vous
pourriez changer de perspective.

o Nous pouvons clore la perspective de type Java EE.

▪ Faire un clic droit sur Java EE et cliquer sur close
▪ Si on veut rajouter Java EE, cliquer sur Perspective puis l’ajouter…

o Fermer la vue "Task List"

o Pour avoir une interface de travail plus large vous pouvez fermer la vue outline
à gauche. Pas d’inquiétude si vous la fermez par erreur et que vous souhaitez la
retrouver. Allez dans le menu Window ---- show View --- Outline

o Pour les fenêtres qu’on aura au centre qui permettront d’éditer du texte, on parle
plutôt d’éditeur : Window --- Editor

o Si vous voulez passer une vue en plein écran ou la réduire, il vous suffit de
double-cliquer sur la vue
Voilà, nous avons parcouru l’essentiel par rapport à la préparation de notre environnement, notre
environnement d’exécution java est installé, on va donc pouvoir travailler. Il est de type jdk.
Nous avons décidé d’installer un atelier Eclipse pour éviter d’utiliser notepad, blocnote etc..
II. Première application java
Dans la première partie du cours de ce jour, nous avons vu comment préparer notre
environnement de développement java. Il est maintenant temps de passer à la production de nos
premières lignes de code.
Je vous propose de démarrer Eclipse et nous allons créer notre premier projet java.

Pour se faire :
o Se placer dans la vue Package Explorer
o Cliquer sur : Create a Java Project
• Vous constaterez qu’un certain nombre de configurations vous est proposées.
• Si vous souhaitez obtenir des configurations complémentaires :
▪ Cliquer sur Next, en bas de la boîte de dialogue
▪ Pas de panique, pour chacune de ces configurations, la plupart du temps, il y a des
valeurs par défaut qui conviennent.
▪ Le seul champ réellement obligatoire est le champ : Project name
▪ Je vous propose d’y renseigner : helloworld. Effectivement, nous allons mettre en
place un petit projet de type helloworld qui va se contenter de produire des
affichages sur la console.
▪ Vous pourriez cliquer sur Next, si vous le souhaiter pour obtenir les écrans
complémentaires.
▪ Mais cliquons plutôt sur Finish : Votre projet est créé
▪ Si vous déroulez l’arborescence, vous avez la présence d’un dossier src. C’est ce
dossier qui est sensé contenir vos fichiers de code java
▪ Pour ajouter un nouveau fichier de code java,
✓ Clic droit sur src
✓ Sélectionner New : on y voit un certain nombre d’assistants, vous sont
proposés notamment l’assistant File :
✓ On pourrait l’utiliser mais c’est surtout utile si vous voulez créer des fichiers
textes ou des fichiers de ce type-là.
✓ Si ce que vous voulez c’est un fichier de code java, je vous conseille de prendre
plutôt l’assistant « class »

▪ Attention : la notion de class en programmation orientée objet est un concept

relative important. Nous y reviendrons dans le futur dans la partie du cours dédiée
à ce sujet.
Pour le moment, on va partir du principe que, une classe pour nous, c’est un
fichier de code. C’est une grosse caricature mais cela nous ira très bien pour
commencer.

▪ Cliquer ensuite sur class : normalement l’assistant de création de classe devrait

apparaître.
Encore une fois, vous avez tout un ensemble de configurations possibles. On
va se focaliser sur l’essentiel.

▪ Ce qu’il faut c’est surtout nommer votre class.

✓ Attention : en java, il y a des conventions de nommage. On va revenir sur ces
conventions tout au long du cours.
✓ Pour l’heure, la règle qu’on va devoir respecter, c’est qu’un fichier de code
java i.e une classe, doit commencer par une majuscule.
✓ Je vous propose d’appeler votre class : Start
✓ Le fichier, techniquement parlant, il s’appellera : Start.java mais ne mettez
pas .java, parce que si vous le faites, l’assistant va être en erreur. Il le rajoutera
lui-même. En effet, il ne veut absolument pas que vous éditiez cette partie-là.
✓ Notez que dans tout l’ensemble des configurations proposées, il y en a juste
une qui va nous intéresser à savoir : public static void main(String[] args)
✓ Normalement cette case à cocher permet de produire un main.
✓ Cocher la case en question.
Le main c’est le point d’entrée de votre programme java. C’est quelque chose
qui est hérité des langages comme C et C++. C’est normalement par cette
fonction que doit commencer votre programme, sauf que, attention, en java,
on n’a pas réellement de notion de fonction.
En lieu et place, on a un concept. C’est le concept de méthode. Encore une
fois, nous reviendrons sur la notion de méthode un peu plus tard.
On va partir du principe aujourd’hui que fonction ou méthode c’est à peu près
la même chose.
Donc la fonction main si je simplifie, c’est votre point de démarrage au niveau
de votre programme java.

✓ Malgré cela, regarder, on va décocher l’option de choix du main

✓ Cliquer sur Finish, cela va produire notre fichier et donc nous avons bien mon
fichier Start.java, qui contient ces quelques lignes de codes. Et effectivement,
le main n’est pas présent.

✓ Pour que le main soit présent, soyons clair, le mieux aurait été de cliquer sur
la case main comme nous l’avons vu précédemment.
✓ Si vous l’avez oublié, je vous propose une autre façon de vous en sortir : créer
une ligne en tapant main et que vous tapez une séquence de touche magique
(Ctrl + Espace)

✓ Eh bien, il vous fait une liste de proposition ou de suggestion, vous repérez ce

qui vous convient puis vous double cliquez sur l’élément, soit vous tapez sur
Entrée.

✓ Normalement, votre saisie est remplacée par le code souhaité.

✓ NB : Si nous avions coché la case main dès le début c’est ce résultat que nous
aurions eu. Vous n’auriez pas à l’insérer à ce stade.

✓ C’est nettement mieux de le générer que de le saisir manuellement pour éviter

de faire des erreurs.

✓ Imaginer, en saisissant vous mettez un "s" majuscule au niveau de static, il y

a risque que vous fassiez une petite coquille quelque part… Donc, attention à
correctement orthographié vos lignes de code.

✓ La séquence (Ctrl + Espace) est une pratique très exploitée et vous verrez
qu’on y reviendra un très grand nombre de fois parce que cela nous permettra
de produire un très grand nombre de lignes de code.

✓ Par exemple, si nous voulons maintenant faire un affichage sur la console,

nous saisirons System.out.println( "Hello world" )

System représente votre environnement java, sur lequel on a un flux de sortie

out. Sur ce flux de sortie, je vais faire un println. Comme vous pouvez vous
rendre compte, ici j’ai tout tapé à la main. Encore une fois j’aurais pu faire des
fautes de frappes.

✓ Le mieux aurait été de taper syso

sys pour system, o pour out

✓ Faire Ctrl + Espace, l’assistant vous complète automatiquement

System.out.println(). Il ne vous reste plus qu’à saisir votre message.

✓ Je vous conseille d’utiliser ces mécanismes-là.

✓ Ces séquences de touches, si vous souhaitez les retrouver, à savoir au niveau
de l’outil, vous avez systématiquement pour chacun des menus, l’ensemble
des raccourcis clavier qui vous sont proposés pour le menu

✓ Faire Ctrl+Shifft+L, normalement cela vous affichera la liste de tous les

raccourcis clavier accessible au niveau de cet éditeur et vous voyez bien le
 content assist, l’assistance à la saisie pour produire du contenu c’est Ctrl +
Espace.

Vous avez tous les autres raccourcis qui sont là. On apprendra à les utiliser au
fil de l’eau

✓ Comme nous l’avons vu il y a quelques minutes, si jamais je fais des bêtises,

je vais produire des erreurs. Nous allons pendant quelques minutes nous
pencher sur ces erreurs. Remplacer le S de system par un s minuscule.

✓ Là, votre fichier a été édité mais l’astérix à côté du nom Start.java signifie
qu’il n’a pas été enregistré.

✓ Faites Ctrl+Espace pour enregistrer ; vous constaterez que l’Astérix disparaît.

✓ A partir de là, votre erreur est matérialisée à différents endroits. Voir capture

✓ Imaginons qu’on ferme Eclipse maintenant et qu’on le réouvre demain ; quand

vous allez le réouvrir, vous vous retrouvez dans cet état-là. Cela vous
permettra de rapidement savoir qu’il y a une erreur dans le projet.

✓ Il vous suffit alors d’ouvrir la hiérarchie de dossiers pour descendre jusqu’au

fichier problématique. En double cliquant sur ce fichier vous réouvrirai ce
fichier-là.

✓ Allez-y sur le nom Start.java et double cliquez dessus. Que constatez-vous ?

l’éditeur passe en plein écran. Je constate mes erreurs là et là. Double-cliquer
pour revenir
✓ On peut être tenter de se demander pourquoi on a les erreurs des deux côtés.
Ça peut être redondant.

❖ En attendant de revenir sur les commentaires dans quelques minutes,

on va exprès augmenter temporairement la taille de notre fichier via
quelques commentaires.

❖ Là, on a un fichier important, il n’y a pas grandes choses dedans.

❖ Ce qu’on constate c’est que sur le côté gauche, nous n’avons pas le
marqueur d’erreur. C’est normal parce que dans cette vue n’est pas
affichée la ligne contenant l’erreur ; par contre sur le côté droit l’erreur
est bien matérialisée ici.

❖ Pourquoi ? Parce que sur le côté gauche c’est la vue qui vous est
proposée et sur le côté droit, ça représente le fichier dans son intégralité.

❖ Regardez : en vous déplaçant sur la verticale de gauche, on a

l’ascenseur en intégralité ; nous avons notre fichier (les bordure de
l’ascenseur). Par contre en dessous, il y a une partie non dévoilée.
Notre erreur est sur la partie inférieure.

❖ Double cliqué sur le signalement côté droit de l’erreur : vous serez

directement ramené sur la ligne de l’erreur en question. La vue se
déplacera pour nous afficher la ligne problématique.

Du coup le message est réapparu sur la gauche.

❖ Personnellement, j’ai tendance à privilégier la barre de droite. Cela me

permet en permanence d’avoir une visualisation sur l’intégralité de
mon fichier et normalement quand j’ai fini de travailler sur un fichier,
je prends soin de vérifier que je n’ai aucune erreur et tant qu’il n’y a
aucun avertissement (je vais revenir sur les avertissements dans
quelques secondes),

❖ Regardez, je vais remettre ici un S (system.out.print…) majuscule et je

vais produire une autre erreur.

Sur la même ligne, enlevez le point-virgule : je ne sais pas si vous avez

vu mais l’icône ici a changé. C’est le standard pour signaler une erreur.
Remettre le s minuscule. Vous avez toujours l’icône d’erreur mais elle
est couplée avec une ampoule.

Si l’atelier vous propose une petite ampoule, c’est qu’il a une idée. En
fait, il vous dit qu’il y a quelque chose qui ne va pas et qu’il a des idées
à vous proposer.
 Si c’est le cas, il vous suffira de cliquer sur l’ampoule pour voir
apparaître un menu contextuel qui vous proposera tout un ensemble de
possibilités.

Ici, il y a un certain nombre de choses mais à ce niveau-là "Change to

‘System’ (java.lang)", double-cliquez sur cet assistant : cela vous
ramène remet correctement le mot.

Constatez que l’erreur n’est plus en rouge, il y a l’icône qui est un peu
blanchâtre. Pourquoi ? C’est parce que le fichier n’est pas encore
sauvegardé. En fait, il me dit par rapport à la précédente sauvegarde, il
y a bien eu une erreur qui a été corrigée parce que maintenant c’est
blanc mais si je veux que cette icone disparaisse, il faut que je
sauvegarde le fichier.

✓ Notez que comme je vous le disais tout à l’heure, il n’y a pas que des erreurs.
Il y a aussi des Warning – avertissement.

✓ Regardez : saisir juste avant le syso : int a = 0; ici, je suis entrain de déclarer
une variable. Pour ceux qui connaissent le langage C, cela devrait
effectivement vous rappeler quelque chose. C’est exactement la même syntaxe
que pour C ou C++.

A savoir : j’ai ma variable, elle s’appelle a, son type int, int pour integer donc
a est un entier, et sa valeur par défaut c’est 0.

Ainsi j’ai déclaré ma variable.

Pour autant, regardé, j’ai ici un warning – avertissement. Regardez, l’icône

n’est plus rouge mais orange. En rouge ce sont les erreurs et en orange les
warning.

A ce niveau-là (à droite), j’ai un marqueur qui me dit qu’il y a un problème :

(pointer sur le a) en l’occurrence, c’est que j’ai déclaré une variable que je
n’utilise nulle part. Donc il me dit qu’il y a un souci.

Si je clique sur l’ampoule, il me fait des suggestions : une des suggestions c’est
de supprimer toute référence à a dans le programme.

Une autre solution, ce serait d’utiliser, regardez je reviens sur mon Hello word :
System.out.println( "Hello world" + a ) ; et regardez, mon problème disparait.

✓ Notez que, outre voir les erreurs sur les côtés de l’éditeur et au niveau du
package Explorer, il y aurait aussi la vue Problems : elle affiche tous les
warnings ou toute erreur.
 Regardez, je supprime l’utilisation de a, j’ai de nouveau le warning. Que faut
il faire pour avoir le warning affiché ?

Remettre le a et enlever le « ; », j’ai mon erreur qui est matérialisée. Dans les
deux cas on vous donne un message : le fichier posant problème et le numéro
de ligne sur laquelle le problème est constaté.

✓ Fermez l’éditeur

✓ Que se passera-t-il si je double-clique sur la ligne montrant l’erreur ?

✓ Cela me rouvrira l’éditeur en lieu et place

✓ Aller, du coup je corrige mon erreur : replacer le " ;" sur la ligne. C’est bien
affiché ici 0 erreur, 0 warning.

✓ Tout à l’heure, j’avais affiché des commentaires pour agrandir la taille de mon
fichier : je vais les supprimer et ne garder qu’un pendant quelques instants. Je
voudrais ainsi discuter de ces commentaires.

✓ Je voudrais ainsi discuter de ces commentaires. Déjà ce qu’on peut constater

c’est qu’il y a un petit aspect qui peut nous perturber dans certains cas.
Actuellement le texte de mon commentaire est surligné. C’est à peu près la
même couleur que pour les warnings.

Il faut quand même comprendre qu’on n’a là pas de warnings en termes de

code. Sur le côté gauche et le côté droit, on ne retrouve pas les marqueurs
visuels

Question : Qu’est-ce que c’est que ce surlignage ?

✓ Cliquez sur Window – Préférences

J’ai ici la configuration de mon workspace :

❖ Cliquez sur General

❖ Ouvrir le menu Editors
❖ Puis Text Editors
❖ Cliquer sur Spelling : on a ici des informations de configuration du
correcteur syntaxique en langue humaine.
Question : Pourquoi il me mettait commentaire en surligné ?
Réponse : Parce qu’en réalité, pour le moment, je n’ai qu’un dictionnaire
en Anglais. Certes, je pourrais rajouter un dictionnaire en français. Ça
pourrait aider à corriger cette erreur-là.
 Le problème ici est que même si vous ajouter des langues et que vous
utilisez des acronymes, il continuera par les souligner et quand il y en aura
énormément de soulignement, il les considérera comme des warnings.
Alors le mieux, c’est de venir sur la boîte de dialogue et de décocher :
"Enable spell checking", la vérification syntaxique en langue humaine ;
Le surlignage disparaît. A partir de cela, s’il vous reste du rouge ou du
orange c’est que vous avez une erreur ou un warning, donc il vous reste
quelque chose à faire. Il faudra corriger vos problèmes.

✓ Deuxième point à savoir, en java, il y a plusieurs formes de commentaires. On

pourrait dire qu’il existe jusqu’à trois formes de commentaires.

Pour le moment, je vais ignorer la troisième forme : juste pour information ce

serait sous cette forme :

Vous pouvez constater qu’il y a une différence de colorisation : vert et bleu.

Ce n’est pas exactement les mêmes commentaires. Ceci est dans un but bien
précis. Je reviendrai là-dessus plu tard.

✓ Pour le moment, je vais vous présenter deux formes de commentaires

❖ La forme qui est ici et qui vient de C. C’est la forme ci-dessous :

Notez que nous avons une étoile au milieu mais elle n’est pas
obligatoire.

Si vous supprimez l’étoile, pour autant le commentaire reste toujours

en vert. Donc ça suffit à faire un commentaire.

Mais pour une question de lisibilité, Eclipse trouve que c’est plus
judicieux de vous mettre ici une barre d’étoiles. Ça permet de mieux le
matérialiser, le borner.
 Il faut savoir que ce type de commentaire est multilignes. Vous
pouvez avoir un commentaire de 20, 30 lignes sans aucun souci.

Il faut bien entendu le fermer, sans quoi le reste du code passe en

commentaires.

Ainsi, c’est la première forme de commentaire. En réalité, elle vient de

C, et donc vous pouvez la réutiliser en java.

❖ La deuxième forme de commentaire, vient en réalité de C++. C’est lui

qui l’avait inventé en premier. Il s’agit du //.

Le // c’est le commentaire qui ne va en effet marcher que sur une seule

et unique ligne. A la fin de la ligne le commentaire est terminé

Exemple :

Noter bien que la suite, il n’y a pas de vert. C’est du code java classic.
Ainsi le commentaire s’est bien terminé au retour à la ligne.

Cette façon de faire les commentaires vient de C++. Il a été réintégré

en 99 à C, puis, il a été aussi ajouté à Java.

C’est la deuxième forme de commentaire et puis celle-ci m’intéresse

particulièrement parce que nous avons des raccourcis claviers qui sont
très intéressants.

Sélectionnez par exemple ce bloc :

Faites Ctrl+7, 7 du pavé numérique. Il vous met le tout en

commentaire.

Refaites Ctrl+7, il vous le supprime.

Autres : Ctrl+Shifft+/

C’est très pratique parce que parfois vous avez des sections de codes
que vous souhaitez enlever temporairement, vous ne voulez pas
complètement les supprimer. Vous les sélectionnez puis vous les mettez
en commentaires.
 Vous pouvez trouver d’autres séquences au niveau du menu Source.

Remettre le code en l’état en ayant supprimer les commentaires.

✓ Lancer le programme : une fois que votre programme est terminé, il nous faut
lancer ce programme.
❖ Pour le faire, c’est très simple : faites clic droit sur l’éditeur ---- Pointer
sur Run us ----- cliquer sur Java Application ----- Votre programme
démarre

❖ Je peux faire des modifications en insérant 2

A partir de là, il me faut relancer le programme pour voir les

modifications apparaître

❖ Vous pouvez aussi faire un clic droit sur le nom de ma classe ---- run as
----- run
❖ Enfin une dernière possibilité pour démarrer votre programme serait de

cliquer sur cette icône . Puisque qu’on a déjà marqué la calss start
comme étant un fichier de démarrage java, il le mémorise. Du coup à
chaque fois que vous allez lancer un run, il exécute le précédant run.

Voila ce qui clos cette partie qui a consisté à créer san première application java.
III. Variables et Entrées clavier
Dans cette partie, nous allons voir comment utiliser les variables en java et comment enregistrer
des entrée clavier.
• Une variable sert à stocker de façon adaptée une valeur en mémoire i.e ça peut être un
entier, un décimal, un caractère, une chaîne de caractères ou autres ;

• Une variable doit être déclarée (une seule fois : soit si c’est une variable globale, soit une
seule fois dans la méthode), avant d’être utilisée. On verra cela plus tard.

• Il existe plusieurs types de variables, dits primitifs. On verra ensuite des variables un peu
plus complexes.
Exemple de variables de types primitifs :
o Type int : entier relatif (cela nécessite 4 octets de mémoire pour le stocker)
o Type double : nombre décimal (cela nécessite 8 octets de mémoire pour le
stocker)
o Type char : caractère (Elle utilisera 2 octets)

• Le nom d’une variable ne doit pas comporter d’espace, ni de caractère spécial

• Par convention, le nom d’une variable commence par une lettre minuscule.

Exemple :
o i (qui sera par exemple régulièrement utilisé pour compteur, qui sera de type
entier) ,
o prix (le prix d’un article, qui sera de type décimal, donc de type double)
o ageDuCapitaine (voyez la façon de noter qu’on appelle le "camel case" i.e pour
simuler les espaces, on met des lettres en majuscules dans la variable ; âge du
capitaine serait un entier par exemple),
o Initiale (qui pourrait par exemple être une lettre de type char).

• Pour affecter une valeur à une variable, on utilise le symbole " = ".
Exemple :
o i = 1 ; (On affecte la valeur 1 dans la variable i).
o prix = 32. ; ( Question : A quoi sert ce point ? ce point sert à signaler au
compilateur que le nombre 32 est un nombre décimal puisque si on ne met pas
le point, il va considérer que c’est un entier. On verra tout ça plus tard).
o initiale = ‘M’ ; (Le M est mis entre des quotes ou entre apostrophes

• Petit exemple de programme utilisant des variables

o Allons dans Eclipse
o On reste toujours dans le même répertoire : notre WorkspaceJava
o Fermer le programme sur lequel nous étions précédemment : clic droit --- close
project ; ainsi j’ai fermé mon projet.
o Créons un nouveau projet que nous appellerons :
▪ Faites File (ou clic droit) ---- New ----- Java Project --- Name :
variable_et_scanner. On verra le scanner après.
o Clic droit sur src --- New --- Class --- Name : Princpale02
o On va créer un programme qui permet de calculer le quotient de deux entiers :

o On va maintenant commencer le programme en remplaçant ce commentaire par

défaut par : // Déclaration des variables

Question : De quelles variables aurions-nous besoin ?

Réponse :
▪ On va en déclarer deux de type int qui s’appellent :
int dividende, diviseur;

▪ Ensuite, une variable de type double qui s’appelle quotient

double quotient;

▪ Ensuite, on va initialiser ces variables :

Commentaire : // Initialisation des variables

Note : On pourrait se dire pourquoi ces surlignement-là. Eh bien ! ce

sont des messages d’avertissement. Une alerte du compilateur qui nous
dit que la valeur de cette variable ou de ces variables n’est pas utilisée.

Bien évidemment, on vient de démarrer le programme et ces variables

ne sont utilisées nulle part.

Si à la fin du programme ces surlignements jaune ou orange sont encore

là, cela suppose que ces variables ne sont jamais utilisées et qu’on peut
peut-être les supprimer pour libérer de l’espace mémoire utilisée de
façon inutile.
▪ Maintenant, on va initialiser dividende à 5 et diviseur à 2 :
dividende = 5;
 diviseur =2;

▪ On va calculer le quotient de la division de dividende par diviseur :

// Calcul du quotient
quotient = dividende / diviseur;

▪ On va enfin afficher le résultat dans la console :

// Affichage du résultat dans la console
System.out.println(" le quotient de la division est : " +
quotient);

▪ Nous avons maintenant notre programme. Constatez avec moi que les
surlignements orange n’y sont plus ; puisqu’effectivement on a utilisé
maintenant ces variables. Notre programme ne présente plus d’erreurs.

▪ Je peux donc maintenant lancer le programme en cliquant sur run

▪ Et je constate que le quotient de la division est 2.0. Cela signifie que c’est
un réel. Par contre de qui est surprenant c’est qu’on aurait pensé trouver
plutôt 2.5 puisque 5/2 donne 2.5.

Question : Que s’est-il passé ?

Réponse : il s’est passé tout simplement que lorsqu’on a fait la division
d’un entier par un entier (dividende et diviseur sont de type entier),
naturellement l’ordinateur fait la division entière i.e la division
euclidienne. Par conséquent, il nous a affiché le quotient de la division
euclidienne de 5 par 2 i.e 2 et en fait, il y aurait un reste qui 1 qu’on n’a
pas là

Si on veut éviter ce genre de problème, en ce moment-là, il faut déclarer

une des deux variables ici (int dividende, diviseur;) dans le type
double (double quotient;) ; comme cela l’ordinateur va choisir le type
le plus étendu.

▪ On va donc essayer cela :

Copier dividende dans (int dividende, diviseur;) et le coller dessous
dans (double quotient;) ;

Cette fois-ci dividende est de type double.

Relançons le programme sans rien modifier
Si on veut, on peut mettre 5.0 dans (dividende = 5;)
Je lance mon programme et cette fois-ci, on constate que le quotient de
la division est bien 2.5

o On va maintenant modifier ce programme de façon à ce que l’utilisateur puisse

rentrer lui-même le diviseur et le dividende de la division.
▪ Qu’est-ce qui va changer ? C’est la partie où nous avions initialiser les
variables. Je parle de cette partie (la montrer dans le code)
Modifier notre commentaires au tout début du programme :
 // Ce programme calcule le quotient de 2 nombres entrés par
l'utilisateur au clavier et l'affiche dans la console

▪ Ici on a un nouvel outil qui s’appelle Scanner. Cet outil n’est pas fourni
dans les outils de base de java.
Par conséquent, il faut l’importer i.e l’ajouter à notre programme et cela
s’ajoute au tout début du programme. On reviendra là-dessus dans
quelques instants.

▪ On va donc commencer par modifier la partie e question :

Commentaires :
// Enregistrement des variables tapées par l'utilisateur

▪ On va introduire le Scanner :
Scanner clavier = new Scanner(System.in); On constate qu’il y a
quelques erreurs. On va regarder le type d’erreur.

▪ Mettons-nous sur le mot Scanner qui contient l’erreur. On a des solutions

qui nous sont proposées. Ce que nous allons faire ce sera de cliquer sur
1

▪ Vous allez trouver cette instruction : import java.util.Scanner; au

début quelque part dans le code.

Enregistrer et maintenant il n’y a plus d’erreur

▪ Ensuite, ici (quotient = dividende / diviseur;), évidemment, nous

avons une erreur, pourquoi ? On va également voire en se positionnant
sur dividende par exemple.

On nous dit que les variables ne sont pas initialisées et bien évidemment
c’est parce qu’on travaille pour l’instant avec des variables qui ne n’ont
pas de valeur initiale puisqu’on a supprimé l’initialisation des variables.
Donc attention à cela
 Si nous allons sur le warning, on nous dit que le clavier n’est jamais
fermé. Il faut en fait à la fin de son programme, fermer le clavier. Je
reviendrai là-dessus plus bas.

Par contre il n’est pas obligatoire de le fermer par le ramasse-miettes car

même si on ne le fait pas, l’erreur est là pour l’instant mais ce sera
corriger par la suite.

▪ Maintenant on va récupérer les valeurs de dividende / diviseur. Pour

cela on va commencer par un message :
System.out.println( " Entrer le dividende : ");

▪ On va récupérer ce dividende à l’aide du scanner :

dividende = clavier.nextDouble();

On peut constater que lorsqu’on tape (dividende = clavier.), on a une

liste de possibilités que nous donne le scanner qui s’affiche. Je prends ce
qui m’intéresse, ici c’est nextDouble(). Double-cliquer dessus pour
choisir et l’instruction s’affiche.
▪ On va maintenant récupérer le diviseur à l’aide du scanner en faisant un
copie-coller de ce qui précède, puis on modifie :
System.out.println( " Entrer le diviseur : ");
diviseur = clavier.nextInt();
▪ On voit bien qu’il n’y a plus aucune erreur si ce n’est que je n’ai pas
encore fermé le clavier. On va le faire à la fin du programme à l’aide de
l’instruction : clavier.close();

On voit qu’il n’y a plus d’erreur. L’avertissement plus haut disparaît.

C’est pour dire qu’une fois qu’on a un objet qu’on a importé nous-mêmes,
on peut le fermer, i.e le détruire de façon à libérer l’espace de mémoire
qu’il utilise. Mais si on ne le fait pas, le programme le fera de lui-même
avec un outil qui s’appelle le ramasse-miette qui est un outil particulier
à java.

▪ Je peux maintenant lancer mon programme : Il m’est demandé d’entrer

le dividende etc...

▪ On a bien le programme qui fonctionne et qui permet cette fois-ci à ce

que l’utilisateur rentre lui-même les valeurs dont il veut connaître le
quotient.
▪ Instructions en Java à retenir :

import java.util.Scanner; // Importation de l'outil Scanner :

instruction à importer pour pouvoir faire la saisie
Scanner clavier = new Scanner(System.in); // Création d'un objet
de la classe Scanner nommée clavier
 clavier.nextDouble(); // Enregistrement d'un nombre décimal tapé
au clavier

clavier.nextInt(); // Enregistrement d'un nombre entier tapé au

clavier

clavier.close(); // Libération de la mémoire réservée à l'objet

clavier

IV. Instructions conditionnelles

Dans cette partie, nous allons étudier les instructions conditionnelles
• Instruction Si … Alors …
if (condition) {
actions
}
• Instruction Si … Alors … Sinon …
if (condition) {
actions
} else {
actions
}

• Opérateurs de comparaison : pour les conditions les opérateurs de comparaisons sont :

égalité == , différence != , supérieur ou égale : >=, inférieur ou égale <=

• Programme avec instruction conditionnelle :

Exercice : Ecrire un programme qui demande à l’utilisateur de saisir au clavier le prix

d’un article avant qu’il ne soit soldé et son code de réduction puis qui calcule affiche le
prix de cet article selon qu’il est soldé à -20% ou à -50%.
• Aller dans Eclipse
• Créer un projet qu’on nommera : if_then_else
• Créer ensuite une classe que vous nommerez : Principal03
• Poursuivre et finaliser le code tel qu’indiqué sur la capture ci-dessous :

• Procéder au test.

• On va compléter ce programme en rajoutant un cas supplémentaire : le cas où le prix de

l’article soldé est de 70 % pour montrer comment on peut restructurer les if…else
• Procéder au test
• Imaginez qu’on ait beaucoup de cas différent à traiter. Nous utiliserons à la place de
l’imbrication des if…else… Il s’agit de l’instruction ci-dessous :

• Instruction à choix multiples

switch (nomVariable) { // nomVariable est une varibale de type int ou char
case valeur1 : actions
break ;
case valeur2 : actions
break ;
default : actions // exécuté si nomVariable ne prend aucune des valeurs
//proposées
// CAS FACULTATIFS
}

• Modifier le programme
V. Instructions itératives
Dans cette partie, nous allons étudier les instructions itératives qu’on appelle aussi boucles.
Le premier type de boucle est la boucle for :
• Instruction Pour … de … à … par pas de …
La boucle for est utilisée lorsqu’on veut répéter une instruction un certain nombre de fois
et que ce nombre de fois est connu à l’avance. Dans ce cas la syntaxe est la suivante :

for (nomVariable = valeurDebut ; nomVariable <= valeurFin ; nomVariable++ ) {

actions // nomVariable est une varibale de type int

Ou bien (par exemple)

for (nomVariable = valeurDebut ; nomVariable > valeurFin ; nomVariable-- ) {

actions

Exercice :
Un capital est placé durant n années à un taux annuel d’intérêts composés de t%.
Ecrire un programme permettant de calculer les intérêts acquis au bout des n années.

Voilà ici un petit programme à analyser : on va demander à l’utilisateur d’entrer le nombre

d’années, d’entrer le taux d’intérêt, d’entrer le capital initial et on va calculer les intérêts
acquis au bout des n années dans ce contexte.

• Démarrons Eclipse de nouveau

• Créer un projet qui sera nommé : boucle_for
• Créer une classe qui sera nommée :Principal04
• Instruction Tant que… Faire

while (condition ) { // La condition est testée en début de boucle

actions

Deuxième instruction de type itérative, c’est la boucle de type while.

Dans ce cas, on a un bloc d’instructions qui sera effectué à condition que la condition entre
parenthèse soit vraie.
A partir du moment où la condition est fausse, le programme continue sa route après la
deuxième accolade.

Le problème avec ce type de boucle c’est qu’on ne sait pas combien de fois on va effectuer
la boucle et il se peut qu’on n’y passe jamais car par exemple si la condition initiale est
jamais réalisée, en ce moment-là ce bloc d’instruction ne sera jamais réalisé.
 Si on veut être sûr que notre bloc d’instruction se réalise une fois, dans ce cas-là on la
possibilité de faire une boucle de type Do… while, où la condition est testée en fin de
boucle. Par conséquent, on est sûr de passer au moins une fois dans cette boucle et donc
d’effectuer la série d’actions qui sont ici.

Do (condition) { // La condition est testée en fin de boule (on passe au moins

une fois)
actions
} while (condition)

Exercice :
Un capital est placé à un taux annuel d’intérêts composés de t %.
Ecrire un programme permettant de connaître le nombre d’années qu’il faut placer ce
capital afin d’obtenir un gain donné.

• Démarrons Eclipse de nouveau

• Créer un projet qui sera nommé : boucle_while
• Créer une classe qui sera nommée : Principal05

• Ecrire le même code avec la boucle do….While

VI. Tableaux statiques

Dans cette partie, nous allons étudier les tableaux statiques i.e les tableaux qui ont une longueur
fixe.
Un tableau est un objet i.e comme (Scanner), c’est une structure de données complexes.
Par contre, contrairement au Scanner, le tableau est un type d’objet contenu dans le package par
défaut.
Création d’un tableau : Pour créer un tableau la syntaxe est la suivante
TypeElements nomTableau [] = new typeElements [nombre de cases] ;

En fait le mot clé new sert simplement à construire un espace mémoire nécessaire à notre
tableau.
Je rappelle que le nombre de cases que contient le tableau est fixe et ne peut pas être modifié.
Affecter des valeurs à un tableau :
Lorsqu’on veut affecter des valeurs à un tableau, la syntaxe est la suivante, d’abord on met le
nom du tableau, suivi entre crochets de la position dans laquelle on veut mettre les éléments
(l’indice), et ensuite égale avec ici la valeur.
nomTableau [position] = valeur ; // Attention ! la 1ère case du tableau à l’indice 0 !! et non pas
le numéro 1 comme on pouvait s’y attendre.

Lecture des valeurs d’un tableau :

Lorsqu’on veut lire des valeurs dans un tableau, en ce moment-là, on peut par exemple les
stocker dans une variable auparavant de la façon suivante :
nomVariable = nomTableau [position] ;

Nombre de cases d’un tableau :

Lorsqu’on veut connaître la longueur d’un tableau i.e le nombre de cases, on a une instruction
prédéfinie à notre disposition qui est :
nomTableau.length // length donne la longueur du tableau i.e le nombre de case du tableau
Par conséquent, sachant que la première case du tableau à l’indice 0, la dernière case du tableau
aura pour indice nomTableau.length – 1.

Exercice :
On place un capital durant n années à un taux annuel d’intérêt composés de t %.
Réaliser un programme qui calcule les intérêt acquis au cours de n années.
On utilisera un tableau pour enregistrer les intérêts acquis chaque année puis les afficher.

VII. Chaines de caractères (String)

Dans cette partie du cours, on va voir comment utiliser les chaînes de caractères en Java.
Chaînes de caractères : objet String
Une chaîne de caractère est un objet du type String contenu dans le package par défaut i.e on
n’a pas besoin de l’importer lorsqu’on veut l’utiliser. On rappelle qu’un objet c’est un type
complexe différents des types primitifs que sont int, double. On a déjà vu des objets tels que le
Scanner, la structure de données des tableaux.
Création d’une chaîne de caractères :
Lorsqu’on veut créer une chaîne de caractères c’est-à-dire une variable de type chaîne de
caractères, l’instruction est la suivante :
String chaine = new String() ;
Instruction de lecture :
Si on veut récupérer une chaîne de caractère qui a été tapée au clavier pour la stocker dans une
variable de type chaîne de caractère, on utilise l’instruction suivante : chaine étant la variable
de type chaine de caractères où l’on veut stocker ce qui a été saisi au clavier, suivit de égale,
suivi du nom Scanner, en général, nous l’avons dans notre cours appelé clavier suivi de .next.
chaine = nomScanner.next() ;
NB : On rappelle qu’on avait next(int) pour récupérer un entier, next(double) pour récupérer
un décimal maintenant nous avons next() pour récupérer une chaîne de caractères.

Instruction d’écriture :
System.out.print(chaine) ;

Opération sur une chaîne de caractères :

Quelles sont les opérations que l’on peut effectuer sur une chaîne de caractères ? On verra
simplement les premières opérations ici, et puis on verra les autres au fur et à mesure lorsqu’on
en aura besoin.

• D’abord, on peut être intéressé par le fait de savoir la longueur de la chaîne de caractères.
On voit ici qu’on a length avec les parenthèses .length.() alors que pour les tableaux on en
avait pas. Donc :

chaine.length // va nous donner la longueur de la chaîne chaine

Exemple : String s = new String() ; // si je je crée un String que j’appelle "s"
S = "Bonjour" ; // que je lui affecte la chaîne de caractère "Bonjour"
System.out.print(s.length()) ; // si j’affiche System.out.print(s.length()) en
// ce moment là qu’est ce que j’aurai comme
//résultat ?
// La valeur 7 va s’afficher

• La deuxième instruction possible

chaine.substring(intDebut, intFin)

Cette instruction permet de récupérer une partie de la chaine de caractères. Il s’agit de la

partie qui va de intDebut (indice de début) jusqu’à l’indice de fin, intFin -1.

Exemple : si je tape l’instruction : System.out.print(s.substring(0,4))

Cela va me permettre d’avoir la sous chaîne de la chaine s (la chaine définie plus haut
"Bonjour"), je vais récupérer les caractères de l’indice 0 jusqu’à l’indice (4 – 1) i.e 3.
Par conséquent, je vais enlever le B, o, n et j puisqu’on commence à 0, donc 0 pour B, 1pour o,
2 pour n et 3 pour j. J’aurais donc comme affichage Bonj

• Autre instruction possible :

 chaine.charAt(i)

Cette instruction me renvoie le caractère de la chaîne de caractère chaine situé en position i.

Ansi avec CharAt, on récupère un caractère et non une chaîne.

Exemple : si je fais System.out.print(s.charAt(2))

J’aurais la lettre n à l’écran. Je rappelle qu’on commence à 0, par conséquent le caractère
d’indice 2 correspond au 3ème caractère de la chaine.

• Autre instruction possible :

chaine.toUpperCase()
Cette instruction permet de convertir tous les caractères d’une chaîne de caractères chaine en
majuscule.
Exemple : si j’affiche System.out.print(s.toUpperCase())

Cette instruction affichera à l’écran, dans la console, la chaine de caractère BONJOUR (le tout
mis en majuscule.

• Autre instruction possible :

chaine.toLowerCase()
Cette instruction permet de convertir tous les caractères d’une chaîne de caractères chaine en
miniuscule.
Exemple : si j’affiche System.out.print(s.toLowerCase())

Cette instruction affichera à l’écran, dans la console, la chaine de caractère bonjour (le tout mis
en minuscule.

Opération avec 2 chaînes de caractères :

chaine1.equals(chaine2)
Si j’ai deux chaînes chaine1 et chaine2 et je veux savoir si elles contiennent la même chose.
Comme ce sont des type complexes, je ne peux pas utiliser le symbole "==" que j’ai utilisé avec
les types primitifs parce qu’en ce moment, cela va me donner des adresses qui correspondent
aux références de cette chaîne (chaine2), on verra cela plus tard et donc ça ne marchera pas.

Donc, si je veux comparer le contenu de chaine1 avec le contenu de chaine2, l’instruction c’est
equals.

Attention : java est sensible à la casse i.e si ici si chaine1 c’est "bonjour" en minuscule et
chaine2 c’est "BONJOUR" en majuscule, bien évidemment le equals renverra la valeur false
puisque les deux chaînes ne sont pas identiques.

Lorsque je veux comparer deux chaines dans tenir compte des majuscules et des minuscules,
en ce moment-là j’utiliserai l’instruction :
 chaine1.equalsIgnoreCase(chaine2)

Dans ce cas java ne s’occupera de la casse ou encore du fait qu’il y ait des minuscules et des
majuscules.

Exercice : chaîne de caractère

Ecrire un programme de reconnaissance de mot de passe.
Le mot à taper par l’utilisateur est SeSaMe. Après 3 échecs consécutifs, le programme se
termine en affichant un message indiquant à l’utilisateur qu’il a épuisé ses trois essais.

Message d’erreur : l’alarme va se déclencher

Message ok : Merci, vous pouvez entrer

VIII. Méthodes (Fonctions)

Dans cette partie du cours, nous allons étudier les méthodes en java qu’on peut aussi appeler
les fonctions.
Une méthode est utilisée pour éviter la répétition d’un même bloc d’instructions plusieurs fois
dans le programme. On distingue deux types de méthodes :
1. Méthode qui ne renvoie pas de valeur (void)
L’entête d’une telle méthode est cellui-ci-dessous. On commence par le mot clé static que nous
expliquerons un peu plus tard, suivi du mot clé void qui indique justement que la méthode ne
renvoie pas de valeur, suivi du nom de la méthode (nomMethode) qu’on a choisi, suivi de ces
arguments entre parenthèses séparés par des virgules (il s’agit du type de la variable et son
nom, etc …)

Ces arguments sont issus du programme principal i.e qu’on va faire une copie du contenu de la
variable (nomVar1 par exemple), on va l’utiliser dans la méthode et bien évidemment lorsqu’on
aura fini l’utilisation de la variable, cette dernière sera rendue dans son état initiale i.e son
contenu ne sera pas modifié.

On peut dans notre corps de méthode, qui est compris entre les deux accolades, déclarer des
variables internes à la méthode, qui seront également détruites en fin d’utilisation de la
méthode, et en suite un certain nombre d’actions que va faire la méthode, qui peuvent influer
par contre sur le programme principal comme on le verra dans l’exemple qui suit.
static void nomMethode (typeVar1 nomVar1, typeVar2 nomVar2, … ) {
// S’il n’y a pas d’arguments, on écrit void nomMethode()
Déclarations des variables internes à la méthode
actions
}

Appel de la méthode :
Lorsque je veux appeler ma méthode dans le programme principal, je ferai
simplement nomMethode, suivi des arguments (nomVar1, nomVar2, … ) qui vienne de mon
programme principal, en relation différence avec l’entête (typeVar1 nomVar1, typeVar2
nomVar2, … ),

nomMethode (nomVar1, nomVar2, … )

Une méthode sera insérée avant la ligne public static void main(String[] args), puisque c’est
également une méthode nommée main, donc on ne va pas mettre une méthode dans une
autre méthode mais on va séparer les méthodes. En général, on met avant mais on peut
mettre après comme on veut.

Exercice :
L’utilisateur tape au clavier le prix d’un produit puis le pourcentage de réduction qu’on lui
applique
Le programme calcule puis affiche le prix "soldé" en Fcfa du produit après avoir appliqué la
réduction.
La méthode est utilisée pour gérer le calcul et l’affichage du prix final.

On va reprendre ce qu’on avait déjà fait avec les soldes i.e l’utilisateur va taper au clavier le
prix d’un produit et le pourcentage de réduction qu’on lui applique et le programme va calculer
et afficher le prix soldé par l’intermédiaire d’une méthode.

2. Méthode qui renvoie une valeur

On s’intéresse maintenant au 2ème type de méthode i.e la méthode qui renvoie une valeur :
return.

Sa déclaration sera toujours précédée du mot clé static. Ensuite, on n’aura plus le mot clé void
mais on aura le type de valeur que renvoie typeValeurRenvoyée la fonction, suivi du nom de la
méthode nomMethode qu’on a choisi, suivi de ces arguments entre parenthèses séparés par des
virgules (il s’agit du type de la variable et son nom, etc …)

Tout comme précédemment, ces arguments sont issus du programme principal i.e qu’on va faire
une copie du contenu de la variable (nomVar1 par exemple), on va l’utiliser dans la méthode
et bien évidemment lorsqu’on aura fini l’utilisation de la variable, cette dernière sera rendue
dans son état initiale i.e son contenu ne sera pas modifié.

On peut dans notre corps de méthode, qui est compris entre les deux accolades, déclarer des
variables internes à la méthode comme précédemment, qui seront également détruites en fin
d’utilisation de la méthode, et ensuite à la fin l’instruction return qui indique quelle est la valeur
renvoyée par la méthode et donc ici valeurRenvoyée.

static typeValeurRenvoyée nomMethode (typeVar1 nomVar1, typeVar2 nomVar2, … ) {

Déclarations des variables internes à la méthode
Actions
return(valeurRenvoyée)
}
Appel de la méthode :
Lorsqu’on voudra appeler cette méthode, cette fois-ci, on pourra stocker la valeur renvoyée
dans une variable qui s’appelle nomVariable et derrière on mettre = nomMethode avec les
paramètres utilisés comme précédemment.

nomVariable = nomMethode (nomVar1, nomVar2, …)

Une méthode sera insérée avant la méthode public static void main(String[] args), ou après
mais pas au milieu, de la méthode main.

Exercice :
L’utilisateur tape au clavier le prix d’un produit puis le pourcentage de réduction qu’on lui
applique
Le programme calcule puis affiche le prix "soldé" en Fcfa du produit après avoir appliqué la
réduction.
La méthode est utilisée pour gérer le calcul et l’affichage du prix final.

Note : C’est le même exemple que dans la première partie, simplement que cette fois-ci on va
demander à la méthode de renvoyer la valeur du prix final i.e le prix qui a été calculé après
l’application du taux de solde.

IX – Classe et Objet