Vous êtes sur la page 1sur 28

Chapitre 2 : Le Langage Java

Le Langage

Java
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 1
Sommaire

„ La Grammaire
Types
Opérateurs et Structures de contrôles
Tableaux
Exceptions
„ Les Objets dans Java
Classes, attributs et méthodes
Le polymorphisme et Java
Paquetages
„ Les Classes de bases
Chaînes de caractères
Outils mathématiques
Dates
Tableaux et tables de hachages

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 2
La Grammaire
Les Types dans Java

„ Types de bases (package Java.lang)


booléen, char(16 bits), byte(8 bits),
short(16 bits), int (32 bits), long(64 bits), float (32 b), double (64 b)

„ Déclaration et Initialisation
int iToto;
boolean bVraiFaux = true;
double e = 3.00e+8, dPi= 3.14, dPi2 = 3.14 * 3.14;
char a = ‘a’, nligne = ‘\n’;
déclaration et initialisation n’importe où dans l’objet
les variables globales sont mises à false, Zéro ou caractère nul
Les variables locales doivent être explicitement initialisées

„ Pas de type de données complexes (structure) en dehors des


mécanismes ‘objet’ (Inner Classes)

„ Pas de sizeof en Java


Toutes les données typées ont la même taille sur tous les OS

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 3
La Grammaire
Opérateurs

„ assignement „ opérateurs logiques


lvalue = rvalue; //@ mémoire AND (&&), OR(||), NOT (!)

„ operateurs arithmétiques „ opérateur sur les bits


+ ,- , /, *, %( modulo) AND(&) OR(|) XOR(^) NOT(~)

„ précédence „ opérateur de décalage


a = x + y - 2/2 + z; gauche (<<), droite (>>)
Unaire, Arith., relationnelle, gauche zero extension (>>>)
logique, cond., assignement „ opérateur de String +
„ operateurs unaires int x = 0, y = 1, z = 2;
x = -a; x = a * (-b); String sString = "x, y, z ";
System.out.println(sString +
„ auto incrementation x + y + z);
++i //(i = i + 1); i++; conversion de x,y,z dans leur
--i //(i = i - 1); i--; représentation en String
x += 4 //(x = x+4) „ opérateur de transtypage
„ opérateurs relationnels void casts() {
int i = 200;
generent un résultat booleén
long l = (long)i;//(long)200;
<, >, >=, ==, != }
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 4
La Grammaire
Structures de contrôle
„ Notion de Bloc
{ string s = “c’est comme en C...”; // cette déclaration
... // a une portée limitée
} // a ce bloc

