JAVA

Introduction
Java 1.02 Java 1.1 Java 2 (Versions 1.2 à 1.4) :
Micro Edition (J2ME) Standard Edition (J2SE) Entreprise Edition (J2EE) Devient le langage de choix pour les nouvelles applications d’entreprise (Web en particulier ) et les applications mobiles.

Java 5.0 (à partir de 1.5)

Introduction
JRE : Java Runtime Environement. Désigne la machine virtuelle et l'ensemble des outils nécessaires pour exécuter une application Java sur votre machine. JDK : Java Development Kit. Ancien terme désignant le SDK. SDK : Standard Development Kit. Désigne l'ensemble d'outils nécessaires au développeur Java. Celui-ci contient :
une JRE, les bibliothèques de développement, le compilateur IDE :
Eclipse Netbeans JBuilder IntelliJ

Avantages
Robuste et sûr Sécurisé Simple portable

Fonctionnement

(1) Créer votre document source, exemple MonProgramme.java (2) Compilation à l’aide de l’instruction javac, ex : javac MonProgramme.java. - Le compilateur recherche les erreurs et refuse de compiler tant qu’il n’est pas sûr que tout fonctionne correctement. (3) Le compilateur crée un nouveau document, MonProgramme.class, codé en bytecode java. (4) Exécuter le programme en lançant la JVM avec le fichier MonProgramme.class : java MonProgramme (la commande java lance la JVM)

Exemple 1
public class PremierProg { public static void main (String[ ] args) { System.out.println("Bonjour"); } }

Types primitifs
Java est un langage à typage fort Il existe deux sortes de variables : les types primitifs et les références aux objets. Les types primitifs contiennent des valeurs élémentaires (de simples suites de bits), dont les entiers, les booléens et les nombres en virgule flottante Exemple : int nombre

Les types primitifs

n = 10. // ne fonctionnera pas Par contre mettre une petite tasse dans une grande tasse est possible.Les types primitifs int taille = 32 . byte y = x . double d = 456.54 boolean test . ne peut plus être modifiée . // erreur : n est déclaré final. test = true . byte x = 24 . Vous ne pouvez pas mettre une grande valeur dans une petite tasse. int y = x + 43 . char lettre = ‘j’ . Int y = x . int x = 24 . // fonctionne Constantes Ce sont des variables dont la valeur ne peut être affectée qu'une fois Exemple : final int n =5 .

Les types primitifs .

Application 1 .

Application 2 .

print(‘’ n est inférieur ou égal à 2 ‘’) . } else { System.out. } .Les structures de contrôle Si (condition ) alors Actions1 sinon : Action2 syntaxe Java : if (condition) { Actions1 } else { Actions2 } Exemple : int n = 3 .print(‘’ n est supérieur à 2’’) . if ( n > 2 ) { System.out.

out. i<tableau. i++) { System. condition . } int[ ] tableau = new tableau[100] .println(i). i++) { tableau[i] = 5 . for ( int i = 0 . } .Les structures de contrôle Boucle for for (initialisation .length . i<10 . modification) { Actions } Exemple : for ( int i = 0 .

} System. x = x +1 .out.println(‘’Après la boucle’’) .println(‘’Avant la boucle’’) .out.out.out. System. .println(‘’Dans la boucle’’) . while (x < 4 ) { System.Les structures de contrôle while ( condition) { Actions } int x = 1 . System.println(‘’ La valeur de x est : ‘’ + x) .

Classes et Objets .

Classes et Objets .

Classes et Objets Caractéristique d’un attribut Variables « globales » de la classe Accessibles dans toutes les méthodes de la classe .

Classes et Objets Une variable locale est visible seulement à l’intérieur du bloc qui le définit : .

Classes et Objets .

mais ces méthodes peuvent se comporter différemment selon la valeur des variables d’instance(attributs). .Classes et Objets Chaque objet qui est une instance de la classe Voiture possède ses propres valeurs d’attributs Toutes les instances d’une classe donnée ont les mêmes méthodes.

taille = 70.out.taille = 8. Chien monChien3 = new Chien().waf’’). System.aboyer() . } else { } } } public class TestChien { public static void main (String[] args) { Chien monChien1 = new Chien(). monChien3.println(‘’Grr. monChien1. if (taille > 60 ) { } else if (taille >14) { System.aboyer() . monChien2.out. monChien3.println(‘’waf.taille = 35. monChien2. . void aboyer() { System. String nom . Chien monChien2 = new Chien().Grr’’). } } monChien1.aboyer() .out.kai’’). String race .println(‘’kai.Classes et Objets Class Chien { int taille .

Classes et Objets On peut transmettre des valeurs aux méthodes .

} } . t.34) .Classes et Objets Les méthodes peuvent retourner des valeurs.out. } void addition(int x. int y) { int z = x+y . int obtenirValeur( ) { return 12 .addition(12. } Les méthodes peuvent avoir plusieurs paramètres class Test { void go( ) { Test t = new Test() .println("le total est : "+z) . System.

Références Il n’existe pas de variables objet Il n’existe que des références à des objets Chien monChien = new Chien() . .

c=b d=c d = null . Chien c = new Chien() . .Chien b = new Chien() . Chien d = c .

.Références Chien b = new Chien() . Chien c = new Chien() .

Références Chien d = c . .

Références c=b .

Références d=c .

.Références d = null .

. et le nom du constructeur porte le même nom que la classe. Il contient le code qui s’exécute lorsque vous dites new Quand on écrit pas de manière explicite un constructeur. le compilateur se charge de le faire à notre place public class Chien public Chien() { } } il n’y a pas de type de retour.Constructeurs Chien monChien = new Chien() .

println(‘’Le Chien mesure ’’+taille) . taille = tailleChien .out. } } . System. } } public class UtiliserChien { public static void main(String[] args) { Chien c = new Chien(42).out.Constructeurs Le meilleur endroit où placer l’initialisation est le constructeur.println(‘’Construction de l’objet Chien’’) . public Chien( int tailleChien ) { System. Il suffit de créer un constructeur avec arguments : public class Chien int taille .

Constructeurs deux constructeurs. un pour la taille par défaut et un autre avec taille comme argument public class Chien int taille . } } public class UtiliserChien { public static void main(String[] args) { Chien c1 = new Chien(42). //on crée un Chien dont on ne connait pas la } } taille . } public Chien( int tailleChien ) { taille = tailleChien . Chien c2 = new Chien(). public Chien( ) { taille = 27 .

Exercice 1 Définissez une classe Point permettant de manipuler un point du plan. Cette classe contiendra : un constructeur. les méthodes d'accès et de modification des coordonnées. une méthode deplacer qui effectue une translation définie par les arguments une méthode afficher qui affiche les coordonnées d'un point On donnera un exemple d'utilisation avec une méthode main .

et d'un numéro de telephone.Exercice 2 Définissez une classe Individu composée d'un nom. Vous écrirez aussi les méthodes constructeur. affectation et consulation des champs et affichage. . d'une adresse.

double. char.Tableaux Les tableaux sont considérés comme des objets Fournissent des collections ordonnées d’éléments Les éléments d’un tableau peuvent être .Des références sur des objets Création d’un tableau : 1) Déclaration = déterminer le type du tableau 2) Dimensionnement = déterminer la taille du tableau 3) Initialisation = initialiser chaque case du tableau . …) . boolean.Des variables d’un type primitif (int.

■ Dimensionnement Le nombre d’éléments du tableau sera déterminé quand l’objet tableau sera effectivement créé en utilisant le mot clé new La création d’un tableau par new : .Alloue la mémoire en fonction du type de tableau et de la taille .Initialise le contenu du tableau à 0 pour les types simples monTableau = new int[3].Tableaux Déclaration int[ ] monTableau. ou int monTableau[ ]. .

length nous donne la taille du tableau Le premier élément du tableau commence toujours à l’indice 0.Tableaux Initialisation • • • L’accès à un élément d’un tableau s’effectue suivant cette forme : monTableau[varInt].length monTableau. et le dernier élément du tableau correspond à l’indice tailleDuTableau – 1 . // varInt >= 0 et <monTableau.

animaux[2] = new Chien() .Tableaux Exemple Chien[] animaux = new Chien[3] animaux[0] = new Chien() . animaux[1] = new Chien() . .

Les tableaux Multidimensionnels .

Application 3 .

Application 4 .

Exercice 3 .

L’objet “courant” • L’objet « courant » est désigné par le mot clé this Permet de désigner l’objet dans lequel on se trouve Désigne une référence particulière qui est un membre caché • Utilité de l’objet « courant » Rendre explicite l’accès aux propres attributs et méthodes définies dans la classe Passer en paramètre d’une méthode la référence de l’objet courant 70 .

L’objet « courant » : attributs et méthodes

Encapsulation
Les méthodes get et set vous permettent d’accéder à des valeurs de variables d’instance La méthode set permet de prendre la valeur d’un argument et s’en servir pour définir celle d’une variable d’instance. class Chien { int taille ; void setTaille(uneTaille) { taille = uneTaille ; } int getTaille() { return taille ; } }

Encapsulation
protéger les données en les rendant inaccessibles directement aux utilisateurs on utilise ce qu’on appelle les modificateurs d’accés : public et private private taille ; monChien.taille =2 //erreur public class Chien { private taille ; public getTaille() { return taille ; } public setTaille( int uneTaille ) { if (uneTaille > 5) { taille = une Taille ; } else { taille = 5 ; } }
}

