Cours_Java.pdf

Programmation
Java SE
Université de Nouakchott Al-Aasriya
Faculté des Sciences et Techniques
L2 MIAGE/DA2I
Année universitaire: 2021/2022

Les bases
• Le code source d’un programme Java est écrit dans un fichier dont l’extension est « .java »
• Ce code source est alors compilé par le compilateur javac en un langage appelé bytecode et
enregistré dans un fichier dont l’extension est « .class »
• Le bytecode ainsi obtenu n’est pas directement utilisable. Il doit être interprété par la machine
virtuelle de Java qui transforme alors le code compilé en code machine compréhensible par le
système d’exploitation.
N.B: Le bytecode reste le même quelque soit l’environnement d’exécution (C’est la raison pour
laquelle Java est un langage portable )

4
Code source
java
Compilateur
Interpréteur
Bytecode /Pseudo-code
Code machine
Système d’exploitation
MonProg.java
javac MonProg.java
MonProg.class
Virtualisation
Système d’exploitation
java MonProg
Exemple

Les bases
• Programme Java = suite d’instructions
• Une instruction se termine par un « ; »
• Un bloc d’instructions est constitué d’une séquence de plusieurs
instructions. Un bloc d’instructions est inclus entre deux accolades

Types de données
• Deux types de données:
• Types primitifs: byte, short, int, long, float, double, char, boolean
• Types objets: String, …etc
• N.B: Tous les types primitifs ont leurs équivalents objets

Types de données: Déclaration
• Pour déclarer une variable:
nom_type nom_variable;
N.B: Possibilité de déclarer plusieurs variables de même type
dans une seule instruction:
nom_type nom_variable1, nom_variable2, …, nom_variableN;

Types de données: Initialisation
• Initialisation = affecter une valeur initiale à une variable
• Possibilité d’initialiser les variables au moment de leur déclaration
int x=5,y=12;
char c=’Y’;
boolean rep=true;
int x,y;
x=5;
y=12;
char c;
c=’Y’
boolean rep;
rep=true;

Les opérateurs
• Affectation:
= (affectation)
+= (incrémentation)
-= (décrémentation)
• Arithmétiques binaires:
+ (addition)
- (addition)
* (multiplication)
/ (division)
% (modulo: reste de la division entière)

Les opérateurs
• Arithmétiques unaires:
- X (opposé) (équivaut à 0 - X)
X++ (incrémentation) (équivaut à X = X + 1)
X - - (décrémentation) (équivaut à X = X - 1)
• Relationnels:
== (égal)
!= (différent)
< (plus petit)
> (plus grand)
<= (plus petit ou égal)
>= (plus grand ou égal)

Les opérateurs
• Logiques:
&& (et)
|| (ou)
! (non)
• Concaténation de chaînes de caractères: +

Structure de contrôle conditionnelle
• Structure sans branche « else »:
• if (condition) { instructions }
• Structure avec branche « else »:
• if (condition) { instructions } else { instructions }

Structure de contrôle à choix multiple
switch identificateur
{
case valeur1 : instruction1;
….
default : instruction par défaut ;
}

• Si les instructions doivent s’exécuter de façon exclusive, alors utiliser
l’instruction break pour sortir de la structure
switch identificateur
{
case valeur1 : instruction1;break;
….
default : instruction par défaut ;
}

• Exemple:
int NumMois;
switch (NumMois)
{
case 1: System.out.println(’’Janvier’’);break;
case 2 : System.out.println(’’Février’’);break;
case 3 : System.out.println(’’Mars’’);break;
….
case 12 : System.out.println(’’Décembre’’);break;
default : System.out.println(’’Ce n’est pas un mois!!!’’);
}

Structures de contrôle itératives
• La boucle « Pour »:
for (initialisation; test; incrémentation) {
instruction(s);
}
Exemple:
int a, b = 6;
for (a=0; a<15; a++) {
b=b+2;
}

