Programmation Orientée

Objet-Java
Pr. Fatima MOURCHID

Année universitaire 2023-2024

Identification du cours

 Intitulé: Programmation orientée objet-Java

 Durée: 24 heures
 10 heures (Cours)
 12 heures (Travaux pratiques)

2
Plan

 Introduction
 Présentation de Java et son environnement d’exécution
 Types de données
 Structures de contrôle
 Tableaux de données
 Opérateurs

3
Plan

 Programmation Orientée Objet

 Classe et Objet
 Attributs et méthodes
 Encapsulation et polymorphisme
 Héritage et redéfinition des méthodes
 Classes abstraites et interfaces
 Collections
 Gestion des exceptions
 Gestion des entrées/sorties
 Bases de données et Java
 Interfaces graphiques
4
Introduction

5
Introduction

 Java est un langage de programmation orienté objet, dont la syntaxe est

proche du langage C et basé sur le langage C++
 Créé en 1995 par Sun Microsystems suite aux recherches, débutées en 1990
 En 2009, Sun Microsystems est racheté par Oracle Corporation qui fournit
dorénavant les outils de développement Java SE (Standard Edition) contenus
dans le Java Development Kit (JDK)
 Dernière version est Java SE 21 (17 octobre 2023)
 Types de programmes en Java
 Applications : exécutées localement
 Applets : exécutées côté client http (page web)
 Servlets : exécutées côté serveur http (page web)

6
Introduction

 Caractéristiques du langage Java

 Orienté objet
 Fortement typé
 Toute variable doit être déclarée avec un type
 Compilateur vérifie que les utilisations des variables sont compatibles avec leur type
(notamment via un sous-typage correct)
 Types fournis par le langage, mais également par la définition des classes
 Compilé
 Bytecode, i.e., code intermédiaire indépendant de la machine
 Interprété
 Bytecode est interpété par une machine virtuelle Java

7
Introduction

 Code source Java est écrit sous la forme de classes, dans des fichiers dont
l’extension est « .java »
 Ce code source est alors compilé par le compilateur « javac » en un langage
appelé bytecode et enregistre le résultat dans un fichier dont l’extension est
« .class »
 Ce Bytecode est interprété par la « machine virtuelle Java » qui transforme le
code compilé en code machine compréhensible par le système d’exploitation
 Exécution s’effectue par la commande « java » suivie du nom de la classe à
exécuter (sans l’extension .class)

8
Introduction

 Machine Virtuelle Java

 Il s’agit d'abstraire le comportement d'une machine afin de le rendre indépendant
de la plateforme d’exécution
 Traduit le bytecode dans le langage machine de la plateforme d’exécution

9
Introduction

 Technologie Java
 Composée du langage de programmation et du compilateur
 JVM et des APIs (Application Programming Interfaces) regroupées dans une «
plateforme »
 Java SE (Java Platform, Standard Edition): pour applications desktop
 Java EE (Java Platform, Enterprise Edition): pour développer et déployer des applications
serveur, Web services, etc…
 Java ME (Java Platform, Micro Edition): J2ME pour les applications embarquées (PDA,
téléphones, etc…)

 Il suffit du JRE (Java Runtime Execution) pour exécuter une application java par
opposition au JDK (Java Developpement Kit)

10
Introduction

public class HelloWorld {

public static void main(String[] args) {
System.out.println(”Hello world”);
}
}

11
Introduction

 Blocs de code sont encadrés par { . . .}

 Chaque instruction se termine par un ;
 Instruction peut tenir sur plusieurs lignes
 Commentaires ne sont pas pris en compte par le compilateur
// commentaire sur une seule ligne
/* commentaires ligne 1
commentaires ligne 2 */

12
Introduction

 Méthode Main
 Constitue la partie principale du programme, permettant l'exécution d'une
application Java
 Doit être déclarée public, static, et void
 Argument est un tableau d'éléments textuels fournissant le moyen de passer des
paramètres au programme
 Argument du array de strings peut être renommé en n'importe quoi, mais la
convention est de choisir entre « args » ou « argv »

13
Introduction

 Déclaration de la méthode main ()

public static void main(String[] args) {
…
}
ou
public static void main(String... args) {
…
}

14
Syntaxe du langage Java

