I- Java :

1- Historique :

Java est un langage de programmation à usage général, évolué et

orienté objet dont la syntaxe est proche du C. Ses caractéristiques ainsi
que la richesse de son écosystème et de sa communauté lui ont permis
d'être très largement utilisé pour le développement d'applications de
types très disparates. Java est notamment utilisée largement pour le
développement d'applications d'entreprises et mobiles.

Le JRE (Java Runtime Environment) contient uniquement

l'environnement d'exécution de programmes Java. Le JDK contient
lui-même le JRE. Le JRE seul doit être installé sur les machines où
des applications Java doivent être exécutées.
Depuis sa version 1.2, Java a été renommé Java 2. Les numéros de
version 1.2 et 2 désignent donc la même version.
Le JDK a été renommé J2SDK (Java 2 Software Development Kit)
mais la dénomination JDK reste encore largement utilisée, à tel point
que la dénomination JDK est reprise dans la version 5.0. Le JRE a été
renommé J2RE (Java 2 Runtime Environment). Trois plateformes
d'exécution (ou éditions) Java sont définies pour des cibles distinctes
selon les besoins des applications à développer :

 Java Standard Edition (J2SE / Java SE) : Environnement

d'exécution et ensemble complet d'API pour des applications de
type desktop. Cette plate-forme sert de base en tout ou partie aux
autres plateformes,

 Java Enterprise Edition (J2EE / Java EE) : Environnement

d'exécution reposant intégralement sur Java SE pour le
développement d'applications d'entreprises,
·
 Java Micro Edition (J2ME / Java ME) : Environnement
d'exécution et API pour le développement d'applications sur

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 1
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
 appareils mobiles et embarqués dont les capacités ne permettent
pas la mise en œuvre de Java SE.

2- Les Concepts de base :

La plate-forme Java utilise quelques notions de base lors de sa mise en

œuvre, notamment :

La compilation du code source dans un langage indépendant de

la plate-forme d'exécution : Le bytecode,
L'exécution du bytecode par une machine virtuelle nommée
JVM (Java Virtual Machine),
La notion de package qui permet d'organiser les classes,
Le classpath qui permet de préciser au compilateur et à la JVM
où elle peut trouver les classes requises par l'application,
Le packaging des classes compilées dans une archive de
déploiement nommée jar (Java ARchive).

3- La compilation et l'exécution

Un programme Java est composé d'un ou plus généralement plusieurs

fichiers source. N'importe quel éditeur de texte peut être utilisé pour
éditer un fichier source Java.

Ces fichiers source possèdent l'extension .java. Ils peuvent contenir

une ou plusieurs classes ou interfaces mais il ne peut y avoir qu'une
seule classe ou interface déclarée publique par fichier. Le nom de ce
fichier source doit obligatoirement correspondre à la classe près au
nom de cette entité publique suivi de l'extension .java

Il est nécessaire de compiler la source pour le transformer en J-code

ou bytecode Java qui sera lui exécuté par la machine virtuelle. Pour
être compilé, le programme doit être enregistré au format de caractères
Unicode : Une conversion automatique est faite par le JDK si
nécessaire.

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 2
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Un compilateur Java, par exemple l'outil javac fourni avec le JDK est
utilisé pour compiler chaque fichier source en fichier de classe
possédant l’extension .class. Cette compilation gère pour chaque
fichier source un ou plusieurs fichiers class qui contiennent du
bytecode.

Exemple :

public class MaClasse {

public static void main(String[] args) {
[Link]("Bonjour tous le monde");
}
}

4- Les packages :

Les fichiers sources peuvent être organisés en packages. Les packages

définissent une hiérarchie de noms, chaque nom étant séparé par le
caractère point. Le nom d'un package est lié à une arborescence de
sous-répertoires correspondant à ce nom.

Ceci permet de structurer les sources d'une application car une

application peut rapidement contenir plusieurs centaines voire milliers
de fichiers source. Les packages permettent aussi d'assurer l'unicité
d'une classe grâce à son nom pleinement qualifié (nom du package
suivi du caractère «.» suivi du nom de la classe).
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 3
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Exemple :
[Link] : Création d'applets
[Link] : Création d'interfaces graphiques avec AWT
[Link] : Accès aux flux entrant et sortant.
I- Classes et Objets
Les programmes Java sont constitués de classes qui représentent des
objets du monde réel. Même si chaque personne écrit des programmes
à sa façon, presque tout le monde est d’accord pour reconnaître que la
meilleure façon de le faire est d’employer le style dit Orienté Objet.
Cela signifie que les bons programmeurs commencent par décider
quels objets doivent être inclus dans le programme et quelles classes
Java vont les représenter. Ce n’est qu’une fois cette étape menée à
bien qu’ils commencent à écrire du code Java.
Les classes Java peuvent posséder des Méthodes et
des Attributs.
Les méthodes définissent les actions qu’une classe
peut effectuer.
Les attributs décrivent la classe.

