Cours JAVA S1_ppt

Cours Programmation Orienté Objet : Java

Version préparée par M. Mohamed Saleh Bouhlel

Présentée par Mme Yosr Naïja2006/2007

Cours POO 2Y.Naïja en collaboration avec M.S Bouhlel

PlanIntroduction généraleÉléments de base du langage JAVALes principes de la programmation Objet « Objet, classe»Tableaux et chaînes de caractères Héritage, Interface et PackageLes exceptionsLes Entrées SortiesJava Data Base Connectivity (JDBC)

Introduction générale


Java est un langage de programmation Orienté Objet.

Il a été développé par SUN.

QuQu’’estest--ce que Java ?ce que Java ?


Simple- Syntaxe proche du C/C++- Élimination de la notion de pointeur, structure…- Assure la gestion de la mémoire (« Garbage collector »)

Un système de ramasse miette permet de décharger le programme d’une gestion fastidieuse de la mémoire

Presque complètement objet - Pas d'utilisation d'objets pour les primitives (int, char, double)

Interprété- Un programme java n’est pas compilé en code machine mais

transformé en code intermédiaire interprété.

PropriPropriééttéés de Javas de Java

Java est un langage:


Fortement typé- Interdiction de conversion de type impliquant une perte de

précision.

Ouvert - Connexion aux bases de données intégrée (JDBC)- Support des caractères internationaux- …

Dynamique et muti-tâches (ou multithread)- Les classes sont chargées au fur et a mesure des besoins.- La mise à jour de l’application peut se faire classe par classe.- Gestion multithreading simple : écouter de la musique en

regardant une animation flash.



Portable- Indépendant de toute plateforme.- Pas de compilation spécifique pour chaque plateforme.


La devise de java : écrire une fois , exécuter partout

« Write once run everywhere »


Génère du code natif directement exécutable, mais spécifique àchaque environnement

Compilateur

MonProg.c

MonProg.o

010110…

DDééploiement dploiement d’’un programme (1/2)un programme (1/2)Paradigme classique de la compilationParadigme classique de la compilation


Chaque programme est compilé et interprété« Write once run everywhere » : écrire une fois exécuterplusieurs fois

MonProg.java

MonProg.class

Compilateur Compilé une seule fois

Traduit le programme en un code intermédiaire

Appelé bytecode – indépendant de la machine

La machine virtuelle JAVA (JVM)Une fois le programme java compilé et converti en Byte-Code, c’est la JVM qui est capable d’interpréter et de permettre au système d’exécuter ce code.

JVM JVM JVM

MAC Windows UNIX

DDééploiement dploiement d’’un programme (2/2)un programme (2/2)Compilation avec JAVACompilation avec JAVA


Plateforme = environnement hardware ou software sur lequel le programme est exécuté.

La Java « Platform » se compose de:La machine virtuelle JAVA (JVM)

Interpréter le bytecode

Les interfaces de programmation d’application (API)Ensemble de classes prédéfinies de java qui existe dans chaque installation.Elles sont organisées sous forme de package. (E/S, Swing, Awt…)

La plateforme JavaLa plateforme Java


Versions de JavaVersions de Java

-XML (SAX/DOM)-SSL, Image, …

13529911.4

-Java SOUND7618421.3

-Swing-Collections

5915201.2

- Classe interne- JVM plus performante- JDBC pour l'accès aux données

235041.1

82121.0

nouveautéNbrpackages

Nbrclasses

Version

Éléments de base du langage JAVA

Chapitre 1 :


Trois notations sont admises pour l’insertion de commentaire :

// commentaire sur une ligne.

/* commentaire surplusieurs lignes */

/** commentaire d’explication utilisé par javadocsur une ou plusieurs lignes */

CommentairesCommentaires

Existe une distinction entre majuscule et minuscule.

ParticularitParticularitéé


Toute instruction doit se terminer par un point virgule «;»

Un bloc est une suite d’instruction délimité par «{» et «}».

Les blancs sont autorisés entre les éléments du code sources. (espace, tabulation et saut de ligne)

Exemple:

{x=2;y=10;

}

Points virgules, blocs et blancsPoints virgules, blocs et blancs

{x=2;y=10;}


Un identificateur désigne le nom de tout objet, variable, classe, programme que le programmeur souhaite manipuler.

Commence par une lettre, un trait de soulignement « _ » ou le signe dollar « $ ».

Les caractères suivants de l’identificateur peuvent contenir des chiffres.

Existe une distinction entre majuscule et minuscule.

Exemple:MaClasse, _maVariable, $maFonction, C1, … (Valide)1var, -maclasse, fonction-recherche, … (non valide)

IdentificateursIdentificateurs


Abstract double int strictfpboolean else interface super break extends long switchbyte final native synchronized case finally new thiscatch float package throw char for private throws class goto protected transient const if public trycontinue implements return void default import short volatile do instanceof static while

IdentificateursIdentificateursNe doit pas appartenir à la liste des mots réservés


Types de donnTypes de donnééesesJava prend en comptes les types de données suivant :

1. Les types primitifs

2. Les chaînes de caractères : Pour manipuler les chaînes de caractères Java offre une classe appelée String. Une constante chaîne de caractères est placée entre " " .

3. Des références : Contrairement aux types primitifs qui possèdent des tailles de mémoire standard et fixes, un type tableau ou un type classe ne peut pas avoir une taille standard. Au lieu de manipuler directement un objet de la classe ou un objet tableau, Java manipule une autre donnée qui représente une référence à l’objet manipulé. Pour cela classes ou types tableau sont appelés des références.


Types primitifsTypes primitifsCatégorie logique : Type booleanen java, un boolean n’est pas considéré comme une valeur numérique. Seules valeurs possibles sont true ou false.Ex:

boolean trouve=true;

Catégorie caractère : Type charle type ‘char’ permet de représenter les caractères isolés (c’est un caractère Unicode représenté sur 16 bits). Elle est délimitépar deux apostrophes.exemples:

char x=‘a’; char omega=(char) 969; char z=‘\u1200’


Types primitifsTypes primitifsCatégorie entier : types byte, short, int et longil existe 4 types d’entiers en java.chaque type est déclaré avec l’un des mots clés :byte, short, int et long.

Exemple:Int x=2;Long y=3L;

-2exp63 .. (2exp63) -18 Octetslong-2exp31 .. (2exp31) -14 Octetsint-2exp15 .. (2exp15) -12 Octetsshort-2exp7 .. (2exp7) -11 Octetbyte

IntervalleTailleType


Types primitifsTypes primitifsCatégorie flottant : type float et doubleune constante numérique est flottante si elle contient un point décimal, une partie exponentielle lettre E ou si elle sont suivit par la lettre F ou D.

Exemple :2.3F2.32.3E44F

Remarque : les expression littérales flottantes sont de type double sauf si elles sont explicitement suivies par la lettre F.


DDééclaration et affectationclaration et affectationLa déclaration et l’affectation s’effectue de manière similaire au C.

Exemple :int x=0, y=0;float z=2.3F;double t=2.3;char c=‘r’;

Les variables constantes : toute variable dont le type est précédépar le mot clé final,

elle ne peut plus être modifiée Elle doit être initialisée lors de sa déclaration.

Exemple :final double PI=3.14;


Les expressions en javaLes expressions en javaLes opLes opéérateursrateurs

Voir document liste des opérateurs


Conversion de typeConversion de typeSi dans une expression les opérandes sont de différents types le résultat est alors converti vers le type le plus grand.Exemple :

int x=2; long y=4, z;z=x*y; //le résultat est alors converti en long

Pour l’affectation, la donnée à droite est convertie dans le type de celle de gauche. Si le type de la destination est plus faible l’instruction est considérée erronée.Exemple :

int i=2; long x=5;x=i; //instruction légalei=x; // instruction erronée

On peut convertir explicitement une valeur en forçant la transformation. Le type ciblé est placé entre () et est utilisé comme préfixe de l’expression dont on veut modifier le type.

<nom_variable> = (<type>) <expression>Exemple :

float z; z=(float) 14.33;int x; x=(int) z; //x contient la valeur 14