15
Variables

 Par convention :
 Identificateurs de classe commencent toujours par une majuscule
 Identificateurs de variables et de méthodes commencent toujours par une
minuscule
 Identificateurs formés par la concaténation de plusieurs mots comportent une
majuscule à chaque début de mot sauf pour le premier mot qui dépend du type de
l’identificateur

16
Types de données

 Variables locales comme les champs des classes et des objets peuvent être de
type
 Primitif
 Dans ce cas, la déclaration de la variable réserve la place mémoire pour stocker sa valeur
(qui dépend de son type)

 Non primitif
 Tableaux, matrices
 Objet ou référence
 Dans ce cas, la déclaration de la variable réserve la place d'une référence afin d'accéder à l'objet
lui-même (null si la référence est inconnue)

17
Types de données

 Types primitifs
 Types entiers signés
 byte (octet) sur 8 bits
 short sur 16 bits
 int sur 32 bits
 long sur 64 bits
 Type caractère
 char sur 16 bits
 Types à virgule flottante
 float sur 32 bits
 double sur 64 bits
 Type booléen: boolean (true ou false)
18
Types de données

 Types primitifs

19
Types de données

 Terme « void » est utilisé pour spécifier le retour vide ou une absence de
paramètres d’une méthode
 Chaque type primitif possède une classe qui encapsule un attribut du type
primitif
 Exemple: la classe Integer encapsule un attribut de type int et permet d’effectuer
des opérations sur les objets de type int

20
Types de données

 Conversion (également appelée transtypage) d’un type primitif en un autre se

fait de la manière suivante :
typeVariableA variableA = (typeVariableA) valeurB

21
Types de données

int a ;
double b = 5.0 ;
a=b;
 est interdit et doit être écrit de la manière suivante :
int a ;
double b = 5.0 ;
a = (int)b ;

22
Types de données

 Opérateurs de comparaison
 Permettent de comparer deux variables d’un même type primitif (entier, flottant,
booléen et caractère) et renvoient une valeur booléenne
 == comparaison d’égalité
 != différence
 < inférieur strict
 <= inférieur ou égal
 > supérieur strict
 >= supérieur ou égal

23
Types de données

 Expressions composées doivent être complètement parenthésées :

double a = 8;
boolean estDansIntervalle = ((a >= 0) && (a <= 10)); // true ssi a appartient
à [0,10]

24
Types de données

 Tableaux à une dimension

int[] tabInt ; // Déclaration d’un tableau d’entiers
char[] tabChar ; // Déclaration d’un tableau de caractères

int[] tabInt ; // Déclaration d’un tableau d’entiers

tabInt = new int[100]; // Instanciation d’un tableau de 100 éléments entiers

25
Types de données

 Tableaux à deux dimensions

char[][] Matrice ; // Déclaration d’un tableau à 2 dimensions de caractères

Matrice= new char[3][5]; // Instanciation d’un tableau contenant 3 tableaux de
// 5 caractères chacun

26
Types de données

 Chaînes de caractères
 Ne sont pas considérées en Java comme un type primitif
 Classe « String », fournie dans le package « java.lang », contenant un ensemble de
méthodes permettent d’effectuer des opérations sur les chaînes de caractères
 Caractéristiques
 Valeur ne peut pas être modifiée
 Initialisation

String s1 = new String(); //pour une chaine vide

String s2 = new String(”hello world”); // pour une chaîne de valeur ”hello
//world”

27
Types de données

 On peut utiliser l’opérateur « + » pour concaténer deux chaînes de caractères

String s1 = “hello” ;
String s2 = “world” ;
String s3 = s1 + ” ” + s2 ; // s3 =“hello world”

28
Types de données

 Objets définies par l’utilisateur

 Classe
 Description des objets, (ex : les clients) et définit les attributs et les méthodes
communes aux objets d’un certain type
 Objets construits à partir de ces classes sont des instances
 Constructeur de la classe
 Toute classe doit contenir au moins une méthode particulière appelée constructeur
 Porte le même nom que la classe et est appelée lorsque l’on instancie un nouvel
objet
 Initialise les valeurs des attributs et ne renvoie aucune valeur

29
Types de données

class Client {
//les attributs de la classe Client
String nom;
String prenom;
int nbCommandes;
}

30
Types de données