Créons et discutons une classe nommée JeuVidéo. Cette classe peut

avoir plusieurs méthodes, qui représentent les actions que les objets de
cette classe peuvent effectuer : démarrer le jeu, l’arrêter, enregistrer
le score, etc. Cette classe peut aussi posséder des attributs ou
propriétés : prix, couleur de l’écran, nombre de télécommandes et
autres.

En langage Java, cette classe pourrait ressembler à ceci :

Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 4
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
class JeuVidéo {
String couleur;
int prix;
void démarrer () {
}
void arrêter () {
}
void sauverScore(String nomJoueur, int score) {
}
}

Notre classe JeuVidéo est sans doute similaire aux autres classes qui
représentent des jeux vidéo – ceux-ci ont tous des écrans de taille et de
couleur différentes, effectuent des actions similaires et coûtent de
l’argent.
Nous pouvons être plus spécifiques et créer une autre classe Java,
nommée GameBoyAdvance. Elle appartient aussi à la famille des jeux
vidéo, mais possède certaines propriétés spécifiques au modèle
GameBoy Advance, par exemple un type de cartouche.

class GameBoyAdvance {
String typeCartouche;
int largeurEcran;
void démarrerJeu() {
}
void arrêterJeu() {
}
}

Dans cet exemple, la classe GameBoyAdvance définit deux attributs –

typeCartouche et largeurEcran – et deux méthodes – démarrerJeu et
arrêterJeu. Mais, pour l’instant, ces méthodes ne peuvent effectuer
aucune action, parce qu’il n’y a pas de code Java entre leurs
accolades.
Après le mot classe, tu dois maintenant t’habituer à la nouvelle
signification du motEnseignant
objet. : Mahamoud Ahmat Hamid 5
Cours : Programmation java
La phrase "créer une instance d’un objet" signifie créer une co pie de cet
Contact : +235 66219059
objet dans
Emailla mémoire de l’ordinateur en respectant la définition de sa
: ahmathamid_mahamoud@[Link]/djangui2022@[Link]
classe.
Un plan de fabrication de la GameBoy Advance correspond à une
console réelle de la même façon qu’une classe Java correspond à l’une
de ses instances en mémoire. Le processus de fabrication des consoles
réelles d’après ce plan est similaire au processus de création
d’instances d’objets GameBoyAdvance en Java.

En Java, les noms de variables ne peuvent pas commencer par un

chiffre ni contenir d’espaces.

Un bit est le plus petit bout de donnée que l’on puisse

stocker en mémoire. Il contient soit 1, soit 0.
Un octet (byte) est composé de huit bits.
En Java, un char occupe deux octets en mémoire.
En Java, une int ou un float occupe quatre octets.
Les variables de type long ou double utilisent huit octets.
Les types de données numériques qui utilisent plus
d’octets peuvent stocker de plus grands nombres :
 1 kilooctet (KO) correspond à 1024 octets.
 1 mégaoctet (MO) correspond à 1024 kilooctets.
 1 gigaoctet (GO) correspond à 1024 mégaoctets

Création d’un animal familier

Nous allons concevoir et créer une classe AnimalFamilier. Tout

d’abord, nous devons décider quelles actions notre animal familier
sera capable d’effectuer. Que dirais-tu de manger, dormir et dire ?
Nous allons programmer ces actions dans les méthodes de la classe
AnimalFamilier. Nous allons aussi donner à notre animal les attributs
suivants : âge, taille, poids et couleur.
Commençons par créer une nouvelle classe Java nommée
AnimalFamilier

Nous sommes maintenant prêts à déclarer les attributs et les méthodes

de la classe AnimalFamilier. Le corps des méthodes et des classes

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 6
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Java est délimité par des accolades. A chaque accolade ouvrante doit
correspondre une accolade fermante :