Les structures de baseLes structures de baseStructure alternative : Structure alternative : if..elseif..elseif (<expression booléenne>){

//instruction ou bloc d’instruction a exécuter si condition= vrai.}else{

//instruction ou bloc d’instruction a exécuter si condition= faux.}

La partie else est optionnelle et peut être omise s’il n’y a pas d’actions a effectuer lorsque la condition est fausse.

Exemple :int i=2; boolean fin;if(i<0){fin=true; i=0;}else i++;


Les structures de baseLes structures de baseStructure alternative : Structure alternative : switchswitch

switch (<expression >){

case <valeur 1> : <bloc 1> break;case <valeur 2> : <bloc 2> break;… …case <valeur n> : <bloc n> break;default : <bloc n+1>

}

l’expression du switch doit être de type compatible avec un entier. Les expression en flottant ou en double ne sont pas permises.

la spécification du break sont nécessaire pour gérer les ruptures de séquences.


Les structures de baseLes structures de baseStructure alternative : Structure alternative : switchswitch

Exemple:int k=0, i=2;switch(i){

case 1: k+=20; break;case 2: k+=2; break;case 3: k+=10; break;

}

Exemple:int k=0, i=2;switch(i){

case 1: k+=20;case 2: k+=2;case 3: k+=10;

}

k=2 K=?


Les structures de baseLes structures de baseOpOpéérateur ternairerateur ternaire

variable = condition ? si_test_vrai : si_test_faux ;

C’est équivalent à : If(condition)

si_test_vraiElse

si_test_faux

Exemple:int a=1,b=3;int min=(a<b)?a:b; //parenthèse facultatives


Les structures de baseLes structures de baseStructure rStructure rééppéétitive : titive : whilewhile

while (<expression_booléenne>){

<instruction ou bloc>}

Exemple:int i=0;System.out.println(‘‘je sais compter jusqu’a 10’’);while (i<10){

System.out.println(i);i++;

}


Les structures de baseLes structures de baseStructure rStructure rééppéétitive :titive : do .. do .. whilewhile

do{

<instruction ou bloc>}while (<expression_booléenne>);

Exemple:int i=10;System.out.println(‘‘je sais compter jusqu’a 10 a l’envers’’);do{

System.out.println(i);i--;

}while(i>=0);


Les structures de baseLes structures de baseStructure rStructure rééppéétitive : titive : forfor

for (<initialisation> ; <expression_booléenne> ; <incrémentation> ){

<instruction ou bloc d’instruction>}

Exemple:for (int i=0;i<=10;i++)

System.out.println(i);

for ( ; ; ) boucle infinie


Convention dConvention d’é’écriturecriture

Classesclass BankAccount, class RacingBike

Interfacesinterface Account

Méthodesdeposer() getName()

Packagespackage coursJava

Variablesint accountNumber; int x

ConstantesMAXIMUM_SIZE

Premier Programme JAVA


Deux façons d’écrire des programmes Java:

En écrivant le code dans un simple éditeur de texteCompilation et exécution du code en ligne de commande DOS

En utilisant un environnement de développement (IDE)Netbeans (http://www.netbeans.com )Borland JBuilder (http://www.borland.com/jbuilder )IBM WebSphere Studio (http://www.ibm.com/software/awdtools

)Sun ONE Studio (http://wwws.sun.com/software/sundev)Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)Jcreator

…

Comment dComment déévelopper une application?velopper une application?


Créer un fichier : HelloWorld.java

La première ligne du programme doit être la déclaration de la classe

Tout programme doit contenir une méthode main qui porte la signature ci-contre

Écrire à l’écran “Hello the World”

Fermer les accolades

public class HelloWorld

{public static void main (String[]args){

System.out.println("Hello the World");}

}

• Compiler le programme : javac HelloWorld.java• Le compilateur génère le bytecode dans le fichier : HelloWorld.class• Exécuter l’application : java HelloWorld• « Hello the World » s’affiche à l’écran

Une premiUne premièère application : re application : ApplicationApplication HelloWorldHelloWorld

Chapitre 2 :Les principes de la programmation Objet« Objet, classe»


C’est une notion très proche de celle de la vie courante. On représente en permanence le monde qui nous entoure sous forme d’objets plus ou moins abstraits (chaise, table, stylo, voiture, animaux...).

Cette vision d’un objet peut être différente en fonction de nos besoins :

Un conducteur voit une voiture comme un ensemble complexe de commande pour la faire avancer, diriger et interagir avec d’autres véhicules.Un policier voit un ensemble de véhicules comme un ensemble d’objets qui doivent respecter des règles de circulation. (camion ou voiture sont de même type)Un garagiste voit un véhicule comme étant un ensemble d’objets qui interagissent entre eux.

Notion dNotion d’’objetobjet


Un objet est définit de la manière dont on peut interagir avec lui et cela en fonction du problème àrésoudre.

Il correspond à un certain niveau d’abstraction de la réalité et est représenté essentiellement par les services qu’il peut nous rendre.

Nous faisons tous en permanence un tel travail d’abstraction pour pouvoir voir et comprendre simplement le monde qui nous entoure.

Notion dNotion d’’objetobjet


Un objet est une boite noire qui offre un certain nombre de fonctions ou méthodes permettant d’interagir avec lui.

La seule chose nécessaire pour pouvoir utiliser un objet est de savoir ce qu’il peut faire et surtout comment le lui demander.

Ex: un poste de télé est une boite noire ayant pour interface : une télécommande , écran, haut parleurs. Pour changer de chaîne il suffit de demander à la boite noire de le faire pour nous en appuyant sur un bouton.

L’ensemble des méthodes proposées par un objet est appeléinterface de l’objet.

Encapsulation, mEncapsulation, mééthodes et invocationthodes et invocation


On dit qu’un objet est encapsulé par son interface la seule façon de communiquer avec cet objet et d’invoquer une des méthodes de son interface.

L’encapsulation d’un objet par son interface permet de masquer son contenu possibilité de modifier son contenu sans impacte pour le reste du monde.

L’encapsulation constitue un des points centraux de l’approche objet. En faisant cela on dit à l’objet ce qu’il doit faire et non comment il doit le faire.

Ex: si on freine avec la voiture on se contente d’appuyer sur la pédale (méthode freinage). Peut importe s’il s'agit d’un frein à disque ou ABS…

Ex:un policer invoque la méthode arrêter en levant la main et il ne s’occupe pas de la manière dont chaque véhicule s’arrête.

Encapsulation, mEncapsulation, mééthodes et invocationthodes et invocation


Soit la table de cuisine de Mme FafaCette table de cuisine particulière est dite «instance » de l’ensemble des tables de cuisine ayant les même fonctionnalités. Cet ensemble de tables de cuisines est appelée « classe ».

classe et instances de classeclasse et instances de classe


Une table de cuisine est une table qui possède des caractéristiques spécifiques. On dit que la classe des tables de cuisine est une classe fille de la classe des tables et qu’elle hérite des caractéristiques de cette classe tout en la spécialisent par l’ajout de nouvelle fonctionnalités.

Une classe fille est définie à partir de sa mère par héritage (réutilisation de ce qui est déjà défini) et spécialisation (ajout de nouvelles fonctionnalités).

Niveau dNiveau d’’abstraction et classes dabstraction et classes d’’objetsobjets

Meubles

Tables Chaises

Table de cuisine Table de salon


C’est un mot Greg « plusieurs formes ».

Signifie qu’une méthode peut être définie dans plusieurs classe et que chaque classe peut implémenter (réaliser) cette méthode à sa manière.

Ex: lorsqu’on freine dans une voiture, on sait que la fonction attendue est de stopper le véhicule. En fonction du type réel de véhicule (de sa classe plus spécifique), les actions réelles sont très différentes (ABS, tambours,…). Le conducteur n’a pas besoin de ce niveau de détail pour savoir s’arrêter.

PolymorphismePolymorphisme


Qu’est ce qu’un objet?C’est l’unité de base de la conception OO.Il regroupe à la fois des données et des opérations qui permettent de manipuler ces dernières.Les données sont généralement appelé attributs et les opérations sont appelées méthodes.

Un objet est caractérisé par :Attributs typés.Méthodes.nom, pour le distinguer des autres objets.

Exemple:On peut modéliser une personne par l’objet Personne. Les attributs sont alors les informations concernant la personne (nom, prénom, tel,…). Et comme méthode on aurait par exemple calcul_Age, calcul_salaire…

Objets, ClassesObjets, Classes


Qu’est ce qu’une classe?C’est une description d’un ensemble d’objets ayant des propriétés et des comportements commun.Les objets sont aussi dits instances de classes.

Une classe en java est définie en précisant son nom, en déclarant ces attributs et en définissant ses méthodes.

Syntaxe:Class nom_classe{

// déclaration des attributs// déclaration des méthodes

}



Exemple:class Rectangle

{//déclaration attributsint long;int larg;// autres attributs éventuels//déclaration des fonctionsvoid allongerRectangle(int lg){ longueur+=lg;}//… autres méthodes

}

Toutes les méthodes sont écrites à l'intérieur de la classeLa classe ne se termine pas par ";"



Déclaration des attributs[<modificateur_visiblité>] <type> <nom>[=<expression>]Ex

public int x;public int y=34;private int z=2;

Déclaration des méthodes[<modificateur_visiblité>] <type_retour> <nom>([<arguments>]){

// déclaration variables// les instructions

}Ex.

public int somme(int a){…

}



Constructeur de classeUn constructeur est une méthode particulière appelée au moment de la création d’un objet. Son rôle est d’initialiser l’objet en fonction des paramètres fournis par l’utilisateur.

Le nom du constructeur doit correspondre au nom de la classe sans aucun type de retour.

Ex: Rectangle(int lg,int larg) {

longueur=lg; largeur=larg;}



Constructeur de classeUne classe peut avoir plus qu’un constructeur

Ex: Rectangle (int lg,int larg) {

longueur=lg; largeur=larg;}

Rectangle () {longueur=0; largeur=0;

}

Chaque classe comporte au moins un constructeur. En effet, si aucun n’est précisé, le système utilise un constructeur par défaut.



Création et initialisation des objets1. Déclaration de l'objet : déclarer une variable de la

classe que l’on désire instancier. Cette variable n’est pas l’objet lui-même mais une référence à cet objet.Ex: Rectangle r1; // r1

2. Allocation de l'espace à l'objet : allouer l’espace mémoire nécessaire à l’objet et renvoyer l’adresse de l’objet à la variable référence. Cette opération se fait àl’aide de l’opérateur new auquel on passe le nom de la classe.ex : r1= new Rectangle();


??


Utiliser un objetAccès à un attribut :

L’accès direct à un attribut dans une classe se fait toujours àl’intérieur d’une méthode. Si on voudrait utiliser les attributs à l’extérieur de la classe, alors on crée un objet de la classe puis on applique cette syntaxe:

<nom_Objet>.<Nom_Attribut>

Invocation d’une méthode :Même principe.

- A l’intérieur de la même classe : appel direct de la méthode : <nom_méthode>(<liste_arguments>);

- A l’extérieur de la classe on utilise un objet.<nom_Objet>. <nom_méthode>(<liste_arguments>);



Contrôle d’accès au membre :L’accès aux membres (données et méthodes) d’une classe peut être contrôlé. En effet, l’utilisation du modificateur d’accès « private »pour un membre rend impossible tout accès à ce membre à partir de l’extérieur.Ex :

Class Rectangle{ private int longueur;

private int largeur;// déclaration des méthodes…}

Class Test{public static void main (String[] args){

Rectangle r=new Rectangle();r.longueur=10; //instruction erronée}

}



Les références :Ce sont les variables qui permettent de désigner et manipuler les objets.Les seuls opérateurs sur les références sont des opérateurs logiques:

==: teste si 2 références désignent le même objet.!= : teste si 2 référence ne désignent pas le même objet instanceof : retourne true si l’objet à gauche est une instance de la classe placée à sa droite ou si la comparaison est faite entre un objet d’une classe implémentant une interface et cette interface . Sinon il retourne false.

Ex :Class Rectangle{ private int longueur; private int largeur;// déclaration des méthodes…}Class Test{public static void main (String[] args){

Rectangle r=new Rectangle();boolean val1=r instanceof Rectangle;//val=trueboolean val2=r instanceof Test;//val=false

}}



La référence this :Le mot clé this représente une référence sur l’objet courant (celui qui est en train d’exécuter la méthode contenant le this).La référence this peut être utile :

Lorsqu’une variable locale ou un paramètre de fonction porte le même nom d'un attribut de la classe.Pour déclencher un constructeur depuis un autre constructeur.

Ex :Class Date{

int jour=1, mois=1, an=1990;Date()

{an=2000; /* peut s’écrire : this.an=2000 (facultatif)*/}Date(int an)

{this.an=an; /*pour pouvoir accéder à l'attribut de la classe (obligatoire)*/}Date(int an, int mois, int jour)

{this.jour=jour;this.mois=mois;this(an); /* Appel du deuxième constructeur*/}

}



La référence null :Le mot clé null permet de représenter la référence qui ne représente rien.On peut assigner cette valeur a n’importe quelle variable ou attribut contenant une référence.C’est aussi la valeur par défaut d’initialisation des attributs représentant des références.Ex :

Class Test{

Voiture v1; //initialisation a null par défaut.void methode(){

…if (v1==null) v1=new Voiture();…

}}



Surcharge des méthodes :Java permet de réutiliser un même nom de méthode pour plusieurs fonctionnalités. On dit que la méthode est surchargée.Ex :

Une méthode qui permet l’affichage de son argument. void print(int)void print(float)void print (double)

Les méthodes surchargées sont soumises à certaines règles:

Arguments suffisamment différents (nombre et/ou type)



Passage de paramètres des méthodes:Java ne transmet les arguments de type simple que par valeur l’argument ne peut être modifié par la méthode appelée.

Si une instance d’un objet est transmise comme argument a une méthode, le contenu de l’objet peut être modifié dans la méthode appelée et non sa référence.



Ex :

class Test{ int val=11;

public void modif(int n) { n=22; }

public void modifObj(Test obj) {obj.val=22;}

public static void main(String a[]){

Test t=new Test();int n=0;t.modif(n); System.out.println(n); //n=0;t.modifObj(t); System.out.println(t.val); //val=22

}}



Attributs de classe:C’est un attribut marqué par le mot clé static.Le mot clé static , utilisé pour un attribut, permet d’indiquer que cet attribut est commun à tous les objets de la classe concernée si on modifie cet attribut pour un objet donné, il sera modifié pour tous les objets de la classe.Ex :

class Voiture{ static int count =0;

int id;voiture(){

count++;id=count;

}


public static void main (String[] args){Voiture V1=new Voiture();Voiture V2=new Voiture();System.out.println(V1.count);V1.count=55;System.out.println(V2.count);Voiture.count=22;System.out.println(V1.count);}

}

1

count

25522


Attributs de classe:On accède à un attribut statique :

Via une instance quelconque de la classe : V1.idVia le nom de la classe : Voiture.id

On peut associer static à final pour un attribut constant et commun à tous les objets de la classe.final static float PI=3.14F;



Méthodes de classe:Une méthode de classe est une méthode de type static.

Une méthode de classe est une méthode dont les actions concernent la classe entière.

Une méthode statique ne peut accéder qu’aux attributs statiques de la classe.

On peut invoquer une méthode statique soit à partir de:La classe elle-mêmeUn objet de cette classe



Méthodes de classe:Ex :

class MathTool{ final static double PI=3.14;static double getPI(){return(PI);}static double diametre(double rayon){return(2*PI*rayon);}static double power(double x){return (x*x);}

}


class Test{

void methode1(){

double i = MathTool.power(6);}void méthode2(){

MathTool t=new MathTool();double i = t.power(6);

}}


Méthodes de classe:Une méthode statique ne peut pas avoir de référence this car elle peut être appelée sans l’intermédiaire d’un objet.

On utilise généralement des méthodes static pour rassembler un ensemble d’outils sur un certain objet.

La méthode main est une méthode de classe, elle est la première à être appelée quand on lance la JVM avec sa classe. La méthode main peut être lancée sans qu’aucune instance de la classe qui la contient n’existe.



Autres remarquesToute classe est une classe fille de la classe prédéfinie ObjectToute classe hérite des méthodes de la classe ObjectMéthode prédéfinie toString de la classeObject :

Prototype public String toString(); Est utilisée générement pour retourner les valeurs des données membres de l'objet appelant.



Ex .class Date{

int jour=1, mois=1, an=1990;Date (int j, int m, int a){ jour=j; mois=m; an=a;}

public String toString(){String a = "La date est : "+ jour+ "/"+ mois+"/"+annee;

return a;}

}

class test{public static void main(String []args){

Date d=new Date(5, 12, 2006);System.out.println(d.toString()); // ou System.out.println(d);

}}


Chapitre 3 :Tableaux et chaînes de caractères


En java le type tableau est assimilable à une classe un tableau est un objet référencé.Utilisation d'un tableau :

1. Déclaration : déclarer un tableau en java revient a réserver de la place mémoire pour l’adresse de ce tableau.

2. Allocation mémoire : après l’avoir déclaré, allouer l’espace mémoire nécessaire pour les cases du tableau

Les tableauxLes tableaux


Tableau à une dimension

Déclaration :<type> <nomTableau>[ ]; ou<type> [ ]<nomTableau>;

Exemples:int notes[]; // tableau entierschar[] lettres; //tableau de caractèresshort t1[100]; //instruction illégale car il n’est pas

//possible de définir un tableau de //taille fixe à la déclaration.




Allocation mémoire :la déclaration ne fait que réserver l’espace mémoire allant contenir l’adresse du tableau. Cette place mémoire est identifié par le nom du tableau.

l’allocation mémoire des cases du tableau se fait par le mot clé new :<nomTableau> = new <Type>[<dimension>];

Exemple :int []notes;notes = new int[3];


Ox123notes Ox123Déclaration Allocation



Initialisation:Lorsqu’un tableau est créé. Chacun de ces éléments est initialisé. Cette initialisation se fait a 0 si les éléments sont des entiers ou des réels, à false s’ils sont des booléens et à null sinon.

Exemples:int []tab={3, 5, 7}; // c’est équivalent a faireint []tab=new int[3]; tab[0]=3; tab[1]=5; tab[2]=7;

La longueur d’un tableau peut être obtenue à partir de la variable membre length.<nomTableau>.length




Utilisation:le premier élément d’un tableau commence a l’indice 0 et le dernier élément a l’indice n-1 (n le nombre d’éléments du tableau).

l’accès à un éléments du tableau se fait en mettant l’indice de cet élément entre crochets. Par ailleurs si on essaie d’accéder à un élément qui se trouve en dehors des bornes du tableau une erreur sera générée.

Utilisation:in[] tab=new int[10];tab[0]=1;tab[10]=2;// erreur à la compilation



Tableau à deux dimensionsUn tableau à 2 dimensions est tableau dont chaque composante est formée par un tableau.

Déclaration & allocation:1. 1ère méthode

<type>[][]<nomtableau>=new<type>[N1][N2];N1: nombre de tableau-élément.N2: nombre d’élément de chaque tableau-élément.

Exemple :créer une matrice carré :int [][] matrice= new int[2][2];matrice[0][0]=1; matrice[0][1]=1; matrice[1][0]=1; matrice[1][1]=1;




2. 2ème méthode<type> [ ][ ]<nomTableau>=new <type> [N1][ ];<nomTableau>[0]=new <type>[N21];<nomTableau>[0]=new <type>[N22];…

Exemples:

Int[][] notes=new int[3][]; notes[0]=new int[3]; notes[1]=new int[2]; notes[2]=new int[1];



Tableau à une dimensionLe nombre de tableau-élément peut être obtenue en utilisant la variable length.

Exemple:int[][] tab={{1,0,9},{2,8},{8,5,7}};tab.length 3tab[1].length 2



Exercice :

1. Écrire une méthode qui permet de faire un affichage de ce genre:



Les chaLes chaîînes de caractnes de caractèèresres

String est une classe qui est fourni avec l’API Java pour la manipulation de chaînes de caractères

Elle dispose des opérateurs + ou += pour concaténation des chaînes de caractères.

Une chaîne constante est délimitée par des guillemets.Ex:

String s=‘‘il est beau java’’;Mise à disposition de méthodes de manipulation de chaînes de caractères


Quelques méthodes de la classe String:

• int length() : retourne le nombre de caractère de la chaîne.

• int indexOf(char c, int i) : retourne la position du caractère c àpartir de la position i.

• String substring(int i, int j): retourne une chaîne extraite de la chaîne sur laquelle est appliquée la méthode en partant de la position i a la position j.

• int compareTo(String s) : effectue la comparaison entre deux chaînes. Elle retourne une valeur <0, =0 ou >0

• char charAt(int i) : retourne la caractère qui se trouve à la position i.

Les chaLes chaîînes de caractnes de caractèèresres

Chapitre 4 :Héritage, Interface et Package


Introduction :

• Un des avantages de la POO est de définir des dépendances entre les classes.

• Supposons qu’on veut définir une 2ème classe DateEvenement qui associe à une date un événement donné.

HHééritageritage

class Date{ int jour, mois, année;Date(int j, int m, int a){jour=j; mois=m; année=a;}

…public void affiche(){ System.out.println(jour+’’/’’+mois+’’/’’+année);}

}


Introduction :

• Une solution est de réécrire entièrement cette classe.

HHééritageritage

class DateEvenement{ int jour, mois, année; String evenement;

DateEvenement(int j, int m, int a, String e){jour=j; mois=m; année=a; evenement=e;}

public void affecter(int j, int m, int a, String e){ jour=j; mois=m; année=a; evenement=e;}…public void affiche(){ System.out.println(jour+’’/’’+mois+’’/’’+année+’’ ‘’+evenement);}

}


Introduction :

• Cette solution est à l’opposé de ce qu’est la programmation objet.

• Puisqu’on a déjà la classe Date, on a un moyen plus simple de définir la classe DateEvenement qui est l’héritage.

• On dira que la classe DateEvenement hérite des attributs et des fonctionnalités de la classe de base Date.

• On parle de classe fille/classe mère ou sous-classe/superclasse, ou classe dérivée/classe de base

HHééritageritage


Introduction : Syntaxe de l'héritage

• <nom_classe_fille> extends <nom_classe_mère>:

HHééritageritage

Ex.class DateEvenement extends Date{ String evenement;…public String quelEvent() {return evenement;}

}


Constructeur de la sous classe :

Lorsqu'on définit une classe dérivée, il faut s'assurer que, lors de la création des objets de cette nouvelle classe, les champs propres à cette classe dérivée ainsi que les champs de la classe de base soient initialisés correctement.

Un constructeur d'une classe dérivée se compose généralement de deux parties :

celle concernant les champs de la classe de base en utilsantsuper(…)et celle concernant les champs propres à la classe dérivée.

HHééritageritage


Constructeur de la sous classe :

HHééritageritage

class DateEvenement extends Date{String evenement;DateEvenement(int j, int m, int a, String e){

super(j,m,a); //appel au constructeur de la classe de Base.evenement=e; //initialisation des champ de la classe dérivée

}…

}

Remarque : L'invocation de super(...) doit être la première instruction du constructeur de la classe dérivée.


Constructeur de la sous classe : remarques importantes

L'invocation de super(...) doit être la première instruction du constructeur de la classe dérivée.

Constructeur par défaut : Si le constructeur de la classe dérivée n'invoque pas le constructeur de la classe de base explicitement avec l'instruction super(...), Java fait quand même appel au constructeur, sans argument, de la classe de base : super(). Un constructeur définit comme suit

public DateEvenement(String e) {event = e ; } est automatiquement transformé en

public DateEvenement(String e) { super() ; event = e ; }

Dans le cas où un tel constructeur n'existe pas dans la classe de base, une erreur de compilation est générée. Il existe un cas où l'absence de l'instruction super(...) ne conduit pas à cet appel implicite : celui où le corps du constructeur commence par l'instruction this(...).

HHééritageritage


Enchainement de constructeur :

Pour tout objet créé, le constructeur de la classe de base est invoqué qui lui à son tour invoque le constructeur de sa classe de base et ainsi de suite. Il existe donc un enchaînement d'invocation de constructeurs. Cette cascade d'appels aux constructeurs s'arrête dès que l'on atteint le constructeur de la classe Object.

La classe Object est la mère de toutes les classes ; toute classe est dérivée directement ou indirectement de la classe Object.

Ainsi, lors de la création d'un objet, le premier constructeur invoquéest celui de la classe Object suivi des autres constructeurs dans l'ordre de la hiérarchie de dérivation des classes.

HHééritageritage


Redéfinition des champs :Les champs déclarés dans la classes dérivée sont toujours des champs

supplémentaires.

Si l'on définit un champ dans la sous classe ayant le même nom qu'un champ de la classe de base, il existera deux champs de même noms :

Le nom de champ désignera toujours le champ déclaré dans la classe dérivée.

Pour avoir accès au champ de la classe de base, il faudra changer le type de la référence pointant sur l'objet ou en utilisant le mot clé super.

HHééritageritage

class B extends A { public int i ; ... public void uneMethode() {

i = 0 ; // i est le champ défini dans la classe B this.i = 0 ; // i est le champ défini dans la classe Bsuper.i = 1 ; // i est le champ défini dans la classe A( (A) this ).i = 1 // i est le champ défini dans la classe A

… } }

class A { public int i ; ... }


Redéfinition des champs :Cette technique peut s'appliquer en cascade de la manière suivante :

class C extends B { public int i ; ... public void uneMethode() {

i = 0 ; this.i = 0 ; // i est le champ défini dans la classe C super.i = 1 ; // i est le champ défini dans la classe B( (B) this ).i = 1; // i est le champ défini dans la classe B ( (A) this ).i = 1 // i est le champ défini dans la classe A

} }

Par contre, l'instruction suivante est incorrecte : super.super.i = 1 ; // Incorrect syntaxiquement !

Tout comme l'utilisation du mot clé this, le mot clé super ne peut pas être utilisé dans les méthodes static.

HHééritageritage


Redéfinition des méthodes:On n'est, évidemment pas, tenu de déclarer des nouveaux champs dans une classe

dérivée : il est possible que l'on dérive une classe pour uniquement modifier les méthodes de la classe de base.

Par exemple, si l'on voulait une nouvelle classe DateAnglais qui ne diffère de la classe Date que par le format d'impression de la date, il suffirait de définir une classe dérivée de la classe Date et de redéfinir la méthode imprimer pour cette nouvelle classe.

La redéfinition d'une méthode consiste à fournir une implantation différente de la méthode de même signature fournie par la classe de base. Dans cet exemple, la méthode affiche des classes Date et DateAnglais ont la même signature ; celle de la classe DateAnglais redéfinit celle de la classe Date.

class DateAnglais extends Date { public void affiche(){

System.out.println(retourneMois() + "/" + retourneJour() + "/" + retourneAnnée() ) ; } }

HHééritageritage


Méthode de la classe de base:Pour avoir accès à une méthode redéfinie de la classe de base, à l'intérieur

d'une méthode de la classe dérivée, il faudra utiliser le mot clé super. Comme pour les champs redéfinis, il suffit de préfixer le nom de méthode par le mot clé super pour invoquer la méthode de la classe de base.

class DateEvenement extends Date {

private String event = null ; public DateEvenement(int j, int m, int a, int e) { super(j, m, a) ; event = e ; }

public void afficher() { super.afficher(); System.out.println(e); }

... }

HHééritageritage


Méthode static:

Une méthode static peut également être redéfinie par une autre méthode static. Par contre, une méthode static ne peut être redéfinie en une méthode non static.

Méthode final:

Une méthode final est une méthode qui ne peut être redéfinie dans aucunesous classe.

Exemple :class Date { private int jour, mois, année ; public final int retouneJour() { return jour ; } ... }

HHééritageritage


Une méthode polymorphe est une méthode déclarée dans une superclasse et redéfinie dans une sous-classe.

Avantage : liaison dynamique :

PolymorphismePolymorphisme

Forme f ;switch(n){case 0: f=new Carre(); break();case 1: f=new Cercle(); break();}

S=f.superficie(); La fonction est déterminée à l'exécution


Classe FinalUne classe final est une classe qui ne peut pas

être dérviée.final class A{…}class B extends A {…}

HHééritageritage


La classe Object :• C’est la classe de base de toutes les classe Java.

• Les méthodes définis dans cette classe peuvent alors être utilisées ou redéfinies.

• Exemples de méthodes :public String toString() public boolean equals(Object obj) public final native Class getClass() public native int hashCode() protected native Object clone() protected void finalize() throws Throwablepublic final native void notify() public final native void notifyAll() public final native void wait(long timeout)throws InterruptedExceptionpublic final void wait(long timeout, int nanos)throws InterruptedExceptionpublic final void wait()throws InterruptedException

HHééritageritage


La classe Object :

public String toString () La méthode toString est utilisée pour donner une

représentation textuelle d'un objet.

HHééritageritage


Exempleclass Date{

int jour=1, mois=1, an=1990;Date (int j, int m, int a){ jour=j; mois=m; an=a;}

public String toString(){String a = jour+ "/"+ mois+"/"+annee;

return a;}

}

class test{public static void main(String []args){

Date d=new Date(5, 12, 2006);System.out.println(d.toString()); // ou System.out.println(d);

}}

HHééritageritage


La classe Object :public boolean equals (Object obj) La méthode equals rend la valeur true si l'objet sur lequel la méthode equals est invoquée est égale àl'objet passé en paramètre. Qu'est ce que l'égalité ? La notion de l'égalité

dépend des objets concernés. Par défaut, la sémantique de la méthode equals fournie dans la classe Object est l'égalité entre les valeurs des références : les deux références désignent le même objet.

HHééritageritage


Classes et méthodes abstraites:

On peut parfois utiliser les classes pour définir, non pas un type d'objet bien précis, mais un concept.

Soit la méthode superficie de la classe Forme On ne sait pas implanter la méthode superficie dans le cas d'une forme générale.

Par contre, une fois connue une forme précise (un carré, un cercle, etc.), on sait implanter cette méthode pour cette forme.

HHééritageritage

Forme

Carré Cercle


Classes et méthodes abstraite:

Une méthode abstraite est une méthode qu'on ne peut pas implémentée

Une classe abstraite est Une classe qui ne peut pas être instanciéeUne classe qui contient au moins une méthode abstraite

Il ne sera jamais possible de créer un objet de type Forme.

Le langage Java impose de qualifier la classe d'abstraite lorsqu'une de ses méthode est abstraite.

HHééritageritage


Classes et méthodes abstraite:abstract class Forme { ... public abstract void superficie() ; ... }

Tout ceci permet de regrouper des données et méthodes communes dans une classe et de spécifier les méthodes qu'une classe dérivée de celle-ci doit absolument implanter. Exemple :

class Carré extends Forme { ... public void superficie () { ... } ... }

Si l'on définit une sous classe sans implanter toutes les méthodes abstraites de la classe de base, une erreur de compilation est générée.

HHééritageritage


Introduction :Le langage Java ne permet pas l'héritage multiple. Il palie ce manque par

l'introduction des interfaces. Le choix délibéré de Java de supprimer l'héritage multiple est dicté par un souci de simplicité.

Pour supprimer les problèmes liés à l'héritage multiple, les interfaces sont des ``sortes de classes'' qui ne possèdent que des champs static final(autant dire des constantes) et des méthodes abstraites.

En fait, les interfaces sont un moyen de préciser les services qu'une classe peut rendre.

On dira qu'une classe implante une interface Z si cette classe fournit les implantations des méthodes déclarées dans l'interface Z.

Autrement dit, la définition d'une interface consiste à donner une collection de méthodes abstraites et de constantes.

L'implantation de ces méthodes devra évidemment être fournie par les classes qui se réclament de cette interface.

InterfaceInterface


Déclaration des interfaces :

Comme les classes, les interfaces sont constituées de champs et de méthodes ; mais, comme nous l'avons déjà dit, il existe de très fortes contraintes sur la nature des membres d'une interface :

Toutes les méthodes sont public et abstract, les mots clés public et abstract n'apparaissent pas : ils sont implicites.

Tous les attributs d'une interface sont public, static et final. Ils sont là pour définir des constantes qui sont parfois utilisées dans les méthodes de l'interface. Les mots clés static et final et public ne figurent pas dans la définition des champs ; ils sont implicites.

InterfaceInterface


Déclaration des interfaces :

Exemple :La syntaxe de la déclaration d'une interface est la suivante : interface Service {

int MAX = 1024 ; ... int une_méthode(...) ; ...

}

InterfaceInterface


Interface publique :

Une interface peut être qualifiée de public. Une interface public peut être utilisée par n'importe quelle classe.

En l'absence de ce qualificateur, elle ne peut être utilisée que par les seules classes appartenant au même package que l'interface.

InterfaceInterface


Implanter les Interfaces :

Les interfaces définissent des ``promesses de services''. Mais seule une classe peut rendre effectivement les services qu'une interface promet. Autrement dit, l'interface toute seule ne sert à rien : il nous faut une classe qui implante l'interface. Une classe qui implante une interface la déclare dans son entête

class X implements Service { ... public int une_méthode(...) { ... } ...

}

InterfaceInterface


Implanter les Interfaces :

Par cette déclaration, la classe X promet d'implanter toutes les méthodes déclarées dans l'interface Service. La classe X doit donc fournir l'implantation des méthodes précisées dans l'interface Service ; on devra donc trouver dans la définition de cette classe, l'implantation de la la méthode une_méthode.

La signature de la méthode doit évidemment être la même que celle promise par l'interface. Dans le cas contraire, la méthode est considérée comme une méthode de la classe et non une implantation de l'interface.

Si une méthode de même signature existe dans la classe mais avec un type de retour différent une erreur de compilation est générée.

InterfaceInterface


Interface dérivé :Mais, contrairement aux classes, une interface peut étendre

plusieurs interfaces. interface A extends B { ... } interface A extends B, C, D { ... }

Une interface dérivée hérite de toutes les constantes et méthodes des interfaces ancêtres ; à moins qu'un autre champ de même nom ou une autre méthode de même signature soit redéfinie dans l'interface dérivée.

InterfaceInterface


Redéfinition des champs :

Tout comme pour les classes, les champs des interfaces peuvent être redéfinis dans une interface dérivée.

Exemple :interface A { int info = 1; } interface B extends A { int info = 2; }

La définition du champ info dans l'interface B masque la définition du champ info de l'interface A. Pour parler du champ info de l'interface A, on le notera A.info.

InterfaceInterface


Héritage diamant :Un même champ peut être hérité de plusieurs manières

pour une même interface

Exemple :interface A { char infoA = 'A'; } interface B extends A { char infoB = 'B'; } interface C extends A { char infoC = 'C'; } interface D extends B, C { char infoD = 'D'; }

Le champ infoA est hérité par l'interface D de deux manières : une fois par l'interface B et une autre fois par celle de C. Mais il n'existera pas deux champs infoA dans l'interface D ; il n'y en aura qu'un.

InterfaceInterface


Introduction :Un package est un ensemble de classes, d'interfaces et d'autres

packages regroupés sous un nom.

Il correspondent, en quelque sorte, au concept de librairies adaptéau langage Java. Un fichier source destiné à faire partie du package monpackage doit préciser son appartenance par la déclaration :

package monpackage ;

Cette déclaration précise que toutes les classes et interfaces définies dans ce fichier font partie du package monpackage. Elle doit apparaître avant toute déclaration de classes et interfaces.

Le nom d'un package sert de convention de nommage : il constitue une sorte de préfixe pour chaque nom figurant dans le fichier source.

PackagePackage


Importer des packages :Lorsqu'on veut utiliser une classe d'un package, le moyen le plus direct est de

nommer cette classe par son nom absolu (fully qualified name) : CoursJava.monpackage.Date d ; d = new CoursJava.monpackage.Date(15, 9, 57) ;

On aura compris que cette manière de faire est bien trop fastidieuse pour qu'on s'en contente.

Pour éviter cette lourdeur, Java dispose de la directive import. Il s'agit de prévenir le compilateur que l'on risque d'utiliser des noms simplifiés pour nos classes et qu'il devra préfixé tout seul les noms de classes quand c'est nécessaire.

import CoursJava.monpackage.Date ; ou import CoursJava.monpackage.*;

Une fois cette classe importée, on pourra désormais utiliser les noms simplifiés pour les classes importées.

Date d = new Date(15, 9, 57) ;

PackagePackage


Visibilité :

PackagePackage


PackagePackage

public


Classe interne non statique :Elles sont une extension du langage JAVA à partir de la version 1.1 du

JDK.

Une classe peut être définie à l’intérieur d’une autre classe. Elle constitue un membre à part entière des classes d’inclusion au même titre que les méthodes ou les variables.

Elle permet de définir une classe à l’endroit où une seule autre en a besoin.

Une classe interne peut être déclarée avec n’importe quel modificateur d’accès (public, protected, par défault ou private) et les modificateurs spéciaux final, abstract et static.

Classe InterneClasse Interne


Classe interne non statique :Si une classe interne est déclarée privée, ceci implique

que cette classe ne pourra être utilisée que dans la classe parente.

Une classe interne ne peut pas déclarer de membre statique sauf s’il comporte le modificateur final.

Tous les membres de la classe externe sont accessibles dans la classe interne mêmes ceux déclarés privés.

Elles sont enregistrées dans un fichier .class particulier dont le nom est de la forme : ClasseParente$ClasseInterne.class



Classe interne non statique :

class ClasseParente{

int x = 10; int y = 12; private int addition(){ return (x + y); }

class ClasseInterne{

void verification(){ if((x + y)== addition())

System.out.println("La classe interne a bien accédé aux membres de sa classe parente.");

}}

public static void main(String[] args){ ClassParente obj_out = new ClasseParente();

ClasseInterne obj_in = obj_out.new ClasseInterne();//c’est équivalent : ClasseInterne obj_in = (new ClassParente()).new ClasseInterne();

obj_in.verification();}}



Classe interne non statique :

class Externe {int x = 10; int y = 12;Externe(){ new Interne(); }

public static void main(String[] args){new Externe();}

class Interne {int x = 8; int y = 14;

Interne() {if (this.x + this.y == Externe.this.x + Externe.this.y)System.out.println( "La classe interne a bien accédé à l'ensemble des

membres des classes imbriquées.");}

}}



public class Famille {

String nom;Maillon premier;Famille(String nom) {this.nom=nom;}

private class Maillon { String prenom;

Maillon suivant;Maillon(String prenom, Maillon suivant) {

this.prenom = prenom; this.suivant = suivant;

}public String toString() {

return prenom + " , " + nom;}

}

Classe Interne (exemple liste chainClasse Interne (exemple liste chainéé))


void inserer(String prenom) {

premier = new Maillon(prenom, premier); }void affichage() {

while (premier!=null){

System.out.println(premier);premier=premier.suivant;

}}

public static void main(String[] args){

Famille f=new Famille("familleAli");f.inserer("ali");f.inserer("ali1");f.inserer("ali2");f.affichage();

}}

Classe Interne (exemple liste chainClasse Interne (exemple liste chainéé))


Classe interne locale (local inner-classes):Elles sont définies à l’intérieure d’une méthode ou d’un

bloc de code.

Elles ne sont utilisables que dans le bloc de code où elle sont définies.

Elles peuvent avoir accès aux membres de la classe englobant.



Classe interne locale (local inner-classes):

class ClasseExterne {int x = 10; int y = 12; int z = x + y;void addition(){ class ClasseLocale {

boolean verification(){ if (x + y == z) return true; else return false;}

}ClasseLocale obj_in = new ClasseLocale();


If (obj_in.verification()){ x = x + y;System.out.println("La classe

interne a bien accédé aux membres de la

classe extérieure.n x = " + x + "ny = " + y + "nz = " + z); }else System.out.println("Erreur

!"); }


ClasseExterne obj_out = new ClasseExterne();

obj_out.addition(); }} }



Seules les variables locales et les paramètres de la méthode d'inclusion, déclarées avec le modificateur final, peuvent être exploitées par les classes internes locales, sinon une erreur se produit lors de la compilation. De plus, ces variables doivent être impérativement assignées avant leur emploi dans la classe locale.

class ClasseExterne {int x = 10; int y = 12;// Paramètre constant utilisable par la classe localeClasseExterne(final int p){

// Constante utilisable par la classe localefinal int a = 20;// Variable inutilisable par la classe localeint b = 44;class ClasseLocale {boolean verification(){if(x + y == a + p)

return true;else

return false;}}


ClasseLocaleClasseLocale obj_inobj_in = new = new ClasseLocaleClasseLocale();();if (if (obj_in.verificationobj_in.verification()){()){

x = x + y;x = x + y;System.out.printlnSystem.out.println("La classe interne a ("La classe interne a

bien bien accaccééddéé aux membres de la classe aux membres de la classe extextéérieure. rieure. nxnx = " + x + "= " + x + "nyny = " + y + = " + y +

"na = " "na = " + a);+ a);}}elseelse

System.out.printlnSystem.out.println("Erreur !");("Erreur !");}}