Client() { // premier constructeur

nom = new String("");
prenom = new String("");
nbComamndes = 0;
}

Client (String nom, String prenom, int nbCommandes) { // deuxième constructeur

this.nom = new String(nom);
this.prenom = new String(prenom);
this.nbCommandes = nbCommandes;
}

31
Structures de contrôle

 Bloc d’instructions
 Accolades {} permettent de délimiter un bloc d’instructions
 Variables déclarées dans un bloc sont accessibles à l’intérieur de ce bloc
uniquement
 Deux variables de même nom peuvent être déclarées dans deux blocs distincts

32
Structures de contrôle

 Structures de contrôle conditionnelles

 Spécifier à quelles conditions (sous forme d’expressions logiques) un bloc
d’instructions va être exécuté
 1.Structure alternative
if (condition) {// (condition == true)
// bloc d’instructions exécutées si condition est vraie
} else {
// bloc d’instructions exécutées si condition est fausse
}

33
Structures de contrôle

if (condition) {// (condition == true)

// bloc d’instructions exécutées si condition est vraie
} else if {
// bloc d’instructions
} else if {
// bloc d’instructions
}
…
} else {
// bloc d’instructions
}

34
Structures de contrôle

 2.Structure à choix multiples

switch (variable) {
case valeur1 :
Liste d’instructions // exécutées si (variable == valeur1)
break;
...
case valeurN :
Liste d’instructions // exécutées si (variable == valeurN)
break;
default:
Liste d’instructions // exécutées sinon
}

35
Structures de contrôle

 Structures itératives
 1.Itération répétée n fois
for (int compteur = 0 ; compteur < n ; compteur = compteur + 1) {
// bloc instructions répétées n fois
}
Ou:
for (int compteur = n ; compteur > 0 ; compteur = compteur - 1) {
// bloc instructions répétées n fois
}

36
Structures de contrôle

 2.Itération répétée tant qu’une condition est vraie

while (condition) { // (condition == true)

// bloc d’instructions répétées tant que condition est vraie
// condition doit être modifiée dans ce bloc
}

37
Structures de contrôle

 3. Itération exécutée au moins une fois

do {
// bloc d’instructions exécutées
// condition doit être modifiée dans ce bloc
} while (condition); // si condition est vraie,
// le bloc est exécuté à nouveau

38
Structures de contrôle

 Break et continue (rupture de séquence)

 Break est utilisée pour sortir immédiatement d’un bloc d’instructions (sans traiter
les instructions restantes dans ce bloc)
 Dans le cas d’une boucle on peut également utiliser l’instruction continue
avec la différence suivante :
 break : l’exécution se poursuit après la boucle (comme si la condition d’arrêt
devenait vraie)
 continue : l’exécution du bloc est arrêtée mais pas celle de la boucle. Une
nouvelle itération du bloc commence si la condition d’arrêt est toujours vraie

39
Structures de contrôle

for (int i = 0, j = 0 ; i < 100 ; i++) {

if (i > tab.length) {
break ;
}
if (tab[i] == null) {
continue ;
}
tab2[j] = tab[i];
j++;
}

40
Méthodes

 Méthode
 Bloc d’instructions exécuté par un appel de la méthode dans le bloc du programme
principal (méthode main) ou dans une autre méthode
 Créée pour
 Regrouper un ensemble d’instructions qui participent à la réalisation d’une même tâche
 Regrouper un ensemble d’instructions qui sont appelées à différents endroits du
programme

41
Méthodes

 1.Méthodes prédéfinies
 Méthodes d’une librairie
 nomMethode (parametre_1,... , parametre_n);
 double racine = Math.sqrt(5.2);
 System.out.println("la chaîne de caractères à afficher");

42
Méthodes

 2.Méthodes définies par l’utilisateur

static TypeRetour nomMethode(Type1 param1,..., TypeN paramN) {
//bloc d’instructions
return valeurRetournee;
}
 TypeRetour: type de valeurRetournee
 Void: si la méthode ne renvoie aucune valeur

43
Méthodes

static int addition(int x, int y) {

return x + y;
}

public static void main (String[] args) {

int a = 7;
int b = 3;
int somme = addition(a,b);
}

44
Méthodes

 3. Méthodes récursives