class AnimalFamilier {

Pour déclarer les variables constituant les attributs de la classe, nous

devons choisir leur type. Prenons par exemple le type int pour l’âge,
float pour la taille et le poids et String pour la couleur.

class AnimalFamilier {
int age;
float poids;
float taille;
String couleur ;
}

L’étape suivante consiste à ajouter des méthodes à notre classe. Avant

de déclarer une méthode, il faut décider si elle prend des arguments et
si elle retourne une valeur :
o La méthode dormir() ne fera qu’afficher le message "Bonne nuit,
à demain" – elle n’a pas besoin d’arguments et ne retourne
aucune valeur.
o Il en est de même pour la méthode manger(). Elle ne fera
qu’afficher le message "J’ai si faim… Donne-moi un biscuit !".
o La méthode dire() affichera aussi un message, mais l’animal
pourra "dire" (afficher) le mot ou la phrase que nous lui
fournirons. Nous passerons ce mot à la méthode dire() comme
un argument de méthode. La méthode construira une phrase en
utilisant cet argument et la retournera au programme appelant.

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 7
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
La nouvelle version de la classe AnimalFamilier ressemble à ceci :

public class AnimalFamilier {

int age;
float poids;
float taille;
String couleur;
public void dormir() {
[Link]("Bonne nuit, à demain");
}

public void manger() {

[Link]("J’ai si faim… Donne-moi un biscuit !");
}

public String dire(String unMot) {

String réponseAnimal = "OK !! OK !! " + unMot;
return réponseAnimal;
}
}

Voyons maintenant la signature de la méthode dormir():

public void dormir()

Elle nous indique que cette méthode peut être appelée depuis
n’importe quelle autre classe Java (public) et qu’elle ne retourne
aucune donnée (void). Les parenthèses vides signifient que cette
méthode ne prend pas d’argument, parce qu’elle n’a besoin d’aucune
donnée du monde extérieur – elle affiche toujours le même texte.

La signature de la méthode dire() est celle-ci :

o public String dire(String unMot)

Cette méthode peut aussi être appelée depuis n’importe quelle autre
classe Java, mais elle doit retourner un texte, ce qu’indique le mot-clé
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 8
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
String devant le nom de la méthode. Par ailleurs, elle attend une
donnée textuelle de l’extérieur, d’où l’argument String unMot.
Comment décider si une méthode doit retourner une valeur ou pas ? Si
une méthode manipule des données et doit fournir le résultat de ces
manipulations à une classe appelante, elle doit retourner une valeur.
Tu vas me dire que notre classe AnimalFamilier n’a aucune classe
appelante ! C’est exact, alors créons-en une, que nous appellerons
MaîtreAnimal. Cette classe aura une méthode main() contenant le
code nécessaire pour communiquer avec la classe AnimalFamilier.
Crée simplement une autre classe nommée MaîtreAnimal.
Rappelle-toi, sans la méthode main() il est impossible d’exécuter
cette classe en tant que programme.

public class MaitreAnimal {

public static void main(String[] args) {
String réactionAnimal;
AnimalFamilier monAnimal = new AnimalFamilier();
[Link]();
réactionAnimal = [Link]("Cui !! Cui !!");
[Link](réactionAnimal);
[Link]();
}
}

Le résultat du programme affichera le texte suivant :

J’ai si faim… Donne-moi un biscuit !
OK !! OK !! Cui !! Cui !!
Bonne nuit, à demain
La classe MaitreAnimal est la classe appelante ; elle commence par
créer une instance de l’objet AnimalFamilier. Elle déclare une
variable monAnimal et utilise l’opérateur Java new :
AnimalFamilier monAnimal = new AnimalFamilier();
Cette ligne déclare une variable du type AnimalFamilier (c’est exact,
tu peux considérer chaque classe que tu crées comme un nouveau type
Java). Maintenant, la variable monAnimal sait où a été créée
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 9
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
l’instance d’AnimalFamilier dans la mémoire de l’ordinateur, et tu
peux utiliser cette variable pour appeler n’importe laquelle des
méthodes de la classe AnimalFamilier, par exemple :
[Link]();
Si une méthode retourne une valeur, tu dois l’appeler d’une autre
façon. Déclare une variable du même type que la valeur retournée par
la méthode. Tu peux maintenant appeler cette méthode :
String réactionAnimal;
réactionAnimal = [Link]("Cui !! Cui !!");
A ce stade, la valeur retournée est stockée dans la variable
réactionAnimal et si tu veux voir ce qu’elle contient, ne te gêne pas :
[Link](réactionAnimal);

II- Constructeurs
Java utilise l'opérateur new (nouveau) pour créer des instances d'objets
en mémoire. Par exemple :
Poisson monPoisson = new Poisson();
Les parenthèses après le mot Poisson signifient que cette classe a une
méthode nommée Poisson(). Oui, il y a des méthodes spéciales
appelées constructeurs (constructors), qui ont les caractéristiques
suivantes :
o Les constructeurs ne sont appelés qu'une fois au cours de la
construction d'un objet en mémoire.
o Ils doivent avoir le même nom que la classe elle-même.
o Ils ne retournent pas de valeur ; il n'est même pas nécessaire
d'utiliser le mot-clé void dans la signature d'un constructeur.
Toute classe peut avoir plusieurs constructeurs. Si tu ne crées pas de
constructeur pour une classe, Java crée automatiquement, lors de la
compilation, un constructeur sans argument par défaut. C'est pour
cela que le compilateur Java n'a jamais réclamé une déclaration
permettant d'écrire new Poisson(), alors que la classe Poisson ne
définit aucun constructeur.
En général, les constructeurs sont utilisés pour affecter des valeurs
initiales aux variables membres d'une classe. Par exemple, la version
suivante de la classe Poisson a un constructeur mono-argument qui se
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 10
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
contente d'affecter la valeur de l'argument à la variable d'instance
profondeurCourante pour une utilisation ultérieure.
public class Poisson extends AnimalFamilier {
int profondeurCourante;
Poisson(int positionDépart) {
profondeurCourante = positionDépart;

}}
Maintenant, la classe MaîtrePoisson peut créer une instance de
Poisson et affecter la position initiale du poisson. L'exemple suivant
crée une instance de Poisson "submergée" sous 20 mètres d'eau :
Poisson monPoisson = new Poisson(20);
Si un constructeur avec arguments est défini dans une classe, il n'est
plus possible d'utiliser le constructeur sans argument par défaut. Si tu
souhaites avoir un constructeur sans argument, écris-en un.

III- Héritage :

Exemple : Un Poisson est aussi un AnimalFamilier

Notre classe AnimalFamilier va nous aider à découvrir un autre
concept important de Java, appelé héritage. Dans la vie réelle, chaque
personne hérite des caractéristiques de l’un ou l’autre de ses parents.
De la même façon, dans le monde Java, tu peux, à partir d’une classe,
en créer une nouvelle.
La classe AnimalFamilier possède un comportement et des attributs
partagés par de nombreux animaux familiers – ils mangent, dorment,
certains d’entre eux émettent des bruits, leurs peaux peuvent être de
différentes couleurs, etc. D’un autre côté, les animaux familiers sont
différents les uns des autres – les chiens aboient, les poissons nagent
et sont silencieux, les perroquets parlent mieux que les chiens. Mais
tous mangent, dorment, ont un poids et une taille. C’est pourquoi il est
plus facile de créer une classe Poisson qui héritera certains
comportements et attributs communs de la classe AnimalFamilier, que
de créer Chien, Perroquet ou Poisson à partir de rien à chaque fois. Le
mot-clé spécial extends est là pour ça :
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 11
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
class Poisson extends AnimalFamilier {

On peut dire que notre Poisson est une sous-classe (subclass) de la

classe AnimalFamilier et que la classe AnimalFamilier est une
superclasse (superclass) de la classe Poisson. Autrement dit, on utilise
la classe AnimalFamilier comme un modèle pour créer la classe
Poisson. Même si tu te contentes de laisser la classe Poisson telle
qu’elle est maintenant, tu peux toujours utiliser chacun des attributs et
méthodes hérités de la classe AnimalFamilier. Regarde :

Poisson monPetitPoisson = new Poisson();

[Link]();

Même si nous n’avons pas encore déclaré de méthode dans la classe

Poisson, nous avons le droit d’appeler la méthode dormir() de sa
superclasse !

IV- Types de données :

1- Variables
Une variable possède un nom, un type et une valeur. La déclaration
d'une variable doit donc contenir deux choses : un nom et le type de
données qu'elle peut contenir.
Une variable est utilisable dans le bloc où elle est définie.
La déclaration d'une variable permet de réserver la mémoire pour en
stocker la valeur.
Le type d'une variable peut être :
 Soit un type élémentaire dit aussi type primitif déclaré sous la
forme type élémentaire variable ;
 Soit une classe déclarée sous la forme classe variable ;
Exemple :
long nombre;
int compteur;
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 12
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
String chaine;
Rappel : Les noms des variables en Java peuvent commencer par une
lettre, par le caractère de soulignement ou par le signe dollar. Le reste
du nom peut comporter des lettres ou des nombres mais jamais
d'espaces. Il est possible de définir plusieurs variables de même type
en séparant chacune d'elles par une virgule.
Exemple :
int jour, mois, annee ;

Java est un langage à typage rigoureux qui ne possède pas de

transtypage automatique lorsque ce transtypage risque de conduire à
une perte d'information.
Pour les objets, il est nécessaire en plus de la déclaration de la variable
de créer un objet avant de pouvoir l'utiliser. Il faut réserver de la
mémoire pour la création d'un objet :
Remarque : Un tableau est un objet en Java avec l'instruction new. La
libération de la mémoire se fait automatiquement.
Exemple :
MaClasse instance ; // déclaration de l'objet
instance = new MaClasse(); // création de l'objet
OU MaClasse instance = new MaClasse(); // déclaration et création de
l'objet

Exemple :
int[] nombre = new int[10];

Il est possible en une seule instruction de faire la déclaration et

l'affectation d'une valeur à une variable ou plusieurs variables.
Exemple :
int i=3 , j=4 ;

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 13
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
 2- Les commentaires

Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas
inclus dans le pseudo code. Ils ne se terminent pas par un caractère ";".
Il existe Trois types de commentaire en Java :

