Vous êtes sur la page 1sur 27

Programmation Orientée Objet

CHAPITRE 2 : Syntaxe JAVA

Rania Mzid
Salwa M’barek
ISI- 2020/2021
Premiers Pas
• Le caractère de fin d’une instruction est “ ;”
• Les commentaires (non traités par le compilateur) : abrégé, multilignes ou de documentation
int a ; // ce commentaire tient sur une ligne appelé commentaire abrégé

/*Ce commentaire nécessite


2 lignes appelé commentaire multilignes*/

/** commentaire de documentation automatique


* commentaire de la méthode
* @param val la valeur à traiter
* @since 1.0
* @return la valeur de retour
* @deprecated Utiliser la nouvelle méthode XXX
*/
• Les identificateurs (identifiers) permettant de nommer des éléments dans du code source Java (
les variables, les classes, les méthodes, les paramètres, les packages…) acceptent les caractères
{a..z}, {A..Z},$ et _ ainsi que les caractères {0..9} s’ils ne sont pas le premier caractère de
l’identificateur.
• Il faut que l’identificateur ne soit pas un mot réservé du langage (int, for…).
• Java 11 utilise 54 mots réservés qui ne peuvent pas être utilisés comme identifiant.
• Les identifiants JAVA sont sensibles à la casse.
Types primitifs

Nouveauté par rapport à C :


boolean et byte :

Les chaînes de caractères en


JAVA sont des objets :
▸ classe String
Déclaration de 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 primitif dit aussi type élémentaire déclarée sous la forme
type_primitif variable;
✓ soit une classe déclarée sous la forme
classe variable ;
Exemples de déclaration
String chaine;
boolean test;
int jour, mois, annee ;
Types primitifs de données (suite)

• 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 (wrapper) qui encapsule un attribut du
type primitif.
Par exemple: la classe Integer encapsule un attribut de type int.
 Cela permet d’effectuer des opérations de traitement et des manipulations qui seraient
impossibles sur une simple variable de type int.

• Interdit d’affecter à une variable la valeur d’une variable d’un type différent si
cette seconde variable n’est pas explicitement convertie (fonction de
conversion) ou forcée par un cast (sauf pour l’héritage).

int a ;
Par exemple : double b = 5.0 ;
a = b ;
est interdit et doit être écrit en utilisant un cast (diapo suivante)
Conversion de types
Conversion entre types primitifs : cast

Lors de la déclaration, il est possible d'utiliser un cast pour convertir des types
primitifs.

Exemple :
int a ;
double b = 5.0 ;
a = (int)b ; // cast

Il est possible de perdre de l'informations lors d'un cast si la variable recevant


l'information "castée" n'est pas capable de stocker en totalité cette information.

Il n'est pas possible de forcer (cast) un type primitif en type objet.

=> Des conversions sont possibles d’un type primitif en type objet et se font
par des méthodes.
Conversion de types
Convertir un type primitif en type Objet

A chaque type élémentaire, il existe une classe portant le même nom mais où la
première lettre est en majuscule (exception pour int qui devient Integer, ...):
Byte, Double, Float, Integer, Long, Short

Dans ce cas, pour effectuer une conversion:


• vous devrez passer par une méthode de cette classe
Par exemple:
La classe java.lang.Integer à un type int et une méthode toString pour
convertir un int en texte.
• ou en utilisant le constructeur de la classe qui peut recevoir le type primitif en
paramètre.
Par exemple:
int x=10;
Float f=new Float(x);
f sera alors positionnée à 10.0
Conversion de types
Convertir un type Objet en type primitif

Sur le même principe, il sera possible en passant par des méthodes de convertir
un type objet en type primitif.

Les méthodes se nomment quelque soit la classe:


byteValue(), doubleValue, floatValue, IntValue, longValue et shortValue

Exemple :
int x = 10;
Float f1;
Integer i1=new Integer(20);
Byte b1;
f1 = new Float (x);
String ch1;
ch1 = f1.toString();
x=i1.intValue();
Conversion de types
Convertir une chaîne de caractères en type objet

Chaque classe possède une méthode pour convertir une chaîne de caractères
dans son format.
• Nous pouvons passer par le constructeur d'un type objet.
• Ou nous utiliserons des méthodes statiques parseType
où Type sera remplacé par Int, Byte, Double, Float, Long, Short.