public public staticstatic voidvoid main(String[] main(String[] argsargs){){ClasseExterneClasseExterne obj_outobj_out = new = new

ClasseExterneClasseExterne(2);(2);}}}}



Lorsqu'une classe locale est déclarée dans une méthode statique, alors les variables d'instances de la classe externe ne sont plus accessibles pour la classe imbriquée.

Seules, les variables statiques de la classe externe peuvent être exploitées par la classe localisée dans la méthode statique.



Classe interne locale (local inner-classes):class ClasseExterne {

static int x = 10;static int y = 12;static int z = x + y;

static void addition(){class ClasseLocale {

boolean verification(){ if(x + y == z)

return true;else

return false;}}

ClasseLocale obj_in = new ClasseLocale();


if (if (obj_in.verificationobj_in.verification())()){ x = x + y;{ x = x + y;

System.out.printlnSystem.out.println("La classe interne("La classe interneaccedeaccede aux membres statiques de aux membres statiques de

lalaclasse");}classe");}

elseelseSystem.out.printlnSystem.out.println("Erreur !"); ("Erreur !");

}}

public public staticstatic voidvoid main (String[] main (String[] argsargs)){ addition(); } { addition(); }

}}


Classe interne statique (static member innerclasses):

Ce sont des classes internes qui ne possèdent pas de référence vers leur classe principale.