 int N=1; // déclaration du compteur

 Commentaire multi ligne /* commentaires ligne 1
 Commentaires ligne 2 */
 Commentaire de documentation automatique
/**
* commentaire de la methode
* @param val la valeur à traiter
* @since 1.0
* @return la valeur de retour
* @deprecated Utiliser la nouvelle methode XXX
*/
3- Durée de vie des variables

Quelle est la durée de vie des variables ?

Si tu déclares une variable à l'intérieur d'une méthode, cette variable
est dite locale. Cela signifie que cette variable n'est accessible que
pour le code à l'intérieur de cette méthode. Quand la méthode se
termine, la variable est automatiquement effacée de la mémoire.
Par exemple, tu peux dire que les variables déclarées à l'intérieur d'une
méthode ont une portée locale.
Si une variable doit être réutilisée par plusieurs appels de méthode, ou
si elle doit être visible par plus d'une méthode d'une classe, il est
préférable de la déclarer en dehors de toute méthode. Dans la classe
Poisson, profondeurCourante est une variable membre (member). De
telles variables sont "vivantes" tant que l'instance de l'objet
Poisson existe en mémoire ; c'est pourquoi on les appelle des
variables d'instance. Elles peuvent être partagées et réutilisées par
toutes les méthodes de la classe et, dans certains cas, elles peuvent
même être visibles depuis des classes extérieures. Par exemple, dans

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 14
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
nos classes, l'instruction [Link]() utilise la variable de
classe out déclarée dans la classe System.

Attends une minute ! Pouvons-nous utiliser une variable membre de la

classe System sans même avoir créé une instance de cette classe ?
Oui, nous le pouvons, si cette variable a été déclarée avec le mot-clé
static. Si la déclaration d'une variable membre ou d'une méthode
commence par static, il n'est pas nécessaire de créer une instance de la
classe pour l'utiliser. Les membres statiques d'une classe sont utilisés
pour stocker les valeurs qui sont identiques pour toutes les instances
d'une classe.

V- Operateurs Conditionnelle :

1- L’IF/ELSE
 Utilisation d’IF :
Nous prenons sans arrêt des décisions dans la vie : Si elle me dit ceci,
je lui répondrai cela ; sinon, je ferai autre chose. Java possède une
clause qui évalue une expression donnée pour savoir si sa valeur est
true ou false. Selon la valeur de cette expression, l'exécution de ton
programme prend une direction ou une autre ; seule la portion de code
correspondante est exécutée.
Par exemple :
Si l'expression Ai-je envie d'aller voir grand-mère ? Retourne true,
tourne à gauche, sinon, tourne à droite.
Si l’expression retourne true, Java exécute le code compris entre les
deux premières accolades, sinon, il va directement au code suivant la
clause else.

Par exemple :
Si un prix est supérieur à cent euros, donner une remise de 20%,
sinon, ne donner que 10%.

// Les biens les plus chers donnent une remise de 20%

if (prix > 100) {
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 15
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
prix = prix * 0.8;
[Link]("Tu as 20% de remise");
}
else {
prix = prix * 0.9;
[Link]("Tu as 10% de remise");
}