Exemple:
String s="150";
Integer i=new Integer("10");
System.out.println ("Valeur de i="+i);
i=Integer.parseInt(s);
System.out.println ("Valeur de i="+i);
Opérateurs
Chaînes de caractères : classe String

String est une classe fournie dans le package java.lang .

Offre des attributs et méthodes pour faciliter la manipulation des chaînes de caractères (voir la
documentaion de la classe java.lang.String).

Les variables de type String ont les caractéristiques suivantes :


• leur valeur ne peut pas être modifiée
• 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 ;
//Après ces instructions s3 vaut ”hello world”
• l’initialisation d’une chaîne de caractères s’écrit :
String s = new String(); //pour une chaine vide
String s2 = new String(”hello world”);
// pour une chaîne de valeur ”hello world”
Tableaux et matrices

• Une variable est déclarée comme un tableau dès lors que des crochets sont présents soit
après son type, soit après son identificateur.

int[] mon_tableau ; // ou bien


int mon_tableau2[];

• Un tableau a toujours une taille fixe qui doit être précisée avant l’affectation de
valeurs à ses indices :
Par exemple : int[] mon_tableau = new int[20]; // indices de 0 à 19 (n-1)

• Un tableau en JAVA est un objet (classe Object), La taille d’un tableau est disponible par
l’attribut length appartenant au tableau et accessible par nom_tableau.length.
• On peut également créer des matrices ou des tableaux à plusieurs dimensions en multipliant
les crochets.
Par exemple : int[][] ma_matrice;).
Pour utiliser des ensembles à taille variable, la classe java.util.Vector est très utile.
Structures de contrôle
Instruction conditionnelle if

Syntaxe
if <condition> <bloc si vrai>
[else if <condition> <bloc si vrai> ]
[else <bloc si faux>]

Exemple
if (emprunteur.getStatut().equals(”employe”)) {
unLivre.setDateRetour(30) ;
} else { unLivre.setDateRetour(15) ;
}
Structures de contrôle
Instruction itérative while

TantQue...Faire... L’exécution de cette instruction suit les étapes suivantes :


1. la condition d’arrêt (booléenne) est évaluée. Si celle-ci est vraie on passe à l’étape 2 ,
sinon on passe à l’étape 4 ;
2. le bloc est exécuté ;
3. retour à l’étape 1 ;
4. la boucle est terminée et le programme continue son exécution en interprétant les instructions
suivant le bloc.

Syntaxe
while <condition> <bloc>

Exemple
while (i < biblio.nbLivres()
) { Livre l =
biblio.getLivre(i) ;
l.setDisponible(true) ;
i++; }
Structures de contrôle
Instruction itérative do………..while

Faire...TantQue... L’exécution de cette instruction suit les étapes suivantes :


1. le bloc est exécuté ;
2. la condition (booléenne) est évaluée. Si celle-ci est vraie on retourne à l’étape 1,
sinon on passe à l’étape 3 ;
3. la boucle est terminée et le programme continue son exécution en interprétant les
instructions
suivant le bloc.
Syntaxe :
do <bloc> while
(<condition>);

Exemple :
do a++
while (a != b);
Structures de contrôle
Instruction itérative for

Pour...Faire Cette boucle est constituée de trois parties : (i)


une initialisation (la déclaration de
variables locales à la boucle est autorisée dans cette partie)
; (ii) une condition d’arrêt ; (iii) un
ensemble d’instructions à exécuter après chaque itération Syntaxe
(chacune de ces instructions est séparée for (<init> ; <condition> ;
par une virgule). L’exécution de cette instruction suit les <instr_post_itération>) <bloc>
étapes suivantes :
Exemple
1. les initialisations dans init sont effectuées ;
2. la condition (booléenne) est évaluée. Si celle-ci est for (int i = 0 ; i < biblio.nbLivres() ; i++)
vraie on passe à l’étape 3, sinon on passe à l’étape 6 ; { Livre l = biblio.getLivre(i) ;
3. le bloc principal est exécuté ; l.setDisponible(true) ; }
4. les instructions à exécuter après chaque itération sont
exécutées (instr_post_itération);
5. retour à l’étape 2 ;
6. la boucle est terminée et le programme continue son
exécution en interprétant les instructions suivant le bloc
principal.
Structures de contrôle
Instruction de choix multiple switch

Syntaxe
switch (<variable>) {
[case <val> : <bloc>]*
default : <bloc> }

