INFO-F-202 Langages II Java

Transcription

1 INFO-F-202 Langages II Vandy BERTEN Université Libre de Bruxelles Vandy BERTEN INFO-F-202 Université Libre de Bruxelles 1 / 109

2 Table des matières 1 Introduction 2 Les bases 3 et Orienté Objet 4 Threads 5 Mais encore... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 2 / 109

3 Introduction Table des matières I 1 Introduction Motivations Historique Principes Premier exemple JVM 2 Les bases 3 et Orienté Objet 4 Threads 5 Mais encore... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 3 / 109

4 Introduction Motivations Pourquoi? Syntaxiquement proche du C++ Mais beaucoup plus orienté objets plus propre! Pas de pointeurs (visibles), d accès direct à la mémoire plus sûr! Adapté à de nombreux environnements : applications, applets (web), cartes à puce, téléphones... Code compilé portable API très fournie, système de documentation natif Nombreux outils pour les systèmes distribués (RMI, sockets, Corba... ) Système de threads (multi-tâches) natif et élégant... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 4 / 109

5 Introduction Motivations Objectifs Apprendre depuis C++ Approfondir sa connaissance du C++ (références, gestion de la mémoire, allocation des objets... ) Se concentrer sur les subtilités du langage Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 5 / 109

6 Introduction Historique Historique Développé par Sun Micro System Début du projet en 1991, première version publique en 1995 Objectif : télévision interactive C : 1972, C++ : 1979, Python : 1989 Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 6 / 109

7 Introduction Principes Principes Compilation/Exécution : Langage précompilé vers du byte code (class file) Exécution (interprétation) au travers de la JVM Write Once Run Anywhere ( Write Once Compile Anywhere) Langage : Tout est objet (... ou presque) Rien n existe en dehors d un objet Fortement (et statiquement) typé Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 7 / 109

8 Introduction Premier exemple Hello World HelloWorld.cpp C++ 1 #include<iostream > 2 using namespace std ; 3 int main ( int argc, const char * argv [ ] ) { 4 cout <<" Hello world!"<<endl ; 5 return 0; 6 } HelloWorld.java 1 public class HelloWorld { 2 public static void main ( String [ ] args ) { 3 System. out. println ( "Hello world!" ) ; 4 } 5 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 8 / 109

9 Introduction JVM Compilation traditionnelle en C++ a.out main.cpp #include<iostre using namespa int main(int arg cout<<"hello return Compiler Intel/Win. Compiler Intel/Mac. Exec Intel/Win a.out Exec Intel/Mac Vandy BERTEN INFO-F-202 Université Libre de Bruxelles 9 / 109

10 Introduction JVM Compilation en Hello.java public class He public static v System.out.pri } } Compiler Hello.class bytecode JVM Intel/Win JVM Intel/Mac Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 10 / 109

11 Introduction JVM Compilation $ javac HelloWorld.java # Compilation $ java HelloWorld # Exécution > Hello World! $ Console Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 11 / 109

12 Les bases Table des matières I 1 Introduction 2 Les bases Instructions simples Types primitifs Tableaux Classes et objets Passage de paramètres Types de langages Exceptions 3 et Orienté Objet 4 Threads Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 12 / 109

13 Les bases Table des matières II 5 Mais encore... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 13 / 109

14 Les bases Instructions simples Instructions de base : la même chose? Instructions C++ Instructions 1 // Un commentaire 2 int n =5; 3 for ( int i =0; i<n ; ++i ) { 4 myfunction ( i ) ; 5 } 6 if ( V[0]%2 == 0) 7 dothis ( ) ; 8 else 9 dothat ( ) ; 10 /* Un autre commentaire 11 sur deux lignes */ 1 // Un commentaire 2 int n =5; 3 for ( int i =0; i<n ; ++i ) { 4 myfunction ( i ) ; 5 } 6 if ( V[0]%2 == 0) 7 dothis ( ) ; 8 else 9 dothat ( ) ; 10 /* Un autre commentaire 11 sur deux lignes */ Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 14 / 109

15 Les bases Instructions simples Instructions de base : pas tout à fait! Instructions C++ Instructions 1 int n=5, m =3; 2 double x =5.5; 3 float * V= new float [ n ] ; 4 if ( n ) 5 if ( n=5) { 6 int m =6; 7 m+n ; 8 m=x ; 9 x=n ; 10 } 1 int n=5, m =3; 2 double x = 5.5; 3 float V [ ] = new float [ n ] ; 4 if ( n ) // Illégal 5 if ( n=5) { // Illégal 6 int m =6; // Illégal 7 m+n ; // Illégal 8 m=x ; // Illégal 9 x=n ; 10 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 15 / 109