Encapsulation

Exercice 4 .

Héritage vous placez le code commun dans une classe En Java. nous disons que la sous-classe étend la superclasse On utilise le mot-clé extends pour indiquer qu’une classe hérite d’une autre .

void traiterPatient() { //faire un bilan de santé } } public class MedecinDeFamille extends Docteur{ boolean faitDesVisites . void donnerConseil() { //donner un simple conseil } } public class Chirurgien extends Docteur { void traiterPatient() { //opérer } void faireUneIncision() { //inciser } } .Héritage public class Docteur { boolean travailALHopital .

. (2) Créer une classe qui représente les états et les comportements communs.Héritage • • • Programme de simulation : lâcher quelques animaux dans un environnement pour voir ce qui se passe liste d’animaux incomplète Et nous voulons que d’autres programmeurs puissent ajouter de nouvelles sortes d’animaux au programme à n’importe quel moment (1) Rechercher les objets qui ont des attributs et des comportements communs.

Héritage .

Héritage Tous les animaux mangent ils de la même manière ? Un Chien fait-il le même bruit qu’un Chat ? manger() et emettreSon() doivent être redéfinies par les sous-classes .

Tigre et Chat aussi .Héritage Loup et Chien présentent des similitudes.

Héritage .

Chat EST UN Felin. donc Baignoire ne peut pas hériter de SalleDeBain. Vous pouvez concevoir les méthodes de votre superclasse de telle sorte qu’elles contiennent des implémentations qui fonctionneront pour toutes les sous-classes. donc Ttriangle peut hériter de Forme . donc Chirurgien peut hériter de docteur . même s’il faut rajouter du code public void vagabonder() { super.vagabonder() . //Ajouter ma propre façon de vagabonder } . c’est faux.Héritage le test EST UN • • • • Triangle EST UNE Forme. Baignoire EST UNE SalleDeBain. donc Chat peut hériter de Felin Chirurgien EST UN Docteur.

imprRapport() .execRapport() . appliquerFrancais() . } void appliquerFrancais() { //traduire } } . puis revenir et faire le travail spécifique à la sous-classe void execRapport() { super.Super Invoquer une méthode de la superclasse class rapport { //la version de la superclasse fait un travail important qui peut être utile aux sous-classes void execRapport() { //préparer le rapport } } void imprRapport() { //impression } class RapportFrancais extends Rapport { //appeler la version de la superclasse.

Exercice 5 .

Exercice 6 .

Polymorphisme le type de la référence peut être la superclasse du type de l’objet réel .

animaux[2] = new Loup().vagabonder(). for (int i=0.length. } . animaux[1] = new Chat()). i<animaux. animaux[4] = new Tigre(). i++ ) { animaux[i]. animaux[3] = new Hippo().Polymorphisme Animal[ ] animaux = new Animal[5] animaux[0] = new Chien() .manger(). animaux[i].

puis il émet un son a.soigner(h).soigner(c). s.Polymorphisme class Soin { public void soigner(Animal a) { //on soigne l’animal. Hippo h = new Hippo(). Chien c = new Chien(). s. } } class ProprietaireDAnimaux { public static void main(String[] args) { Soin s = new Soin(). } } .emettreSon() .

il lui suffit de s’assurer que ses nouveaux sous-types d’Animal étendent la classe Animal.Polymorphisme Le polymorphisme vous permet d’écrire du code qui ne change pas quand vous introduisez de nouveaux types de sous-classes dans le programme La classe Soin peut gérer n’importe quelle sousclasse d’Animal Si quelqu’un d’autre veut tirer parti de la classe Soin . .

Application 5 .

Exercice 7 .

Classes abstraites .

. Il nous faut la classe Animal pour les besoins de l’héritage et du polymorphisme.Classes abstraites que se passe-t-il si on veut écrire : Animal anim = new Animal(). ou créer un tableau polymorphe. Mais nous ne voulons pas que les programmeurs puissent créer un objet Animal Solution : déclarer la classe abstract Une des principales raisons de l’existence de ces classes abstraites : l’employer comme argument ou comme type de retour polymorphe.

la classe doit l’être également La première classe concrète de la hiérarchie d’héritage doit implémenter toutes les méthodes abstraites. } Canin c = new Chien() // Ceci est legal Canin c = new Canin() . . Si vous déclarer une méthode abstraite.Classes abstraites abstract class Canin extends Animal { public void vagabonder(). // Ceci est illégal on peut également définir des méthodes abstraites Une méthode abstraite n’a pas de corps public abstract void manger() .

Exercice 8 .

Private : visible que dans la classe courante.Modificateurs d’accès Public : visible par n'importe quelle classe du package ou extérieure au package. ( non visible même des classes filles ) .

ses sous classes du même package ou de packages différents et les autres classes du package ainsi que leurs filles Friendly : n'est utilisable que par la classe et les classes du même package. .Modificateurs d’accès Protected : n'est utilisable que par la classe.

} } . } } public class Chien extends Animal { public Chien( ) { super( ) . System.out. } } public class TestChien( ) { public static void main(String[ ] args) { Chien c = new Chien( ).Constructeurs et héritage public class Animal { public Animal( ) { System.println(‘’Nouvel Animal’’) .out.println(‘’Nouveau Chien’’) .

Et qu’on n’aurait pas besoin de parcourir pour vérifier chaque élément .ArrayList Il serait intéressant d’avoir à notre disposition un tableau qui rétrécirait quand on supprime quelque chose. mais auquel on pourrait simplement demander s’il contient ce qu’on cherche. Et on pourrait en extraire des valeurs sans savoir exactement où elles sont add(Object element) : ajoute le paramètre de type Object à la liste remove(int indice) : supprime l’objet à l’indice spécifié remove(Object element) : supprime cet objet s’il est dans l’ArrayList contains(Object element) : retourne true si l’objet est dans ArrayList isEmpty() : retourne true si l’objet n’a plus d’éléments indexOf(Object element) : retourne soit l’indice de l’objet. soit -1 size() : retourne le nombre d’éléments dans la liste get(int indice) : retourne l’objet se trouvant à l’indice spécifié .

// retourne 2 . maListe.add(monChien1) .size() . 4) savoir combien elle en contient : int taille = maListe.ArrayList 1) création d’une ArrayList : ArrayList<Chien> maListe = new ArrayList<Chien> ( ) . 3) on y place autre chose Chien monChien2 = new Chien() . maListe. 2) on y place quelque chose Chien monChien1 = new Chien() .add(monChien2) .

// on supprime l’objet à l’indice 0. // la liste n’est pas vide. indexOf() retourne 1 7) savoir si elle est vide : boolean vide = maListe.contains(monChien2) //L’ArrayList contient l’objet Chien référencé par monChien2 6)trouver quelque chose : int indc = maListe. et la liste rétrécit automatiquement .indexOf(monChien2) // le premier indice d’ArrayList est 0 .ArrayList 5) savoir si elle contient quelque chose : boolean qqch = maListe. isEmpty retourne false 8) en enlever quelque chose maListe. comme l’objet référencé par monChien2 est le deuxième élément de la liste.remove(0) .isEmpty() .

. 50. 20.) . . etc. 20 le deuxième.. Les entiers doivent être dans cet ordre dans la liste (10 sera le premier élément.Exercice 9 Concevez un programme (une classe avec la méthode main) qui crée une liste contenant les 5 nombres entiers 10.

Classe Object Certaines méthodes de la classe ArrayList acceptent comme paramètre un type Object. l’Héritage multiple n’existe pas. la classe Chien étend déjà la classe Canin. la superclasse universelle. Comme toute classe Java est une sous-classe d’Object. Toutes les classes Java étendent la classe Object. comment peut elle étendre en même temps la clase Object . La classe Object est la mère de toutes les classes. les méthodes d’ArrayList peuvent accepter n’importe quoi.

else System.println (x.Classe Object 1) equals(Object o) : indique si 2 objets sont égaux.out.equals(x) ) System. . if (c. // affiche : class Chat 3) toString() : affiche l’objet sous forme de string Chat x = new Chat() .println (x. Chat x = new Chat() . System. Chien c = new Chien() .getClass() ) . System. // affiche : Chat@7d279f 4) hashCode() : donne un code de hashage On discutera de cette méthode plus loin dans le cours.println (‘’Faux’’) .out. 2) getClass() : indique à quelle classe appartient l’objet Chat x = new Chat() .out.toString() ) .out.println (‘’Vrai’’) .

add(unChien) .add(unChien) .Classe Object ArrayList<Chien> mesChiens = new ArrayList<Chien> (). Chien unChien = new Chien() . Chien c = mesChiens. Chien unChien = new Chien() . Chien c = mesChiens. Mais que se pass-t-il si on déclare une ArrayList<Object> qui accepte n’importe quoi ? ArrayList<Object> mesChiens = new ArrayList<Object> .get(0) .get(0) . mesChiens. mesChiens. // ??? .

Classe Object .

//impossible !! Le compilateur décide si vous pouvez appeler une méthode en fonction du type de la référence et non du type de l’objet réel. .vagabonder() .Classe Object ArrayList<Object> mesChiens = new ArrayList<Object > .vagabonder() . c. Chien c = (Chien) o . Object o = mesChiens.add(unChien) . mesChiens. // on reconvertit l’objet o en Chien c. Object c = mesChiens.get(0) . mesChiens.get(0) . comment reconvertir une référence à un objet dans son type réel ? ArrayList<Object> mesChiens = new ArrayList<Object > .add(unChien) . Chien unChien = new Chien() . Chien unChien = new Chien() .

// on reconvertit l’objet o en Chien c. Object o = mesChiens. ArrayList<Object> mesChiens = new ArrayList<Object > . mesChiens. Chien unChien = new Chien() . } .get(0) . on utilise l’opérateur instanceof pour vérifier.vagabonder() .add(unChien) . if ( o instanceof Chien ) { Chien c = (Chien) o .Classe Object Si on n’est pas sur que l’objet est un Chien.

Un compagnon aura besoin de méthodes comme etreAmical() et jouer(). et nous y plaçons toutes les méthodes nécessaires. . Nous créons une nouvelle classe nommée Compagnon.Interfaces Supposons maintenant que l’on désire améliorer notre diagramme d’animaux pour l’utiliser comme programme d’animalerie. Certains de nos animaux devront avoir un comportement d’animal de compagnie.

Interfaces .

Interfaces .

la JVM ne se demandera pas laquelle des deux versions héritées elle est censée appeler Une interface Java est une classe 100% abstraite . Au moment de l’exécution.Interfaces La façon dont les interfaces esquivent le problème du losange de la mort est très simple : rendre toutes les méthodes abstraites La sous-classe est alors obligée d’implémenter les méthodes.

on écrit : public interface Compagon {….Interfaces Pour définir une interface.} Pour implémenter une interface : public class Chien implements Compagon {…} On peut implémenter une interface et étendre une classe en même temps. public class Chien extends Canin implements Compagon {…} . on peut aussi implémenter plusieurs interface en même temps.

void jouer() . } public class Chien extends Canin implements Compagon { public void etreAmical() { // lecher son maitre } public void jouer() { // apporter la balle } public void vagabonder() {….} public void manger() {…. public abstract void jouer() . } public interface Compagon { void etreAmical() .} } .Interfaces public interface Compagon { public abstract void etreAmical() .

Interfaces Une interface est un modèle pour une classe • Quand toutes les méthodes d’une classe sont abstraites et il n’y a aucun attribut on aboutit à la notion d’interface • Elle définit la signature des méthodes qui doivent être implémentées dans les classes qui respectent ce modèle • Toute classe qui implémente l’interface doit implémenter toutes les méthodes définies par l’interface •Tout objet instance d’une classe qui implémente l’interface peut être déclaré comme étant du type de cette interface •Les interfaces pourront se dériver Exemple : Les choses « Démarrable » doivent posséder une méthode « démarre() » .

. { . { ... } Si une classe hérite d’une autre classe elle peut également implémenter une ou plusieurs interfaces public class NomClasses extends SuperClasse implements Interface1. . On y utilise simplement le mot clé interface à la place de class public interface NomInterface { . } .. ...Interface3. on peut préciser qu’elle implémente une ou plusieurs interfaces donnée(s) en utilisant une fois le mot clé implements public class NomClasses implements Interface1.Interfaces Mise en œuvre d’une interface La définition d’une interface se présente comme celle d’une classe. } Lorsqu’on définit une classe.....

} • Une interface ne possède pas de mot clé abstract • Les interfaces ne sont pas instanciables (Même raisonnement avec les classes abstraites) NomInterface jeTente = new NomInterface().Interfaces Mise en œuvre d’une interface • Une interface ne possède pas d’attribut • Une interface peut posséder des constantes public interface NomInterface { public static final int CONST = 2. // Erreur!! .

Interfaces .

// Déclaration d’un objet de type Démarrable Démarrable dem2. // Déclaration et création d’un objet Personne Personne pers1 = new Personne(dem1).mettreEnRoute(). // Création d’un objet Ordinateur dem2 = new Ordinateur(). pers2.mettreEnRoute(). // Déclaration et création d’un objet Personne Personne pers1 = new Personne(dem2). // Création d’un objet Voiture dem1 = new Voiture(). } } Une personne peut démarrer tous les objets « Démarrable » . pers1.Interfaces Tout objet instance d’une classe qui implémente l’interface peut être déclaré comme étant du type de cette interface public class Test { public static void main (String[] argv) { // Déclaration d’un objet de type Démarrable Démarrable dem1.

demarre(). } public void mettreEnRoute() { objetDemarrable. } } Une personne peut démarrer Voiture et Ordinateur sans connaître leur nature exacte .Interfaces Une « Voiture » et un « Ordinateur » sont des objets « Démarrable » public class Personne { private Demarrable objetDemarrable. public Personne(Demarrable dem) { objetDemarrable = dem.

Interfaces Les interfaces pourront se dériver Une interface peut hériter d’une autre interface : « extends » • Conséquences NomInte1 << Interface >> La définition de méthodes de l’interface mère (NomInte1) sont reprises dans l’interface fille (NomInte2). Toute classe qui implémente l’interface fille doit donner une implémentation à toutes les méthodes mêmes celle héritées +… NomInte2 << Interface >> +… • Utilisation Lorsqu’un modèle peut se définir en plusieurs sous-modèles complémentaires .

Classes abstraites versus interfaces • Les classes Elles sont complètement implémentées Une autre classe peut en hériter • Les classes abstraites Elles sont partiellement implémentées Une autre classe peut en hériter mais doit donner une implémentation aux méthodes abstraites Elles ne peuvent pas être instanciées • Les interfaces Elles ne sont pas implémentées Toute classe qui implémente une ou plusieurs interfaces doit implémenter toutes leurs méthodes (abstraites) .

..Exercice Établissez une interface 'Car' représentant une voiture du monde réel. . sous-classe de la classe 'BasicCar'. rajoutant une caractéristique par rapport à une voiture : on est capable de spécifier son type de chargement sous la forme d'une chaîne de caractères et d'accéder à ce type (ex. à la vitesse courante de déplacement ("speed"). prévoyez des méthodes pour changer et accéder à la couleur. les initialiser avec des valeurs par défaut et écrire le code des méthodes de l'interface. vide. . Ecrivez ensuite la classe 'BasicTruck' (camion). au nombre de roues. cailloux. beton. Ecrivez ensuite la classe 'BasicCar' implémentant cette interface : vous devez définir les champs de la classe. à la vitesse courante du boîtier de vitesse ("gear").).

. System. Object. java..awt..lang : rassemble les classes de base JAVA..util : classes pour les collection java.Packages un package est un groupe de classes associées à une fonctionnalité exemples de packages java. String.awt : classes pour interfaces utilisateurs (Abstract WindowToolkit) java.images : classes pour manipulation d’images bitmap .. .

.

.

min( ). abs( ) Ces méthodes n’utilisent jamais la valeur d’une variable d’instance Math ne possède aucune variable d’instance .y) agit sur l’argument mais n’est jamais affecté par l’état d’une variable d’instance Gaspillage d’espace sur le tas pour créer une instance de la classe Math à seul fin d’exécuter la méthode max() .Static Le comportement de la méthode max( ) de la classe Math ne varie jamais la méthode max(x.

Math objetMath = new Math( ) // erreur de compilation les méthodes de la classe Math sont static. On a juste besoin de la classe Math.2) int y = Math. int x = Math.56) int z = Math.min(12. on a pas besoin d’une instance de Math.Static Java ne vous permettra pas de créer une instance de la classe Math.abs(-56) .round(42.

Static Le mot-clé static permet à une méthode de s’exécuter en l’absence de toute instance de la classe. . et donc qu’aucune instance. int b) { //retourne la plus petite valeur } et on écrit : Math. public static int min(int a. n’est nécessaire.56). aucun objet. Une méthode static signifie que le comportement ne dépend pas d’une variable d’instance.min(23. La classe suffit.

Static Une classe contenant des méthodes static peut être instanciée On est donc libre de combiner méthodes static et non-static au sein d’une même classe .

} public int getTaille( ) { return taille .out.println(“Le chien mesure : “ + taille). public static void main( String[ ] args ) { System. public class Chien { private int taille . } } .Static Les méthodes static ne peuvent pas utiliser de variables d’instance non-static. //ne compile pas } public void setTaille(int t) { taille = t .

} } .out. } public int getTaille() { return taille . parce que les méthodes non-static utilisent des variables d’instance public class Chien { private int taille .Static Les méthodes static ne peuvent pas non plus utiliser des méthodes non static.println(“Le chien mesure : “ + getTaille()). //ne compile pas } public void setTaille(int t) { taille = t . public static void main( String[] args ) { System.

Static Variables static : La valeur est la même pour toutes les instances de la classe une variable partagée par toutes les instances de la classe et c’est précisément le rôle des variables static. une valeur par classe et non une valeur par objet. .

public Chien( ) { nbreChiens++ . } public int getTaille( ) { return taille . } public void setTaille(int t) { taille = t . } } .Static public class Chien { private int taille . private static int nbreChiens =0.

Static Les variables static d’une classe sont initialisées avant qu’on ne puisse créer un objet de ce type. et avant l’exécution de toute méthode statique .

exemples: erreurs d'entrée-sortie (I/O fichiers) erreurs de saisie de données par l’utilisateur Le programmeur peut : «Laisser planter» le programme à l’endroit où l’erreur est détectée Tenter une correction .Prévoir les erreurs d'utilisation Certains cas d'erreurs peuvent être prévus à l'avance par le programmeur.

Notion d'exception En Java. Une exception : est un objet. instance d'une classe d'exception provoque la sortie d'une méthode correspond à un type d'erreur contient des informations sur cette erreur . les erreurs se produisent lors d'une exécution sous la forme d'exceptions.

de continuer l'exécution normale. malgré l'exception. Lever une exception consiste à signaler quelque chose d'exceptionnel. Deux solutions alors : laisser le programme se terminer avec une erreur. essayer.Terminologie Une exception est un signal qui indique que quelque chose d'exceptionnel est survenu en cours d'exécution. Capturer l'exception consiste à essayer de la traiter. .

exceptions prédéfinies . VosExceptions...Arbre des exceptions Throwable String (message d'erreur) Exception Error OutOfMemoryError RunTimeException Les erreurs sont graves et il est recommandé de ne pas les corriger.. NullPointerException ClassCastException ..

les exceptions sont des objets ayant 3 caractéristiques: Un type d’exception (défini par la classe de l’objet exception) Une chaîne de caractères (option).Nature des exceptions En Java. Error sont des exceptions et des erreurs prédéfinies et/ou gérées par Java . Les exceptions construites par l'utilisateur étendent la classe Exception RunTimeException. Un « instantané » de la pile d’exécution au moment de la création. (hérité de la classe Throwable).

Quelques exceptions prédéfinies en Java Division par zéro pour les entiers : ArithmeticException Référence nulle : NullPointerException Tentative de forçage de type illégale : ClassCastException Tentative de création d'un tableau de taille négative : NegativeArraySizeException Dépassement de limite d'un tableau : ArrayIndexOutOfBoundsException .

. } ici…. } . catch { ……… ……… } On tente de récupérer là.Capture d'une exception Les sections try et catch servent à capturer une exception dans une méthode (attraper la bulle…) exemple : public void XXX(………) { Si une erreur se produit try{ …………….

Bloc finally facultatif.. } catch (<une-exception>) { . } catch (<une_autre_exception>) { .... } Autant de blocs catch que l'on veut. .. } . finally { .try / catch / finally try { ......

Traitement des exceptions (1) Le bloc try est exécuté jusqu'à ce qu'il se termine avec succès ou bien qu'une exception soit levée. Si une clause catch convenant à cette exception a été trouvée et le bloc exécuté. les clauses catch sont examinées l'une après l'autre dans le but d'en trouver une qui traite cette classe d'exceptions (ou une superclasse). Dans ce dernier cas. . Les clauses catch doivent donc traiter les exceptions de la plus spécifique à la plus générale. l'exécution du programme reprend son cours.

Traitement des exceptions (2) Si elles ne sont pas immédiatement capturées par un bloc catch. L'interpréteur Java affiche un message identifiant : l'exception. . la méthode qui l'a causée. Si une exception n'est jamais capturée. les exceptions se propagent en remontant la pile d'appels des méthodes. ce qui pousse l'interpréteur Java à afficher un message d'erreur et à s'arrêter. la ligne correspondante dans le fichier. elle se propage jusqu'à la méthode main(). jusqu'à être traitées.

La seule instruction qui peut faire qu'un bloc finally ne soit pas exécuté est System. .exit(). capturée ou non. que l'exception soit levée ou non.Bloc finally Un bloc finally permet au programmeur de définir un ensemble d'instructions qui est toujours exécuté.

Ce champ est utilisé pour stocker le message décrivant l'exception. Ce message peut être récupéré par la méthode getMessage(). . La classe Throwable définit un message de type String qui est hérité par toutes les classes d'exception. Il est positionné en passant un argument au constructeur.Les objets Exception La classe Exception hérite de La classe Throwable.

} public MonException(String s) { super(s). } } .Exemple public class MonException extends Exception { public MonException() { super().

Levée d'exceptions Le programmeur peut lever ses propres exceptions à l'aide du mot réservé throw. Les objets exception sont souvent instanciés dans l'instruction même qui assure leur lancement. throw new MonException("Mon exception s'est produite !!!"). . throw prend en paramètre un objet instance de Throwable ou d'une de ses sous-classes.

. else {..Emission d'une exception L'exception elle-même est levée par l'instruction throw.} } . Une méthode susceptible de lever une exception est identifiée par le mot-clé throws suivi du type de l'exception exemple : public void ouvrirFichier(String name) throws MonException {if (name==null) throw new MonException().

throws (1) Pour "laisser remonter" à la méthode appelante une exception qu'il ne veut pas traiter. le programmeur rajoute le mot réservé throws à la déclaration de la méthode dans laquelle l'exception est susceptible de se manifester. public void uneMethode() throws IOException { // ne traite pas l'exception IOException // mais est succeptible de la générer } .

.throws (2) Les programmeurs qui utilisent une méthode connaissent ainsi les exceptions qu'elle peut lever. Une même méthode peut tout à fait "laisser remonter" plusieurs types d'exceptions (séparés par des . La classe de l'exception indiquée peut tout à fait être une superclasse de l'exception effectivement générée. Une méthode doit traiter ou "laisser remonter" toutes les exceptions qui peuvent être générées dans les méthodes qu'elle appelle.).

Résumé Grâce aux exceptions. Le programme peut capturer et traiter les exceptions grâce au bloc d’instruction catch … try … finally Le programmeur peut définir ses propres classes d ’exceptions . Java possède un mécanisme sophistiqué de gestion des erreurs permettant d ’écrire du code « robuste » Le programme peut déclencher des exceptions au moment opportun.

Exercice 1 .

Exercice 2 .

Exercice 3 .

.

Character.AutoBoxing Il se peut que vous vouliez traiter des valeurs primitives comme des objets Il existe une classe enveloppe (wrapper) pour chaque type primitif. Les classes enveloppes sont : Boolean. Short. Integer. Double . Long. Float. Byte.

Integer iEnv = new Integer(i) .AutoBoxing Pour envelopper une valeur : int i = 288 .intValue() . . pour revenir au type primitive : int x = iEnv.

intValue Avec autoboxing ArrayList<Integer> liste = new ArrayList<Integer>( ) . liste.0 ) ArrayList liste = new ArrayList( ) . .AutoBoxing sans autoboxing ( avant Java 5. Integer un = (Integer) liste.add( new Integer(3) ) . liste.add(3). int num = liste.get(0).get(0). int intUn = un.

AutoBoxing Integer i = new Integer(42) . . Integer k = j+3. i++. Integer j = new Integer(5).

Serialisation .

oos.ser’’) .writeObject(personnage1) .writeObject(personnage2) .close() . 3) Ecrire l’objet oos.Serialisation 1) Créer un FileOutputStream FileOutputStream fos = new FileOutputStream(‘’MonJeu. . 2) Créer un ObjectOutputStream ObjectOutputStream oos = new ObjectOutputStream(fos) . oos. 4) Fermer l’ObjectOutputStream oos.writeObject(personnage3) .

Serialisation L’API d’E/S (entrée/sortie) comprend des flots de communication et des flots de traitement qui ne fonctionnent que s’ils sont chaînés à d’autres flots .

déclarez la avec le mot-clé transient.Serialisation La sérialisation sauvegarde la valeur des variables d’instance (attributs) Si vous voulez que vote classe soit sérialisable. . implémentez l’interface Serializable Si vous voulez que le processus de serialisation ignore une variable d’instance.

public void setLargeur(int l) { largeur = l .ser”). } } } . try { FileOutputStream fos = new FileOutputStream(“boite. oos.printStackTrace().Serialisation public class Boite implements Serializable { private int largeur . maBoite. hauteur.writeObject(maBoite). } catch (Exception ex) { ex. } public transient void setHauteur(int h) {hauteur =h .setHauteur(20). public static void main(String[ ] args ) { } Boite maBoite = new Boite(). ObjectOutputStream oos = new ObjectOutputStream(fos).setLargeur(50).close(). maBoite. oos.

Object deux = ois.Deserialisation 1) Créer un FileInputStream FileInputStream fis = new FileInputStream(‘’MonJeu.ser’’) .close() . 2) Créer un ObjectInputStream ObjectInputStream ois = new ObjectInputStream(fis) 3) Lire les objets Object un = ois. 4) Convertir les objets Personnage archer = (Personnage) un . Personnage guerrier = (Personnage) deux .readObject() . .readObject() . 5) Fermer l’ObjectInputStream ois.

