Langage Java
Cliquez pour modifier lesyntaxe
style des sous-titres du masque
contact@[Link] [Link] - Formation Java 1
Syntaxe de base
•
Mêmes convention que le langage C
•
Les instructions sont terminées par le point-
virgule ;
•
Les instructions sont contenues dans des blocs
de code {}
•
Le langage est case sensitive
•
L'opérateur point . permet de manipuler les
membres d'une classe ou d'une instance
contact@[Link] [Link] - Formation Java 2
Syntaxe de base
•
Java est un langage fortement typé
–
les variables et propriétés doivent être typées lors
de la déclaration
–
le type de retour des méthodes est précisé
•
Les variables doivent être déclarées avant de
pouvoir être utilisées
–
les variables se trouvent dans les méthodes
–
leur portée est celle du bloc de déclaration
contact@[Link] [Link] - Formation Java 3
Commentaires
•
// commentaire sur une ligne
•
/*
commentaire sur plusieurs
lignes
*/
•
/**
commentaire de documentation
*/
–
se reporter à l'utilitaire javadoc
contact@[Link] [Link] - Formation Java 4
Bloc de code
•
Le code est contenu dans un bloc de code { }
•
Un bloc peut contenir d'autres bloc de code
•
Un bloc de code
–
regroupe des instructions
–
limite la portée des variables
•
Un bloc de code static est chargé à
l'initialisation de la classe
contact@[Link] [Link] - Formation Java 5
Les opérateur mathématiques
Opérateur Description Exemple
= affectation int i = 3;
* multiplication int x = i*3;
/ division (attention aux divisions entre entier) int x = i/3;
% modulo (reste d'une division entière) int x = 10 % 3;
+ addition int x = 20 + i;
- soustraction int x = 10 - 6;
contact@[Link] [Link] - Formation Java 6
Opérateurs d'incrémentation
•
L'opérateur ++ incrémente une variable
–
ajoute 1 à la valeur de la variable
–
en fonction de la position
++i;
• avant : pré-incrémentation
i++;
• après : post-incrémentation
•
L'opérateur -- décrémente une variable
–
retranche 1 à la valeur de la variable
–
en fonction de la position --i;
• avant : pré-décrémentation i--;
• après : post-décrémentation
contact@[Link] [Link] - Formation Java 7
Opérateurs de comparaison
•
Comparent les valeurs des variables de type
primitif ou les références des instances
Opérateur Description
== égalité
!= inégalité
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
contact@[Link] [Link] - Formation Java 8
Opérateurs logiques
•
Utilisés lors des tests, pour lier les expressions
logiques
Opérateur Description Exemple
! NON if(!vide)...
&& ET if(i==3 && b<10)...
|| OU if(i==3 || b==10)...
contact@[Link] [Link] - Formation Java 9
Opérateurs binaires
•
Utilisés lors de la manipulations des entiers,
au format binaire
–
masquage, décalages, ...
Opérateur Description Exemple
& ET i & 0x00FF;
| OU i | 0x0001;
^ OU EXCLUSIF (XOR) i ^ 0x00FF;
~ complément ~i;
>> décalage à droite i>>2;
>>> décalage à droite avec remplissage 0 -1>>>2;
<< décalage à gauche i<<2;
contact@[Link] [Link] - Formation Java 10
Autres opérateurs
Opérateur Description Exemples
. point, opérateur d'accès aux membres [Link]();
d'une instance
() parenthèses, opérateur de regroupement (2+3)*5;
d'expression
[] crochet, opérateur de gestion des tableaux tab[2] = 3;
instanceof vérifie si l'instance est d'un type particulier if(d instanceof De)
new instancie une classe De d = new De()
- opérateur unaire, signe opposé i = -i;
? : opérateur ternaire int i = j>0 ? j : -j;
contact@[Link] [Link] - Formation Java 11
Opérateurs d'affectation
•
Une affectation mettant en jeu une variable
comme lvalue et rvalue peut-être simplifiée
–
var = var OP expression
–
var OP= expression
int i = 3; int i = 3;
i = i + [Link](); i += [Link]();
contact@[Link] [Link] - Formation Java 12
Préséance entre opérateurs
•
. () []
•
! ~ ++ -- instanceof
•
new
•
*/%
•
+-
•
<< >> >>>
•
< > <= >=
•
== !=
•
&
•
|
•
^
•
&&
•
||
•
?: (opérateur ternaire)
•
= += -= *= /= %=
•
&= |= ^= <<= >>= >>>=
contact@[Link] [Link] - Formation Java 13
Syntaxe de définition de classe
•
Une classe publique par fichier
–
le nom du fichier est le même que le nom de la classe
public class Voiture
{
...
}
•
Une classe qui dérive d'une autre classe utilise
extends
–
pas de multi-héritage
public class Voiture extends Vehicule
{
...
}
contact@[Link] [Link] - Formation Java 14
Structures de contrôle
•
Structure conditionnelle sur une seule ligne
–
expression est une expression booléenne
• peut être complexe (avec &&, || et !)
if(expression)
instruction;
•
Sur plusieurs lignes if(expression)
{
–
nécessite un bloc de code instruction 1;
instruction 2;
...
}
contact@[Link] [Link] - Formation Java 15
Structures de contrôle
•
Structure conditionnelle avec else
–
la clause else peut être suivi par un if
if(expression)
instruction;
else if(expression)
instruction; {
...
if(expression) }
instruction; else
else if {
instruction; ...
else }
instruction;
contact@[Link] [Link] - Formation Java 16
Opérateurs conditionnels
Opérateur Description
< <= > >= comparaison numérique
== != relationnel (égalité, inégalité)
! NON logique
&& || opérateurs ET et OU
contact@[Link] [Link] - Formation Java 17
Structures de contrôle
•
Structure switch
–
applicables aux types entier : int et char
• la clause default switch(i)
est facultative {
case 1:
...
break;
case 2: case 3:
...
break;
default:
...
break;
}
contact@[Link] [Link] - Formation Java 18
Structures de contrôle
•
La boucle while
–
le corps de boucle est exécuté tant que
l'expression est vraie
while(expression)
{
...
}
contact@[Link] [Link] - Formation Java 19
Structures de contrôle
•
La boucle for
–
l'initialisation est effectuée une seule foir
–
le corps de boucle est exécuté tant que
l'expression est vraie
–
la clause de changement est effectuée après
l'exécution du corps de boucle
for(initialisation ; expression ; changement)
{
...
}
contact@[Link] [Link] - Formation Java 20
Syntaxe des propriétés
•
Toujours rendre les propriétés privées
–
respecte le principe de responsabilité
–
bien réfléchir dans le cas contraire
–
seules les méthodes de la classe peuvent y accéder
public class Voiture
{
private int nbPortes;
private String couleur = "vert";
}
•
Toutes les propriétés reçoivent une valeur par
défaut si elles ne sont pas initialisées.
contact@[Link] [Link] - Formation Java 21
Syntaxe des méthodes
public class De
{
private int valeur;
private final int VALEUR_MAX = 6;
public void lancer()
{
[Link] = (int)([Link]()*VALEUR_MAX) + 1;
}
public int getValeur()
{
return valeur;
}
public void setValeur(int valeur)
{
[Link] = valeur;
}
public int getVALEUR_MAX()
{
return VALEUR_MAX;
}
}
contact@[Link] [Link] - Formation Java 22
Syntaxe des méthodes
•
Une méthode est décrite par
–
un modificateur facultatif
• public, private, protected
–
son type de retour
• si pas de retour utiliser void
–
son nom
–
la liste de ses paramètres
• ne sont visibles que dans le corps de la méthode
• si pas de paramètres mettre les parenthèses vides ()
contact@[Link] [Link] - Formation Java 23
Méthode abstraite
•
Une méthode abstraite n'est pas codée
•
Elle est déclarée dans une classe abstraite ou
une interface
•
Elle doit être définie par les classes
d'implémentations
public abstract class De
{
private int valeur;
private final int VALEUR_MAX = 6;
public abstract void lancer();
}
contact@[Link] [Link] - Formation Java 24
Les packages
•
Les packages permettent d'organiser les
classes
–
arborescence de répertoire
•
le mot clé package doit apparaître avant
toute instruction
–
indique le package auquel appartient la classe
•
le mot clé import permet d'importer des
packages autres que celui de la classe
–
pas nécessaire pour [Link]
contact@[Link] [Link] - Formation Java 25
Les types en Java
•
En java tout est objet
–
toutes les classes sont construites sur la classe
Object
•
Il existe des types de base : les types primitifs
–
ils possèdent un équivalent objet
• les enveloppes (wrappers)
• depuis JDK 5 : autoboxing
contact@[Link] [Link] - Formation Java 26
Types primitifs
Type Description Valeur par défaut Wrapper
boolean booléen false Boolean
char caractère unicode (2 octets) \u0000 Character
byte entier signé sur 1 octet 0 Byte
short entier signé sur 2 octets 0 Short
int entier signé sur 4 octets 0 Integer
long entier signé sur 8 octets 0 Long
float flottant sur 32 bits 0.0 Float
double 0.0 Double
contact@[Link] [Link] - Formation Java 27
Constantes
•
Les variables final sont constantes et en
lecture seule
–
par convention le nom d'une constante est tout en
majuscule
–
peuvent être public et static pour être
accessibles par les autres objets
–
voir aussi les énumérations enum depuis JDK 1.5
final int MAX = 10;
...
int i = MAX;
contact@[Link] [Link] - Formation Java 28
Objets et références
•
Une référence est l'adresse mémoire d'un objet
–
new crée un objet - instance de classe
•
L'affectation d'un objet copie sa référence
–
deux variables peuvent utiliser la même instance
d1 :De
De d1 = new De();
De d2 = new De();
d2
De d3 = d2; :De
d3
contact@[Link] [Link] - Formation Java 29
Références spéciales
•
La variable globale this renvoie à l'objet
courant
–
le compilateur ajoute implicitement this aux
appels de méthodes lorsque le récepteur n'est pas
spécifié
–
ne peut pas s'utiliser sur des membres statiques
• modificateur static
• car sont des membres de classe
•
La variable super renvoie à l'instance de la
classe mère
contact@[Link] [Link] - Formation Java 30
La méthode main()
•
C'est la méthode invoquée par la JVM
•
Signature :
public static void main(String[] args)
{
...
}
• les modificateurs public, static seront vus plus
tard
• String[] args permet de récupérer des
paramètres passés à la ligne de commande
contact@[Link] [Link] - Formation Java 31
La méthode main()
•
Toute classe peut contenir une méthode
main()
–
car le nom de la classe de démarrage est fournit à
la JVM
•
Un pratique courante est d'appelée Main la
classe contenant la méthode main()
principale
contact@[Link] [Link] - Formation Java 32
Les chaînes de caractères
•
Les chaînes de caractères sont des instances
de la classe String
•
Les chaînes littérales peuvent être crées par
–
affectation directe
• optimisation du compilateur par élimination des
doublons
–
création d'une instance de String
String s1 = "hello";
String s2 = new String("hello");
contact@[Link] [Link] - Formation Java 33
Manipulation des chaînes
•
Concaténation
–
opérateur + "hello" + "world";
–
toutes les valeurs primitives peuvent être concaténées avec
les chaînes
–
les instances d'objets peuvent aussi être concaténés avec les
chaînes
• redéfinir la méthode String toString() héritée de Object
•
Comparaison de chaînes avec la méthode equals()
–
l'opérateur == compare les références
String s1 = new String("hello");
String s2 = new String("hello");
[Link](s2);
contact@[Link] [Link] - Formation Java 34
Affichages sur la console
•
Par l'utilisation des méthodes sur le flux
standard de sortie [Link]
–
classiquement par un println(...)
–
par la méthode format(...) depuis JDK 5
[Link]("Hello world");
[Link]("Nombre de dés : %d\n",2);
contact@[Link] [Link] - Formation Java 35
Les constructeurs
•
Les constructeurs sont des méthodes
spécifiques qui sont appelées lors de
l'instanciation de l'objet
–
après l'initialisation si celle-ci n'a pas été faite
• code static
•
Les constructeurs n'on pas de type de retour
–
ne pas indiquer void
•
Le nom du constructeur est celui de la classe
contact@[Link] [Link] - Formation Java 36
Constructeur par défaut
•
Le constructeur par défaut ne prend pas de
paramètres
–
si la classe ne possède aucun constructeur le
compilateur en ajoute un
• ne fait rien
public class De
{
private int valeur;
private final int VALEUR_MAX = 6;
public De()
{
}
...
}
contact@[Link] [Link] - Formation Java 37
Constructeurs multiples
•
Une classe peut avoir plusieurs constructeurs
–
ils se distinguent entre eux par les types des
paramètres
–
surcharge de constructeur
•
Si un constructeur est codé dans la classe le
compilateur ne fournit plus de constructeur par
défaut. public class De
{
private int valeur;
public De(){}
public De(int valeur)
{[Link]=valeur;}
contact@[Link] [Link] - Formation Java 38
Appel des constructeurs
•
Le constructeur adéquat est invoqué par le
passage de paramètres
De d1 = new De();
De d2 = new De(3);
•
En cas de hiérarchie de classe les
constructeurs des classes mères sont d'abord
invoquées
–
le constructeur par défaut si aucune précision
–
le constructeur adéquat avec l'utilisation de
super(...)
contact@[Link] [Link] - Formation Java 39
Les tableaux
•
Ce sont des collections de taille fixe
–
le premier élément est indicé à 0
•
Les éléments peuvent être de type primitif ou
classe
•
Les tableaux sont eux-mêmes des objets
–
créés avec l'opérateur new
–
ont une propriété length
contact@[Link] [Link] - Formation Java 40
Les tableaux
•
Déclaration d'un tableau de primitifs
int[] entiers;
•
Déclaration d'un tableau de références sur des
objets
Voiture[] voitures;
contact@[Link] [Link] - Formation Java 41
Les tableaux
•
La création utilise l'opérateur new et la taille
doit être spécifiée
•
Création d'un tableau de primitifs
int[] entiers = new int[4];
•
Création d'un tableau de références sur des
objets
Voiture[] voitures = new Voiture[4];
contact@[Link] [Link] - Formation Java 42
Initialisation des tableaux
•
Après la création des tableaux les éléments ne
sont pas initialisés
–
contiennent 0 ou null
•
Initialiseurs de tableaux
int[] entiers = new int[] {1,2,3};
Voiture[] voitures = new Voiture[]{new Voiture(),new Voiture()};
–
l'instruction new peut être implicite
int[] entiers = {1,2,3};
Voiture[] voitures = {new Voiture(),new Voiture()};
•
Tableaux anonymes
return new String[]{"hello","bonjour};
contact@[Link] [Link] - Formation Java 43
Classe abstraite
•
Une classe abstraite ne peut pas être instanciée
•
Une classe abstraite peut contenir des membres
concrets
–
propriétés
–
méthodes concrètes
•
Les modificateur abstract marque les
méthodes et classes abstraites
contact@[Link] [Link] - Formation Java 44
Interface
•
Une interface décrit les méthodes qui
définissent des comportement
•
Une interface ne comporte que des méthodes
abstraites
–
peut contenir des propriétés final
•
Une classe peut implémenter plusieurs
interfaces
public class Voiture implements Roulable, Demarrable
{
...
}
contact@[Link] [Link] - Formation Java 45
Travaux pratiques JAVA
•
TP N°1 : installation kit de développement java JDK 6
•
TP N°2 : votre premier programme JAVA
•
TP N°3 : Installation environnement Eclipse TP1 à TP6 :
•
TP N°4 : documentation de programme JAVA avec l’outil javadoc support internet (cliquez)
•
TP N°5 : création d’archives JAR et livraisons avec l’outil jar
•
TP N°6 : création de classes et manipulation d’objets
•
TP N°7 : maîtriser la notion d’héritage en Java
•
TP N°8 : surcharge, redéfinition, polymorphisme
•
TP N°9 : maîtriser la notion d’interface en java TP7 à TP13 :
•
TP N°10 : accès données base de données avec JDBC support papier (TPs)
•
TP N°11 : manipuler des collections en Java
•
TP N°12 : application multi-langues (i18N)
•
TP N°13 : maîtriser la lecture/écriture de données dans fichiers
contact@[Link] [Link] - Formation Java 46