• La boucle « Tant que … faire »:
while (test) {
instruction(s);
}
Exemple:
int a=0, b=6;
while (a<15) {
b+=2;
a++;
}

• La boucle « Faire … tant que »:
do {
instruction(s);
} while (test);
Exemple:
int a=0, b=6;
do{
b+=2;
a++;
} while (a<15);

Les tableaux
• Un tableau est une structure de données contenant un groupe
d'éléments
• Les éléments du tableau sont tous du même type
• Le type des éléments peut être un type primitif ou un type objet (une
classe)
• Il est impossible de changer la taille d'un tableau : la taille d'un
tableau est fixe et ne peut pas être modifiée une fois que le tableau a
été instancié

Les tableaux
• Déclaration d’un tableau: il faut spécifier un type (soit primitif, soit
objet) suivi de la notation []
• Exemple: int[] t  t est un tableau d’entiers
String[] s  s est un tableau de chaînes de caractères
(Attention: « int t » différent de « int[] t »)

Les tableaux
• Initialisation d’un tableau: se fait en invoquant l’opérateur new et en
donnant une taille au tableau
• Exemple:
int[] t = new int[10];
Le tableau t contiendra 10 éléments

Les tableaux
• Initialisation d’un tableau: Il est également possible d'initialiser un
tableau en donnant directement son contenu
• Exemple:
int[] t = {1,2,3,4,5}
Ou:
int[] t = new int[] {1,2,3,4,5}

Les tableaux
• Accéder au contenu d’un tableau: il faut utiliser la syntaxe suivante
nom_du_tableau[index_de_la_case]
L'objet retourné est du même type que le contenu du tableau.
La première cellule du tableau est toujours à l'index 0. Ainsi, un tableau
de taille N sera indexable par la plage d'indices [0, N-1].

Les tableaux
• Accéder au contenu d’un tableau:
• Exemple:
int[] t = {1,2,3,4,5};
int x = t[2];
t[1] = 0;

Les tableaux
• La taille d’un tableau:
Chaque tableau dispose d'un membre length qui contient la taille du
tableau sous forme d'une valeur entière positive ou nulle et auquel on
accède par la syntaxe suivante
nom_du_tableau.length
Exemple: int[] t = {1,2,3,4,5};
System.out.println(t.length);

Les commentaires
• La séquence « // » permet d’insérer un commentaire sur une seule
ligne
• La séquence « /* */ » permet d’insérer un commentaire sur plusieurs
lignes
Exemple:
• // Ceci est un commentaire sur une seule ligne
• /* Ceci est un
commentaire
Sur plusieurs lignes */

Introduction aux concepts de
l’Approche Orientée Objets

Approche Orientée Objets
• Objectifs:
• Conception de l’organisation de grands projets informatiques autour d’entités
précisément structurées (objets)
• Amélioration de la sûreté des logiciels en gérant l’accès aux données sensibles
(encapsulation)
• Simplifier la réutilisation de code grâce à l’extension des objets existants
(héritage) et partage des méthodes (polymorphisme)

• Concepts de base:
• Concept d’Objet : unité ou entité logique manipulée par un langage orienté
objets. Un objet est défini par :
1.Une identité qui permet de distinguer les objets entre eux, chaque objet a une
existence concrète
2.Un état interne définissant les caractéristiques de l’objet et représenté par des
variables appelées « champs » ou « attributs » auxquelles des valeurs sont
affectées
3.Un comportement défini par des « méthodes » modifiant les états de l’objet
• Concept de Classe: Elle regroupe l’ensemble des objets ayant en commun les
mêmes caractéristiques

Personne
NCIN:entier
Nom:chaine de caractères
Prénom:chaine de caractères
QuelNom():chaine de caractères
QuelPrénom():chaine de caractères
Les Attributs
Les méthodes
(comportement)
NCIN=44556677
Nom = Med Ali
Prénom = Sidi
LaPersonne1
Classe 
Objet 
 LaPersonne1 est un objet de la classe Personne
 LaPersonne1 est une instance de la classe Personne
 Objet = Instance
 Créer un objet = instanciation