* . } catch(Exception ex) { ex.close().txt”). fw.E/S import java.io. fw. } } } .write(“Bonjour”).printStackTrace(). public class EcrireTexte { public static void main( String[] args) { try{ FileWriter fw = new FileWriter(“texte.

bw.* . } } } .txt”).write(“le monde”).E/S import java. bw. } catch(Exception ex) { ex.close(). public class EcrireTexte { public static void main( String[] args) { try{ FileWriter fw = new FileWriter(“texte.write(“Bonjour”).io. bw. BufferedWriter bw = new BufferedWriter(fw).printStackTrace().

2) créer un repertoire File rep = new File(“Chapitre2”).io. mais elle ne représente pas le contenu du fichier.mkdir(). rep. . Vous pouvez voir un objet File plutôt comme le nom de chemin d’un fichier 1) Créer un objet représentant un fichier File f = new File (‘’monCode.File représente un fichier sur le disque.txt’’) .E/S La classe java.

isDirectory() ) { String[] contenuRep = rep.println(contenuRep[i].getAbsolutePath() . .length.out. 5) Supprimer un fichier ou un répértoire (retourne true en cas de succès ) boolean supprime = f.delete() .E/S 3) lister le contenu d’un repertoire if ( rep. i++ ) { System. } } 4) obtenir le chemin absolu d’un fichier ou d’un repertoire rep. for ( int i=0. i< contenuRep.list().

while ( (ligne = br.readLine() ) != null) { System.println(ligne). Filereader fr = new Filereader(monFichier).* .close().E/S lecture import java.out. public class LireTexte { public static void main( String[] args) { try{ File monFichier = new File(“texte. } } } .io.txt”). } catch(Exception ex) { ex. BufferedReader br = new BufferedReader (fr).). } br. String ligne = null.printStackTrace().