Exemple
switch (l.getCategorie()) {
case 1 : l.setDuree(15) ; break ;
case 2 : l.setDuree(20) ; break ;
default : l.setDuree(30) ;
}
Structures de contrôle
Instruction break et continue

L’instruction 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.

Exemple :
for (int i = 0, j = 0 ; i < 100 ; i++) {
if (i > tab.length) {
break ;
}
if (tab[i] == null) {
continue ;
}
tab2[j] = tab[i];
j++;
}
Autres particularités

Comparaison d’instances
▸ L’opérateur = = compare les adresses de deux instances

▸ La méthode equals() que possède toute instance en Java permet


de comparer les valeurs de deux instances
Integer a1 = new Integer(2) ;
Integer a2 = new Integer(2) ;
System.out.println(a1 == a2) ; // false
System.out.println(a1.equals(a2)) ; // true
API JAVA

L’API (Application Programming Interface) : bibliothèques de classes fournies par JAVA SE


(Standard Edition), implémentant des données et traitements génériques utilisables par un grand
nombre d’applications.

L'API Java est organisée en packages. Les packages sont regroupés en collections appelées
modules depuis la version Java SE 9 :
• Packages standards : ce sont les sous−packages du package java
• Packages d'extensions : ce sont les sous−packages du package javax
• Packages tiers : ces packages concernant notamment Corba et XML

Une documentation en ligne pour les API JAVA SE (dernière version 15) est disponible à l’URL :
https://docs.oracle.com/en/java/javase/

Principaux packages standards :


API JAVA (suite)

Pour accéder à une classe d’un package donné, il faut préalablement importer cette
classe ou son package.
Par exemple, la classe Date appartenant au package java.util qui implémente un
ensemble de méthodes de traitement sur une date peut être importée de deux
manières :
● une seule classe du package est importée :
import java.util.Date ;

● toutes les classes du package sont importées (même les classes non utilisées) :
import java.util.* ;

Le programme suivant utilise cette classe pour afficher la date actuelle :


import java.util.Date ;
public class DateMain {
public static void main(String[] args) {
Date today = new Date();
System.out.println(”Nous sommes le ” + today.toString());
}
}
JAVA vs C & JAVA vs SGBD
Comparaison avec C
▸ Syntaxe similaire (instructions, types primitifs,etc.)
▸ Java est interprété (machine virtuelle) et multi-plateformes
▸ Java est plus haut niveau : pas de gestion explicite des pointeurs, E/S
formattées, etc.
▸ Java est modulaire par essence (compilation séparée par défaut)
▸ …

Comparaison avec SGBD


▸ La technologie objet est fortement inspirée des BDD
▸ Java ne stocke pas de manière persistente les données
▸ Java attache des traitements aux données (méthodes)
▸ Java peut utiliser un SGBD pour sauvegarder des objets (JDBC)
▸ …
Ecriture d’une classe : exemple classe Livre

Syntaxe
class <nom de la classe> {
Données = <contenu de la classe>
}

Encapsulation
• Regroupement de données dans
une classe
• Droits d’accès aux données
Traitements = (visibilité) pour cacher ou non
leur existence aux autres objets
de l’application
Ecriture d’une classe

Le code source d’un programme JAVA est contenu dans plusieurs fichiers
d’extension .java
▸ une seule classe publique par fichier
▸ Le nom du fichier doit être le même que celui de la classe
▸ Par convention, le nom d’une classe commence toujours par une majuscule

Le code source d’une classe commence par le mot-clé class suivi de son contenu
Écriture des méthodes

Une méthode est composée de sa signature et d’un traitement associé


▸ La signature d’une méthode contient notamment
▸ un nom de méthode

▸ un type de données de retour

▸ des types de données pour ses


▸ …
arguments
▸ Par convention le nom des méthodes et attributs commencent toujours
par une minuscule

Syntaxe
<type de retour><nom de méthode> (<arguments> *) {
<traitement associé>
}
Portée d’une variable

public class Portee { Portée de classe


int a; l’entier a est visible dans toute la
classe Portee
public void test(int b) {
if (a > b) {
int c = b; Portée de méthode
b = a; l’entier best visible à l’intérieur
a = c; de la méthode test
}
afficher(b);
} Portée de bloc { }
} l’entier cest visible à l’intérieur
du bloc de la structure de
contrôle if
Références
■ Java Platform, Standard Edition Documentation : https://docs.oracle.com/en/java/javase/