Affectation des valeurs aux attributs

• Déclaration d’une classe:
class NomClasse{
// déclaration des attributs
// déclaration des méthodes
}

• Déclaration des attributs et des méthodes:
• Les attributs sont déclarés comme des variables
• Les méthodes sont déclarées selon le schéma suivant:
• TypeRetour NomMéthode (arguments) {
instructions
}
N.B: Ce schéma de déclaration d’une méthode est appelé la “signature”
de la méthode

Les méthodes:
Les méthodes décrivent les traitements réalisés par la classe
 Elles forment l’interface permettant de manipuler les objets
Elles retournent le résultat du traitement (type objet ou type primitif) ou ne
retournent rien (type « void »)
Elles prennent une liste de variables comme arguments (Type1 var1, Type2
var2, …, TypeN varN)

• Le constructeur:
• Méthode particulière permettant de créer des objets d’une classe
• Initialise les attributs au moment de la création des objets
• Porte le même nom que la classe
• Pas de type de retour
• Toute classe java possède au moins un constructeur avec des arguments si
défini
• Si aucun constructeur n’est défini explicitement, alors un constructeur sans
arguments par défaut est associé à la classe

• Le constructeur:
• Une classe peut posséder plusieurs constructeurs tant qu’ils ont des
signatures différentes (càd des paramètres différents)
• Possibilité d’appeler un constructeur à l’intérieur d’un autre
• Si l'on définit un constructeur explicite, alors le constructeur vide par défaut
n'existe plus ; on doit le déclarer explicitement si l'on veut encore l'utiliser

• Le mot clé « this »:
Le mot clé « this » fait référence à l’objet courant
• this(…) désigne le constructeur de la classe
• this.x désigne l’attribut ou la méthode x de la classe

Structure générale d’une classe:
class NomClasse {
//déclaration des attributs de la classe
Type1 NomAttribut1;
…
TypeN NomAttributN;
// déclaration des constructeurs de la classe
NomClasse(arguments){
//instructions d’initialisation
}
//déclaration des méthodes de la classe
TypeRetour1 NomMethode1(arguments){
//instructions
}
….
TypeRetourN NomMethodeN(arguments){
//instructions
}
}

• Création d’objets:
 La création d’un objet à partir d’une classe est appelée une
instanciation (objet=instance de la classe)
 La création d’un objet nécessite l’appel du constructeur

Créer un objet se fait en deux étapes:
• Déclaration : définit le type et le nom de l’objet (vaut null si seulement déclaré)
Exemple: Personne sidi;
• Création et allocation de la mémoire par l’appel du constructeur (réserve la mémoire
et initialise les objets)
Exemple: sidi = new Personne(arguments);

 Possibilité de faire la déclaration et l’initialisation d’un objet dans
une même instruction.
Exemple: Personne sidi = new Personne(arguments);

• Les modificateurs d’accès:
• Précédent la déclaration d’une classe, d’une méthode ou d’un attribut
• Indiquent si les autres classes de l’application pourront accéder ou non à
cette classe, méthode ou attribut
Exemples de modificateurs d’accès: public, private, …

• public: un membre déclaré « public » est accessible par toutes les classes
• private: un membre déclaré « private » n’est accessible que depuis
l’intérieur de la classe où il est défini

Exemple:

• Les membres privés d'une classe ne sont accessibles que par les méthodes
de la classe:
• Les attributs privés d'une classe ne peuvent être utilisés que par les méthodes de
cette classe.
• Les méthodes privées d'une classe ne peuvent être appelées que par les méthodes
de cette classe.
• Les membres publics d'une classe sont accessibles de l'intérieur et de
l'extérieur de la classe, par conséquent:
• Les attributs publiques d'une classe sont donc accessibles depuis n'importe quelle
méthode.
• Les méthodes publiques d'une classe peuvent être appelées par n'importe quelle
méthode.