readLine()) != null) { System. while ((line = input.class ConsoleIO { public static void main(String[ ] args) { try { InputStreamReader isr = new InputStreamReader(System.E/S clavier import java. BufferedReader input = new BufferedReader(isr).*.in). String line.io. } } } .println(line).out. } } catch(Exception ex) { ex.printStackTrace().

in).out. int str = sc.util.E/S clavier import java. } } .out.nextInt(). System. System.scanner.println("Vous avez saisi : " + str). class ConsoleIO { public static void main(String[] args) { Scanner sc = new Scanner(System.println("Veuillez saisir un nombre :").

Génériques La classe Solo travaille avec des références de type String .

Génériques Solo travaille maintenant avec des références de type Object .

//erreur } } Chien c2 = (Chien) val. Solo val = new Solo(c1). Chien c2 = val.Génériques public class Chien { int taille . …… } public class Test { public static void main(String[] args) { Chien c1 = new Chien().getValeur().getValeur(). .

une classe SoloChien pour gérer les Chiens. nous créons une seule classe Solo qui peut accepter n’importe quel type.0. une classe SoloInteger pour gérer les entiers. une classe SoloString pour gérer les strings. . etc… Et c’est la que la généricité introduite avec Java 5. intervient.Génériques créer une classe Solo pour chaque type d’objets. Avec la généricité.

} public T getValeur(){ return this.valeur = val. } } .Génériques public class Solo<T> { private T valeur. } public void setValeur(T val){ this.valeur = val. } public Solo(T val){ this.valeur = null. public Solo(){ this.valeur.

Génériques Dans cette classe. l'objet ne pourra travailler qu'avec le type de données que vous lui avez spécifié. Vous le ferez à l'instanciation de cette classe. Par contre. le T n'est pas encore défini. une fois instanciée avec un type. .

Chien c2 = val.getValeur().getValeur(). Solo<Chien> val = new Solo<Chien>(c1). } } public class Test { public static void main(String[ ] args) { Chien c1 = new Chien(). } } .Génériques public class Test { public static void main(String[] args) { Solo<Integer> val = new Solo<Integer>(12). int nbre = val.

En effet. étant donné que les éventuelles erreurs de transtypage sont levées à la compilation.Génériques L’ avantage des generics réside dans la suppression du contrôle de type à l’exécution. . il n’est plus nécessaire de contrôler le type à l’exécution.

on va trouver : public class ArrayList<E> extends AbstractList<E> implements List<E> { ……… public boolean add(E o) { …. vu précédemment est aussi une classe générique. } } . Si on regarde la documentation d’ArrayList.Génériques ArrayList.

} } .Génériques Dire qu’une méthode est générique signifie que sa signature contient un paramètre de type 1) utiliser un paramètre de type défini dans la déclaration de la classe public class ArrayList<E> extends AbstractList<E> implements List<E> { public boolean add(E o) { ….

Génériques 2) utiliser un paramètre de type qui n’a pas été défini dans la déclaration de la classe public <T extends Animal> void accepter ( ArrayList<T> liste ) . .

je ne peux plus la changer en un autre type.Génériques Lorsque je déclare une référence de type Solo<Chien>. //erreur } } . val = new Solo<Chat>(new Chat( ) ) . public class Test { public static void main(String[ ] args) { Chien c1 = new Chien(). Solo<Chien> val = new Solo<Chien>(c1).

Chien c1 = new Chien().Génériques wildcard : ?. Avec ce type de déclaration. val = new Solo<Chat>(new Chat( ) ) . votre objet accepte bien n'importe quel type de référence. Solo< ?> val = new Solo<Chien>(c1). val = new Solo<Tigre>(new Tigre( ) ) . . val = new Solo<Lion>(new Lion( ) ) .

setValeur(c1) .Génériques Inconvénient Chien c1 = new Chien(). // erreur de compilation String s = val. val. puisque le type est inconnu. Solo< ?> val = new Solo<Chien>(). . // erreur de compilation le compilateur ne peut pas savoir si l’argument qu’on passe à la méthode setValeur() a le bon type.getValeur() .

//erreur . la classe Client hérite de la classe Habitant ArrayList< Client> clients = new ArrayList<Client>.Génériques et héritage habitants d’une ville et clients d’un magasin de cette ville. ArrayList< Habitant > habitants = clients.

nous tentons d’assigner une instance de Habitant une instance de Client .add(new Habitant (…)).get(0).Génériques et héritage habitants. Client c = clients.

Chien[ ] chiens = { new Chien(). } } . new Chien ().manger(). new Chien() }. } public void accepterAnimaux(Animal[ ] animaux) { for (int i=0 . i<animaux. accepterAnimaux(animaux). new Chat(). new Chien() }.méthodes génériques public void go() { Animal[ ] animaux = { new Chien(). i++ ) { animaux[i].length . accepterAnimaux(chiens).

méthodes génériques public void go( ) { ArrayList<Animal> animaux = new ArrayList<Animal>( ). animaux.manger( ). } } . } public void accepterAnimaux(ArrayList<Animal> animaux) { for ( Animal a : animaux) { a. animaux.add(new Chien( ) ).add(new Chien( ) ). accepterAnimaux(animaux).add(new Chat( ) ). animaux.

accepterAnimaux(chiens). } } . chiens.manger( ).add(new Chien( ) ).add(new Chien ( ) ).méthodes génériques public void go( ) { ArrayList<Chien > chiens = new ArrayList<Chien >( ). //erreur de compilation } public void accepterAnimaux(ArrayList<Animal> animaux) { for ( Animal a : animaux) { a. chiens.

méthodes génériques public void accepterAnimaux(ArrayList<Animal> animaux) { animaux.) accepte une ArrayList de n’importe quel sous-type d’Animal.. Le plus simple consiste à utiliser le wildcard .add( new Chat( ) ) . } On essaie de mettre un chat dans une liste de chiens Comment faire alors si nous voulons que notre méthode accepterAnimaux(.

} . // ne compilera pas. } } est ce qu’on ne retombe pas sur le même problème ??? public void accepterAnimaux(ArrayList< ? extends Animal> animaux) { animaux.manger().add( new Chat() ).méthodes génériques public void accepterAnimaux(ArrayList< ? extends Animal> animaux) { for ( Animal a : animaux) { a.

Collections Documentation d’ArrayList : ArrayList implémente l’interface List .

Collections Les éléments insérés dans un ArrayList restent dans l’ordre dans lequel ils ont été insérés. Utiliser la classe Collections pour effectuer les tris La méthode Collections. .sort() trie une liste de chaînes de caractères par ordre alphabétique.

Collections Et si notre ArrayList contient des objets?? Comment trier des objets. quel est le critère de tri?? .

Collections la méthode sort() n’accepte que des listes d’objets Comparable Mais pourquoi est ce que ça fonctionne avec des String ? .

égal ou supérieur à l’objet spécifié . } compareTo() : retourne un entier négatif. zéro ou un entier positif selon que cet objet est inférieur.Collections public interface Comparable<T> { int compareTo( T o ) .

Collections .

. Ce sont des collections qui utilisent des paires clé-valeur. Une List sait où se trouve quelque chose dans la liste. Une map connaît la valeur associée à une clé donnée. Vous ne pouvez pas avoir plus d’un élément référençant le même objet ( ou plus d’un élément référençant deux objets considérés comme égaux ). Set : collections qui interdisent les doublons. Vous pouvez avoir plusieurs éléments référençant le même objet (doublons autorisés). Vous pouvez avoir deux clés qui référencent la même valeur mais vous ne pouvez avoir des clés dupliquées. Map : Pour trouver quelque chose par clé.Collections List : collections qui reconnaissent les indices. Un set sait qu’il y a déjà quelque chose dans la collection.

il faut utiliser un Set au lieu d’une List comment le HashSet peut déterminer que deux objets sont égaux ? .Collections Si on ne veut pas de doublons dans nos collections.

si bien que deux objets ne peuvent avoir le même .Collections La méthode hashCode() est une méthode de la classe Object que vous pouvez redéfinir. le comportement par défaut est que chaque objet aura un numéro unique. si vous ne la redéfinissez pas. Java affecte un code de hashage en fonction de l’adresse mémoire de l’objet sur le tas.

Collections Egalité des références : deux références. un seul objet sur le tas .

mais les objets sont considérés comme équivalents. .Collections Egalité des objets : deux références. deux objets sur le tas.

il faut à la fois redéfinir la méthode hashCode() pour qu’elle soit identique et la méthode equals() .Collections Si vous voulez que deux objets soient traités comme étant égaux.

Collections .

. t.Threads Pile. fil d’exécution Création d’un Thread : Thread t = new Thread() .start() .

Threads Lancer un nouveau thread Créer un objet Runnable ( la tâche du thread ) Runnable threadTache = new MonRunnable() . public class MonRunnable implements Runnable { public void run() { } } .

Threads Créer un objet Thread ( le travailleur ) et lui passer l’objet Runnable ( la tâche). .start() . Lancer le thread monThread. Thread monThread = new Thread(threadTache) .

start(). } } class TestThread { public static void main(String[ ] args) { Runnable tache = new MonRunnable(). Thread monThread = new Thread(tache). monThread.Threads public class MonRunnable implements Runnable { public void run() { System.println(“je suis la tâche du thread’’) . } } .out.

start() . 3) S’EXECUTANT l’ordonnanceur de threads permuter entre les deux états .Threads Les trois états d’un nouveau thread 1) NOUVEAU Thread t = new Thread(tache) . 2) EXECUTABLE t.