 Utilisation d’else if :

Tu peux construire des clauses if plus complexes avec plusieurs blocs

else if. Nous allons maintenant créer la classe BulletinAppréciation.
Cette classe doit avoir la méthode main() ainsi qu'une méthode
acceptant un argument – la note du devoir. En fonction du nombre,
cette méthode affichera ton niveau sous la forme I (Insuffisant), P
(Passable), A (Assez bien), B (Bien), T (Très bien) ou E (Excellent).
Nous la nommerons convertirNiveaux().
Outre l'utilisation de la condition else if, cet exemple te montre aussi
comment utiliser des variables de type char. Tu peux aussi voir que tu
peux utiliser l'opérateur && pour vérifier si un nombre appartient à
une plage de valeurs donnée. Tu ne peux pas écrire simplement if
résultatTest entre 16 et 18, mais en Java nous écrivons que
résultatTest doit être à la fois supérieur ou égal à 16 et inférieur à 18.

public class BulletinAppréciation {

/**
Cette méthode attend un argument entier – la note du devoir
- et retourne une mention, I, P, A, B, T ou E, en fonction
de sa valeur.
*/
public char convertirNiveaux(int noteDevoir) {
char niveau;
if (noteDevoir >= 18) {
niveau = 'E';
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 16
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
}
else if (noteDevoir >= 16 && noteDevoir < 18) {
niveau = 'T';
}
else if (noteDevoir >= 14 && noteDevoir < 16) {
niveau = 'B';
}
else if (noteDevoir >= 12 && noteDevoir < 14) {
niveau = 'A';
}
else if (noteDevoir >= 10 && noteDevoir < 12) {
niveau = 'P';
}
else {
niveau = 'I';
}
return niveau;
}

public static void main(String[] args) {

BulletinAppréciation convertisseur = new BulletinAppréciation();

char tonNiveau = [Link](17);
[Link]("Ton premier niveau est " +tonNiveau);
tonNiveau = [Link](15);
[Link]("Ton second niveau est " +tonNiveau);
}
}

2- SWITCH/CASE

La clause switch peut parfois être utilisée comme alternative à if.

L'expression après le mot-clé switch est évaluée et le programme va
directement à la case (cas) correspondant :
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 17
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
public static void main(String[] args) {

BulletinAppréciation convertisseur = new BulletinAppréciation();

char tonNiveau = [Link](15);

switch (tonNiveau) {
case 'E':
[Link]("Excellent travail !");
break;
case 'T':
[Link]("Très bon travail !");
break;
case 'B':
[Link]("Bon travail !");
break;
case 'A':
[Link]("Tu peux mieux faire !");
break;
case 'P':
[Link]("Tu dois travailler plus !");
break;
case 'I':
[Link]("Change d'attitude !");
break;
}
}

N'oublie pas le mot-clé break à la fin de chaque cas – il faut que le

code saute hors de la clause switch. Sans les instructions break, ce
code imprimerait, par exemple, les quatre dernières lignes si la
variable tonNiveau avait la valeur 'B'.

Remarque : La clause switch Java a une limitation – l'expression à

évaluer doit être de l'un de ces types :
 char
 int
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 18
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
  byte
 short

VI- Opérateurs logiques