• Un membre est publique si sa déclaration est précédée du mot clé public. Il
est privé, s'il elle précédée du mot clé private.
• Le modificateur d’accès par défaut (si rien n’est précisé) ou ‘friendly’: les
membres sont visibles par les classes du même package.

• Encapsulation:
• Définir une classe de telle sorte que ses attributs ne puisse pas être
directement manipulés de l'extérieur de la classe, mais seulement
indirectement par l'intermédiaire des méthodes
• C’est un mécanisme de protection correspondant au fait que des champs et
des méthodes privées ne soient accessibles par l’utilisateur d’une classe que
par certaines méthodes publiques

• Les paquetages ou « packages »:
• Java permet de regrouper les classes en ensembles appelés « packages »
• Un package porte un nom
• Les packages sont organisés sous forme de hiérarchie, c'est-à-dire qu'il est
possible de les imbriquer: Un package peut contenir des sous packages

• Dans les faits, un package est associé à un dossier et un sous package
à un sous dossier.
• Il vous sera plutôt demandé d'organiser vos classes par paquets
sémantiquement cohérents. Bien entendu, un paquet sera équivalent
à un package Java

• Création d’un package:
• package nom_du_package;
• Doit être la première instruction dans un programme java

• Chaque sous-package est séparé de son parent avec un point.
• Exemple: package nom1.nom2.nom3;
 Création du répertoire nom1/nom2/nom3

• Exemples de packages:
• java.io gestion des entrées sorties
• java.lang types et fonctions de base
• java.math types et fonctions mathématiques
• java.awt éléments des interfaces graphiques
• …

• Inclusion d’un package: mot clé import
• Exemple: import java.io.File;
• Inclusion ‘complète’ d’un package: le caractère * désigne ‘toutes les classes du
package’
• Exemple: import java.io.*
• N.B: Les inclusions des packages sont faites au début du fichier

• Les « accesseurs » et les « mutateurs »:
• Les méthodes permettant d'accéder aux attributs sont appelées accesseurs,
parfois getters (appelation d'origine anglophone)
• Les méthodes permettant de modifier les attributs sont appelées mutateurs,
parfois setters (appelation d'origine anglophone)

Un accesseur, pour accomplir sa fonction :
• doit avoir comme type de retour le type de la variable à renvoyer
• ne doit pas nécessairement posséder d'arguments

Un mutateur, pour accomplir sa fonction :
• doit avoir comme paramètre la valeur à assigner à l’attribut. Le
paramètre doit donc être du même type de l’attribut
• ne doit pas nécessairement renvoyer de valeur, il possède le type void

• Conventions de nommage:
Les conventions de nommage permettent de rendre les programmes
plus lisibles et plus faciles à comprendre.
• Les packages:
• écrits tout en minuscules
• Les classes et les constructeurs:
• la première lettre est en majuscule
• Si le nom est composé de plusieurs mots, la première lettre de chaque mot
doit être en majuscule, ne pas mettre de caractère underscore '_'

• Les variables:
• La première lettre est obligatoirement une minuscule
• Leur nom devrait contenir un verbe et donner une idée claire de la fonction
accomplie par la méthode
doit être en majuscule sans mettre de caractère underscore '_‘

• Les méthodes:
• La première lettre est obligatoirement une minuscule
• Leur nom devrait contenir un verbe et donner une idée claire de la fonction
accomplie par la méthode
doit être en majuscule sans mettre de caractère underscore '_‘
• Les méthodes pour obtenir la valeur d'un champ doivent commencer par get
suivi du nom du champ
• Les méthodes pour mettre à jour la valeur d'un champ doivent commencer
par set suivi du nom du champ

Cours_Java.pdf

Contenu connexe

Similaire à Cours_Java.pdf (20)

Dernier (20)

Cours_Java.pdf