le langage -...
TRANSCRIPT
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 1
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 2
Sommaire
La GrammaireTypesOpérateurs et Structures de contrôlesTableauxExceptions
Les Objets dans JavaClasses, attributs et méthodesLe polymorphisme et JavaPaquetages
Les Classes de basesChaînes de caractèresOutils mathématiquesDatesTableaux et tables de hachages
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 3
La GrammaireLes 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 Initialisationint 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’objetles variables globales sont mises à false, Zéro ou caractère nulLes 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 JavaToutes 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 4
La GrammaireOpérateurs
assignementlvalue = rvalue; //@ mémoire
operateurs arithmétiques+ ,- , /, *, %( modulo)
précédencea = x + y - 2/2 + z;
Unaire, Arith., relationnelle, logique, cond., assignement
operateurs unairesx = -a; x = a * (-b);
auto incrementation++i //(i = i + 1); i++; --i //(i = i - 1); i--;
x += 4 //(x = x+4)
opérateurs relationnelsgenerent un résultat booleén<, >, >=, ==, !=
opérateurs logiquesAND (&&), OR(||), NOT (!)
opérateur sur les bitsAND(&) OR(|) XOR(^) NOT(~)
opérateur de décalagegauche (<<), droite (>>)gauche zero extension (>>>)
opérateur de String +int x = 0, y = 1, z = 2; String sString = "x, y, z "; System.out.println(sString + x + y + z); conversion de x,y,z dans leur représentation en String
opérateur de transtypagevoid casts() { int i = 200; long l = (long)i;//(long)200;
}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 5
La GrammaireStructures 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 conditionnellesif (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 :
instruction;[case int expression :
instruction;...default :
instructions;]}
switch (xCursor) {case milieuEcran:
corpDePage = true;break;
case basEcran:case hautEcran:
corpDePage = false;}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 6
La GrammaireStructures de contrôle (2)
BouclesTantque
while (condition) {
... //instructions}
Répéterdo {
... //instructions} while(condition);
Pour for(init, condition, incrémentation) {
... //instructions }
// WhileTest.java/** * Demonstrates the while loop */public class WhileTest {
public static void main(String args[]) { double r = 0; while (r < 0.99d) {r = Math.random();System.out.println(r);
}}
}
// ListCharacters.java/** * Demonstrates "for" loop by listing * all the ASCII characters. */ public class ListCharacters {
public static void main(String args[]) { for ( char c = 0; c < 128; c++ )
if (c != 26 ) // ANSI Clear screenSystem.out.println(
"value: " + (int)c + " character: " + c );
} }
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 7
La GrammaireStructures de contrôle (3)
Break et Continue :break quitte la bouclecontinue passe à l’itération suivante
L’infame Goto :Dans de très rare cas le gotopeut être efficace => le goto existe encore en Java
Ce cours ne dit pas comment l’utiliser...
// BreakAndContinue.java/** les clauses break et continue */public class BreakAndContinue { public static void main(String args[]) {
for(int i = 0; i < 100; i++) { if(i == 74) break; // Out of loopif(i % 9 != 0) continue; // Next iter.System.out.println(i);
} int i = 0; // An "infinite loop": while(true) {
i++; int j = i * 27; if(j == 1269) break; // Out of loopif(i % 10 != 0) continue; // Top
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 8
La grammaireTableaux simples
Opérateur spéciale “new” permet de construire une instance de tableau spéc. de la la taille : notation []
Un tableau en Java ne contient que des élements de type référence
Eléments d’un tableau = références à ces objetsil n’y a pas allocation de la mémoire pour les élémentsref = null jusqu’à affectationla méthode System.arraycopypermet la copie d’élément d’un tableau dans un autre
le champ length est une variable qui donne la taille du tableau
import java.util.*; /** TabNew.java* Création de tableaux par l’operateur new*/ public class TabNew {
static Random rand = new Random(); static int pRand(int mod) {
return Math.abs(rand.nextInt()) % mod; } public static void main(String args[]) { // déclaration et init. de tableauxint tab[]; // <=> int [] tab;tab = new int[pRand(20)];// int tab[] = {1,2,3,4,5};// utilisation de tableauxprt("length of tab = " + tab.length);for(int i = 0; i < tab.length; i++)
prt("tab[" + i + "] = " + tab[i]); } static void prt(String s) { System.out.println(s);
} }
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 9
La grammaireTableaux multi-dimensionnels
gestion de tableaux de tableaux
au moins la première dimension du tableau doit être initialisée
les tableaux ne sont pas forcément rectangulaires
Un tableau est instance de classes spéciales dans le langage Java
Gestion des débordementstableauMultidim [900] // lève une exception
// tableau multi-dimensionnels...pieceEchec [][] jeuEchec;jeuEchec = new pieceEchec [8][8];pieceEchec [] initFirstLine = {
new pieceEchec(“Tour”), new pieceEchec(“Cavalier”),...
}jeuEchec[0] = initFirstLine;jeuEchec[0][1]= new pieceEchec (“Pion”);...
// tableau triangulaireint tri [][] new int [8][];for (int i=0; i < tri.length; i++) {
triangle[i] = new int [i+1];for (int j =0; j < i+1; j++)
tri[i][j] = i+j;}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 10
La grammaireles exceptions : “I take exception to that”
Le principeMoyen de passer le contrôle à un niveau de code capable de gérer correctement une erreurGestion des erreurs une seule foisSéparation du code de gestion d’erreur du code opératoire
Implémentationtoute code qui a un problème lève une exceptionvoid testeHeure(int heure) throws
HorsLimiteException {if (heure>24) throw new HorsLimiteException(“er...”);
}
Chaque appelant de ce code doit intercepter l’exception sinon le compilateur peut sévirtry { ...//code qui peut planter }catch (UneException e) {...}
/** ex : exception du package java.io */private void fire(...){
...getArea().paintGun(this);try {
Thread.sleep(50);} catch (InterruptedException e) {}...
}/** ex : exceptions du package java.lang* de gestion facultative */public int getSize(){
String string = size.getText();try {
value = Integer.parseInt(string);if (value < 1)throw new
IllegalArgumentException();} catch (NumberFormatException e) {
value = 100;} catch (IllegalArgumentException e) {
System.exit(1);}
}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 11
La grammaireles exceptions (suite)
Le renvoi d’exceptionfait suivre une exception apréstraitement partiel de l’erreurcatch (UneException e) {
System.err.println(“er...”);throw e;
}
la clause finallyprécise le traitement à la sortie du bloc catch (UneException e) {
System.err.println(“UneEr”);} finally {
System.exit(0);}
Capture de toutes les exceptionscatch (Exception e) {
System.err.println(“erreur”);}
Exemple d’exceptions Java en souligné les principales à attraper
java.io.IOExceptionjava.io.EOFExceptionjava.io.FileNotFoundExceptionjava.io.InterruptedIOExceptionjava.net.MalformedURLExceptionjava.net.ProtocolExceptionjava.net.SocketExceptionjava.io.UTFDataFormatExceptionjava.net.UnknownHostExceptionjava.net.UnknownServiceException
java.lang.IllegalAccessExceptionjava.lang.InstantiationExceptionjava.lang.InterruptedExceptionjava.lang.NoSuchMethodExceptionjava.lang.RuntimeException
java.lang.ArithmeticExceptionjava.lang.ArrayStoreExceptionjava.lang.ClassCastExceptionjava.util.EmptyStackExceptionjava.lang.IllegalArgumentExceptionjava.lang.IllegalThreadStateExceptionjava.lang.NumberFormatException...
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 12
Sommaire
La GrammaireTypesOpérateurs et Structures de contrôlesTableauxExceptions
Les Objets dans JavaClasses, attributs et méthodesLe polymorphisme et JavaPaquetages
Les Classes de basesChaînes de caractèresOutils mathématiquesDatesTableaux et tables de hachages
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 13
Les Objets dans JavaLes objets
PrincipesRegroupement des attributs et des méthodesSert souvent à modéliser des objets réels
Les attributs représentent l’état de l’objetLes méthodes représentent son comportement
En général, les attributs ne sont accessibles que par les méthodes : EncapsulationMéthodes ou attributs peuvent être masquées
AvantagesL’encapsulation améliore l’autonomie et l’indépendance facilite la réutilisationLe 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 14
Les Objets dans JavaLes classes
PrincipeModèle ou prototype définissant les attributs et les méthodes communes aux objets d’un certain typeLes objets construits à partir de ces classes sont des instancesChaque instance possède ses attributs et ses méthodes
Les attributs et les méthodes d’instance sont spécifiques à chaque objetLes 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 15
Les Objets dans JavaClasses, Attributs, Méthodes
Création de classes et d’objetsdéclaration d’une classe/** documentation * @author R.Courdier* @version 2.0*/class Labyrinthe {
// corps de la classe }
création d’un objet de cette classeLabyrinthe unLab;unLab = new Labyrinthe();
Constructeurméthode de même nom que la classe appelée lors de la création d’un objetil peut y avoir plusieurs constructeurs
Attributsdéclaration dans le corps de classe
/** documentation */int nbCellX, nbcelly;
utilisation dans une méthodeunLab.nbCellX = 50;
Méthodesdéclaration dans le corps de classe/** documentation * @param arg1...* @return RetType* @exception pas d’exception*/RetType nomFunc( //args ) {
// corps de méthode}
utilisation dans une méthodeRetType x = unLab.nomFunc();
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 16
Les Objets dans JavaClasses, 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 variablePour une Méthode : méthode qui à un sens pour la classe elle même indépendamment d’une instance donnéestatic 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 classeLabyrinthe f() {
...// corps de méthodereturn 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 17
Les Objets dans JavaL’héritage
PrincipeRegrouper les caractéristiques générales des classes dans une superclasse facilite la structuration et la réutilisation du code
Certaines classespeuvent êtreabstraites pasd’instances
Certainesméthodespeuvent nepas être implémentées
méthodesabstraites
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 18
Les Objets dans JavaLe polymorphisme : classes dérivées et spécialisation
classe dérivéenotation :
class WallCell extends Cell{// corps de la classevoid display(){...}
}
classe non dérivablefinal class WallCellextends Cell{// corps de la classevoid display(){...}
}
Une méthode protected dans la calsse de base est visible dans la dérivée
spécialisationutilisation 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
l’opérateur instanceof
class WallCell extends Cell {...} class FloorCell extends Cell{...}...if (aCell instanceof WallCell) {
...} else{...}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 19
Les Objets dans JavaLe polymorphisme : classes et méthodes abstraites
Les classes abstraitesclasses non instanciablesdirectementabstract class myClass { ...}
Une telles classe peut contenir des méthodes sans corps. De telles méthodes sont qualifiées d’abstraitesabstract void f();
les méthodes abstraites définissent le format des méthodes à implanter dans les classes dérivées.Le compilateur vérifie la cohérence de l’arbre d’héritage et oblige toute classe non abstraite à ne plus avoir de méthodes abstraites
abstract class Cell {public abstract void display();
}class Wall extends Cell {
public void display(){ ...//corps }}class Floor extends Cell {
public void display(){ ...//corps }}class Lab {
void displayLine(Cell[] tCell) {for (int i=0; i<tCell.length; i++)
tCell[i].display();}public static void main (String args[]){
Cell[] ligneDeLab = new Cell[50];int i = 0;ligneDeLab[i++] = new Wall;...
ligneDeLab[i++] = new Floor;displayLine (ligneDeLab);
}}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 20
Les Objets dans JavaLes interfaces
PrincipeUne classe abstraite n’ayant que des méthodes abstraitesEnsemble de méthodes non implémentées et de constantesLorsqu’une classe implémente une interface, elle doit implémenter toutes les méthodes de l’interface
AvantagesPermet de regrouper les similarités entre classes sans forcer des relations d’héritage entre les classesPermet 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 21
Les Objets dans JavaLe polymorphisme : Les interfaces
définition de classes abstraites “pures”déclaration de méthodes sans corpsque 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 {void display();
}
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
class Wall implements Cell {void display(){ ...//corps }
}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 22
Les Objets dans JavaLe 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 23
Les Objets dans JavaLe polymorphisme : Les inner classes
Définition d’une classe à l’intérieur d’une autre classeclass 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 compilateurLabyrinthe.classLabyrinthe$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 24
Les Objets dans JavaPaquetages 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 Javaimport 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 paquetagepackage nomDuPaquetage; // on ajoute ce code au paquetage
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 25
Les Objets dans JavaRè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 constantesur une méthode : pas de surcharge ou de spécialisation possibleSur 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 26
Sommaire
La GrammaireTypesOpérateurs et Structures de contrôlesTableauxExceptions
Les Objets dans JavaClasses, attributs et méthodesLe polymorphisme et JavaPaquetages
Les Classes de basesChaînes de caractèresOutils mathématiquesDatesTableaux et tables de hachages
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 27
java.utilClasses d’utilité générale
BitSet : construit des tableaux extensibles de bits avec les opérations and, or, xor,...
Date,Calendar : manipulation de dates
ArrayListTableau extensiblesget, contains,,...size() retourne le nbre d’éléments
HashMap:implémentation d’une collection indexéecouleurs.put(“rouge“,Color.red);
Properties :Hashtable qui peut être sauvée et chargée sur des flots d’entrée/sortie InputStream ou OutputStream
Randomnombres aléatoiresnextInt(),nextFloat(),...
Stackgestion d’une pile d’objetspush, pop, peek, search, objectAt
StringTokenizerdécoupe une chaine en tookenStringTokenizer s = new
StringTokenizer ( “bientot la fin”);
while( s.hasMoreTokens())println(s.nextToken());
IteratorPermet de parcourir une collectionfor(Iterator it =
collection.iterator();it.hasNext();) {
item = it.next();}
© Rémy Courdier (Révisions M. Gangat) 1996-2003 - Le langage Java - Version du cours 2.8 28
Références
The Java™ Language Specification Second Edition http://java.sun.com/docs/books/jls/index.htmlversion HTML ou PDF
Learning the Java Languagehttp://java.sun.com/docs/books/tutorial/java/TOC.html
Cours JAVAhttp://www-sor.inria.fr/~dedieu/java/cours/