le langage -...

© 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


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


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


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;

}


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;}


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 );

} }


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


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);

} }


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;}


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);}

}


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...


Sommaire





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é


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


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();


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

}


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


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{...}


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);

}}


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


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 }

}


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();


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);

}}


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


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


Sommaire





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é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/

le langage -...

Documents