Threads Ordonnanceur de threads Sélection des threads exécutables Temps d’activité d’un thread On peut pas y accéder Imprévisibilité Solution : sommeil .

afficher() .println(“je suis le nouveau thread’’) .start(). i<100 . Thread monThread = new Thread(tache). } public void afficher() { System. monThread. System. i++) .println(“ je suis main”).Threads class MonRunnable implements Runnable { public void run() { for (int i = 1 . } } public class TestThread { public static void main(String[ ] args) { Runnable tache = new MonRunnable().out. } } .out.

} catch ( InterruptedException ex) { ex.Threads: sommeil Une fois que la méthode run() d’un thread est terminée. } .sleep(2000) .printStackTrace(). On utilise sleep() pour rendre notre programme plus prévisible try { Thread. il est impossible de le relancer.

Threads Quand le thread se réveille. il redevient exécutable et attend que l’ordonnanceur le choisisse à nouveau. .

i<25.setName(“le thread beta”).out.start(). Thread beta = new Thread(exec). beta. Thread alpha = new Thread(exec). } } } . System.start(). } public void run() { for (int i=0.println(nom + “ s’exécute”).getName().setName(“le thread alpha”). alpha. alpha. beta. i++) { String nom = Thread.Threads public class ExecThreads implements Runnable { public static void main(String[ ] args ) { ExecThreads exec = new ExecThreads().currentThread().

setName(‘’rachid’’) . . 2) On crée deux threads avec la même tâche Thread un = new Thread(tache) .Problèmes d’accès concurrents 1) On crée une instance de JobAnasEtRachid JobAnasEtRachid tache = new JobAnasEtRachid() .start() . 3) On nomme les threads et on les lance un.setName(‘’Anas’’) . deux. un. Thread deux = new Thread(tache).start() . deux.

sleep(500) . } catch ( InterruptedException ex) { ex.printStackTrace() . if ( compte.getSolde() >= montant ) { try { Thread. } } . mais seulement si le compte est provisionné.Problèmes d’accès concurrents 4) on regarde les deux threads exécuter la méthode run() Les deux threads vérifient le solde en permanence puis effectue un retrait.

Les verrous ne sont pas associés à une méthode mais à un objet. .Solution Utilisation du verrou La méthode effectuerRetrait() doit s’exécuter comme une entité atomique On utilise le modificateur synchronized pour qu’un seul thread à la fois puisse accéder à la méthode. Attention aux verrous mortels.

Sign up to vote on this title
UsefulNot useful