 Le OU et le ET
Parfois, pour prendre une décision, il peut être nécessaire de vérifier
plus d'une expression conditionnelle. Par exemple, si le nom d'un état
est "Texas" ou "Californie", ajouter la taxe d'état au prix de chaque
article du magasin. C'est un cas d'emploi du ou logique (logical or ) –
soit "Texas" soit "Californie". En Java, un ou logique est représenté
par une ou deux barres verticales. Ca fonctionne comme ceci : si l'une
quelconque des conditions est vraie, le résultat de l'expression dans
son ensemble vaut true.
Dans les exemples suivants, j'utilise une variable de type String. Cette
classe Java possède une méthode equals() que j'utilise pour comparer
la valeur de la variable état avec "Texas" ou "Californie" :

if (é[Link]("Texas") | é[Link]("Californie"))
Tu peux aussi écrire ceci en utilisant deux barres verticales :
if (é[Link]("Texas") || é[Link]("Californie"))

La différence entre les deux est que, si tu utilises deux barres et que la
première expression est vraie, la seconde expression ne sera même pas
évaluée. Si tu ne mets qu'une seule barre, Java évalue les deux
expressions.
Le et logique (logical and) est représenté par un ou deux "et
commercial" (&&) et l'expression dans son ensemble vaut true si
chacune de ses parties vaut true.
Par exemple :
Imputer les taxes commerciales uniquement dans le cas où l'état est
"New York" et où le prix est supérieur à 110. Les deux conditions
doivent être vraies en même temps :

if (é[Link]("New York") && prix > 110)

ou
if (é[Link]("New York") & prix > 110)
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 19
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Si tu utilises un double "et commercial" et que la première expression
vaut false, la seconde ne sera même pas évaluée, car l'expression
entière vaudra false de toutes façons. Avec un simple "et commercial",
les deux expressions seront évaluées.
Le non logique (logical not) est représenté par le point d'exclamation
et donne à l'expression le sens opposé. Par exemple, si tu veux
effectuer certaines actions uniquement si l'état n'est pas "New York",
utilise cette syntaxe :

if (!é[Link]("New York"))
Voici un autre exemple – les deux expressions suivantes produiront le
même résultat :

if (prix < 50)

if (!(prix >= 50))

Le non logique est ici appliqué à l'expression entre parenthèses.

VII- Structure de contrôle :