Elles ne peuvent pas accéder aux membres d’instance de la classe englobant mais peuvent accéder au membre statique.

Pour les déclarer on utilise le modificateur static dans la déclaration de la classe.

Elles sont interprétée par le compilateur comme étant une classe à part entière.



class ClasseParente {static int x = 10; static int y = 12;// La classe interne statique ne peut accèder à cette variableint z = x + y;static int addition() { return (x + y); }// La classe interne statique ne peut accèder à cette méthodeint resultat() { return (z); }static class ClasseInterne{ClasseInterne(){

if((x + y)== addition())System.out.println("La classe interne a bien accédé aux membres

statiques de sa classe parente.");}

}public static void main(String[] args){ new ClasseInterne(); }

}



Classe interne statique (static member innerclasses):

Il n'est pas nécessaire de créer une instance de la classe parente pour pouvoir instancier la classe intérieure statique contrairement aux classes internes simples.

Le mot-clé this n'est pas utilisable dans le contexte des classes internes statiques, celles-ci n'ont pas accès aux variables et méthodes non-statiques de leur classe d'inclusion.

Les méthodes d'une classe interne statique peuvent être accédées dans la classe parente de la même façon que les classes internes simples, c'est-à-dire, suite à l'instanciation de leur propre classe.



Classe anonyme (anonymous classes):Elles sont déclarées immédiatement après l'expression d'instanciation

