COURS DE PROGRAMMATION

1
AVANCEE EN JAVA
INTRODUCTION A JAVA

Chargé du cours 04/15/19

Dr Romaric SAGBO Master 1 / ENEAM 2023-2024

2 Plan

 Introduction
 Historique
 Les besoins
 Installation de Java
 Types de données en Java
 Identificateurs
 Opérateurs et expressions
 Les instructions conditionnelles
 Concepts de classes et objets
3 Big Image
4 JAVA ?
 Java est un langage de programmation moderne développé par Sun
Microsystems (aujourd'hui racheté par Oracle)
 Ne pas le confondre avec JavaScript (langage de scripts)
 Langage orienté objet, robuste et sécurisé
 Plus grande force ➔ Sa portabilité
 Programme multiplateforme : Windows, Mac, Linux, etc.
 Plusieurs sortes de programmes avec Java :
 des applications, sous forme de fenêtre ou de console
 des applets, qui sont des programmes Java incorporés à des pages
web
 des applications pour appareils mobiles, avec J2ME
 et des applications web JEE
 5 Les versions de Java
 Versions 1.01 en 1995 et 1.02 en 1996
 Versions 1.1 en 1998 et 1.2 (rebaptisée Java 2) en 1999, 1.3 en 2000
 Versions 1.4 en 2002, 5.0 en 2004 (toujours appelées Java 2)
 On parle du J2SE 1.4 (Java 2 Standard Edition 1.4) basée sur le JDK 1.4 et de
J2SE 5 (JDK 5.0) ou encore de Java 5
 En 2006, la version suivante s’intitule JSE 6 ou plus simplement Java 6
 En 2011, Java SE 7
 En 2014, sortie de Java SE 8
 En 2017, sortie de Java SE 9
 En mars 2018, sortie de Java SE 10
 En septembre 2018, sortie de Java SE 11
 En mars 2019, sortie de Java SE 12
 En septembre 2019, sortie de Java SE 13
 En mars 2020, sortie de Java SE 14
 6
Les éditions de Java
3 éditions de Java
Java SE : Java Standard Edition ; JDK = Java SE
Development Kit
Java EE : Enterprise Edition qui ajoute les API pour écrire
des applications installées sur les serveurs dans des
applications distribuées : servlet, JSP, JSF, EJB,…
Java ME : Micro Edition, version pour écrire des
programmes embarqués (carte à puce/Java card,
téléphone portable,…)
 7 Besoins

Interpréteur : Machine virtuelle Java

JRE (Java Runtime Environment)
ou JDK (Java Development Kit)

Pour plus de facilité

IDE (Integrated Development Environment)
Netbeans, Eclipse, Jdeveloper, Jbuilder, …
 8 Installation JRE/JDK

 Télécharger JAVA sur le site www.oracle.com

 Installer le JRE ou le JDK
 Ajouter Java aux variables d’environnement :
nom de la variable : "JAVA_HOME"
valeur : "C:\Program Files (x86)\Java\jdk1.8.0_05" par exemple
Ajouter au début de la variable Path, la valeur :
"%JAVA_HOME%\bin;"
 Vérifier en tapant java dans une invite de commande dos
9 Mon premier programme

 Créer un fichier Bonsoir.java

 Ajouter le code suivant :

public class Bonsoir {

public static void main(String [] args) {

System.out.print(“Bonsoir la classe !");
}
}
 Compiler le programme en tapant dans une invite de commande dos :
javac Bonsoir.java (le fichier Bonsoir.class est généré (bytecode))
 Exécuter en tapant : java Bonsoir (la JVM interprète le bytecode)

javac Bonsoir.java
java Bonsoir
Bonsoir la classe !
10 Installation de l’IDE Netbeans

 Télécharger Netbeans sur le site www.netbeans.org

 Créer un nouveau projet et reprendre l’exercice précédent
11 Netbeans
12
Ce qu’il faut savoir
13 Identificateurs
 Un identificateur est un nom qui identifie de façon unique une
variable, une méthode ou une classe
 Règles générales
 Identificateur :
suite de lettres
minuscules ou majuscules,
chiffres,
underscore (_) et dollar ($).
 Un identificateur ne doit pas commencer par un chiffre.
 Java distingue minuscules et majuscules (Valeur diffère de
VALEUR).
14 Identificateurs

 Conventions
 Toute méthode publique et variable d’instance commence par
une minuscule.
 Variables locales et privées : lettres minuscules avec des
underscores.
Ex : next_val, temp_val.
 Variables dites final représentant des constantes : lettres
majuscules avec underscores.
Ex: DAY_FRIDAY, GREEN.
 Tout nom de classe ou d’interface commence par une
majuscule
15
Mots clés du langage
16 Mots clés du langage

 Les mots clés sont toujours écrits en minuscules, comme dans C/C++.
 De façon générale, les mots clés Java peuvent être classés par catégories
selon leurs fonctions de la façon suivante (exemples entre parenthèses) :
 Mots clés de déclaration des données (boolean, float, int)
 Mots clés de boucle (continue, while, for)
 Mots clés conditionnels (if, else, switch)
 Mots clés d’exception (try, throw, catch)
 Mots clés de structure (class, extends, implements)
 Mots clés de modification et d’accès (private, public, transient)
 Mots clés divers (true, null, super)
17
Types de données en Java
 Entité qui représente une valeur spécifique pouvant être stockée en
mémoire.
 Il y a deux catégories de types de données : intégrés et composites.
 Les types de données intégrés (ou primitifs) peuvent ensuite être
divisés en trois autres catégories : numérique, booléen et
caractère.
 Ils sont compris par le compilateur et ne nécessitent pas de
bibliothèques spéciales.
 Les types composites sont de deux sortes : tableaux et chaînes.
 Généralement, les types composites nécessitent l’utilisation
de bibliothèques spéciales.
18
Les types primitifs

 Huit types primitifs :

 Entiers : byte, short, int et long, tous signés.
 Nombres à virgule flottante : float et double.
 Caractères : char.
 booléens : boolean, pour les valeurs logiques.
19 Types de données numériques

Type Taille Description (valeurs extrêmes)

byte 8 bits très petit nombre entier signé (–128 ⇒127)
short 16 bits nombre entier signé court (–32768 ⇒ 32767)
int 32 bits nombre entier signé (–2.14e+9 ⇒ 2.14e+9)
long 64 bits nombre entier signé long (–9.22e+18 ⇒ 9.22e+18)
float 32 bits nombre en virgule flottante (1.402e-45 ⇒ 3.402e+38)
double 64 bits nombre en virgule flottante double précision (4.94e-324 ⇒ 1.79e+308)
20 Types de données booléens
 Un type de données booléen a deux valeurs : true et false. A
la différence de C/C++, qui stocke les types de données
booléens sous forme numérique (0 pour false et 1 pour true),
Java utilise le type de données intégré boolean.
 Les variables de type boolean non initialisées ont
automatiquement la valeur false.
 int a = 1, b = 0;
 boolean bool = a < b; //bool a la valeur false
21 Types de données caractère

 Java utilise le type de données char pour stocker un

caractère Unicode unique.
 Toutefois, le type char de Java a une largeur de 16 bits, alors
qu’il n’a que 8 bits de large (par défaut) dans C/C++.
22 Types de données composites: les tableaux

 Un tableau est une structure de données qui peut contenir plusieurs

éléments du même type.
 Les éléments d’un tableau peuvent être de n’importe quel type : type
primitif, type composite ou classe définie par l’utilisateur.
 Exemples de déclaration
 int idEtudiant[];
 char[] grades;
 float coordonnees[][];
 La taille du tableau n’est pas précisée ; dans la plupart des langages, la
taille d’un tableau doit faire partie de sa déclaration.
 Les crochets peuvent suivre l’identificateur, comme dans le premier
exemple ou suivre le type de données, comme dans le deuxième exemple.
23 Types de données composites: les tableaux

 Pour affecter réellement de la mémoire aux variables tableaux, il

faut utiliser l’opérateur new de la façon suivante :
 int idEtudiant[] = new int[20];
 char[] grades = new char[20];
 float[][] coordonnees = new float[10][5];
 Quand un tableau est créé, tous ses éléments sont vides.
 Dans Java, l’utilisation de l’opérateur new est semblable à
l’utilisation de la commande malloc en langage C et de
l’opérateur new en C++.
24 Types de données composites: les tableaux

 Initialisation
 char[] grades = {‘A’, ‘B’, ‘C’, ‘D’, ‘F’};
 float[][] coordonnées = {{0.0, 0.1}, {0.2, 0.3}};
 Accès aux éléments du tableau
 premierElément = grades[0]; //premierElément = ‘A’
 cinquièmeElément = grades[4]; //cinquièmeElément = ‘F’
 ligne2Col1 = coordonnées[1][0]; //ligne2Col1 = 0.2
 Autre exemple
 int[] tableauInt = new int [5];
 int index;
 for (index = 0; index < 5; index++)
 tableauInt [index] = index;
25 Types de données composites: les chaînes

 Chaîne: suite de caractères.

 Pour stocker des chaînes, Java utilise le type String. Ce type de données
fait partie du paquet java.lang
 String s = new String (“Bureau");
 Pour disposer d’un meilleur contrôle sur vos chaînes, utilisez la classe
StringBuffer.
 fournit des méthodes permettant de modifier le contenu des chaînes.
 Exemple
 StringBuffer s = new StringBuffer ("Bureau");
 s.setCharAt (1, 'e'); //s a maintenant la valeur "Bereau"
26
Opérateurs : Opérateurs arithmétiques
27 Opérateurs : Opérateurs arithmétiques

class IncDec {
public static void main(String
args[]) {
int a = 1;
int b = 2;
int c = ++b;
int d = a++;
c++;
La sortie du programme
System.out.println("a = " + a);
est :
System.out.println("b = " + b);
a=2
System.out.println("c = " + c);
b=3
System.out.println("d = " + d);
c=4
}
d=1
}
28 Opérateurs : Opérateurs entiers sur les bits

 On peut manipuler les bits des types entiers long, int, short, char et byte à l’aide
des opérateurs suivants :

 Exemple
 short i = 13; //i a la valeur 0000000000001101
 i = i << 2; //i a la valeur 0000000000110100
 i >>= 3; //i a la valeur 0000000000000110
29 Opérateurs : Opérateurs relationnels
 ==, !=, >, <, >= et <=
 Tout type java, y compris les types primitifs et les
références à des instances d’objets peuvent être
comparés avec == et !=
 Seuls les types numériques peuvent être comparés avec
les opérateurs d’ordre. Les entiers, flottants et caractères
peuvent être comparés avec les opérateurs d’ordre
strict
 Chaque opérateur renvoie un type boolean
30 Opérateurs : Opérateurs booléens logiques
31
Priorité des opérateurs
32
Expressions
 Une expression est une combinaison significative d’identificateurs, de
mots clés, de symboles et d’opérateurs qui a une valeur. De façon
générale, tout ce qui peut être mis du côté droit d’un signe d’affectation
est une expression.
 Voici quelques exemples d’expressions :
 s = "Bonjour à tous";
 x = 123.4;
 y = (x * 5) / 2;
 valeur = obtenirValeur();
 Mammifère m = new Mammifère();
 Affectations de variables
 Expressions d’opérateur
 Affectations de méthodes
 Affectation d’objet
33 Les instructions de contrôle : Instruction switch

 Instruction switch
 Forme strictement analogue à celle du C
switch (c){
switch ( expression ) { case '1': case '3': case '5': case '7': case
case valeur1 : '9':
break; System.out.println("c est un chiffre
case valeurN : impair");
break; break;
default : case '0': case '2': case '4': case '6': case
} '8':
System.out.println("c est un chiffre pair");
break;
default :
System.out.println("c n’est pas le chiffre
attendu");
}
34 Les instructions de contrôle : Instruction if-else

 if ( expression-booleenne ) expression1;
 [ else expression2; ]
 expression1 peut être une expression composée entourée de {}.
 expression-booleenne est toute expression renvoyant un boolean.

if (condition1) {
//blocCode 1
}
else if (condition2) {
//blocCode 2
}
else {
//blocCode 3
}
35 Les instructions de contrôle : Instructions
while/do-while/for
 while
[ initialisation; ]
while ( terminaison ) {
corps;
[ iteration; ]
}
 do-while
[ initialisation; ]
do {
corps;
[ iteration; ]
} while ( terminaison );
 for
for (initialisation; terminaison; iteration)
corps;
36 Les instructions de contrôle : Instructions
while/do-while/for
int x = 1, z = 0;
while (x <= 20) {
z += x;
x++;
}

int x = 0;
do{
System.out.println("Bouclage");
x++;
}while (x < 10);

int z = 0;
for (int x=1; x <= 20; x++) {
z+= x;
}
37 Instructions de contrôle des boucles

 L’instruction break
 L’instruction break permet de sortir d’une structure de boucle avant que la
condition du test soit respectée
 Quand la boucle rencontre une instruction break, elle se termine
immédiatement en ignorant le code restant.

int x = 0;
while (x < 10){
System.out.println("Bouclage");
x++;
if (x == 5)
break;
else
//faire quelque chose d’autre
}
38 Instructions de contrôle des boucles

 L’instruction continue
 L’instruction continue permet d’ignorer le reste de la boucle et de reprendre
l’exécution à l’itération suivante de la boucle.
for ( int x = 0 ; x < 10 ; x++)
{
if(x == 5)
continue; //revient au début de la boucle avec x=6
System.out.println("Bouclage");
}
 Cet exemple n’imprime pas “Bouclage” si x a la valeur 5.
39 Les commentaires
 Les commentaires sont des instructions écrites en langage naturel par le
programmeur pour ajouter des remarques concernant le code.
 Trois styles de commentaires.
 Le premier commence par /* et se termine par */ ;
 il permet d’écrire des commentaires sur plusieurs lignes. Ce style est identique à celui du
langage C.
 x = y + z; /* Ceci est un commentaire.*/
 z = q / p; /*Ce commentaire
s’étend sur deux lignes*/

 Le deuxième commence par /** et se termine par */.

 Ce style est utilisé par l’outil javadoc du JDK pour générer automatiquement une
documentation à partir du code source.

 Le troisième style de commentaire est tiré du langage C++. Il

commence par // et ne peut être écrit que sur une ligne.
 x = y + z; //Ce commentaire ne peut pas être écrit sur plusieurs lignes
40 Classes et Objets

 La programmation orientée objet met dans une même structure les

données et les opérations qui leurs sont associées.
 Le concept de classe correspond simplement à la généralisation de la
notion de type que l’on rencontre dans les langages classiques. En effet,
une classe n’est rien d’autre que la description d’un ensemble d’objets
ayant une structure de données commune et disposant des mêmes
méthodes.
41 Classes et Objets (2)

 Les objets apparaissent alors comme des variables d’un tel type
classe (en P.O.O., on dit aussi qu’un objet est une instance de sa
classe).
 Seule la structure est commune,
 Les valeurs des champs étant propres à chaque objet.
 En revanche, les méthodes sont effectivement communes à
l’ensemble des objets d’une même classe.
42 Classes et Objets (3)

 Toute entité identifiable, concrète ou abstraite, peut être considérée

comme un objet
 Un objet réagit à certains messages qu’on lui envoie de l’extérieur ; la
façon dont il réagit détermine le comportement de l’objet
 Il ne réagit pas toujours de la même façon à un même message ; sa
réaction dépend de l’état dans lequel il est.
43 Classes et Objets (4)
 Un objet possède
 une adresse en mémoire (identifie l’objet)
 un comportement (ou interface)
 un état interne
 L’état interne est donné par des valeurs de variables
 Le comportement est donné par des fonctions ou procédures, appelées
méthodes
 La programmation objet est un paradigme, une manière de « modéliser le
monde » :
 des objets ayant un état interne et un comportement
 collaborent en s’échangeant des messages
 pour fournir les fonctionnalités que l’on demande à l’application
44 Classes et Objets (5)

 Déclaration et instanciation des classes

 Une classe Java peut être très simple. Voici la définition d’une classe
vide :
class MaClasse {
}
 MaClasse monObjet;
Elle crée une référence appelée monObjet, mais n’instancie pas
l’objet. C’est le rôle de l’opérateur new.
 monObjet = new MaClasse();
le nom de la classe est utilisé comme s’il s’agissait d’une méthode.
45 Données membre
 Classe qui ne contient que des données membre :
 public class ClasseChien {
String nom,couleurYeux;
int age;
boolean avecQueue;
}
 Une variable membre d’une classe peut avoir n’importe quel type
primitif, composite et types d’objets.
 Pour accéder à une donnée membre, il faut d’abord créer une
occurrence ou instance de la classe puis accéder aux données
avec l’opérateur “.”
46
Méthodes de classe

public class ClasseChien {

String nom,couleurYeux;
int age;
boolean avecQueue;
public void aboie() {

…
}
}

 ClasseChien chien = new ClasseChien();

 chien.age = 4;
 chien.aboie();
47 Exercice 1 - Création et affichage
 Créer un tableau de 20 entiers, y placer les nombres de 1 à 20,
inverser l'ordre des éléments et les afficher.
48 Exercice 2 - Compte à rebours
 Ecrire un sous-programme prenant un nombre n et affichant les
valeurs n, n - 1,n-2, : : :, 1, 0.
49
Exercice 3 - Nombres amis
 Soient a et b deux entiers strictement positifs. a est un diviseur strict
de b si a divise b et a≠b. Par exemple, 3 est un diviseur strict de 6.
Mais 6 n'est pas un diviseur strict de 6. a et b sont des nombres amis si
la somme des diviseurs stricts de a est b et si la somme des diviseurs
de b est a. Le plus petit couple de nombres amis connu est 220 et
284.
 1. Ecrire une fonction static int sommeDiviseursStricts(int n), elle doit
renvoyer la somme des diviseurs stricts de n.
 2. Ecrire une fonction static boolean sontAmis(int a, int b), elle doit
renvoyer true si a et b sont amis, false sinon.
50 Exercice 4 - Nombres parfaits
 Un nombre parfait est un nombre égal à la somme de ses diviseurs
stricts. Par exemple, 6 a pour diviseurs
 stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.
 1. Est-ce que 18 est parfait ?
 2. Est-ce que 28 est parfait ?
 3. Ecrire la fonction static boolean estParfait(int n), elle doit retourner
true si n est un nombre parfait, false sinon.
51 Bibliographie

 www.google.fr
52
Merci
Contact : rask9@yahoo.fr