„ Déclarations conditionnelles
if (condition) static int ternary(int i) {
instruction; if (i<1) return i * 100;
[else else return i * 10;
instruction;] // return i<10 ? i*100 : i*10;
_____________________________________}__________________________________
switch (int expression) {
case int expression : switch (xCursor) {
instruction; case milieuEcran:
[case int expression : corpDePage = true;
instruction; break;
... case basEcran:
default : case hautEcran:
instructions;] corpDePage = false;
} }
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 5
La Grammaire
Structures de contrôle (2)
// WhileTest.java
„ Boucles /** * Demonstrates the while loop */
Tantque public class WhileTest {
while (condition) { public static void main(String args[]) {
double r = 0;
while (r < 0.99d) {
... //instructions
r = Math.random();
} System.out.println(r);
}
}
Répéter }
do {
... //instructions // ListCharacters.java
} while(condition); /** * Demonstrates "for" loop by listing
* all the ASCII characters. */
public class ListCharacters {
Pour public static void main(String args[]) {
for(init, condition, for ( char c = 0; c < 128; c++ )
incrémentation) { if (c != 26 ) // ANSI Clear screen
... //instructions System.out.println(
"value: " + (int)c +
}
" character: " + c );
}
}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 6
La Grammaire
Structures de contrôle (3)
„ Break et Continue : // BreakAndContinue.java
/** les clauses break et continue */
break quitte la boucle public class BreakAndContinue {
continue passe à l’itération public static void main(String args[]) {
suivante
for(int i = 0; i < 100; i++) {
if(i == 74) break; // Out of loop
if(i % 9 != 0) continue; // Next iter.
„ L’infame Goto : System.out.println(i);
Dans de très rare cas le goto }
peut être efficace int i = 0; // An "infinite loop":
while(true) {
=> le goto existe encore en Java i++;
int j = i * 27;
Ce cours ne dit pas comment if(j == 1269) break; // Out of loop
if(i % 10 != 0) continue; // Top
l’utiliser... System.out.println(i);
}
}
}
„ Résultat : (avec un nombre par ligne)
0 9 18 27 36 45 54 63 72 10 20 30 40

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 7
La grammaire
Tableaux simples
„ Opérateur spéciale “new” import java.util.*;
/** TabNew.java
permet de construire une instance de
tableau * Création de tableaux par l’operateur new
spéc. de la la taille : notation [] */
public class TabNew {
static Random rand = new Random();
„ Un tableau en Java ne contient static int pRand(int mod) {
que des élements de type return Math.abs(rand.nextInt()) % mod;
référence }
public static void main(String args[]) {
Eléments d’un tableau = références à
// déclaration et init. de tableaux
ces objets
int tab[]; // <=> int [] tab;
il n’y a pas allocation de la mémoire
tab = new int[pRand(20)];
pour les éléments
// int tab[] = {1,2,3,4,5};
ref = null jusqu’à affectation
// utilisation de tableaux
la méthode System.arraycopy
prt("length of tab = " + tab.length);
permet la copie d’élément d’un tableau
dans un autre for(int i = 0; i < tab.length; i++)
prt("tab[" + i + "] = " + tab[i]);
}
„ le champ length est une variable static void prt(String s) {
qui donne la taille du tableau System.out.println(s);
}
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 8
La grammaire
Tableaux multi-dimensionnels
„ gestion de tableaux de tableaux // tableau multi-dimensionnels
...
pieceEchec [][] jeuEchec;
„ au moins la première dimension jeuEchec = new pieceEchec [8][8];
du tableau doit être initialisée pieceEchec [] initFirstLine = {
new pieceEchec(“Tour”),
new pieceEchec(“Cavalier”),
„ les tableaux ne sont pas ...
forcément rectangulaires }
jeuEchec[0] = initFirstLine;
jeuEchec[0][1]= new pieceEchec (“Pion”);
„ Un tableau est instance de ...
classes spéciales dans le langage
// tableau triangulaire
Java
int tri [][] new int [8][];
for (int i=0; i < tri.length; i++) {
„ Gestion des débordements triangle[i] = new int [i+1];
tableauMultidim [900] for (int j =0; j < i+1; j++)
// lève une exception tri[i][j] = i+j;
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 9
La grammaire
les exceptions : “I take exception to that”
/** ex : exception du package java.io */
„ Le principe private void fire(...){
...
Moyen de passer le contrôle à un niveau
getArea().paintGun(this);
de code capable de gérer correctement
une erreur try {
Thread.sleep(50);
Gestion des erreurs une seule fois
} catch (InterruptedException e) {}
Séparation du code de gestion d’erreur du ...
code opératoire }
„ Implémentation /** ex : exceptions du package java.lang
toute code qui a un problème lève une * de gestion facultative */
exception public int getSize(){
void testeHeure(int heure) throws String string = size.getText();
HorsLimiteException { try {
if (heure>24) value = Integer.parseInt(string);
throw new HorsLimiteException if (value < 1)
(“er...”); throw new
} IllegalArgumentException();
Chaque appelant de ce code doit } catch (NumberFormatException e) {
intercepter l’exception sinon le value = 100;
compilateur peut sévir } catch (IllegalArgumentException e) {
try { ...//code qui peut planter } System.exit(1);
catch (UneException e) {...} }
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 10
La grammaire
les exceptions (suite)
„ Le renvoi d’exception Exemple d’exceptions Java
en souligné les principales à attraper
fait suivre une exception aprés
traitement partiel de l’erreur java.io.IOException
catch (UneException e) { java.io.EOFException
System.err.println(“er...”); java.io.FileNotFoundException
java.io.InterruptedIOException
throw e; java.net.MalformedURLException
} java.net.ProtocolException
java.net.SocketException
„ la clause finally java.io.UTFDataFormatException
java.net.UnknownHostException
précise le traitement à la sortie du java.net.UnknownServiceException
bloc java.lang.IllegalAccessException
catch (UneException e) { java.lang.InstantiationException
System.err.println(“UneEr”); java.lang.InterruptedException
} finally { java.lang.NoSuchMethodException
System.exit(0); java.lang.RuntimeException
java.lang.ArithmeticException
}
java.lang.ArrayStoreException
„ Capture de toutes les exceptions java.lang.ClassCastException
java.util.EmptyStackException
catch (Exception e) { java.lang.IllegalArgumentException
System.err.println(“erreur”); java.lang.IllegalThreadStateException
} java.lang.NumberFormatException
...
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 11
Sommaire

„ La Grammaire
Types
Opérateurs et Structures de contrôles
Tableaux
Exceptions

„ Les Objets dans Java


Classes, attributs et méthodes
Le polymorphisme et Java
Paquetages

„ Les Classes de bases


Chaînes de caractères
Outils mathématiques
Dates
Tableaux et tables de hachages

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 12
Les Objets dans Java
Les objets

„ Principes
Regroupement des attributs et des méthodes
Sert souvent à modéliser des objets réels
„ Les attributs représentent l’état de l’objet
„ Les méthodes représentent son comportement
En général, les attributs ne sont accessibles que par les méthodes :
Encapsulation
Méthodes ou attributs peuvent être masquées

„ Avantages
L’encapsulation améliore l’autonomie et l’indépendance Æ facilite la
réutilisation
Le fonctionnement interne de l’objet n’est pas exposé et peut être
facilement modifié

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 13
Les Objets dans Java
Les classes

„ Principe
Modèle ou prototype définissant les attributs et les méthodes communes
aux objets d’un certain type
Les objets construits à partir de ces classes sont des instances
Chaque instance possède ses attributs et ses méthodes

Les attributs et les méthodes d’instance sont spécifiques à chaque objet


Les attributs et les méthodes de classe sont partagées entres tous les
objets

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 14
Les Objets dans Java
Classes, Attributs, Méthodes

„ Création de classes et d’objets „ Attributs


déclaration d’une classe déclaration dans le corps de classe
/** documentation /** documentation */
* @author R.Courdier int nbCellX, nbcelly;
* @version 2.0 utilisation dans une méthode
*/ unLab.nbCellX = 50;
class Labyrinthe {
// corps de la classe
„ Méthodes
} déclaration dans le corps de classe
/** documentation
création d’un objet de cette classe
* @param arg1...
Labyrinthe unLab;
* @return RetType
unLab = new Labyrinthe();
* @exception pas d’exception
„ Constructeur */
méthode de même nom que la RetType nomFunc( //args ) {
classe appelée lors de la création // corps de méthode
d’un objet }
il peut y avoir plusieurs utilisation dans une méthode
constructeurs RetType x = unLab.nomFunc();

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 15
Les Objets dans Java
Classes, Attributs, Méthodes

„ Variable et méthode de classe : le mot clé “static”


pour une Variable : variable qui existe pour la classe globalement et non
spécifiquement pour chaque instance – toutes les instances se partagent la
même variable
Pour une Méthode : méthode qui à un sens pour la classe elle même
indépendamment d’une instance donnée
static Date d;
static {
d=new Date(); // init au moment du chargement
} // de la classe
System.out.println (ClassName.nbInst);

„ La pseudo variable “this”


référence sur l’objet courant au sein des méthodes d’une classe
Labyrinthe f() {
...// corps de méthode
return this; // retourne la référence à l’objet courant
}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 16
Les Objets dans Java
L’héritage

„ Principe
Regrouper les caractéristiques générales des classes dans une
superclasse Æ facilite la structuration et la réutilisation du code

Certaines classes
peuvent être
abstraites Æ pas
d’instances

Certaines
méthodes
peuvent ne
pas être
implémentées
Æ méthodes
abstraites

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 17
Les Objets dans Java
Le polymorphisme : classes dérivées et spécialisation

„ classe dérivée
notation : l’opérateur instanceof
class WallCell extends Cell{
// corps de la classe class WallCell extends Cell {...}
void display(){...} class FloorCell extends Cell{...}
} ...
classe non dérivable if (aCell instanceof WallCell) {
final class WallCell ...
extends Cell{ } else{...}
// corps de la classe
void display(){...}
}
Une méthode protected dans la calsse de base est visible dans la dérivée
„ spécialisation
utilisation d’une méthode de la classe de base :
aWall = new WallCell();
super.display(); // ((Cell)aWall).display(); conversion à éviter
Une méthode ou une variable final ne peut être masquée par spécialisation
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 18
Les Objets dans Java
Le polymorphisme : classes et méthodes abstraites

„ Les classes abstraites abstract class Cell {


public abstract void display();
classes non instanciables }
directement class Wall extends Cell {
abstract class myClass { ...} public void display(){ ...//corps }
}
class Floor extends Cell {
Une telles classe peut contenir des public void display(){ ...//corps }
méthodes sans corps. }
De telles méthodes sont qualifiées class Lab {
d’abstraites void displayLine(Cell[] tCell) {
for (int i=0; i<tCell.length; i++)
abstract void f();
tCell[i].display();
}
les méthodes abstraites définissent public static void main (String args[]){
le format des méthodes à implanter Cell[] ligneDeLab = new Cell[50];
dans les classes dérivées. int i = 0;
ligneDeLab[i++] = new Wall;
Le compilateur vérifie la cohérence
...
de l’arbre d’héritage et oblige toute ligneDeLab[i++] = new Floor;
classe non abstraite à ne plus avoir displayLine (ligneDeLab);
de méthodes abstraites }
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 19
Les Objets dans Java
Les interfaces

„ Principe
Une classe abstraite n’ayant que des méthodes abstraites
Ensemble de méthodes non implémentées et de constantes
Lorsqu’une classe implémente une interface, elle doit implémenter
toutes les méthodes de l’interface

„ Avantages
Permet de regrouper les similarités entre classes sans forcer des
relations d’héritage entre les classes
Permet de définir des spécifications que d’autres classes devront
implémenter

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 20
Les Objets dans Java
Le polymorphisme : Les interfaces
„ définition de classes abstraites “pures”
déclaration de méthodes sans corps
que des variables vue comme static final (constantes allouées à la compilation).
toutes les déclaration sont par défaut public

„ Une interface n’est pas instanciable mais peut être implémentée par
une classe
interface Cell { class Wall implements Cell {
void display(); void display(){ ...//corps }
}
}

„ Java n’autorise pas l’héritage multiple, possibilité pour une classe


d’implémenter cependant plusieurs interfaces

„ Préférer quand c’est possible de définir plutôt des interfaces que


des classes abstraites
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 21
Les Objets dans Java
Le polymorphisme : Les interfaces

„ Exemple: Interface Connection :

Utilisée pour se connecter à une base de donnée en JDBC.

Les pilotes JDBC des bases de données vont implémenter les


méthodes de cette interface définie si dessous :

public interface Connection {


public Statement createStatement();
public void commit();
public void close();
...
}

Les programme Java pourront y accéder de manière transparente:

maConnection.commit();

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 22
Les Objets dans Java
Le polymorphisme : Les inner classes

„ Définition d’une classe à l’intérieur d’une autre classe


class Labyrinthe { ...
class LigneLabyrinthe {
...
}
}
„ Une inner classe est vue comme une classe amie qui a accès aux
attributs et méthodes privées de la classe englobante.

„ Une classe peut également être définie dans une méthode ou à tout niveau
de bloc fonctionnel

„ Un fichier .class est produit par le compilateur


Labyrinthe.class
Labyrinthe$LigneLabyrinthe.class

„ Une inner classe peut être anonyme:


new JPanel() {
public Dimension getPreferredSize() {
return new Dimension(100,100);
}
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 23
Les Objets dans Java
Paquetages ou packages

„ Regroupement de classes sous un même espace de nommage

„ A l’intérieur d’un paquetage les attributs et méthodes non qualifiés


(public,private,protected) sont visibles des autres classes du paquetage

„ A l’extérieur d’un paquetage seuls les attributs et méthodes public sont


visibles

„ Bien connaître les paquetages disponibles est fondamental en Java


import java.util.* // on utilise ce paquetage pour notre code

„ Pour qu’une classe fasse partie d’un paquetage il faut ajouter en tête du
fichier le nom du paquetage
package nomDuPaquetage; // on ajoute ce code au paquetage

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 24
Les Objets dans Java
Règles de visibilité

par défaut sans mot clé particulier :


„ accessible à partir de toute autre classe appartenant au même package
que cette classe
public :
„ accessible dans la classe et à partir de toute autre classe
protected :
„ accessible dans la classe, les sous-classes ou les classes du package
private protected :
„ accessible dans la classe et les sous-classes
private :
„ accessible dans la classe de déclaration uniquement

le mot clé final :


„ sur une variable : correspond à la définition d’une constante
„ sur une méthode : pas de surcharge ou de spécialisation possible
„ Sur une classe: la classe ne peut plus être dérivée

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 25
Sommaire

„ La Grammaire
Types
Opérateurs et Structures de contrôles
Tableaux
Exceptions
„ Les Objets dans Java
Classes, attributs et méthodes
Le polymorphisme et Java
Paquetages

„ Les Classes de bases


Chaînes de caractères
Outils mathématiques
Dates
Tableaux et tables de hachages

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 26
java.util
Classes d’utilité générale

„ BitSet : „ Random
construit des tableaux extensibles de nombres aléatoires
bits avec les opérations and, or, xor,... nextInt(),nextFloat(),...
„ Date,Calendar : „ Stack
manipulation de dates gestion d’une pile d’objets
„ ArrayList push, pop, peek, search, objectAt
Tableau extensibles „ StringTokenizer
get, contains,,... découpe une chaine en tooken
size() retourne le nbre d’éléments StringTokenizer s = new
StringTokenizer ( “bientot la
„ HashMap: fin”);
implémentation d’une collection indexée while( s.hasMoreTokens())
couleurs.put(“rouge“,Color.red); println(s.nextToken());
„ Properties : „ Iterator
Hashtable qui peut être sauvée et Permet de parcourir une collection
chargée sur des flots d’entrée/sortie for(Iterator it =
InputStream ou OutputStream collection.iterator();
it.hasNext();) {
item = it.next();
}

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 27
Références
„ The Java™ Language Specification Second Edition
http://java.sun.com/docs/books/jls/index.html
version HTML ou PDF

„ Learning the Java Language


http://java.sun.com/docs/books/tutorial/java/TOC.html

„ Cours JAVA
http://www-sor.inria.fr/~dedieu/java/cours/

© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 28