public class Factorielle {
static int calculeFactorielle(int n) {
if(n > 0) { // cas général
return n * calculeFactorielle (n-1); }
else { //cas d’arrêt
return 1; }
}
public static void main (String[] args) {
int valeur = 4;
System.out.println(calculeFactorielle(valeur));
}
}

45
Exercices

 Outils de développement
 Utiliser Eclipse, un environnement de développement intégré (IDE)
 Utiliser Eclipse en mode collaboratif sur GitHub grâce à l’extension Git pour
Eclipse

46
Exercices

 Exercice 1: Écrire un programme Java pour afficher le message «Hello

World». Utiliser la méthode System.out.println() pour afficher un argument
qui lui est transmis
public class Main {
public static void main(String[] args) {
System.out.println("Hello world");
}
}

47
Exercices

 Exercice 2: Écrire un programme Java pour calculer la somme de deux

nombres et l’afficher

public class Main {

public static void main(String[] args) {
System.out.println( 10+ 5);
}
}

48
Exercices

 Exercice 3:Écrire un programme Java pour calculer le résultat de la division

de deux nombres et l’afficher

public class Main {

public static void main(String[] args) {
System.out.println(10 / 5);
}
}

49
Exercices

 Exercice 4: Écrire un programme Java qui prend un nombre en entrée et affiche sa table de multiplication
jusqu’à 100

import java.util.Scanner;
public class Exercice4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Entrer un nombre: ");
int n = sc.nextInt();
for (int i=0; i<100; i++){
System.out.println(n + " x " + (i+1) + " = " + (n * (i+1)));
}
}
}

50
Exercices

 Exercice 5: Écrire un programme Java pour calculer l’aire et le périmètre d’un cercle et
l’afficher
public class Exercice5 {
public static void CalculerAirePerimetre(double rayon){
double perimeter = 2 * Math.PI * rayon;
double aire = Math.PI * rayon * rayon;
System.out.println("Le périmètre est = " + perimeter);
System.out.println("L'aire est = " + aire);
}
public static void main(String[] args) {
CalculerAirePerimetre(4.2);
}
}
51
Exercices

 Exercice 6: Écrire un programme Java qui prend 4 nombres en entrée pour

calculer et afficher la moyenne de ces nombres

52
Exercices

import java.util.Scanner;
public class Exercice6 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Entrer le premier nombre: ");
int nbr1 = sc.nextInt();
System.out.print("Entrer le deuxième nombre: ");
int nbr2 = sc.nextInt();
System.out.print("Entrer le troisième nombre: ");
int nbr3 = sc.nextInt();
System.out.print("Entrer le quatrième nombre: ");
int nbr4 = sc.nextInt();
System.out.println("La moyenne est: "+ (float) (nbr1 + nbr2 + nbr3 + nbr4) /4 );
}
}

53
Exercices

 Exercice 7: Écrire un programme Java pour permuter deux variables

54
Exercices

public class Exercice7 {

public static void main(String[] args) {
int a, b, tmp;
a = 100;
b = 50;
System.out.println("Avant la permutation: a = "+a+", b = "+b);
tmp = a;
a = b;
b = tmp;
System.out.println("Après la permutation: a = "+a+", b = "+b);
}
}

55
Exercices

 Exercice 8: Écrire un programme Java qui calcule la factorielle d’un nombre

donné

56
Exercices

public class Exercice8 {

static int calculerFactorielle(int n) {
if(n > 0) { // cas général
return n * calculerFactorielle (n-1); }
else { //cas de base ou d’arrêt
return 1; }
}
public static void main (String[] args) {
int valeur = 4;
System.out.println(calculerFactorielle(valeur));
}
}

57
Exercices

 Exercice 9: Écrire un programme Java pour calculer la diagonale, l’aire et le

périmètre d’un rectangle et l’afficher

58
Exercices

public class Exercice9 {

public static void CalculerAirePerimetre(double L, double l){
double perimeter = (L+l) *;
double aire =L*l;
double diagonale = Math.sqrt(L*L + l*l);
System.out.println("Le périmètre est = " + perimeter);
System.out.println("L'aire est = " + aire);
System.out.println("La diagonale est = " + diagonale);
}
public static void main(String[] args) {
CalculerAirePerimetre(12.5,85);
}
}

59