d'une classe, permettant directement d'étendre ou d'implémenter respectivement la classe ou l'interface instanciée.

La déclaration d'une classe anonyme doit être toujours suivie d'un point virgule immédiatement après son accolade fermante.

Les classes anonymes obéissent aux mêmes restrictions que les classes locales et de plus, ne peuvent ni être abstraites (abstract) ni être statiques (static).Par contre, elles portent toujours implicitement le modificateur final.

En fait, aucun modificateur n'est permis dans une déclaration de classe anonyme



class ClasseExterne {static int x = 10; static int y = 12;public static void main(String[] args){Calcul obj = new Calcul() {

float resultat;public float soustraction(float a, float b) {

resultat = a - b; System.out.println(resultat);return resultat; }

public float multiplication(float a, float b) {resultat = a * b;System.out.println(resultat);return resultat; }

public float division(float a, float b) {if(b != 0){

resultat = a / b;System.out.println(resultat);return resultat;

}else return 0;

} };


obj.additionobj.addition(x, y);(x, y);obj.soustractionobj.soustraction(x, y);(x, y);obj.multiplicationobj.multiplication(x, y);(x, y);obj.divisionobj.division(x, y);(x, y);

}}}}

class Calcul {class Calcul {public public floatfloat addition(addition(floatfloat a, a, floatfloat b) {b) {

return a + b;return a + b;}}public public floatfloat soustraction(soustraction(floatfloat a, a, floatfloat b) {b) {

return a return a -- b;b;}}public public floatfloat multiplication(multiplication(floatfloat a, a, floatfloat b) {b) {

return a * b;return a * b;}}public public floatfloat division(division(floatfloat a, a, floatfloat b) {b) {

return a / b;return a / b;}}

}}


Classe anonyme (anonymous classes):On Pourrat remarquer que le compilateur génèrera un fichier .class de

la classe anonyme sous la forme ClasseEnglobante$1.class.

Une classe anonyme ne peut déclarer explicitement un constructeur, le compilateur Java fournissant automatiquement un constructeur anonyme pour ce genre de classe.

Une classe anonyme ne possède pas d'identificateur et est immédiatement utilisée lors de l'instanciation de la classe ou l'interface concernée.

Dans le cas d'une implémentation, la classe anonyme doit définir chacune des méthodes abstraites de l'interface à instancier, sinon une erreur de compilation se produira.



class ClasseExterne {static int x = 10; static int y = 12;


ICalcul obj = new ICalcul() {public float addition() { return (x + y); }public float soustraction() { return (x - y); }public float multiplication() { return x * y; }public float division() {

if(y != 0) return x / y; else return 0;

}};


obj.addition();obj.soustraction();obj.multiplication();obj.division();

}}

interface ICalcul {float addition();float soustraction();float multiplication();float division();

}

Classes de base


Un objet de type Vector est un tableau à taille variable (pas de limite de taille sauf la mémoire)Un Vector est un tableau dont les éléments dont des objetsIncluse dans bibliothèque java.util.*

Classe Classe VectorVector


Quelques méthodes :Constructeurs : ex. Vector v=new Vector()void addElement(Object obj) : ajout de obj à la finvoid insertElementAt(Object obj, int i) : insertion de obj à la position ivoid removeElementAt(int i) : suppression de l'élémént à la position ivoid removeAllElements() : suppression de tous les élémentsObject elementAT(int i) : retourne (sans le supprimer) l'élément à la position i