16 Les bases Instructions simples Boucle for-each for-each 1 int V [ ] = new int [ 1 0 ] ; 2 int sum =0; for ( int f : V ) { 5 sum += f ; 6 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 16 / 109

17 Les bases Types primitifs Types primitifs Nom #bits Remarque Wrapper boolean - true/false Boolean byte 8 C++ : signed char Byte char 16 C++ : 8 bits Char short 16 Short int 32 Integer long 64 Long idem C++ float 32 Float double 64 Double void - Void Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 17 / 109

18 Les bases Tableaux Tableaux En, tout tableau est un objet Tous les tableaux sont dynamiques (heap), jamais statiques (stack) créés via new Un tableau (= objet) possède un champ length de type final ( const en C++) C++ (dynamique) : pointeur vers le 1 er élément ; : référence vers le tableau entier Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 18 / 109

19 Les bases Tableaux Tableaux Tableaux dynamiques C++ Tableaux 1 int * a ; 2 a = new int [ 1 0 ] ; 3 delete [ ] a ; 4 a = new int [ 1 5 ] ; 5 int * b = a ; 6 int * * c = new int * [ 8 ] ; 7 for ( int i =0; i <8; ++i ) 8 c [ i ] = new int [ 8 ] ; 9 // Impossible! 1 int [ ] a ; // = int a[]; 2 a = new int [ 1 0 ] ; 3 4 a = new int [ 1 5 ] ; 5 int b [ ] = a ; 6 int c [ ] [ ] = new int [ 8 ] [ 8 ] ; a [ a. length 1]=4; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 19 / 109

20 Les bases Tableaux Tableaux Tableaux statiques C++ Tableaux 1 int a [ 5 ] ; 2 3 // Impossible! 4 // Impossible! 5 int c [ 5 ] [ 5 ] ; 6 7 int d [ ] = { 1, 2, 3, 4 } ; 1 int [ ] a ; // = int a[]; 2 a = new int [ 5 ] ; 3 a = new int [ 9 ] ; 4 int b [ ] = a ; 5 int c [ ] [ ] = new int [ 5 ] [ 5 ] ; 6 7 int d [ ] = { 1, 2, 3, 4 } ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 20 / 109

21 Les bases Classes et objets Classes et objets : quelques différences Classes C++ Classes 1 class Foo { 2 private : 3 int x ; 4 public : 5 Foo ( ) : x ( 1 ) { } 6 int f ( int y=0) { 7 return y * x ; 8 } 9 } ; 1 class Foo { 2 3 private int x = 1; 4 5 public Foo ( ) { } 6 public int f ( int y ) { 7 return y * x ; 8 } 9 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 21 / 109

22 Les bases Classes et objets Classes et objets : quelques différences (suite) Objets 1 Foo a ; // Appelle Foo() 2 z = a. f ( 3 ) ; 3 4 Foo * b ; 5 b = new Foo ( ) ; 6 z = b >f ( 3 ) ; C++ Objets 1 Foo a ; 2 a = new Foo ( ) ; 3 z = a. f ( 3 ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 22 / 109

23 Les bases Classes et objets Classes et objets : quelques différences (suite) Après avoir rendu x public : Objets C++ Objets 1 Foo a ; 2 a. x = 3; 3 4 Foo b = a ; 5 b. x = 4; 1 Foo a = new Foo ( ) ; 2 a. x = 3; 3 4 Foo b = a ; 5 b. x = 4; Que valent a.x et b.x dans ces deux exemples? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 23 / 109

24 Les bases Classes et objets Vecteurs et objets Vecteurs d objets 1 Foo * a = new Foo [ 1 0 ] ; C++ 10 appels à Foo() implicites Vecteurs d objets 1 Foo a [ ] = new Foo [ 1 0 ] ; 2 for ( int i =0; i<a. length ; ++i ) 3 a [ i ]= new Foo ( ) ; Et avec un for-each? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 24 / 109

25 Les bases Classes et objets Variables En, une variable est : une variable primitive une référence ( pointeur) vers un objet ou un vecteur jamais un objet proprement dit pas de référence vers une primitive Variable primitive : sur le stack Objet/tableau : référence sur le stack, objet sur le heap Pas de * (objet pointé par), & (adresse de) ou -> (champ) Générer une matrice triangulaire de Integer de taille n : 1 élément pour M[0], n éléments pour M[n-1] Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 25 / 109

26 Les bases Passage de paramètres Passage de paramètres Le passage de paramètre se fait toujours par valeur... Mais pour un objet (ou tableau), c est la référence qui est passée par valeur Comment faire un swap? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 26 / 109

27 Les bases Passage de paramètres Passage de paramètres 1 public void dosomething ( Point arg1, Point arg2 ) { 2 arg1. x = 100; 3 arg1. y = 100; 4 Point temp = arg1 ; 5 arg1 = arg2 ; 6 arg2 = temp ; 7 } 8 public static void main ( String [ ] args ) { 9 Point pnt1 = new Point ( 0, 0 ) ; 10 Point pnt2 = new Point ( 0, 0 ) ; 11 dosomething ( pnt1, pnt2 ) ; 12 } Que valent pnt1 et pnt2, avant et après dosomething? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 27 / 109

28 Les bases Types de langages Types de langages Statiquement typé : & C++ Fortement/faiblement typé : plus fort que C++ Safe/unsafe : C++ autorise à peu près tous les cast, pas Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 28 / 109

29 Les bases Types de langages Sûreté de typage : C++ Safety1.cpp C++ 1 class Test1 { public : int a ; } ; 2 3 class Test2 { public : double b ; } ; 4 5 int main ( ) { 6 Test2 * t2 = new Test2 ( ) ; 7 t2 >b = 2. 4 ; 8 9 Test1 * t1 = ( Test1 * ) t2 ; // Not safe 10 cout << t1 >a << endl ; 11 return 0; 12 } Compile, avec un comportement aléatoire à l exécution Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 29 / 109

30 Les bases Types de langages Sûreté de typage : Safety1.java 1 class Test1 { public int a ; } 2 3 class Test2 { public double b ; } 4 5 public class Safety1 { 6 public static void main ( String [ ] arg ) { 7 Test2 t2 = new Test2 ( ) ; 8 t2. b = 2. 4 ; 9 10 Test1 t1 = ( Test1 ) t2 ; // Ne compile pas! 11 System. out. println ( t1. a ) ; 12 } 13 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 30 / 109

31 Les bases Exceptions Exceptions Idée : séparer le plus possible les cas normaux des cas problématiques Rend le code plus lisible, évite de nombreux tests (existence, bornes, nullité... ) Jamais de core dump en! En cas d erreur la JVM lance (throws) une exception Si on ne fait rien : arrêt du programme Deux réactions : tout arrêter, ou corriger l erreur et continuer On peut intercepter une exception : try... catch générer une exception : throw déclarer les exceptions d une méthode : throws Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 31 / 109

32 Les bases Exceptions Exception : interception 1 try { a [ i ] = x ; // 0 <= i < a.length? 4 s. dosomething ( ) ; // s!= null? 5 } catch ( IndexOutOfBoundsException e ) { 6 // Oops! 7 } catch ( NullPointException e ) { 8 e. printstacktrace ( ) ; 9 } finally { 10 // Clean up. Toujours exécuté 11 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 32 / 109

33 Les bases Exceptions Affichage du stack d appel printstacktrace() java.lang.nullpointerexception at MyTest.print(MyTest.java:19) at MyMainTest.doSomething(MyMainTest.java:13) at MyMainTest.main(MyMainTest.java:3) Console Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 33 / 109

34 Les bases Exceptions Exception : déclaration et génération 1 public int mytest ( int x ) throws Exception { 2 if ( x==0) { 3 throw new Exception ( "x==0!!" ) ; 4 } } try { 9 mytest ( x ) ; 10 } catch ( Exception e ) { 11 e. printstacktrace ( ) ; 12 throw e ; 13 } finally { 14 // Clean up. Toujours exécuté, même après le throw e 15 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 34 / 109

35 et Orienté Objet Table des matières I 1 Introduction 2 Les bases 3 et Orienté Objet Constructeurs et surcharge Modifiers Packages Héritage Interfaces Généricité 4 Threads Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 35 / 109

36 et Orienté Objet Table des matières II 5 Mais encore... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 36 / 109

37 et Orienté Objet Constructeurs et surcharge Classes et Objets Tout doit être dans une classe! Les classes ont des champs (fields, data members) et des méthodes (methods, member functions) Une seule classe publique par fichier ( NomDeLaClasse.java ) Pas de séparation en-tête/corps Modifiers : private, public idem C++. protected et par défaut cf. packages et héritage Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 37 / 109

38 et Orienté Objet Constructeurs et surcharge Constructeur et surcharge Constructeur : méthode du même nom que la classe. Très similaire à C++ Différents constructeurs avec un nombre et/ou des types de paramètres différents : surcharge (overloading polymorphisme paramétrique) Pas de surcharge des opérateurs (+, []... ) Pas de paramètre par défaut Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 38 / 109

39 et Orienté Objet Constructeurs et surcharge Constructeurs et surcharge 1 class Point { 2 private int x, y ; 3 4 public Point ( int x, int y ) { this. x=x ; this. y=y ; } 5 public Point ( ) { this ( 0, 0) ; } 6 public Point ( double x, double y ) 7 { this ( ( int ) x, ( int ) y ) ; } 8 public Point ( Point p ) { this ( p. x, p. y ) ; } 9 } 10 class Test { 11 public static void main ( String [ ] argv ) { 12 Point p1 = new Point ( 1, 2) ; 13 Point p2 = new Point ( 1. 3, 2. 3 ) ; 14 Point p3 = new Point ( p2 ) ; 15 } 16 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 39 / 109

40 et Orienté Objet Constructeurs et surcharge Destructeur finalize Un équivalent du destructeur C++ : méthode finalize() Appellé lors que le Garbage Collector détruit l objet peut être très tard! Utile pour libérer des ressources utilisables jusqu à la fin (fichiers, sockets... ) Toujours appellée après un exit (même d erreur) finalize 1 Class A extends B { 2 protected void finalize ( ) { 3 super. finalize ( ) ; 4 // clean... 5 } 6 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 40 / 109

41 et Orienté Objet Modifiers Modifiers : final Un champ, une variable, une méthode peut être déclaré(e) final Champ ou variable final const Si primitive : valeur constante Si objet : la référence est constante, pas l objet! 1 final Foo a = new Foo ( 3 ) ; 2 a = new Foo ( 4 ) ; // Illégal 3 a. setvalue ( 4 ) ; // Légal Si l objet est immutable (String, Integer... ), il devient constant Sur des classes ou des méthodes cf. héritage Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 41 / 109

42 const et final et Orienté Objet Modifiers const C++ final 1 const Foo * a= new Foo ( ) ; 2 a >x = 5; // Illégal 3 a = new Foo ( ) ; // Légal 4 5 Foo * const b= new Foo ( ) ; 6 b >x = 5; // Légal 7 b = new Foo ( ) ; // Illégal 1 // Pas d équivalent final Foo b= new Foo ( ) ; 6 b. x = 5 ; // Légal 7 b= new Foo ( ) ; // Illégal Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 42 / 109

43 et Orienté Objet Modifiers Modifiers : static Définit une caractéristique de la classe (pas de l objet) static constant!! Méthode static : a uniquement accès à des champs/méthodes static peut être invoquée en dehors d un objet Champ static : copie commune à toutes les instances Une variable qui n est pas un champ ne peut pas être static! Pourquoi public static void main(string [] args)? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 43 / 109

44 et Orienté Objet Packages Packages Les classes peuvent être regroupées en packages Structure hiérarchique : packagea.packageb.myclass Concept similaire au namespace et/ou include de C++ Package : nom complet 1 java. util. ArrayList list = new java. util. ArrayList ( ) ; Packages : importation 1 import java. util. ArrayList ; ArrayList list = new ArrayList ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 44 / 109

45 et Orienté Objet Packages Packages Le. sépare les entités : java.lang.system.out.println() : package java sous-package lang classe System champ (static) out fonction println() import java.util. * : importe toutes les classes de java.util import PackageA.PackageB.MyClass : cherche le fichier MyClass.class dans le répertoire PackageA/PackageB Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 45 / 109

46 et Orienté Objet Packages Fichier./PackageA/PackageB/MyClass.java 1 package PackageA. PackageB ; 2 public class MyClass { 3 public int x = 0; 4 public MyClass ( int x ) { this. x=x ; } 5 } Fichier./PackageC/HelloWorld.java 1 package PackageC ; 2 import PackageA. PackageB. MyClass ; 3 public class HelloWorld { 4 public static void main ( String args [ ] ) { 5 MyClass a = new MyClass ( 5 ) ; 6 System. out. println ( a. x ) ; 7 } } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 46 / 109

47 et Orienté Objet Packages Compilation Packages : compilation $ javac PackageA/PackageB/MyClass.java $ javac PackageC/HelloWorld.java Console $ java PackageC.HelloWorld Autre syntaxe $ cd PackageA/PackageB/ ; javac MyClass.java ; cd - $ cd PackageC/ ; javac HelloWorld.java ; cd - Console $ java PackageC/HelloWorld Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 47 / 109

48 et Orienté Objet Packages Classpath Si le package n est pas accessible depuis le répertoire courant : il faut préciser à javac et java le classpath Exemple : Mylib/PackageA/PackageB/MyClass.java Classpath $ javac -cp Mylib PackageC/HelloWorld.java $ java -cp Mylib:. PackageC.HelloWorld Console Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 48 / 109

49 et Orienté Objet Packages Jar On peut rassembler les.class dans une archive (fichier jar ) Jar $ jar cf mypackage.jar PackageA $ java -cp mypackage.jar:. PackageC.HelloWorld Console Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 49 / 109

50 et Orienté Objet Héritage Héritage Comme en C++, offre un mécanisme d héritage Héritage multiple interdit Par défaut, une classe hérite de Object Toute classe (sauf Object) hérite de une et une seule classe Un mécanisme d interface simule l héritage multiple Héritage = héritage public de C++ Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 50 / 109

51 et Orienté Objet Héritage Héritage En C++, on aura : Héritage C++ 1 class Derived : public Base {... } ; Deux significations : Derived peut faire tout ce que Base peut faire (et peut-être plus) héritage d interface Derived fait les choses de la même façon que Base, sauf si explicité héritage de méthode En : les deux concepts sont distincts Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 51 / 109

52 et Orienté Objet Héritage Héritage de méthode Héritage 1 class Base { 2 int f ( ) { /*... */ } 3 void g ( int x ) { /*... */ } 4 } 5 6 class Derived extends Base { 7 void g ( int x ) { /* overriding */ } 8 double h ( ) { /*... */ } 9 } Base : super-classe de Derived Derived : sous-classe de Base Redéfinition : overriding ( overloading), ou polymorphisme d héritage Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 52 / 109

53 et Orienté Objet Héritage Modifiers : private Base Dérivée C++ Classe : V V Objet : X X Classe : X X Objet : X X Classe : accessible au sein des fonctions de la classe Objet : accessible au contexte des instances Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 53 / 109

54 et Orienté Objet Héritage Modifiers : public Base Dérivée C++ Classe : V V Objet : V V Classe : V V public : V Objet : V protected : X private : X Classe : accessible au sein des fonctions de la classe Objet : accessible au contexte des instances Un seul niveau d héritage pour C++ Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 54 / 109

55 et Orienté Objet Héritage Modifiers : protected Base Dérivée C++ Classe : V V Objet : Même package : V Autre package : X X Classe : V V Objet : Même package : V Autre package : X X Classe : accessible au sein des fonctions de la classe Objet : accessible au contexte des instances Un seul niveau d héritage pour C++ Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 55 / 109

56 et Orienté Objet Héritage Modifiers : par défaut Base Dérivée Classe : Objet : Classe : Objet : V Même package : V Autre package : X Souvent comparé au friend de C++ Classe : accessible au sein des fonctions de la classe Objet : accessible au contexte des instances Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 56 / 109

57 et Orienté Objet Héritage Constructeurs et Héritage C++ et : crée implicitement un constructeur sans paramètre UNIQUEMENT si aucun constructeur avec paramètre n est défini! Héritage du constructeur : si pas de super(...) en première ligne, appelle le constructeur sans paramètre Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 57 / 109

58 et Orienté Objet Héritage Héritage et constructeur 1 class Parent { 2 Parent ( int x ) {... } 3 } 4 5 class Child extends Parent { 6 Child ( int y ) { 7 f ( y ) ; // Illégal 8 } 9 } Solutions : Écrire un constructeur sans paramètre pour Parent Commencer Child(int y) par super (...) Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 58 / 109

59 et Orienté Objet Héritage Abstract et Virtual Méthode non virtuelle C++ 1 class Base { 2 public : void echo ( ) { cout <<" Base"<<endl ; } 3 } ; 4 5 class Derived : public Base { 6 public : void echo ( ) { cout <<" Derived"<<endl ; } 7 } ; Base * a = new Base ( ) ; 10 Derived * b = new Derived ( ) ; a >echo ( ) ; 13 b >echo ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 59 / 109

60 et Orienté Objet Héritage Abstract et Virtual Méthode non virtuelle C++ 1 class Base { 2 public : void echo ( ) { cout <<" Base"<<endl ; } 3 } ; 4 5 class Derived : public Base { 6 public : void echo ( ) { cout <<" Derived"<<endl ; } 7 } ; Base 10 Base * a = new Base ( ) ; * b = new Derived ( ) ; a >echo ( ) ; 13 b >echo ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 60 / 109

61 et Orienté Objet Héritage Abstract et Virtual Héritage virtuel C++ 1 class Base { 2 public : virtual void echo ( ) { cout <<" Base"<<endl ; } 3 } ; 4 5 class Derived : public Base { 6 public : void echo ( ) { cout <<" Derived"<<endl ; } 7 } ; Base 10 Base * a = new Base ( ) ; * b = new Derived ( ) ; a >echo ( ) ; 13 b >echo ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 61 / 109

62 et Orienté Objet Héritage Abstract et Virtual Méthode virtuelle pure C++ 1 class Base { 2 public : virtual void echo ( ) =0; 3 } ; 4 5 class Derived : public Base { 6 public : void echo ( ) { cout <<" Derived"<<endl ; } 7 } ; Base * a = new Base ( ) ; // Illégal 10 Base * b = new Derived ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 62 / 109

63 et Orienté Objet Héritage Abstract et Virtual En : les méthodes sont toujours virtuelles pas de virtual Fonction virtuelle 1 class Base { 2 public void echo ( ) { System. out. println ( "Base" ) ; } 3 } 4 5 class Derived extends Base { 6 public void echo ( ) { System. out. println ( "Derived" ) ; } 7 } Base a = new Base ( ) ; 10 Base b = new Derived ( ) ; a. echo ( ) ; 13 b. echo ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 63 / 109

64 et Orienté Objet Héritage Abstract et Virtual Une méthode virtuelle pure est dite abstract ( force la redéfinition) Méthode abstract Classe abstract Méthode abstract 1 class abstract Base { 2 public void abstract echo ( ) ; 3 } 4 5 class Derived extends Base { 6 public void echo ( ) { System. out. println ( "Derived" ) ; } 7 } Base a = new Base ( ) ; // Illégal 10 Base b = new Derived ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 64 / 109

65 et Orienté Objet Héritage Abstract et Virtual abstract force la redéfinition final empêche la redéfinition Méthode final 1 class Base { 2 public void final echo ( ) { 3 System. out. println ( "Base" ) ; 4 } 5 } 6 7 class Derived extends Base { 8 public void echo ( ) {... } // Illégal 9 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 65 / 109

66 et Orienté Objet Héritage Abstract et Virtual Classe final 1 final class Base { 2 public void echo ( ) { 3 System. out. println ( "Base" ) ; 4 } 5 } 6 7 class Derived extends Base {... } // Illégal Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 66 / 109

67 et Orienté Objet Héritage Abstract et Virtual C++ Méthodes non virtuelles par défaut X Méthodes virtuelles virtual par défaut Méthodes virtuelles pures virtual=0 abstract Héritage final X final Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 67 / 109

68 et Orienté Objet Héritage final : synthèse final int a : variable non modifiable final MyClass a : référence non modifiable final int a(){} : méthode non redéfinissable final class a{} : classe non dérivable Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 68 / 109

69 et Orienté Objet Héritage Retour sur la sûreté de typage (type safety) Exemple de safety précédent : ne compilait pas Avec l héritage, on peut le mettre en défaut : compile, mais exception à l exécution Reste plus safe que C++! Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 69 / 109

70 et Orienté Objet Héritage Safety 1 class Parent { } 2 class Child1 extends Parent { public int a ; } 3 class Child2 extends Parent { public double b ; } 4 5 public class Safety2 { 6 public static void main ( String [ ] arg ) { 7 Child1 c1 = new Child1 ( ) ; c1. a = 5; 8 Child2 c2 = new Child2 ( ) ; c2. b = 2. 4 ; 9 Parent p = c1 ; // Down -conv. (safe) 10 Child1 pc1 = ( Child1 ) p ; // Up-conv. (unsafe) 11 System. out. println ( pc1. a ) ; // Ok 12 p = c2 ; // Safe 13 pc1 = ( Child1 ) p ; // Unsafe -> Exception 14 System. out. println ( pc1. a ) ; 15 } 16 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 70 / 109

71 et Orienté Objet Interfaces Interfaces Interface : classe purement abstraite (que des déclarations, sans aucune définition) class interface Constitue un contrat de ce que la classe s engage à implémenter On peut implémenter plusieurs interfaces Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 71 / 109

72 et Orienté Objet Interfaces Interfaces 1 interface MyIntf { 2 int f1 ( ) ; 3 } 4 5 interface MySubIntf extends MyIntf { 6 int f2 ( ) ; 7 } 8 9 public class MyClass extends AnotherClass 10 implements MySubIntf { 11 public int f1 ( ) {... } 12 public int f2 ( ) {... } 13 } MyIntf a = new MyClass ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 72 / 109

73 et Orienté Objet Généricité Généricité (Generics) Considérons un simple container Box qui contient un objet, et deux méthodes : add et get : Box 1 public class Box { 2 private Object object ; 3 4 public void add ( Object object ) { 5 this. object = object ; 6 } 7 public Object get ( ) { 8 return object ; 9 } 10 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 73 / 109

74 et Orienté Objet Généricité Classe Box : utilisation 1 Box integerbox = new Box ( ) ; 2 3 integerbox. add ( new Integer (10) ) ; 4 Integer someinteger1 = ( Integer ) integerbox. get ( ) ; 5 6 integerbox. add ( "10" ) ; 7 Integer someinteger2 = ( Integer ) integerbox. get ( ) ; Que se passe-t-il à la compilation? Que se passe-t-il à l exécution? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 74 / 109

75 et Orienté Objet Généricité Solution : classe générique Classe Box générique 1 public class Box<T> { 2 private T t ; 3 4 public void add ( T t ) { 5 this. t = t ; 6 } 7 8 public T get ( ) { 9 return t ; 10 } 11 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 75 / 109

76 et Orienté Objet Généricité Generics vs. Template Generics Template C public class Box<T> { 3 private T t ; public void add ( T t ) { 7 this. t = t ; 8 } 9 10 public T get ( ) { 11 return t ; 12 } 13 } 1 template <class T> 2 class Box { 3 private : T t ; 4 5 public : 6 void add ( T t ) { 7 this >t = t ; 8 } 9 10 T get ( ) { 11 return t ; 12 } 13 } ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 76 / 109

77 et Orienté Objet Généricité Méthodes : Generics vs. Template Generics 1 public <U, V> U dosomething ( U u, V v ) { } Template C++ 1 template <class U, class V> 2 U dosomething ( U u, V v ) { } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 77 / 109

78 et Orienté Objet Généricité Généricité limitée Bounded type generics 1 public <U extends Number > void dosomething ( U u ) { 2 System. out. println ( u. doublevalue ( ) ) ; 3 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 78 / 109

79 et Orienté Objet Généricité Généricité et sous-typage Integer est un sous-type de Number. Donc un Integer est un Number. On peut donc écrire : 1 Integer i = new Integer ( 5 ) ; 2 Number n = i ; Donc dans une Box<Number>, on peut mettre des Integer : 1 Box<Number > bn = new Box<Number > ( ) ; 2 Integer i = new Integer ( 5 ) ; 3 Number n =... ; 4 bi. add ( i ) ; 5 bi. add ( n ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 79 / 109

80 et Orienté Objet Généricité Généricité et sous-typage Box<Integer> est-il un sous-type de Box<Number>? ou Un Box<Integer> est-il un Box<Number>? Autrement dit, peut-on écrire : 1 Box<Integer > bi = new Box<Integer > ( ) ; 2 Box<Number > bn = bi ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 80 / 109

81 et Orienté Objet Généricité Generics vs. Template (Generics) C++ (Templates) Quoi Uniquement références Tout type (objet ou prim.) + int Comment Une seule copie Copies séparées à la compilée compilation Spécialisation X V Valeur par défaut X V (classes) Type bounding V X Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 81 / 109

82 Threads Table des matières I 1 Introduction 2 Les bases 3 et Orienté Objet 4 Threads Définition et motivations Principes de base Synchronisation 5 Mais encore... Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 82 / 109

83 Threads Définition et motivations Définition Thread : processus léger (lightweight process) Processus : possède son propre contexte d exécution (stack) Léger : s exécute dans le contexte d un programme, et partage des ressources (heap) Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 83 / 109

84 Threads Définition et motivations Motivations Utilités : Puissance de modélisation Puissance d exécution Légèreté grâce au partage des données Meilleures performances au lancement et en exécution Facilités : Gestion des threads est intégrée au langage Simplicité d utilisation Thread = objet Primitives pour écrire des programmes concurrents et synchronisés Difficultés : Gérer la concurrence (synchronisation, sections critiques, deadlock) Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 84 / 109

85 Threads Définition et motivations Utilisations Animation dans un interface graphique (à intervalle régulier) Traitement en tâche de fond Application Client-Serveur Parallélisation d un algorithme Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 85 / 109

86 Threads Principes de base Classe java.lang.thread Thread 1 interface Runnable { 2 void run ( ) ; 3 } 4 5 class Thread implements Runnable { 6 Thread ( ) ; 7 Thread ( Runnable target ) ; 8 void run ( ) ; 9 void start ( ) ; } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 86 / 109

87 Threads Principes de base Exemple (extends Thread) BGSorter.java 1 class BGSorter extends Thread { 2 List l ; 3 public BGSorter ( List l ) { this. l = l ; } 4 public void run ( ) { /* sort l */ } 5 } List l = new ArrayList ( ) ; BGSorter sorter = new BGSorter ( l ) ; 10 sorter. start ( ) ; En quoi cette solution est-elle contraignante? Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 87 / 109

88 Threads Principes de base Exemple (implements Runnable) Exemple de thread 1 class BGSorter extends SomeClass implements Runnable { 2 List l ; 3 public BGSorter ( List l ) { this. l = l ; } 4 public void run ( ) { /* sort l */ } } List l = new ArrayList ( ) ; BGSorter sorter = new BGSorter ( l ) ; 11 Thread thread = new Thread ( sorter ) ; 12 thread. start ( ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 88 / 109

89 Threads Principes de base Exemple avec start automatique Exemple de thread 1 class BGSorter extends Thread { 2 List l ; 3 public BGSorter ( List l ) { this. l = l ; start() ; } 4 public void run ( ) { /* sort l */ } 5 } List l = new ArrayList ( ) ; BGSorter sorter = new BGSorter ( l ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 89 / 109

90 Threads Principes de base Méthodes diverses getname()/setname(string s) getpriority()/setpriority(int p) : p grand = haute priorité yield() : suggère au scheduler de prendre la main sleep(int millis) : pause setdaemon(boolean on) : programme s arrête lorsqu il ne reste plus que des démons!!! Runtime.exit(int status) sort du programme (tue tous les threads). Fin d un thread = sortie de run() Possibilité de hiérarchiser les threads en ThreadGroup Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 90 / 109

91 Threads Synchronisation Attendre la fin Thread et join 1 class BGSorter extends Thread { 2 List l ; 3 public BGSorter ( List l ) { this. l = l ; start ( ) ; } 4 public void run ( ) { /* sort l */ } 5 } List l = new ArrayList ( ) ; BGSorter sorter = new BGSorter ( l ) ; try { 12 sorter.join() ; 13 } catch ( InterruptedException e ) { /*... */ } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 91 / 109

92 Threads Synchronisation Sections critiques Difficulté de la programmation parallèle : les accès concurrents Exemple : s1 = new BGSorter(l) ; l.get(i).setvalue(4); Solution : verrouillage des objets synchronized synchronized 1 class MyListMgr { 2 List l ;... 3 public synchronized void sort ( ) { /* sort */ } 4 } public void run ( ) { // dans un Thread 7 // Do non critical stuffs 8 mylistmgr. sort ( ) ; 9 // Do non critical other stuffs 10 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 92 / 109

93 Threads Synchronisation Sections critiques On empêche deux tris en parallèle Mais accès en lecture/écriture sur List l toujours possible! Il faut rendre l accès synchronized Dans l exemple, le manager est verrouillé. Il faudrait verrouiller la liste List l Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 93 / 109

94 Threads Synchronisation Sections critiques synchronized private void sort ( ) { 3 synchronized ( l ) { 4 /* sort */ 5 } 6 } List mylist = new ArrayList ( ) ; 9 BGSorter sorter = new BGSorter ( mylist ) ; 10 synchronized ( mylist ) { 11 a = mylist. get ( 5 ) ; 12 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 94 / 109

95 Threads Synchronisation Exemple plus complet BGSorter (incomplet!!) 1 class BGSorter extends Thread { 2 List < Integer > list ; 3 4 public BGSorter ( List <Integer> l ) { list = l ; } 5 public void run ( ) { 6 for ( int i =0; i<list. size ( ) ; ++i ) 7 for ( int j =0; j<list. size ( ) i 1; ++j ) 8 if ( list. get ( j ) > list. get ( j+1) ) { 9 Integer tmp = list. get ( j ) ; 10 list. set ( j, list. get ( j+1) ) ; 11 list. set ( j+1, tmp ) ; 12 } 13 } 14 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 95 / 109

96 Threads Synchronisation Exemple plus complet Hypothèse : tous les éléments sont différents FindDuplicates (incomplet!!) 1 class FindDuplicates extends Thread { 2 boolean stop = false ; 3 List <Integer > list ; 4 5 public FindDuplicates ( List <Integer > l ) { list=l ; } 6 public void run ( ) { 7 while (! stop ) 8 for ( int i = 0; i < list. size ( ) 1; ++i ) 9 if ( list. get ( i ) == list. get ( i+1) ) 10 ; // print something 11 } 12 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 96 / 109

97 Threads Synchronisation Exemple plus complet Solutions pour éviter les accès concurrents synchronized(list) dans les deux run synchronized(list) plus local synchronized(list.get(i)) Vandy BERTEN INFO-F-202 Université Libre de Bruxelles 97 / 109

98 Threads Synchronisation Coordination de Threads Outre la concurrence, il faut souvent gérer la coordination Attendre des résultats d un autre threads, attendre un signal pour manipuler un objet... obj.wait() : le thread s endort sur obj obj.notify() : réveille un des threads endormis sur obj obj.notifyall() : réveille tous le threads endormis sur obj Ces trois méthodes : dans un bloc ou une méthode synchronized Une mise en attente libère le verrou (le reprend au réveil) Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 98 / 109

99 Threads Synchronisation Exemple de coordination On considère une file partagée, avec deux méthodes : push et pop Deux threads : un producteur, un consommateur Coordination 1 public class MyQueue { 2 private Queue q = new Queue ( ) ; 3 public synchronized void put ( Object o ) { 4 q. enqueue ( o ) ; 5 } 6 public synchronized Object get ( ) { 7 // Si la liste est vide, attendre un " push" 8 9 return q. dequeue ( ) ; 10 } 11 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 99 / 109

100 Threads Synchronisation Coordination : 1 ère mauvaise solution (sans wait/notify) 1 public class MyQueue { 2 private Queue q = new Queue ( ) ; 3 public synchronized void put ( Object o ) { 4 q. enqueue ( o ) ; 5 } 6 public synchronized Object get ( ) { 7 while ( q. isempty ( ) ) 8 ; 9 10 return q. dequeue ( ) ; 11 } 12 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 100 / 109

101 Threads Synchronisation Coordination : 2 ème mauvaise solution (avec wait/notify) 1 public class MyQueue { 2 private Queue q = new Queue ( ) ; 3 public synchronized void put ( Object o ) { 4 q. enqueue ( o ) ; 5 this.notify() ; 6 } 7 public synchronized Object get ( ) { 8 if ( q. isempty ( ) ) { 9 try { 10 this.wait() ; 11 } catch ( InterruptedException e ) { } 12 } 13 return q. dequeue ( ) ; 14 } 15 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 101 / 109

102 Threads Synchronisation Coordination : Bonne solution 1 public class MyQueue { 2 private Queue q = new Queue ( ) ; 3 public synchronized void put ( Object o ) { 4 q. enqueue ( o ) ; 5 this. notify ( ) ; 6 } 7 public synchronized Object get ( ) { 8 while ( q. isempty ( ) ) { 9 try { 10 this. wait ( ) ; 11 } catch ( InterruptedException e ) { } 12 } 13 return q. dequeue ( ) ; 14 } 15 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 102 / 109

103 Mais encore... Table des matières I 1 Introduction 2 Les bases 3 et Orienté Objet 4 Threads 5 Mais encore... Dynamic Class Loader et Réflexion doc Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 103 / 109

104 Mais encore... Dynamic Class Loader et Réflexion Dynamic Class Loader Implicitement : classes chargées dans la mémoire au plus tard Encore plus dynamique : nom d une classe connue à l exécution Exemple : plug-ins Utilisation des classes Object et Class Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 104 / 109

105 Mais encore... Dynamic Class Loader et Réflexion MyIntf.java 1 public interface MyIntf { String sayhello ( String a ) ; } MyTest.java (externe) 1 public class MyTest implements MyIntf { 2 public String sayhello ( String a ) { return " Hi "+a ; } } Dynamic Class Loader 1 try { 2 Class myclass = Class.forName ( " MyTest" ) ; 3 MyIntf test = ( MyIntf ) myclass.newinstance() ; 4 System. out. println ( test. sayhello ( "Bob" ) ) ; 5 } catch ( Exception e ) {... } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 105 / 109

106 Mais encore... Dynamic Class Loader et Réflexion MyTest.java (externe) 1 public class MyTest implements MyIntf { 2 String myname ; 3 public MyTest ( String name ) { myname = name ; } 4 public String sayhello ( String a ) { return "..." ; } 5 } Dynamic Class Loader 1 Class myclass = Class. forname ( "MyTest" ) ; 2 Class types [ ] = new Class [ ] { String. class } ; 3 Object args [ ] = new Object [ ] { "Bond" } ; 4 5 Constructor constr = myclass.getconstructor(types) ; 6 7 MyIntf test = ( MyIntf ) constr. newinstance ( args ) ; 8 System. out. println ( test. sayhello ( "James" ) ) ; Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 106 / 109

107 Mais encore... doc doc Système de documentation intégré HTML Reconnu par la plupart des IDE Permet la description structurée des classes, champs et méthodes Englobé dans /**... */ Tags de classe ou @since... Tags de @exception... Compilation : javadoc File.java Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 107 / 109

108 Mais encore... doc doc 1 /** Petite description de ma classe 2 Vandy BERTEN <vandy. berten@ulb. ac.be > */ 5 public class MyTest implements MyIntf { 6 /** Courte description ( avec point final). 7 * 8 * Un peu plus de blah blah. Peut être plus long <br > 9 * Peut même contenir des <u>balises </u> HTML. 10 * 11 name Blah Blah 12 MyException si quelque chose a foiré 13 Dit bonjour à name 14 */ 15 public String print ( String name ) 16 throws MyException {... } 17 } Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 108 / 109

109 Mais encore... doc Sources for C++ Programmers : and C++, a critical comparison (Robert C. Martin) Vandy BERTEN (vandy.berten@ulb.ac.be) INFO-F-202 Université Libre de Bruxelles 109 / 109