Vous êtes sur la page 1sur 30

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 (String).
• 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); //convertir int -> Float (rappel : Float(x) le constructeur)
//f sera alors positionnée à 10.0
String s=f.toSting(); // convertir Floar -> String
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(); //Integer -> int
double b=f1.doubleValue();// Float -> double
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");
Integer x=new Integer (s);
System.out.println ("Valeur de i="+i); //i vaut 10
System.out.println ("Valeur de i="+x);// x vaut 150
i=Integer.parseInt(s); // String -> Integer
System.out.println ("Valeur de i="+i); //i vaut 150
*********************************************
Classe.méthode() : méthode statique (de classe)
obj.méthode() : méthode non statique (d’instance)
public static void main (String [ ] args)
Opérateurs
Chaînes de caractères : classe String

String est une classe fournie dans le package java.lang (dans le module
java.base).

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 peut ê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 Syntaxe
itération (chacune de ces instructions est séparée for (<init> ; <condition> ;
par une virgule). L’exécution de cette instruction suit <instr_post_itération>) <bloc>
les étapes suivantes : Exemple
1. les initialisations dans init sont effectuées ;
for (int i = 0 ; i < biblio.nbLivres() ; i++)
2. la condition (booléenne) est évaluée. Si celle-ci
est vraie on passe à l’étape 3, sinon on passe à { Livre l = biblio.getLivre(i) ;
l’étape 6 ; l.setDisponible(true) ; }
3. le bloc principal est exécuté ;
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 références de deux instances (objets)

▸ La méthode equals() que possède toute instance en Java permet de comparer les valeur
de deux instances
a1
Integer a1 = new Integer(2) ;
Integer a2 = new Integer(2) ; // a1 et a2 deux
références différentes a2,a3
Integer a3 = a2;// affectation entre références
System.out.println(a3 == a2) ; // true
System.out.println(a1 == a2) ; // false
System.out.println(a1.equals(a2)) ; // true
Notion de référence

Mémoire Ex 2:
Un pointeur contient l’adresse p pointeur sur objet en c++
variables de
de la variable vers laquelle il p->attribut
type primitifs
pointe P->méthode
a,b

Vehicule v1= new Vehicule (); En java


P une référence sur un objet
Pointeurs (ex: p) p.attribut
V1 est une référence vers un
objet de type Vehicule p.méthode
Objets ,
références
Une référence est un alias(un
subtitut, un autre nom) à l’objet

En c++:
int a=10;
int *p=&a; //pointeur sur a
int& b=a; //b référence sur a
a=20; // b vaut 20
b=30; // a vaut 30
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 b est 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/
Ajout/surcharge de constructeur
import java.util.Date;
public class MaDate {
int jour, mois, annee; // attributs , portée de classe

public MaDate ( ) //redéfinition du constructeur par défaut


{ jour=1; mois=1; annee=2020; }
// surcharge du constructeur
public MaDate (int j, int m, int a) {
jour=j; mois=m ; annee=a;
}
//3ème consctructeur
public MaDate (int j, int m) {
jour=j; mois=m ; }
Ajout/surcharge de constructeur
//4ème consctructeur
public MaDate (Date d) {
jour=d.date; mois=d.month; annee=d.year;
}
public String toString( ) { //reféfinition de la méthode toString ( )
return (jour+"/" +mois+"/"+annee);
}
public static void main (String [] args) {
MaDate d1=new MaDate();
System.out.println (d1); // invoque toString () de MaDate
MaDate d2=new MaDate(14,10,2020); //2ème constructeur
System.out.println (d2); // invoque toString () de MaDate
Date dt=new Date();
MaDate d3=new MaDate(dt );
}
}

Vous aimerez peut-être aussi