Quelques méthodes :void setElementAt(Object obj,int i) : place l'objet à la position i( en remplaçant l'ancien objetboolean contains(Object obj) : retourne true si obj est dans le tableauint indexOf(Object obj) : retourne la position de obj (-1 si obj n'est pas présente)int size() : retourne la taille du vecteur



Exemple d'utilisation


class test{public static void main (String[] args){

Carre c1=new Carre(5);Carre c2=new Carre(10);Vector v=new Vector();v.addElement(c1);v.addElement(c2);for(int i=0; i<v.size(); i++){

int a=( (Carre)v.elementAt(i)).getCote().

System.out.println(a);}

}

public class carre{

private Int cote;

public cote(int c){

cote=c

}

public int getCote(){

return cote;

}

}


La classe StringTokenizer permet de construire des objets qui savent découper des chaînes de caractères en sous chaînesLors de la création d'un objet de cette classe, il faut préciser :

La chaîne à découper etLes caractères qui doivent être utilisés pour découper la chaîne

Ex : StringTokenizer st=new StringTokenizer("Voici la liste : voiture, moto, camion.",", :.")

Classe Classe StringTokenizerStringTokenizer


Quelques méthodesBoolean hasMoreTokens() : retourne trues'il y a encore des mots à traiter sinon falseString nextToken() : retourne la prochaine sous chaîne dans la chaîne à découper.




Class test(){static void afficheMots(String s){

StringTokenizer st=new StringTokenizer(s, " ,:.")while(st.hasMoreTokens()){

System.out.println(st.nextToken());}

}}

Tets.afficheMots("Voici la liste : voiture, moto, camion.")Voici

la

liste

voiture

moto

camion

Chapitre 5 :La gestion des exceptions


Une exception est un événement (une erreur) qui se produit lors de l'exécution d'un programme, et qui va provoquer un fonctionnement anormal (par exemple l'arrêt du programme) de ce dernier.

Soit le programme suivant :1 public class Div1 {2 public static int divint (int x, int y) {3 return (x/y);4 }5 public static void main (String [] args) {6 int c=0,a=1,b=0;7 c= divint(a,b);8 System.out.println("res: " + c);9 System.exit(0); } }

Le système affiche l'erreur suivante:Exception in thread "main" java.lang.ArithmeticException: / by zeroat Div.divint(Div.java:3)at Div.main(Div.java:7)

CC’’est quoi une exceptionest quoi une exception


La gestion des exceptions se substitue en quelque sorte à l'algorithmique permettant la gestion des erreurs. Dans l'exemple précédent, si nous avons voulu anticiper sur la gestion de l'erreur, il fallait prévoir un traitement adéquat pour contrer la division par zéro:

if (y!=0)return(x/y);

else// traitement de l'erreur.

Le traitement de l'erreur pourrait consister à retourner une valeur: -1 pour une division par zéro, -2 pour un index qui déborde etc. Ce traitement devient fastidieux à la longue !

traitement Aif (!traitement_A) méthodes de correctionelse

traitement_Bif (!traitement_B) méthodes de correctionelse

etc.

Gestion des exceptionsGestion des exceptions


Le langage Java offre un mécanisme très souple pour la gestion des erreurs. Ce mécanisme permet d'isoler d'une part la partie du code générant l'erreur du reste du programme, et d'autre part de dissocier les opérations de détection et de traitement de cette erreur.

Par ailleurs, le langage Java utilise des objets pour représenter les erreurs (exceptions) et l'héritage pour hiérarchiser les différents types d'exception.

La gestion des erreurs consiste donc A définir le bloc pouvant provoquer l'erreur (le bloc try), ainsi ce bloc devient isolé du reste du programme ; A lancer (throw) ou attraper (catch) les "objets" représentant les exceptions générées.

public class Div2 {public static int divint (int x, int y) { return (x/y); }public static void main (String [] args) {

int c=0,a=1,b=0;try { c= divint(a,b); }catch (ArithmeticException e) { System.out.println("Erreur capturée"); }System.out.println("res: " + c);System.exit(0);}}

Gestion des exceptionsGestion des exceptions


Il existe deux types d’exception :Exceptions contrôléeException non contrôlée

Une exception non contrôlée se subdivise en deux catégories Error et RuntimeException. Elles ne nécessitent pas d’être capturée.

Une exception contrôlée est une exception qui doit être capturée par le programme. Les exceptions créées par le programmeur doivent être contrôlées sinon une erreur de compilation sera signalée.

HiHiéérarchie des exceptionsrarchie des exceptions



Object

Error Exception

LinkageError

ThreadDeath

VirtualMachineError

IllegalAccessException

Throwable

IOEcxeption

NoSuchMethodExceptionRuntimeException

NumberFormatException

IndexOutOfBoundsException

NullPointerException

ArithmeticException


Lorsqu'une exception est levée dans une méthode donnée, les instructions qui suivent le lancement de l'exception, se trouvant dans cette méthode, sont ignorées (voir exemple en cours)

L'exception peut-être attrapée par un bloc catch (s'il existe un try) se trouvant dans cette méthode.

Si l'exception n'a pas été capturée, le traitement de cette exception remonte vers la méthode appelante, jusqu'à être attrapée ou bien on est arrivé à la fin du programme (ici nous nous trouvons au niveau de la méthode main).

MMéécanisme de traitement des exceptionscanisme de traitement des exceptions


1. Une exception est levée

En dehors d'un bloc try :Dans ce cas, on remonte immédiatement dans la méthode appelante pour lui donner la possibilité de traiter cette exception.

Si elle ne peut pas, il y a arrêt du programme.



dans un bloc try :

Un bloc try est défini et contient quelques instructions qui risqueraient de lever une ou plusieurs exceptions.try {c= divint(a,b);System.out.println ("la suite du programme!");}

Si une instruction donnée de ce bloc try (par exemple c=divint(a,b)) ne génère pas une exception, le programme passe au traitement de l'instruction suivante dans ce bloc.



Par contre, si une des instructions du bloc tryprovoque une exception (par exemple: c=divint(a,b)), les instructions suivantes du bloc tryne seront pas exécutées.

Dans le précédent exemple : System.out.println …. ne sera pas exécutée. On sort complètement du bloc try ; et la main sera donnée à un bloc catch …

Dans une méthode, si nécessaire, il peut y avoir plusieurs bloc try.



2. Capturons l’exception

Un bloc catch sert à capturer un type d'exception donné, par exemple ArithmeticException, etc. et de réaliser des opérations comme:

corriger l'erreur qui a provoqué l'exception, proposer un traitement alternatif, retourner une valeur particulière, sortir de l'application, relancer la même exception, faire qu'une partie du traitement et la méthode appelante fera le reste etc.

Un bloc catch, s'il existe dans un programme, il suit immédiatement un bloc try (donc contigu au bloc try).



Dans le cas où il n'y pas eu d'exception levée par aucune des instructions du bloc try, l'exécution du programme se poursuit après le dernier bloc catch. Comme si aucun bloc catch n'a été défini dans le programme.

Par contre, si une exception est levée, deux cas se présentent:

1er cas :S'il existe un bloc catch qui peut capturer cette exception, il sera exécuté en premier, puis le programme poursuit après le dernier bloc catch.



public class Div3 {

public static void main (String [] args) {

int c=0,a=1,b=0;try{ c= a/b }catch (ArithmeticException e) { System.out.println("Erreur a été

capturée"); }

System.out.println("res: " + c);}

}



2ème cas :Si aucun bloc catch ne peut capturer cette exception, la main est donnée à la méthode appelante. À elle de voir si elle peut traiter cette exception, sinon on remonte de méthode en méthode à la recherche d'un bloc catch adéquat, jusqu'à terminer le programme (donc niveau main).



public class Div3 {

public static int divint (int x, int y) {return (x/y);

}public static void main (String [] args) {

int c=0,a=1,b=0;try{ c= divint(a,b); }catch (ArithmeticException e) { System.out.println("Erreur a été capturée"); }


}



3 … mais peut-on la lever?Si on est sûr qu'une une opération illégale risquerait d'avoir lieu, nous pouvons nous même lever l'exception. Pour le faire, nous utilisons le mot clé throw mais il faudra faire attention aux points suivants:

Les exceptions sont représentées en quelque sorte par des "objets", instanciés donc à partir de classes ; de ce fait, chaque exception fait référence à une classe. Pour lever une exception, nous devons créer une instance de la classe où réside cette exception.




Object

Error Exception

LinkageError

ThreadDeath

VirtualMachineError


Throwable

IOEcxeption





ArithmeticException


public class Div3 {

public static void main (String [] args) {

int c=0,a=1,b=0;try{if (y==0) throw new ArithmeticException();c= a/b

}catch (ArithmeticException e) { System.out.println("Erreur a été capturée"); }


}



public class Div3 {

public static int divint (int x, int y) {if (y==0) throw new ArithmeticException();return (x/y);


int c=0,a=1,b=0;try{ c= divint(a,b); }catch (ArithmeticException e) { System.out.println("Erreur a été capturée"); }


}

Req : les exceptions de type RuntimeException sont propagées automatiquement



Si nous avons affaire à une méthode susceptible de lever une exception qu'elle ne traite pas localement, cette méthode doit mentionner son type dans son en-tête en utilisant pour cela, le mot réservé throws. Soit l'exception est traitée localement, soit elle est propagée par throws.

public class Div3 {

public int divint (int x, int y) throws IllegalAccessException{ if (y==0) throw new IllegalAccessException();

return (x/y);}public int carré(int x, int y) throws IllegalAccessException{ return divint(x,y)*divint(x,y); }

public static void main (String [] args) { int c=0,a=1,b=0;

try { c= divint(a,b); }catch (IllegalAccessException e) {System.out.println("Erreur capturée");}System.out.println("res: " + c);

}}



Si on veut pouvoir signaler un événement exceptionnel d’un type non prévue par java, il faut étendre la classe java.lang.Exception.

Les méthodes utiles de la classe Exception sont :

Exception() : constructeur sans argument, construit une exception.

Exception(String s) : Construit une exception avec le message s qui sera stocké dans l’exception créée.

String getMessage() : (méthode hérité de la classe throwable), renvoie le message stocké dans une exception.

Définir sa propre exception


class MaArithmeticException extends Exception{

MaArithmeticException(String s){

super(s);}MaArithmeticException(){}public String toString(){

return "Mon erreur MaArithmeticException";}

}

Définir sa propre exception


class Factorielle{

public int calcul(int x){

if(x==0) return 1;else return x*calcul(x-1);

}public static void main(String[] args){

Factorielle f=new Factorielle();System.out.println(f.calcul(-5));

}}

Exemple : factorielle

Mais, pourquoi ça plante …!!!

La solution est simple, tu t’es trompé : tu as tapé -5 au lieu de 5. Fais attention la prochaine fois !!!



Que faire ?Si je me trompe

encore une fois ?

Quelqu’un peut-il m’aider?


class EntierNegatifException extends Exception{

EntierNegatifException(){}public String toString(){

return "Mon exception : entier < 0";}

}class EntierGrandException extends Exception{

EntierGrandException(String s){

super(s);}

}


Simple ! Mais tu n'as pas vu les exceptions ???


C’est tout???C’est facile alors !!!


Non !!!!Il manque une

dernière étape???


class Factorielle{

public int calcul(int x) throws EntierNegatifException, EntierGrandException{

if(x<0) throw new EntierNegatifException();

else if (x>27) throw new EntierGrandException("Mon exception entier > 27");

else if(x==0) return 1;else return x*calcul(x-1);

}public static void main(String[] args){

Factorielle f=new Factorielle();try {System.out.println(f.calcul(88));}catch (EntierGrandException e) {System.out.println(e.getMessage());}catch (EntierNegatifException e){System.out.println(e);}

}}



public class Div3 {



int c=0,a=1,b=0;try{ c= divint(a,b); }

catch (Exception e){System.out.println("1ère exception captuerèe");

}catch (ArithmeticException e)

{ System.out.println("Cette exception ne sera jamais capturée"); }


}

Erreur de compilation affichée par java : Catch is never unreachable

Ordre des catchOrdre des catch

Capturer les exceptions dans l'ordre suivant de la classe fille à la classe mère



Object

Error Exception

LinkageError

ThreadDeath

VirtualMachineError


Throwable

IOEcxeption





ArithmeticException


public class Div3 {



int c=0,a=1,b=0;try{ c= divint(a,b); }

catch (ArithmeticException e) { System.out.println("Cette exception peut être capturée"); }

catch (Exception e){System.out.println("Aère exception capturèe");

}


}



On peut avoir un bloc d’instructions commençant avec le mot clé finally :

Soit après un bloc try.Soit après un bloc try suivit d’un bloc catch.

Les instructions du bloc finally sont exécutées :Dans le premier cas après la sortie du bloc try.Dans le second cas après l’exécution du bloc catch.

Il est généralement utilisé pour effectuer des nettoyages tels que la fermeture de fichier…

Le bloc finally


Exemple

Chapitre 6Les Entrées Sorties


Dans la plupart des langages de programmation les notions d'entrées / sorties sont considérées comme une technique de base, car les manipulations de fichiers, notamment, sont très fréquentes.

En Java, et pour des raisons de sécurité, on distingue deux cas :

le cas des applications Java autonomes, où, comme dans n'importe quel autre langage, on distingue un usage important de fichiers,

le cas des applets Java qui, ne peuvent pas, en principe, accéder, tant en écriture qu'en lecture, aux fichiers de la machine sur laquelle s'exécute le navigateur (machine cliente).

Les E/S Généralités


Les E / S sont gérées de façon portable (selon les OS) grâce à la notion de flux (stream en anglais).

Un flux est en quelque sorte un canal dans lequel de l'information transite. L'ordre dans lequel l’information y est transmise est respecté.

Un flux peut être :Soit une source d’octets à partir de laquelle il est possible de lire de l'information. On parle de flux d'entrée.Soit une destination d’octets dans laquelle il est possible d'écrire de l'information. On parle de flux de sortie.

Certains flux de données peuvent être associés à des ressources qui fournissent ou reçoivent des données comme :

les fichiers,les tableaux de données en mémoire, les lignes de communication (connexion réseau).

Notion de Flux


L'intérêt de la notion de flux est qu'elle permet une gestion homogène :

quelle que soit la ressource associée au flux de données,quel que soit le flux (entrée ou sortie).

Certains flux peuvent être associés à des filtresCombinés à des flux d’entrée ou de sortie, ils permettent de traduire les données.

Les flux sont regroupés dans le paquetage java.io

Il existe de nombreuses classes représentant les flux

il n'est pas toujours aisé de se repérer.

Notion de Flux


Il existe des flux de bas niveau et des flux de plus haut niveau (travaillant sur des données plus évoluées que les simples octets) :

Les flux d’octetsclasses abstraites InputStream et OutputStream et leurs sous-classes concrètes respectives.

Les flux de caractèresclasses abstraites Reader et Writer et leurs sous-classes concrètes respectives.

Flux Octets et Flux Caractères


Exemples

Mme Tout ca est Mme Tout ca est bien!!!bien!!!

mais comment vaismais comment vais--je lire un caractje lire un caractèère re

que je viens dque je viens d’é’écrire crire au clavier ???au clavier ???


La plupart des plateformes ont une notion classique d’entrée, de sortie standard et de sortie d’erreur standard.

En effet, un clavier, un fichier, ou la sortie d’un autre programme peuvent représenter l’entrée standard.

Une fenêtre, une imprimante, un fichier ou l’entrée d’un autre programme peuvent constituer la sortie standard.

La sortie d’erreurs standard sert pour afficher les messages d’erreurs à l’utilisateur.

Exemples


First : System : La classe System possède les variables statiques in, out et err qui sont connectées aux trois flots du système avant que le programme commence son exécution

PrintStream out

InputStream in

PrintStream err

Exemples

Flot standard de sortie

Flot standard d’entrée

Flot standard de sortie d’erreur


Second : utiliser l’entrée standard

Exemples

b=System.in.read() ;

try{

}catch(IOException e){System.out.println(‘’erreur E/S’’);}

int b=0;

System.out.println(“Donnée lue :”+(char)b);

public char lectureChar(){

return (char)b;}


2ème possibilité

Exemples

InputStreamReader isr=new InputStreamReader(System.in);b=(char)isr.read();

try{


char b=‘0’;

System.out.println(“Donnée lue :”+b);

public char lectureChar(){

return b;}


Cette classe abstraite InputStream représente la super classe de toutes les classes d’entré de flux d’octet.

Parmi ces méthodes on site :

public abstract int read() throws IOException : cette méthode lit un octet sur le flux spécifié et retourne cette valeur sous la forme d’un entier.public void close() throws IOException : cette méthode referme le flux d’entrée et libère les ressources système.

…

La classe abstraite Reader joue le même rôle que la classe InputStream, mais elle agit sur les caractères.

La classe InputStream / Reader


Exemple

Je crois que je commence a comprendre mais !!!

Mais si c’est une chaîne de caractère je fais quoi???


J’aurais besoin de quelque chose qui me permet de stocker les valeurs (BufferedReader) que je vais entrer au clavier (System.in).

c’est ce qu’on appelle un buffer.

Il existe en java des classes prédéfinies qui me permettent de gérer ca : InputStreamReader, BufferedReader.

Exemple


Exemple


Exemples

InputStreamReader isr = new InputStreamReader(System.in);BufferedReader br=new BufferedReader(isr);res=br.readLine();

try{


String res=null;

System.out.println(“Donnée lue :”+res);

public String lectureChaine(){

return res;}


Exemples

Et maintenant pour voir si vous avez

compris.

Comment je fais pour lire un entier.


Exemples

InputStreamReader isr = new InputStreamReader(System.in);BufferedReader br=new BufferedReader(isr);res=Integer.parseInt (br.readLine());

try{

}catch(NumberFormatException e){}catch(IOException e){}

int res=0;

public int lectureEntier(){

return res;}


La classe abstraite OutputStream représente la super classe de toutes les classes de sortie de flux d’octet.

Parmi ces méthodes on site :

public abstract void write(int b) throws IOException : cette méthode écrit un octet sur le flux de sortie. L’octet a écrire est passé en paramètre a la méthode. Cette méthode est bloquante jusqu’à la réalisation de l’écriture.

public void close() throws IOException : cette méthode referme le flux de sortie et libère les ressources système relative a ce flux.

…

La classe abstraite Writer joue le même rôle que la classe outputStream, mais elle agit sur les caractères.

La classe OutputStream / Writer


Exemples de méthodes pour gérer les fichiers :

Les classes FileInputStream et FileOutputStream :définit respectivement des flux d’octets en lecture et en écriture.

Les classes FileReader et FileWriter : définit respectivement des flux de caractère en lecture et en écriture.

La classe File : qui peut représenter un fichier ou un répertoire. Elle possède un ensemble de méthodes qui permettent d'interroger ou d'agir sur le système de gestion de fichiers du système d'exploitation.

Gestion des Fichiers


Il faut instancier un objet de la classe FileInputStream.

Cette classe offre plusieurs constructeurs qui leventune exception de type FileNotFoundException :

FileInputStream(String nom) : ouvre un flux en lecture sur le fichier dont le nom est donné en paramètre.FileInputStream(File f) : idem mais le fichier est préciséavec un objet de type File.

Cette classe offre aussi plusieurs méthodes :int read() : permet de lire un octet du flux. void close() : ferme le flux et libère les ressources qui lui étaient associé.

Flux d’octet en lecture sur un fichier


public static void main (String[] args){

try{

FileInputStream f=new FileInputStream("e:\\test\\a.txt");int octet=0;while(octet!=-1){

octet=f.read();System.out.print((char)octet);

}f.close();

}catch(FileNotFoundException e){ System.out.print("fichier introuvable");}catch(IOException e){}

}

Flux d’octet en lecture sur un fichier


Il faut instancier un objet de la classe FileOutputStream.

Cette classe offre plusieurs constructeurs:FileOutputStream(String nom) : si le fichier précisé n’existe pas, il sera créé. Si il existe et qu’il contient des données celles-ci seront écrasées.FileOutputStream(String nom, boolean ajout) : le boolean permet de préciser si les données seront ajoutées au fichier (valeur true) ou écrasent les données existantes (valeur false).

Cette classe offre aussi plusieurs méthodes :void write(int a) : permet d’écrire l’octet en paramètre dans le flux. void close() : permet de fermer le flux et libère les ressources qui lui étaient associé.

Flux d’octet en écriture sur un fichier



try{FileInputStream f=new FileInputStream("e:\\test\\a.txt");FileOutputStream fcopy=new FileOutputStream("e:\\test\\acopy.txt");int octet=0;while(octet!=-1){

octet=f.read();fcopy.write(octet);

}f.close();fcopy.close();

}catch(FileNotFoundException e){System.out.print("errrrrrue");}catch(IOException e){}

}

Flux d’octet en écriture sur un fichier


Il faut instancier un objet de la classe FileReader. Cette classe hérite de la classe InputStreamReader.

Cette classe offre plusieurs constructeurs qui lèvent une exception de type FileNotFoundException :

FileReader(String nom) : ouvre un flux en lecture sur le fichier dont le nom est donné en paramètre.FileReader(File f) : idem mais le fichier est précisé avec un objet de type File.

Cette classe offre aussi plusieurs méthodes :int read() : permet de lire un octet du flux. void close() : ferme le flux et libère les ressources qui lui étaient associé.

Flux de caractères en lecture sur un fichier



try{

FileReader f=new FileReader("e:\\test\\a.txt");int octet=0;while(octet!=-1){

octet=f.read();System.out.print((char)octet);

}f.close();


}

Flux de caractère en lecture sur un fichier


Il faut instancier un objet de la classe Filewriter.

Cette classe offre plusieurs constructeurs:FileWriter(String nom) : si le fichier précisé n’existe pas, il sera créé. Si il existe et qu’il contient des données celles-ci seront écrasées.FileWriter(String nom, boolean ajout) : le boolean permet de préciser si les données seront ajoutées au fichier (valeur true) ou écrasent les données existantes (valeur false).

Cette classe offre aussi plusieurs méthodes :void write(int a) : permet d’écrire l’octet en paramètre dans le flux. void close() : permet de fermer le flux et libère les ressources qui lui étaient associé.

Flux de caractère en écriture sur un fichier



try{

FileReader f=new FileReader("e:\\test\\a.txt");FileWriter fcopy=new FileWriter("e:\\test\\acopy.txt",true);int octet=0;while(octet!=-1){

octet=f.read();fcopy.write(octet);

}f.close();fcopy.close();


}

Flux de caractère en écriture sur un fichier


Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites permet de traiter un ensemble de caractères représentant une ligne plutôt que de traiter les données caractères par caractères. Le nombre d’opération est alors réduit.

Il faut instancier un objet de la classe BufferedReader ou BufferedWriter.

Ces classes offre plusieurs constructeurs:BufferedReader(Reader a) : a correspond au flux a lire.BufferedReader(Reader a, int taille) : taille correspond a la taille du buffer.BufferedWriter(writer a) : a correspond au flux dans lequel les données sont écrites.BufferedWriter(writer a, int taille) : taille correspond a la taille du buffer.

La classe BufferedReader offre aussi plusieurs méthodes :String readLine() : permet de lire une ligne de caractère dans le flux (\r, \n).

La classe BufferedWriter offre aussi plusieurs méthodes :void newLine() : écrit un séparateur de ligne dans le flux.void write(String ligne) : écrit une ligne dans le buffer.

Flux de caractère tamponnés avec un fichier


Exemple


public void lecture (String source){

try{

FileReader f=new FileReader(source);BufferedReader br=new BufferedReader(f);String ligne;while((ligne=br.readLine())!=null){

System.out.println(ligne);}br.close();

}catch(FileNotFoundException e){System.out.print("errrrrreur");}catch(IOException e){}

}

Exemple


public void copy (String source, String destination){

try{

FileReader f=new FileReader(source);BufferedReader br=new BufferedReader(f);FileWriter fcopy=new FileWriter(destination);BufferedWriter bw=new BufferedWriter(fcopy);String ligne;while((ligne=br.readLine())!=null){

bw.write(ligne);bw.newLine();

}br.close();bw.close();

}catch(FileNotFoundException e){System.out.print("errrrrreur");}catch(IOException e){}

}

Exemple


Voici un aperçu de quelques constructeurs et méthodes de la classe File :File (String name)File (String path, String name)File (File dir, String name)

boolean isFile( ) : teste si le File courant est un fichier.boolean isDirectory( ) : teste si le File courant est un répertoire.boolean mkdir( ) : créer le répertoire présent dans le File.boolean mkdirs( ) : créer le répertoire présent dans le File et toutes l’arborescence si elle n’existe pas.boolean exists( ) : teste l’existence du File.boolean delete( ) : supprime le File courant.boolean canWrite( ) : Teste la possibilité d’écriture sur le File.boolean canRead( ) : teste la possibilité de lecture sur le File.File getParentFile( ) : retourne le chemin du File parent, or null s’il n’y on a pas.long lastModified( ) : retourne le temps de la dernière modification du fichier.String[] list() : retourne un tableau de String représentant les noms des répertoires et fichiers present dans le File courant.File[] listFiles() : retourne un tableau de File représentant les Files présent dans le File courant.

La classe File



try{

File fs= new File("e:\\test\\a.txt");BufferedReader br=new BufferedReader(new FileReader(fs));File fd= new File("e:\\test\\acopy.txt");BufferedWriter bw=new BufferedWriter(new FileWriter(fd));String ligne;while((ligne=br.readLine())!=null){

bw.write(ligne); bw.newLine();}br.close(); bw.close();


}

Exemple


Exemples

EstEst--ce que lce que l’’utilitutilitééde la classe File de la classe File

ss’’arrête arrête àà ce stade?ce stade?

Alors cAlors c’’est pareil est pareil ààce qui prce qui prééccèède.de.


Exemples

C’est une très bonne question.

La réponse est non son utilitédépasse ce cadre d’utilisation


Exemple : simulation de la commende dir

public void dir(File rep){

String[] names=rep.list();for(int i=0; i<names.length;i++){

File interim=new File(rep.getPath()+"\\"+names[i]);if (interim.isFile())

System.out.println(names[i]);else

System.out.println("repertoire =>"+names[i]);}

}

On teste si le nom correspond a un fichier ou un répertoire.

Je récupère la liste des fichiers est répertoire dans le tableau names.

La méthode dir prend comme paramètrele répertoire a parcourir.

On fait l’affichage adéquat


Exemples

Et maintenant pour voir si vous avais compris???

1. Ecrire une méthode qui permet de dupliquer une arborescence.

2. Ecrire une méthode qui permet de tester si un fichier existe dans un répertoire ou non.

3. Ecrire une méthode qui retourne le nombre d’occurrence d’un fichier dans une arborescence.


Hiérarchie des flux d'octets en entrée


Hiérarchie des flux d'octets en sortie

Java Data Base Connectivity (JDBC)

Chapitre 7


Besoin d’accès a une base de donnée à partir d’une application JAVA.Fournir un accès homogène aux SGBDR.Abstraction des SGBDR cibles.Support du langage SQL.Simple à mettre en œuvre.

Introduction


Java DataBase Connectivity (Core API 1.1)

API Java adaptée à la connexion avec les bases de données relationnelles (SGBDR).

Fournit un ensemble de classes et d’interfaces permettant l’utilisation sur le réseau d’un ou plusieurs SGBDR à partir d’un programme Java.

Indépendance vis-à-vis des fournisseurs.

Qu’est ce que JDBC ?


Est fournie par le package java(x).sqlPermet de formuler et gérer les requêtes aux bases de données relationnelles.

supporte le standard « SQL »

Contient les Classes/interfaces définissant les objets nécessaires :

à la connexion à une base de donnéeet à la création et exécution de requêtes SQL et récupération du résultat.

L’API JDBC


Chargement du driver de la BD.

Connexion à la base de données.

Exécution des commandes SQL.

Inspection des résultats (si disponible).

Interaction avec une BD

DriverManager

Connection

Statement

ResultSet

charge et configure le driver de la base

de données.

réalise la connexion et l'authentification àla base de données.

contient la requèteSQL et la transmet àla base de données.

permet de parcourir les informations retournées par la base de données dans le

cas d'une sélection de données


Il existe quatre types de drivers JDBC:

1. JDBC-ODBC bridge driver : c’est un pont entre JDBC et ODBC. ODBC (Open Data Base Connectivity) est une API de Windows permettant d'accéder à diverses bases de données .

2. Native-API partly-Java driver : fait appel à des fonctions natives (non Java) de l ’API du SGBDR qui sont souvent fournis par le constructeur.

3. JDBC-Net all-Java driver : interagit avec une API réseau générique et communique avec une application intermédiaire (middleware) sur le serveur. Le middleware accède par un moyen quelconque aux différents SGBDR. Il est portable car entièrement écrit en Java.

4. Native-protocol all-Java driver : utilise le protocole réseau du SGBDR. Interagit avec la base de données via des sockets généralement fourni par l’éditeur.

Chargement du driver de la BD


JDBC-ODBC bridge driver


Application javaDriver JDBCDriver ODBC

SGBD

Les méthodes du driver JDBC font appel à des fonctions en langage C d'un driver ODBC.


Native-API partly-Java driver


Application javaPartie JAVAPartie Native

SGBD

Driver

Protocole du SGBDR

Les méthodes du driver JDBC font appel à des fonctions d'une bibliothèque écrite dans un autre langage que Java, qui accèdent au SGBD


JDBC-Net all-Java driver


Application javaDriver en JAVA

Serveur middleware

SGBD

Protocole du middleware

Les méthodes du driver JDBC se connectent par socket au serveur middleware et lui envoient les requêtes SQL ; le serveur middleware les traitent en se connectant au SGBD


Native-protocol all-Java driver


Application javaDriver en JAVA

SGBD

Protocole réseau du SGBD

Les méthodes du driver JDBC utilisent des sockets pour dialoguer avec le SGBD selon son protocole réseau


Pour se connecter à une base de données via ODBC, il faut tout d'abord charger le pilote JDBC-ODBC qui fait le lien entre les deux.

Utiliser la méthode forName de la classe Class :Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Pour se connecter à une base en utilisant un driver spécifique, la documentation du driver fournit le nom de la classe à utiliser. Ex

Class.forName("oracle.jdbc.driver.OracleDriver");

Travailler avec JDBC

1. Chargement du driver


Ce traitement charge le pilote et crée une instance de cette classe.

La méthode static forName() de la classe Class peut lever l'exception java.lang.ClassNotFoundException.


1. Chargement du driver


Pour se connecter à une base de données, il faut instancier un objet de la classe Connection en lui précisant sous forme d'URL la base à accéder.

La syntaxe de l’URL peut varier d'un type de base de données à l'autres mais elle est toujours de la forme :

protocole : sous_protocole : nomprotocole désigne le protocole est vaut toujours « jdbc ».sous_protocole désigne le sous protocole qui définit le mécanisme de connection pour un type de bases de données. Ex : « odbc ».nom désigne le nom de la base de données et doit être celui saisie dans le nom de la source sous ODBC.


2. Etablissement de la connexion


Exemple :String dbURL=‘‘ jdbc : odbc : test ’’

Connection con = DriverManager.getConnection(dbURL);

La méthode getConnection peut lever une exception de la classe java.sql.SQLException.

Si la base a laquelle on va ce connecté nécessite un login et un mot de passe alors :Connection con = DriverManager.getConnection(dbURL, "Login", "Pwd");




String dbURL=‘‘ jdbc : odbc : test ’’



Mais que représente test ?

Le nom de la base ou quoi?


L’accès à la BD se fait a travers un objet Statement que l’on obtient depuis l’objet Connexion.

Statement stmt = con.createStatement();

Cet objet Statement sert d’intermédiaire pour passer les requêtes SQL à la BD.

Comment vais-je exécuter la requête alors ?


3. Accéder à la base de données


Ca dépond du type de requête qu’on a :

executeQuery : pour les requêtes de sélection (SELECT).

executeUpdate : pour les requêtes INSERT, UPDATE, DELETE, CREATE TABLE et DROP TABLE. Requête de mise à jour dans le cas générale.

execute : pour quelques cas rares (exécution de procédures stockées)




Ex : requête de sélectionString req = "SELECT * FROM personne" ;ResultSet rs = stmt.executeQuery ( req ) ;

Le résultat d’une requête de sélection est un ensemble de ligne stocker dans un objet ResultSet.

Ex : requête de mise à jourString req = "INSERT INTO personne VALUES (3,‘ali',‘salah')";int nbMaj = stmt.executeUpdate ( req ) ;

Le résultat d’une requête de mise à jour est un entier représentant le nombre de mise à jour effectuer.




La méthode executeQuery est susceptible de générer une exception du type SQLException :

Si la requête SQL est fausse.Si la requête SQL passer comme paramètre ne correspond pas a une requête de sélection.

La méthode executeUpdate est susceptible de générer une exception du type SQLException :

Si la requête SQL est fausse.Ne correspond pas à une requête de mise à jour.

Si executeUpdate retourne 0 alors :La requête n’a affecter aucune ligne.

Ou La requête est une requête DDL.




L’instruction :

ResultSet rs = stmt.executeQuery ( req )

Dans le cas d’une requête de sélection le résultat est stockédans un ResultSet.

Un ResultSet représente une abstraction d'une table qui se compose de plusieurs enregistrements constitués de colonnes qui contiennent les données.

Reste alors le parcours de ce ResultSet ?


4. Inspection du résultat


Les principales méthodes de la classe ResultSet sont :

getInt(int) / getInt(String) : retourne le contenu de la colonne dont le numéro / nom est passé en paramètre sous forme d'entier.

getFloat(int) / getFloat(String) : retourne le contenu de la colonne dont le numéro / nom est passé en paramètre sous forme de nombre flottant.

getDate(int) / getDate(String) : retourne le contenu de la colonne dont le numéro / nom est passé en paramètre sous forme de date.

next() : se déplace sur le prochain enregistrement : retourne false si la fin est atteinte.

Close() : ferme le ResultSet

getMetaData() : retourne un objet ResultSetMetaData associé au ResultSet.




La méthode next() déplace le curseur sur le prochain enregistrement.

Le curseur pointe initialement juste avant le premier enregistrement : il est nécessaire de faire un premier appel à la méthode next() pour ce placer sur le premier enregistrement.

Des appels successifs à next permettent de parcourir l'ensemble des enregistrements.

Elle retourne false lorsqu'il n'y a plus d'enregistrement. Il faut toujours protéger le parcours d'une table dans un bloc de capture d'exception.





4. Inspection du résultat : exemple

Soit la table personne suivante :

Elle est constituée des tuples suivant :


try{

stmt=con.createStatement();String req= "select * from personne" ;rs = stmt.executeQuery (req) ;while(rs.next()){

System.out.print("id = "+ rs.getInt (1) +",\t ");System.out.print("nom = "+ rs.getString (2) +",\t ");System.out.print("prenom = "+ rs.getString (3) +"\n ");

}}catch(SQLException e){e.printStackTrace(); }


4. Inspection du résultat : exemple


Une fois le travail terminer on ferme toutes les connexions ouvertes.

On utilise la méthode close() de la classe :ResultSetStatementConnection

Exemple :try {

rs.close();stmt.close();con.close();

} catch(SQLException e){}


5. fermeture


import java.sql.*;class Test {

public static void main(String[] args) {Connection con=null;Statement stmt=null;ResultSet rs=null;try {

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");}catch(ClassNotFoundException e){System.out.println("impossible de charger le drivers");}try {

String url="jdbc:odbc:test";con=DriverManager.getConnection(url,"","");

}catch(SQLException e){System.out.println("impossible de crèer une connexion");}


Exemple Complet :


try {stmt=con.createStatement();String req="select * from personne";rs=stmt.executeQuery(req);while(rs.next()){

System.out.print("id = "+rs.getInt(1)+",\t ");System.out.print("nom = "+rs.getString(2)+",\t ");System.out.print("prenom = "+rs.getString(3)+"\n ");

}}catch(SQLException e){e.printStackTrace(); }try {

rs.close();stmt.close();con.close();

} catch(SQLException e){} } }


Suite exemple Complet :

Cours JAVA S1_ppt

Documents

Transcript of Cours JAVA S1_ppt