 Boucle for/while /do-while :

Les boucles (loops) sont utilisées pour répéter la même action

plusieurs fois,
Par exemple :
Si nous avons besoin de féliciter plusieurs joueurs. Si tu sais à l'avance
combien de fois l'action doit être répétée, utilise une boucle avec le
mot-clé for (pour) :

int nombreJoueurs = [Link];

int compteur;

for (compteur = 0; compteur < nombreJoueurs; compteur++) {

String leJoueur = joueurs[compteur];

[Link]("Félicitations, " +leJoueur + " !");}
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 20
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Java exécute chaque ligne entre les accolades puis retourne à la
première ligne de la boucle, pour incrémenter le compteur et évaluer
l'expression conditionnelle. Ce code signifie ceci :

Affiche la valeur de l'élément du tableau dont l'indice est identique à

la valeur courante du compteur. Commence de l'élément 0 (compteur
= 0) et incrémente de 1 la valeur du compteur (compteur++). Continue
à faire ainsi tant que le compteur est inférieur à nombreJoueurs
(compteur < nombreJoueurs).

Il y a un autre mot-clé permettant d'écrire des boucles – while

(pendant). Avec ces boucles, il n'est pas nécessaire de savoir
exactement combien de fois l'action doit être répétée, mais il faut tout
de même savoir à quel moment terminer la boucle. Voyons comment
nous pouvons féliciter les joueurs en utilisant une boucle while qui se
terminera lorsque la valeur de la variable compteur sera égale à la
valeur de nombreJoueurs :

int nombreJoueurs = [Link];

int compteur = 0;

while (compteur < nombreJoueurs) {

String leJoueur = joueurs[compteur];

[Link]("Félicitations, "+ leJoueur + " !");
compteur++;
}

Tu peux aussi utiliser deux mots-clés importants dans les boucles :

break et continue.
Le mot-clé break est utilisé pour sortir de la boucle quand une
condition particulière est vraie. Disons que nous ne voulons pas
afficher plus de 3 félicitations, indépendamment du nombre de joueurs
que nous avons. Dans l'exemple suivant, après avoir affiché les
éléments 0, 1 et 2 du tableau, le break fera sortir le code de la boucle
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 21
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
et le programme continuera à partir de la ligne suivant l'accolade
fermante.

Dans cet exemple de code, il y a un double signe égal dans la clause

if. Cela signifie que tu compares la valeur de la variable compteur
avec le nombre 3. Un seul signe égal à cet endroit signifierait qu'on
affecte la valeur 3 à la variable compteur. Remplacer == par = dans
une instruction if est un piège très subtil, qui peut mener à des erreurs
du programme imprévisibles et difficiles à trouver.

int compteur = 0;

while (compteur < nombreJoueurs) {

if (compteur == 3) {
break; // Sortie de la boucle
}
String leJoueur = joueurs[compteur];
[Link]("Félicitations, " + leJoueur + " !");
compteur++;
}

Le mot-clé continue permet au code de sauter des lignes et de revenir

au début de la boucle. Imagine que tu veuilles féliciter tout le monde
sauf David – le mot-clé continue fait revenir le programme au début
de la boucle :

while (compteur < nombreJoueurs) {

compteur++;
String leJoueur = joueurs[compteur];
if ([Link]("David")) {
continue;
}
[Link]("Félicitations, " + leJoueur + " !");
}

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 22
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Il y a encore une autre forme de la boucle while, qui commence par le
mot-clé do :

do {
// Place ton code à cet endroit
} while (compteur < nombreJoueurs);

Une telle boucle évalue l'expression après avoir exécuté le code entre
les accolades, ce qui signifie que le code à l'intérieur de la boucle est
exécuté au moins une fois. Les boucles qui commencent par le mot-clé
while peuvent ne pas être exécutées du tout si l'expression
conditionnelle est fausse dès le début.

VIII-Tableaux :

Ce sont des objets : ils sont donc dérivés de la classe Object. Il est
possible d'utiliser les méthodes héritées telles que equals() ou
getClass(). Le premier élément d'un tableau possède l'indice 0.

La déclaration des tableaux

Java permet de placer les crochets après ou avant le nom du tableau
dans la déclaration.
Exemple :
int tableau[] = new int[50]; // déclaration et allocation
OU int[] tableau = new int[50];
OU int tab[]; // déclaration
tab = new int[50]; //allocation

Java ne supporte pas directement les tableaux à plusieurs dimensions :

il faut déclarer un tableau de tableau.
Exemple :
float tableau[][] = new float[10][10];

La taille des tableaux de la seconde dimension peut ne pas être

identique pour chaque occurrence.

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 23
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
Exemple :
int dim1[][] = new int[3][];
dim1[0] = new int[4];
dim1[1] = new int[9];
dim1[2] = new int[2];

Chaque élément du tableau est initialisé selon son type par

l'instruction new : 0 pour les numériques, '\0' pour les caractères, false
pour les booléens et null pour les chaines de caractères et les autres
objets.

Exemple :
Disons que ton programme doit stocker les noms de quatre joueurs.
Au lieu de déclarer quatre variables de type String, tu peux déclarer un
tableau (array) qui a quatre éléments de type String. Les tableaux sont
repérés par des crochets, placés soit après le nom de la variable, soit
après le type de données :

String [] joueurs;
Ou
String joueurs[];

Ces lignes indiquent juste au compilateur Java que tu as l'intention de

stocker plusieurs chaînes de caractères dans le tableau joueur. Chaque
élément possède son propre indice partant de zéro. L'exemple suivant
crée en fait une instance de tableau qui peut stocker quatre éléments
de type String puis leur affecte des valeurs :

joueurs = new String [4];

joueurs[0] = "David";
joueurs[1] = "Daniel";
joueurs[2] = "Anna";
joueurs[3] = "Gregory";
Tu dois connaître la taille du tableau avant d'affecter des valeurs à ses
éléments. Si tu ne sais pas à l'avance combien d'éléments tu vas avoir,
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 24
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
tu ne peux pas utiliser de tableaux ; tu devrais examiner d'autres
classes Java, par exemple Vector (vecteur). Mais concentrons-nous
pour l'instant sur nos tableaux.
Tous les tableaux ont un attribut nommé length (longueur) qui se
"rappelle" le nombre d'éléments de ce tableau. Tu peux donc toujours
savoir combien d'éléments il y a :

int nombreJoueurs = [Link];

Si tu connais toutes les valeurs qui seront stockées dans le tableau au

moment où tu le déclares, Java te permet de déclarer et d'initialiser le
tableau d'un seul coup :

String [] joueurs = {"David", "Daniel", "Anna", "Gregory"};

Imagine que le second joueur soit un gagnant et que tu souhaites lui
faire part de tes félicitations. Si le nom des joueurs est stocké dans un
tableau, nous avons besoin de son deuxième élément :

String leGagnant = joueurs[1];

[Link]("Félicitations, " + leGagnant + " !");

Voilà ce qu'affiche ce code : Félicitations, Daniel !

Sais-tu pourquoi le deuxième élément a l'indice [1] ? Bien sûr que tu

le sais : l'indice du premier élément est toujours [0].

Le tableau de joueurs de notre exemple est unidimensionnel, car nous

les stockons en quelque sorte en ligne. Si nous voulons stocker les
valeurs sous forme de matrice, nous pouvons créer un tableau
bidimensionnel.

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 25
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
 IX- Le mot-clé :
1- Le mot-clé throw

Si une exception se produit dans une méthode, mais que tu penses que
c'est à l'appelant de la traiter, il suffit de la réémettre vers celui-ci.
Parfois, tu peux vouloir capturer une exception mais en lever une autre
avec une description différente de l'erreur, comme dans le bout de
code ci-dessous.
L'instruction throw est utilisée pour lever des exceptions en lançant
des objets Java. L'objet lancé par un programme doit être émissible
(throwable). C'est-à-dire que tu ne peux lancer que les objets qui sont
des sous-classes directes ou indirectes de la classe Throwable - ce que
sont toutes les exceptions Java.

Le fragment de code suivant montre comment la méthode

chargerTousLesScores() capture une IOException, crée un nouvel
objet Exception avec une description plus sympathique de l'erreur, et
le lance vers la méthode main(). Du coup, pour que la méthode main()
puisse être compilée, il faut ajouter une ligne qui appelle
chargerTousLesScores() dans le bloc try/catch, car cette méthode
peut émettre un objet Exception qui doit être traité ou réémis. La
méthode main() ne devant lever aucune exception, elle doit traiter
celle-ci.

class ListeDesScores {
// Ce code doit être complété pour pouvoir le compiler

static void chargerTousLesScores() throws Exception {

try {
[Link](); // Cette ligne peut lever une exception
} catch (IOException e) {
throw new Exception("Cher ami, le fichier des scores a un
problème.");
}
}
Enseignant : Mahamoud Ahmat Hamid
Cours : Programmation java 26
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]
public static void main(String[] args) {
[Link]("Scores");
try {
chargerTousLesScores();
}
catch(Exception e1) {
[Link]([Link]());
}
}
}

Si une erreur fichier se produit, la méthode main() la prend en charge

et l'appel à [Link]() renvoie le message "Cher ami …"

2- Le Mot-clé this

Le mot-clé this est utile lorsque tu as besoin de te référer à l'instance

de l'objet dans laquelle tu te trouves. Regarde cet exemple :

class Poisson {
int profondeurCourante ;
Poisson(int profondeurCourante) {

[Link] = profondeurCourante;

}
}

Le mot-clé this permet d'éviter les conflits de nom. Par exemple,

[Link] fait référence à la variable membre
profondeurCourante, alors que profondeurCourante fait référence à la
valeur de l'argument.
En d'autres termes, l'instance de l'objet Poisson pointe sur elle-même.

Enseignant : Mahamoud Ahmat Hamid

Cours : Programmation java 27
Contact : +235 66219059
Email : ahmathamid_mahamoud@[Link]/djangui2022@[Link]