penser_java

Thinking in Java, 2nd edition, Revision 12 2000 by Bruce Eckel

Table des matiresPrface........................................................................3Prface la 2me dition....................................................................3 Java 2.............................................................................................3 Le CD ROM..........................................................................................4 Prrequis.............................................................................................4 Apprendre Java...................................................................................5 Buts.....................................................................................................5 Documentation en ligne......................................................................6 Les chapitres.......................................................................................6 Exercices.............................................................................................8 Le CD ROM Multimdia........................................................................9 Le Code Source....................................................................................9 Typographie et style de code..............................................................9 Les versions de Java..........................................................................10 Seminars and mentoring...................................................................10 Errors................................................................................................10 propos de la conception de la couverture du livre..........................10 Remerciements.................................................................................11 Collaborateurs Internet....................................................................12 Les bienfaits de l'abstraction.............................................................13 Un objet dispose d'une interface.......................................................14 L'implmentation cache...................................................................15 Rutilisation de l'implmentation......................................................16 Hritage : rutilisation de l'interface.................................................16 Les relations est-un vs. est-comme-un ..............................................18 Polymorphisme : des objets interchangeables...................................19 Classes de base abstraites et interfaces..............................................21 Environnement et dure de vie des objets.........................................21 Collections et itrateurs...................................................................22 La hirarchie de classes unique.........................................................23 Bibliothques de collections et support pour l'utilisation aise des collections......................................................................................23 Le dilemme du nettoyage : qui en est responsable ?............................24 Traitement des exceptions : grer les erreurs...................................25 Multithreading...................................................................................25 Persistance........................................................................................26 Java et l'Internet...............................................................................26 Qu'est-ce que le Web ?....................................................................26Le concept Client/Serveur.........................................................................26 Ramasse-miettes vs. efficacit et flexibilit.................................................24 Transtypages descendants vs. patrons gnriques.......................................23

Introduction................................................................4

Penser en JavaSeconde ditionBruce EckelPresident, MindView, Inc. Traducteurs pour cette version franaise : Cdric BABAULT, Phillipe BOITE, Yannis CHICHA, Nate CULWELL-KANAREK, Jrome DANNOVILLE, Florence DEFAIX, Armel FORTUN, Daniel LE BERRE, Anthony PRAUD, Jrome QUELIN, RACZY, Olivier THOMANN, Jean-Pierre VIDAL.

1) Introduction sur les Objets...................................13

Traduction de Thinking in Java 2nd Edition - - Page 1/459

La programmation ct client............................................................27Les plugins (modules d'extension)..............................................................28 Les langages de script..............................................................................28 Java.......................................................................................................28 ActiveX...................................................................................................29 La scurit..............................................................................................29 Internet vs. intranet.................................................................................30

Le Web en tant que serveur gant.............................................................27

Tableaux en Java............................................................................46 Vous n'avez jamais besoin de dtruire un objet................................46 Notion de porte.............................................................................46 Porte des objets............................................................................47 Crer de nouveaux types de donnes : class.....................................47 Champs et mthodes.......................................................................48 Mthodes, paramtres et valeurs de retour.......................................49 La liste de paramtres.....................................................................49 Construction d'un programme Java...................................................50 Visibilit des noms..........................................................................50 Utilisation d'autres composantes.......................................................50 Le mot-clef static............................................................................51 Votre premier programme Java.........................................................52 Compilation et excution..................................................................52 Commentaires et documentation intgre.........................................53 Commentaires de documentation......................................................53 Syntaxe.........................................................................................53 HTML intgr..................................................................................54 @see : faire rfrence aux autres classes...........................................54 Class documentation tags.................................................................54@version................................................................................................54 @author.................................................................................................55 @since...................................................................................................55 Valeurs par dfaut des membres primitifs...................................................48

La programmation ct serveur.........................................................30 Une scne spare : les applications..................................................30 Analyse et conception.......................................................................31 Phase 0 : Faire un plan....................................................................32 Phase 1 : Que construit-on ?.............................................................32 Phase 2 : Comment allons-nous le construire ?....................................34 Phase 3 : Construire le coeur du systme...........................................36 Phase 4 : Itrer sur les cas d'utilisation..............................................36 Phase 5 : Evolution.........................................................................37 Les plans sont payants.....................................................................37 Programmation Extrme...................................................................38 Commencer par crire les tests.........................................................38 Programmation en binme...............................................................38 Les raisons du succs de Java...........................................................39 Les systmes sont plus faciles exprimer et comprendre......................39 Puissance maximale grce aux bibliothques.......................................39 Traitement des erreurs....................................................................39 Mise en oeuvre de gros projets.........................................................39 Stratgies de transition.....................................................................40 Rgles de base...............................................................................401. 2. 3. 4. 5. Cours.................................................................................................40 Projet faible risque............................................................................40 S'inspirer de bonnes conceptions...........................................................40 Utiliser les bibliothques de classes existantes.........................................40 Ne pas traduire du code existant en Java................................................41 Les cinq tapes de la conception d'un objet.................................................35 Indications quant au dveloppement des objets...........................................36 L'expos de la mission..............................................................................32

Les onglets de documentation de variables.........................................55 Les onglets de documentation de mthodes........................................55@param.................................................................................................55 @return..................................................................................................55 @throws.................................................................................................55 @deprecated...........................................................................................55

Les obstacles au niveau du management............................................41Cots de mise en oeuvre..........................................................................41 Problmes de performances......................................................................41 Erreurs classiques de conception...............................................................41

3 : Contrle du Flux de Programme...........................57

Exemple de documentation...............................................................55 Style de programmation....................................................................56 Sommaire..........................................................................................56 Exercices...........................................................................................56

Utilisation des oprateurs Java.........................................................58 Priorit..........................................................................................58 L'affectation...................................................................................58 Les oprateurs mathmatiques.........................................................59 Incrmentation et dcrmentation automatique...................................60 Les oprateurs relationnels...............................................................61 Les oprateurs logiques...................................................................62 Les oprateurs bit bit....................................................................63 Court-circuit .....................................................................................62 Tester l'quivalence des objets..................................................................61 Les oprateurs unaires ( un oprande) moins et plus..................................60 L'aliasing pendant l'appel des mthodes.....................................................59

2 : Tout est Objet.......................................................44

Java vs. C++ ?...................................................................................42 Rsum.............................................................................................42 Les objets sont manipuls avec des rfrences.................................44 Vous devez crer tous les objets.......................................................44 O rside la mmoire ?....................................................................45 Cas particulier : les types primitifs.....................................................45Nombres de grande prcision....................................................................46


Les oprateurs de dcalage..............................................................64 Oprateur ternaire if-else.................................................................65 L'oprateur virgule..........................................................................66 L'oprateur + pour les String............................................................66 Les piges classiques dans l'utilisation des oprateurs..........................66 Les oprateurs de transtypage..........................................................67 Java n'a pas de sizeof .................................................................68 Retour sur la priorit des oprateurs..................................................68 Rsum sur les oprateurs...............................................................68 Le Contrle d'excution.....................................................................73 true et false...................................................................................73 if-else............................................................................................73 Itration........................................................................................74 do-while........................................................................................74 for................................................................................................75 break et continue............................................................................75 switch...........................................................................................78 Rsum.............................................................................................80 Exercices...........................................................................................81Dtails de calcul :....................................................................................79 L'infme goto ....................................................................................76 L'oprateur virgule...................................................................................75 return....................................................................................................74 Les littraux............................................................................................67 La promotion...........................................................................................68

5 : Cacher l'Implmentation....................................103Collisions..............................................................................................106

Initialisation des tableaux.................................................................98 Tableaux multidimensionels............................................................100 Rsum...........................................................................................101 Exercices.........................................................................................101 package : l'unit de bibliothque.....................................................103 Crer des noms de packages uniques...............................................104 Une bibliothque d'outils personnalise............................................106 Utilisation des imports pour modifier le comportement........................107 Avertissement sur les packages.......................................................108 Les spcificateurs d'accs Java.......................................................108 Friendly .................................................................................108 public : accs d'interface................................................................108 private : ne pas toucher !...............................................................109 protected : sorte d'amical ........................................................110 Interface et implmentation............................................................111 L'accs aux classes..........................................................................111 Rsum...........................................................................................113 Exercices.........................................................................................113Le package par dfaut............................................................................109

6 : Rutiliser les classes..........................................114

4: Initialisation & Nettoyage.....................................81Garantie d'initialisation grce au constructeur..................................82 Surcharge de mthodes.....................................................................83 Diffrencier les mthodes surcharges...............................................84 Surcharge avec types de base...........................................................84 Surcharge sur la valeur de retour......................................................86 Constructeurs par dfaut..................................................................86 Le mot-cl this...............................................................................86 Nettoyage : finalisation et ramasse-miettes......................................88 A quoi sert finalize( ) ?.....................................................................89 Le nettoyage est impratif................................................................89 La death condition.......................................................................91 Comment fonctionne un ramasse-miettes ?.........................................91 Initialisation de membre...................................................................93 Spcifier une initialisation.................................................................94 Initialisation par constructeur...........................................................95Ordre d'initialisation.................................................................................95 Initialisation de donnes statiques..............................................................95 Initialisation statique explicite....................................................................97 Initialisation d'instance non statique...........................................................97 Appeler un constructeur depuis un autre constructeur..................................87 La signification de static............................................................................88

Syntaxe de composition..................................................................115 La syntaxe de l'hritage..................................................................116 Initialiser la classe de base.............................................................117 Combiner composition et hritage...................................................119 Garantir un nettoyage propre..........................................................119 Cacher les noms............................................................................121 Choisir la composition la place de l'hritage.................................121 protected.........................................................................................122 Dveloppement incrmental............................................................122 Transtypage ascendant...................................................................123 Pourquoi le transtypage ascendant ? ...............................................123 Le mot cl final................................................................................124 Donnes finales.............................................................................124 Mthodes final..............................................................................126 Classes final.................................................................................127 Attention finale.............................................................................127 Initialisation et chargement de classes...........................................128 Initialisation avec hritage..............................................................128final et private.......................................................................................126 Finals sans initialisation...........................................................................125 Arguments final.....................................................................................125 Composition la place de l'hritage revisit..............................................123 L'ordre du ramasse-miettes.....................................................................121 Constructeurs avec paramtres................................................................118 Attraper les exceptions du constructeur de base........................................118


7: Polymorphisme....................................................130Upcasting........................................................................................130 Pourquoi utiliser l'upcast?...............................................................131 The twist.........................................................................................132 Liaison de l'appel de mthode.........................................................132 Produire le bon comportement........................................................132 Extensibilit..................................................................................134 Redfinition et Surcharge................................................................135 Classes et mthodes abstraites.......................................................136 Constructeurs et polymorphisme.....................................................138 Ordre d'appel des constructeurs......................................................138 La mthode finalize() et l'hritage...................................................139 Comportement des mthodes polymorphes dans les constructeursname="Index722">....................................................141 Concevoir avec l'hritage................................................................142 Hritage pur contre extensionname="Index739">..............................142 Downcasting et identification du type l'excution.............................143 Rsum...........................................................................................144 Exercices.........................................................................................145 Interfaces.......................................................................................146 Hritage multiple en Java..........................................................147 Etendre une interface avec l'hritage................................................149 Groupes de constantes...................................................................150 Initialisation des donnes membres des interfaces.............................150 Interfaces imbriques....................................................................151 Classes internes..............................................................................152 Classes internes et transtypage ascendant........................................153 Classes internes dfinies dans des mthodes et autres portes............154 Classes internes anonymes.............................................................155 Lien vers la classe externe..............................................................157 Classes internes static....................................................................158 Se rfrer l'objet de la classe externe............................................159 Classe interne plusieurs niveaux d'imbrication.................................159 Driver une classe interne..............................................................159 Les classes internes peuvent-elles redfinies ?...................................160 Identifiants des classes internes......................................................161 Raison d'tre des classes internes....................................................161 Classes internes & structures de contrle..........................................163 Rsum...........................................................................................167 Exercices.........................................................................................167Fermetures & callbacks...........................................................................162 Combinaison d'interfaces et collisions de noms .........................................149

Rsum...........................................................................................129 Exercices.........................................................................................129

Les tableaux....................................................................................169 Les tableaux sont des objets...........................................................169 Renvoyer un tableau......................................................................171 La classe Arrays............................................................................172 Remplir un tableau........................................................................177 Copier un tableau..........................................................................177 Comparer des tableaux..................................................................178 Comparaison d'lments de tableau.................................................178 Trier un tableau............................................................................179 Effectuer une recherche sur un tableau tri.......................................180 Rsum sur les tableaux.................................................................181 Introduction sur les conteneurs.....................................................181 Imprimer les conteneurs................................................................182 Remplir les conteneurs...................................................................183 L'inconvnient des conteneurs : le type est inconnu........................186 Quelquefois a marche quand mme................................................187 Crer une ArrayList consciente du type.............................................187 Itrateurs........................................................................................188 Classification des conteneurs..........................................................190 Fonctionnalits des Collections........................................................192 Fonctionnalits des Lists.................................................................193 Raliser une pile partir d'une LinkedList.........................................195 Raliser une file partir d'une LinkedList..........................................195 Fonctionnalits des Sets..................................................................196 Sets tris : les SortedSets..............................................................197 Fonctionnalits des Maps................................................................197 Maps tries : les SortedMaps..........................................................199 Hachage et codes de hachage.........................................................200 Redfinir hashCode().....................................................................204 Stocker des rfrences....................................................................205 Le WeakHashMap..........................................................................206 Les itrateurs revisits....................................................................207 Choisir une implmentation.............................................................207 Choisir entre les Lists.....................................................................208 Choisir entre les Sets.....................................................................209 Choisir entre les Maps....................................................................210 Trier et rechercher dans les Lists....................................................211 Utilitaires........................................................................................212 Rendre une Collection ou une Map non-modifiable..............................212 Synchroniser une Collection ou une Map...........................................213 Oprations non supportes..............................................................214Echec rapide..........................................................................................213 Comprendre hashCode().........................................................................201 Facteurs de performance d'un HashMap....................................................203 Rcursion indsirable..............................................................................189 Types paramtrs..................................................................................188 Conteneurs de scalaires..........................................................................171

8 : Interfaces & Classes Internes............................146

9 : Stockage des objets...........................................168


Gestion des erreurs avec les exceptions .................220

Les conteneurs Java 1.0 / 1.1.........................................................215 Vector & Enumeration....................................................................215 Hashtable.....................................................................................215 Stack...........................................................................................216 BitSet..........................................................................................216 Rsum...........................................................................................217 Exercices.........................................................................................217 Les exceptions de base ...................................................................220 Les paramtres des Exceptions .......................................................221 Attraper une exception ...................................................................221 Le bloc try ...................................................................................221 Les gestionnaires d'exceptions .......................................................221 Crez vos propres Exceptions .........................................................222 Spcifier des Exceptions .................................................................224 Attraper n'importe quelle exception .................................................225 Relancer une exception .................................................................225 Les exceptions Java standard .........................................................227 Le cas particulier RuntimeException ................................................228 Faire le mnage avec finally ...........................................................228 Quoi sert le finally ? ...................................................................229 Le dfaut : l'exception perdue ........................................................230 Restriction d'Exceptions .................................................................231 Les constructeurs ...........................................................................232 Indication d'Exception ....................................................................234 Recommandations pour les exceptions ............................................235 Rsum ..........................................................................................235 Exercices ........................................................................................235Terminaison contre Restauration .............................................................222

Flux d'Entre................................................................................2471. 2. 3. 4. Entre en tampon du fichier [Buffered input file]....................................247 Entre depuis la mmoire....................................................................247 Entre de mmoire formate...............................................................247 Sortie de Fichier.................................................................................247

Flux de sortie................................................................................248 Un bogue ?...................................................................................248 Flux Piped....................................................................................249 Standard E/S...................................................................................249 Lire depuis une entre standard......................................................249 Modifier System.out en un PrintWriter..............................................249 Rorienter l'E/S standard................................................................250 Compression....................................................................................250 Compression simple avec GZIP........................................................251 Stockage de fichiers multiples avec Zip.............................................251 ARchives Java (JARs).....................................................................252 La srialisation objet.......................................................................253 Trouver la classe...........................................................................255 Contrler la srialisation.................................................................256Le mot-cl transient .........................................................................258 Une alternative Externalizable...............................................................259 Versioning.............................................................................................260 5. Stocker et rcuprer des donnes........................................................248 6. Accs alatoire en lecture et criture aux fichiers...................................248

11: Le systme d'E/S de Java..................................237Les classes internes anonymes................................................................238

La classe File...................................................................................237 Lister un rpertoire........................................................................237 Vrification et cration de rpertoires...............................................239 Entre et sortie...............................................................................240 Les types d'InputStream................................................................240 Les types d'OutputStream..............................................................241 Ajouter des attributs et des interfaces utiles...................................242 Lire depuis un InputStream avec FilterInputStream............................242 crire vers un OutputStream avec FilterOutputStream........................243 Lecteurs & crivains [ Loaders & Writers ]......................................244 Les sources et les rceptacles de donnes.........................................244 Modifier le comportement du flux.....................................................244 Les classes inchanges...................................................................245 Et bien sr : L'accs alatoire aux fichiers (RandomAccessFile)......245 L'usage typique des flux d'E/S........................................................246

12: Identification dynamique de type......................272Les littraux Class..................................................................................274

Utiliser la persistence.....................................................................260 Tokenizer l'entre...........................................................................264 StreamTokenizer...........................................................................264 StringTokenizer.............................................................................265 Vrifier le style de capitalization......................................................266 Rsum...........................................................................................270 Exercices.........................................................................................271

Le besoin de RTTI............................................................................272 L'objet Class.................................................................................273 Vrifier avant de transtyper............................................................274Utiliser les littraux de classe...................................................................276 Un instanceof dynamique........................................................................277 instanceof vs. quivalence de classe.........................................................277

13: Cration de Fentres et Applets........................284

La syntaxe du RTTI..........................................................................278 Rflexion : information de classe dynamique .................................279 Un extracteur de mthodes de classe...............................................280 Rsum...........................................................................................282 Exercices.........................................................................................283 L'applet de base..............................................................................285 Les restrictions des applets.............................................................285


Les avantages d'une applet.............................................................285 Les squelettes d'applications...........................................................286 Excuter des applets dans un navigateur Web...................................286 Utilisation de Appletviewer..............................................................287 Tester les applets..........................................................................288 Excuter des applets depuis la ligne de commande.........................288 Un squelette d'affichage.................................................................289 Utilisation de l'Explorateur Windows.................................................290 Cration d'un bouton.......................................................................291 Capture d'un vnement.................................................................291 Zones de texte.................................................................................293 Contrle de la disposition................................................................293 BorderLayout................................................................................294 FlowLayout...................................................................................294 GridLayout...................................................................................294 GridBagLayout..............................................................................295 Positionnement absolu...................................................................295 BoxLayout....................................................................................295 La meilleure approche ?.................................................................297 Le modle d'vnements de Swing..................................................297 Evnements et types de listeners.....................................................298 Surveiller plusieurs vnements......................................................301 Un catalogue de composants Swing.................................................302 Boutons.......................................................................................302 Icones.........................................................................................304 Infobulles [Tooltips].......................................................................305 Champs de texte [Text Fields].........................................................305 Bordures......................................................................................306 JScrollPanes.................................................................................306 Un mini-diteur.............................................................................307 Botes cocher [Check boxes].........................................................308 Boutons radio...............................................................................309 Botes combo (listes ouverture vers le bas) [combo boxes (drop-down lists)]..........................................................................................309 Listes [List boxes].........................................................................310 Panneaux tabulations [Tabbed panes]............................................311 Botes de messages.......................................................................311 Menus.........................................................................................312 Menus pop-up...............................................................................315 Dessiner......................................................................................316 Botes de dialogue.........................................................................317 Dialogues pour les fichiers [File dialogs] ..........................................319 HTML sur des composants Swing ....................................................320 Curseurs [sliders] et barres de progression [progress bars].................321 Arbres [Trees]..............................................................................321Groupes de boutons...............................................................................303 Utilisation de listener adapters pour simplifier............................................300

14) Les Threads multiples.......................................339

Tables.........................................................................................323 Slection de l'aspect de l'interface [Look & Feel]................................324 Le presse-papier [clipboard]...........................................................325 Empaquetage d'une applet dans un fichier JAR ..............................326 Techniques de programmation........................................................326 Lier des vnements dynamiquement...............................................326 Sparation entre la logique applicative [business logic] et la logique de l'interface utilisateur [UI logic] .......................................................327 Une forme canonique.....................................................................329 Programmation visuelle et Beans....................................................329 Qu'est-ce qu'un Bean ?..................................................................330 Extraction des informations sur les Beans [BeanInfo] l'aide de l'introspecteur [Introspector]..........................................................331 Un Bean plus complexe..................................................................333 Empaquetage d'un Bean.................................................................335 Un support des Beans plus sophistiqu.............................................336 Davantage sur les Beans................................................................336 Rsum...........................................................................................337 Exercices.........................................................................................337

Interfaces utilisateurs dynamiques [Responsive user interfaces]. . .339 Hritage de Thread........................................................................340 Threading pour une une interface ractive........................................341 Combiner le thread avec la classe principale......................................342 Crer plusieurs threads..................................................................343 Threads dmons............................................................................345 Partager des ressources limites.....................................................346 Des ressources accdes improprement............................................346 Comment Java partage les ressources..............................................348 JavaBeans revisits.......................................................................351 Blocage [Blocking]..........................................................................353 Passer l'tat bloqu.....................................................................353Dormant (Sleeping)................................................................................354 Suspension et reprise.............................................................................355 Attendre et notifier.................................................................................355 Bloqu sur I/O.......................................................................................357 Tester...................................................................................................357 La dprciation de stop(), suspend(), resume(), et destroy() en Java 2........358 Synchroniser les compteurs.....................................................................348 Efficacit de la synchronisation................................................................350

Interblocage [Deadlock].................................................................358 Priorits..........................................................................................360 Lire et changer les priorits............................................................360 Les groupes de threads..................................................................362 Runnable revisit............................................................................366 Trop de threads............................................................................367Controller les groupes de threads.............................................................363


15 : Informatique Distribue...................................370La programmation rseau...............................................................371 Identifier une machine...................................................................371Serveurs et clients.................................................................................372 Tester les programmes hors rseau..........................................................372 Les Ports : un emplacement unique dans la machine.................................373 Un serveur et un client vraiment simples...................................................374

Rsum...........................................................................................369 Exercices.........................................................................................370

Utilisation de l'objet distant............................................................402 Introduction CORBA.....................................................................403 Principes de base de CORBA............................................................403

Un exemple..................................................................................404crire le source IDL................................................................................404 Cration des stubs et des skeletons..........................................................404 Implmentation du serveur et du client.....................................................404 Quelques services CORBA.......................................................................405 Activation du processus du service de nommage........................................406 Activation du serveur et du client.............................................................406

CORBA Interface Definition Language (IDL - Langage de Dfinition d'Interface)... 403 Le service de nommage (naming service)..................................................404

Les sockets..................................................................................373 Servir des clients multiples.............................................................376 Les Datagrammes.........................................................................379 Utiliser des URLs depuis un applet...................................................379 En savoir plus sur le travail en rseau..............................................380 Se connecter aux bases de donnes : Java Database Connectivity (JDBC).............................................................................................380 Faire fonctionner l'exemple.............................................................382tape tape tape tape tape 1 2 3 4 5 : : : : : Trouver le Driver JDBC.............................................................382 Configurer la base de donnes...................................................382 Tester la configuration..............................................................383 Gnrer votre requte SQL.......................................................383 Modifier et insrer votre requte................................................384 Lire un fichier depuis un serveur..............................................................380

Les Applets Java et CORBA.............................................................406 CORBA face RMI.........................................................................407 Enterprise Java Beans.....................................................................407 JavaBeans contre EJBs...................................................................408 Que dfinit la spcification des EJBs ?...............................................408Les rles...............................................................................................408 Composants EJB....................................................................................408 Conteneur d'EJB................................................................................408 Serveur EJB......................................................................................409 Java Naming and Directory Interface (JNDI).........................................409 Java Transaction API / Java Transaction Service (JTA/JTS).....................409 CORBA et RMI/IIOP...........................................................................409

Une version GUI du programme de recherche....................................384 Pourquoi l'API JDBC parat si complexe.............................................385 Un exemple plus sophistiqu...........................................................385 Les Servlets.....................................................................................389 Le servlet de base.........................................................................389 Les Servlets et le multithreading.....................................................391 Grer des sessions avec les servlets.................................................392 Faire fonctionner les exemples de servlet..........................................394 Les Pages Java Serveur - Java Server Pages...................................394 Les objets implicites......................................................................395 Les directives JSP..........................................................................395 Les lments de scripting JSP.........................................................396 Extraire des champs et des valeurs..................................................397 Attributs et visibilit d'une page JSP.................................................397 Manipuler les sessions en JSP..........................................................398 Crer et modifier des cookies..........................................................399 Rsum sur les JSP........................................................................399 RMI (Remote Method Invocation) : Invocation de mthodes distantes. 400 Interfaces Remote.........................................................................400 Implmenter l'interface distante......................................................400 Cration des stubs et des skeletons.................................................402Mise en place du registre........................................................................401 La classe Cookie....................................................................................392 La classe Session...................................................................................392

Qu'est-ce qui compose un composant EJB ?......................................409Enterprise Bean.....................................................................................409 Interface Home......................................................................................409 Interface Remote...................................................................................409 Descripteur de Dploiement....................................................................409 Fichier EJB-Jar.......................................................................................410

Comment travaille un EJB ?............................................................410 Types d'EJBs.................................................................................410Session Beans.......................................................................................410 Les Session Beans non-persistants......................................................410 Les Session Beans persistants.............................................................410 Entity Beans..........................................................................................410 Gestion de la persistance par le conteneur (CMP - Container Managed Persistence).....................................................................................410 Gestion de la persistence par le Bean (BMP - Bean Managed Persistence).411

Dvelopper un Enterprise Java Bean................................................411 En rsum....................................................................................413 Jini : services distribus..................................................................413 Contexte de Jini............................................................................413 Qu'est-ce que Jini ?.......................................................................414 Comment fonctionne Jini................................................................414 Le processus de dcouverte............................................................414 Le processus de jonction................................................................415 Le processus de recherche..............................................................415 Sparation de l'interface et de l'implmentation.................................415


A : Passage & et Retour d'Objets.............................418

Abstraction des systmes distribus.................................................416 Rsum...........................................................................................416 Exercices.........................................................................................416

C : Conseils pour une programmation style en Java. . . . 444 D : Ressources.........................................................449Logicielles.......................................................................................449 Livres..............................................................................................450 Analyse & conception.....................................................................450 Python.........................................................................................451 La liste de mes livres.....................................................................451 Conception......................................................................................444 Implmentation...............................................................................446

Passage de rfrences.....................................................................418 Aliasing........................................................................................418 Cration de copies locales...............................................................419 Passage par valeur........................................................................420 Clonage d'objets...........................................................................420 Rendre une classe cloneable...........................................................421 Pour un clonage russi...................................................................421 Le mcanisme de Object.clone( ).....................................................423 Cloner un objet compos................................................................424 Copie profonde d'une ArrayList........................................................424 Copie profonde via la srialisation....................................................425 Supporter le clonage plus bas dans la hirarchie................................426 Pourquoi cet trange design ?.........................................................427 Contrler la clonabilit....................................................................427 Le constructeur de copie................................................................429 Classes en lecture seule..................................................................431 Crer des classes en lecture seule....................................................432 L'inconvnient de l'immuabilit........................................................432 Chanes immuables........................................................................433 Les classes String et StringBuffer.....................................................435 Les Strings sont spciales...............................................................437 Rsum...........................................................................................437 Exercises.........................................................................................437Constantes implicites..............................................................................434 Surcharge de l'oprateur + et les StringBuffer.....................................434 Pourquoi cela fonctionne-t-il en C++ et pas en Java ?................................431 Utilisation d'une astuce avec protected.....................................................421 Implmenter l'interface Cloneable............................................................421

#TIJ_PAGE01#25.04.2001 - Version 0.2 : - Mise en forme du code html (armel). 19.08.2000 - Version 0.1 : - Dernire mise jour de la version franaise Traducteur : - Jean-Pierre VIDAL Texte original : - Thinking in Java, 2nd edition, Revision 10 2000 by Bruce Eckel

PrfaceJ'ai suggr mon frre Todd, qui est en train de migrer du hardware vers le software, que la prochaine grande rvolution serait l'ingnierie gntique.Nous crerons bientt des organismes ddis la fabrication de nourriture, de carburant, de plastique ; ils digreront la pollution et, de manire gnrale, nous permettront de matriser la manipulation du monde rel, ceci pour un cot minime compar celui d'aujourd'hui. J'ai prtendu que la rvolution informatique serait vraiment peu de chose au regard de cela. Puis j'ai ralis que j'tais en train de commettre une erreur triviale chez les auteurs de science-fiction : oublier le propos de la technologie (ce qui est videmment trs facile faire en science-fiction). Un crivain expriment sait qu'on ne raconte jamais une histoire propos de choses, mais de gens. La gntique aura un trs grand impact sur nos vies, mais je ne suis pas persuad qu'elle clipsera la rvolution informatique (qui d'ailleurs rend possible la rvolution gntique) ou

B: L'Interface Native Java [Java Native Interface] (JNI).......................................................................438

Appeler une mthode native............................................................439 Le gnrateur d'entte [ header file generator] : javah.......................439 Les conventions de nommage [name mangling]et les signatures de fonctions......................................................................................440 Implmenter votre DLL..................................................................440 Accder des fonctions JNI : l'argument JNIEnv............................441 Accder des chanes Java.............................................................441 Passer et utiliser des objets Java....................................................441 JNI et les exceptions Java...............................................................442 JNI et le threading..........................................................................443 Utiliser une base de code prexistantes..........................................443 Information complmentaire...........................................................443


au moins la rvolution de l'information. L'information, c'est essentiellement se parler les uns les autres : bien entendu, les voitures, les chaussures, et surtout les maladies gntiques sont importantes, mais en dfinitive ce ne sont que des fauxsemblants. La vrai question est notre relation au monde. Ainsi en est-il de la communication. Ce livre est un cas. Une majorit d'amis pensa que j'tais soit vraiment hardi soit lgrement drang pour mettre tout cela sur le Web. Pourquoi quelqu'un voudrait-il l'acheter ? me disaient-ils. Si j'avais eu un temprament plus conservateur, je ne m'y serais pas pris de cette manire ; en ralit je ne voulais pas crire un livre supplmentaire de style traditionnel sur les ordinateurs. Je ne savais ce qui en aurait rsult si je n'avais pas agi ainsi, mais en tout cas ce fut la meilleure chose que j'ai jamais ralise avec un livre. Tout d'abord, chacun commena m'envoyer des correctifs. Ce fut un processus trs amusant, parce que mes amis avaient furet dans chaque coin et recoin et repr les erreurs techniques aussi bien que grammaticales, ce qui me permit d'liminer les fautes de toutes sortes que j'aurais laiss passer sans cela. Dans ce travail, ils ont t tout simplement formidables, commenant trs souvent par me dire bon, je ne dis pas a pour critiquer... pour me mettre ensuite sous le nez un ensemble d'erreurs que je n'aurais jamais t capable de trouver par moi-mme. Je crois que ce fut une espce de travail de groupe, et cela a rellement ajout quelque chose de spcial ce livre. Mais ensuite, j'ai commenc entendre ceci : OK, trs bien, c'est bien gentil vous avez fait une version lectronique, mais moi j'aurais prfr une version complte imprime chez un vrai diteur . Alors j'ai beaucoup travaill afin que chacun puisse l'imprimer dans un format adquat, mais cela n'a pas suffi rsorber la demande d'un livre publi . La plupart des gens n'ont pas envie de lire le livre l'cran dans son intgralit, et l'ide de transporter un paquet de feuilles volantes, mme impeccablement imprimes, ne leur conviendrait pas davantage (de plus, je pense que ce n'est pas forcment conomique en terme de toner). Aprs tout il semblerait que la rvolution informatique ne risque pas de mettre les diteurs au chmage. Un tudiant suggra toutefois que cela pourrait servir de modle pour l'dition du futur : les livres seraient d'abord publis sur le Web, et, condition qu'ils rencontrent un certain intrt, on les coucherait sur papier. Actuellement, une grande majorit de livres reprsentent des dsastres financiers, et cette nouvelle approche pourrait peut-tre rendre l'industrie de l'dition plus rentable. Ce livre a t par ailleurs une exprience enrichissante pour moi. Ma premire approche de Java fut juste un nouveau langage de programmation , ce qu'il est de fait par ailleurs. Mais, le temps passant, et au fur et mesure que je l'tudiais plus en profondeur, je commenais m'apercevoir que son propos fondamental tait diffrent de celui de tous les langages que j'avais connu auparavant. Programmer, c'est grer la complexit : complexit du problme que l'on veut

rsoudre, superpose la complexit de la machine sur laquelle il va tre rsolu. Bien des projets de programmation ont avort cause de cette complexit. Je voudrais maintenant dire que, de tous les langages de programmation que je connaisse, aucun n'a t conu pour grer la complexit du dveloppement et de la maintenance de programmes [1]. Bien entendu, dans la conception des langages, beaucoup de dcisions ont t prises en gardant la complexit prsente l'esprit, mais, dans chaque exemple et partir d'un certain moment, d'autres problmes ont surgi qui furent considrs comme essentiels et par suite intgrs la mixture. Fatalement, ces nouveaux problmes furent de ceux qui envoyrent finalement les programmeurs droit dans le mur avec ce langage. Par exemple, C++ se devait de possder une compatibilit ascendante avec C (afin de favoriser la migration des programmeurs C), ainsi qu'une certaine efficacit. Ces deux buts taient trs utiles et ont grandement particip au succs de C++, mais dans le mme temps ils ont gnr une complexit supplmentaire qui a eu pour rsultat d'empcher certains projets d'arriver terme (bien entendu, vous pouvez toujours vous en prendre la responsabilit des programmeurs et/ou de leur encadrement, mais, si un langage pouvait vous aider reprer vos erreurs, pourquoi ne le ferait-il pas ?). Autre exemple, Visual Basic (VB) tait li BASIC, lequel n'tait pas vraiment conu comme un langage extensible, et par suite toutes les extensions superposes VB se sont traduites par une syntaxe vraiment horrible et impossible maintenir. Perl a une compatibilit ascendante avec Awk, Sed, Grep ainsi que d'autres outils Unix qu'il tait cens remplacer, le rsultat est qu'il est souvent accus de produire du code--crire-seulement (c'est dire qu'on est incapable de se relire quelques mois plus tard). D'un autre ct, C++, VB, Perl, et d'autres langages comme Smalltalk, de par leur conception, ont abord le problme de la complexit, et par l se rvlent remarquablement efficaces dans la rsolution de certains types de problmes. Ce qui m'a le plus frapp alors que je commenais comprendre Java est quelque chose qui s'apparente l'incroyable finalit de diminuer la complexit pour le programmeur. Un peu comme si l'on disait rien n'est important, mis part rduire le temps et la difficult pour produire un code robuste . Dans les premires versions de Java, cette finalit s'est traduite par un code qui ne tournait pas trs vite (bien que l'on ait fait de nombreuses promesses concernant la vitesse de Java) mais il n'empche que cela a rduit le temps de dveloppement de manire stupfiante : la moiti, ou moins, du temps ncessaire la cration d'un programme quivalent en C++. Ce seul rsultat pourrait dj se traduire par une incroyable conomie de temps et d'argent, mais Java ne s'arrte pas l. Il s'attache encapsuler toutes les tches complexes qui ont pris de l'importance, comme le multithreading et la programmation rseau, au moyen de fonctionnalits du langage ou de bibliothques rendant parfois ces tches triviales. Et pour finir, il traite quelques problmes d'une relle complexit : programmes multi-plate-forme, changements dynamiques de code, sans oublier la scurit, chacun d'entre eux pouvant s'adapter votre gamme de difficults, depuis un obstacle jusqu' un point bloquant . Ainsi, malgr les


problmes de performance que nous avons vus, les promesses de Java sont normes : il est capable de faire de nous des programmeurs encore plus productifs. Le Web est l'un des lieux o cela se rvle le plus. La programmation rseau a toujours t difficile, et Java la rend facile (et les concepteurs du langage Java travaillent la rendre encore plus facile). La programmation rseau, c'est ce qui fait que nous parlons entre nous de manire plus pertinente et meilleur march que nous ne l'avons jamais fait avec le tlphone (l'email lui seul a rvolutionn bien des entreprises). Alors que nous nous parlons de plus en plus, des choses sensationnelles commencent merger, peut-tre plus incroyables que celles promises par l'ingnierie gntique. Dans tous les cas en crant des programmes, en travaillant en groupe pour crer des programmes, en concevant des interfaces utilisateur permettant aux programmes de dialoguer avec l'utilisateur, en faisant tourner des programmes sur diffrents types de machine, en crivant facilement des programmes qui communiquent au travers de l'Internet Java accrot la bande passante de la communication entre les gens. Je pense que le but de la rvolution de la communication n'est certainement pas de transmettre de grandes quantits de bits ; la vraie rvolution sera l lorsque nous serons tous capables de nous parler plus facilement : de personne personne, mais aussi en groupe, et, pourquoi pas, sur la plante entire. J'ai entendu dire que la prochaine rvolution verra l'mergence d'une espce d'esprit global associant un grand nombre de personnes un grand nombre d'interconnexions. Il se peut que Java soit, ou pas, l'outil de cette rvolution, mais en tout cas cette possibilit m'a fait comprendre qu'il n'tait pas insens de tenter d'enseigner ce langage.

dition du livre, librement tlchargeable (http://www.BruceEckel.com). Si c'est l'ancienne version qui vous intresse, elle existe encore, et ceci est un merveilleux soulagement pour un auteur. Par exemple, vous pouvez remarquer que le dernier chapitre de l'dition originale, Projects , a disparu ; deux des projets ont intgr d'autres chapitres, et le reste n'avait plus d'intrt. Pareillement, le chapitre Design Patterns , devenu trop gros, a fait l'objet d'un livre spar (galement tlchargeable sur le site Web). Ainsi, logiquement, le livre devrait tre plus mince. Mais, hlas, il n'en sera pas ainsi. Le plus gros problme est le continuel dveloppement du langage Java lui-mme, et en particulier l'extension de l'API qui nous promet de nous procurer une interface standard pour tout ce que nous pourrions imaginer (et je ne serais pas surpris de voir paratre une API JCafetiere pour couronner le tout). Le propos de ce livre n'est certainement pas de parler de ces API, d'autres auteurs se chargeront de cette tche, mais certaines questions ne peuvent tre ignores. Parmi les plus importantes, Java ct serveur (principalement les Servlets et les Java Server Pages, ou JSP), qui reprsentent rellement une excellente solution au problme du World Wide Web, pour lequel nous avons dcouvert que les divers navigateurs Web ne sont pas suffisamment consistants pour traiter la programmation ct client. En outre, un problme reste entier, celui de crer facilement des applications qui se connectent des bases de donnes, qui supervisent des transactions, qui grent la scurit, etc., ce que traitent les Enterprise Java Beans (EJBs). Ces sujets se retrouvent dans le chapitre anciennement nomm Programmation Rseau , appel maintenant Informatique Distribue , un sujet qui est en passe de devenir essentiel. Ce chapitre a galement grossi afin d'inclure une vue d'ensemble de Jini (prononcez djini , ce n'est pas un acronyme, mais un nom), qui est une technologie de pointe permettant de concevoir diffremment les interconnexions entre applications. Et, bien entendu, le livre a volu pour utiliser tout au long des exemples la bibliothque de composants graphiques Swing (GUI, Graphics User Interface, Interface Graphique Utilisateur, NdT). Ici aussi, si vous vous intressez aux anciennes versions Java 1.0/1.1, vous les trouverez dans le livre que vous pouvez tlcharger gratuitement http://www.BruceEckel.com (et qui est galement inclus dans le CD ROM fourni avec cette nouvelle dition ; vous en saurez davantage ce sujet un peu plus tard). Outre les quelques nouvelles fonctionnalits du langage Java 2 et les corrections effectues dans tout le livre, un autre changement majeur est le chapitre sur les collections (chapitre 9), qui met maintenant l'accent sur les collections Java 2 utilises tout au long du livre. J'ai galement amlior ce chapitre pour traiter plus en profondeur certaines facettes des collections, entre autres expliquer comment fonctionne une fonction de hashing (afin que vous sachiez comment en crer une convenablement). Il y a eu d'autres changements, tels que la rcriture du Chapitre 1, la suppression de quelques appendices ainsi que d'autres parties qui ne me paraissent plus indispensables pour le livre imprim, mais ce fut le plus gros des

Prface la 2me ditionLes lecteurs de la premire dition de ce livre ont fait normment de commentaires logieux son propos, ce qui m'a t trs agrable. Toutefois de temps autres l'un ou l'autre s'est plaint, et l'une des critiques rcurrentes est le livre est trop gros . Dans mon esprit, je dois dire que si trop de pages est votre seule plainte, c'est une faible critique (on se souvient de l'empereur d'Autriche se plaignant du travail de Mozart : trop de notes ! , mais n'allez pas penser que je cherche d'une manire ou d'une autre me comparer Mozart). De plus, je peux seulement supposer qu'une telle demande provient d'une personne qui en est encore prendre conscience de l'tendue du langage Java lui-mme, et qui n'a pas encore vu ou lu les autres livres traitant du sujet par exemple, ma rfrence favorite, Core Java de Cay Horstmann & Gary Cornell (Prentice-Hall), qui a tellement grossi qu'on a d le scinder en deux volumes. Malgr cela, une des choses que j'ai essay de faire dans cette dition a t d'liminer les parties obsoltes, ou tout au moins non essentielles. Je n'ai pas eu de scrupules en faisant cela car l'original existe toujours sur le site Web ainsi que sur le CD ROM qui accompagne ce livre, sous la forme de la premire


suppressions. D'une manire gnrale, j'ai essay de tout revoir, d'enlever de cette 2e dition tout ce qui n'tait plus indispensable (mais que l'on peut trouver sous la forme lectronique de la premire dition), de traiter les modifications, et d'amliorer tout ce qui pouvait l'tre. Comme le langage continue d'voluer mais toutefois pas la mme allure vertigineuse qu'auparavant il ne fait pas de doute que de nouvelles ditions de ce livre verront le jour. Je dois m'excuser auprs de ceux qui persistent dans leur critique propos de la taille du livre. Que vous me croyiez ou non, j'ai travaill dur pour le rendre plus mince. Malgr sa taille, je pense qu'il existe assez d'alternatives pour vous satisfaire. D'une part, le livre existe sous forme lectronique (sur le site Web, ainsi que sur le CD ROM accompagnant ce livre), ainsi lorsque vous prenez votre ordinateur portable vous pouvez galement emporter le livre sans supplment de poids. Si vous tes rellement partisan de la minceur, il existe des versions Palm Pilot (quelqu'un m'a dit qu'il lirait le livre au lit sur l'cran rtro-clair de son Palm afin de ne pas dranger sa femme. Je ne peux qu'esprer que cela l'aidera glisser dans les bras de Morphe). Si vous le prfrez sur papier, je connais des personnes qui impriment un chapitre la fois et l'emmnent dans leur attach-case afin de le lire dans le train.

me souviens pas avoir jamais rencontr l'ensemble de ces fonctionnalits dans aucun outil auparavant). Et Java a trouv une trs importante niche dans la programmation ct serveur sous la forme des Servlets, une technologie qui est une norme amlioration de la programmation CGI traditionnelle (ceci est dcrit dans le chapitre Informatique Distribue ). Aussi, malgr le fait que j'aimerais n'utiliser que les toutes nouvelles fonctionnalits de Java, il est essentiel que l'ensemble puisse tre compil sous Linux, et donc que lorsque vous installerez le code source et que vous le compilerez sous cet OS (avec le dernier JDK) vous puissiez constater que l'ensemble peut tre compil. Toutefois, vous verrez que le texte est parsem et l de notes propos des fonctionnalits du JDK 1.3.

Le CD ROMUn autre bonus de cette dition est le CD ROM que vous trouverez la fin du livre. J'ai nagure rejet cette ide, pensant que mettre quelques Ko de code source sur cet norme CD n'tait pas justifi, et prfr cela que les gens le tlchargent depuis mon site Web. Cependant, vous allez voir tout de suite que ce CD ROM reprsente autre chose. Le CD contient le code source que l'on trouve dans le livre, mais il contient aussi l'intgralit du livre, sous diffrents formats lectroniques. Mon prfr est le format HTML, parce qu'il est rapide et compltement index vous cliquez simplement sur une entre de l'index ou de la table des matires et vous vous retrouvez immdiatement l'endroit voulu dans le livre. Toutefois la plus grande partie des 300 Mo du CD consiste en un ensemble multimdia complet nomm Thinking in C : Foundations for C++ & Java. A l'origine, j'avais dlgu Chuck Allison la cration de ce sminaire sur CD ROM en tant que produit part entire, puis j'ai dcid de l'inclure dans les secondes ditions de Thinking in C++ et de Thinking in Java aprs avoir vcu, lors d'un sminaire, l'arrive de personnes dpourvues de connaissances suffisantes en langage C. Leur propos tait apparemment je suis un bon programmeur et je n'ai pas envie d'apprendre le C, mais plutt C++ ou Java, c'est pourquoi je compte passer rapidement sur C pour aller directement C++/Java . Peu aprs leur arrive au sminaire, ils prennent conscience que le prrequis de la connaissance de la syntaxe du C se trouve l pour d'excellentes raisons. En incluant le CD ROM dans le livre, nous nous assurons que chaque participant un sminaire a une prparation suffisante. Le CD permet galement d'largir l'audience du livre. Mme si le chapitre 3 (Contrle du flux de programme) traite de parties fondamentales de Java provenant du langage C, le CD est une introduction en douceur, et l'inverse du livre suppose de la part de l'tudiant une moindre connaissance de la programmation. Le CD tant

Java 2Alors que j'cris ceci, la sortie de la version 1.3 du Java Development Kit (JDK) de Sun est imminente, et les modifications proposes pour le JDK 1.4 ont t publies. Bien que ces numros de version soient encore dans les uns , la manire standard de se rfrer une version du JDK 1.2 ou suprieur est de l'appeler Java 2 . Ceci souligne les modifications significatives entre le vieux Java qui possde beaucoup de verrues, ce que je critiquais dans la premire version de ce livre et la nouvelle version du langage, amliore et plus moderne, comportant bien moins de verrues et beaucoup de complments, ainsi qu'une conception agrable. Ce livre est crit pour Java 2. J'ai la grande chance de dominer l'ancien langage et de n'crire que pour le nouveau langage amlior, parce que l'ancienne information existe encore dans la 1re dition sur le Web et sur le CD ROM (ce qui reprsente votre source d'information si vous utilisez une version antrieure Java 2). D'autre part, et parce que n'importe qui peut librement tlcharger le JDK depuis java.sun.com, cela signifie qu'en crivant sur Java 2 je n'oblige personne une contrainte budgtaire leve en lui imposant une mise jour. Il y a toutefois une nuance. JDK 1.3 possde quelques amliorations que j'aimerais rellement utiliser, mais la version de Java actuellement fournie pour Linux est le JDK 1.2.2. Le systme Linux (voir http://www.Linux.org) est un dveloppement trs important en conjonction avec Java, parce qu'il est en train de devenir rapidement la plus importante plate-forme serveur rapide, fiable, robuste, scurise, bien maintenue, et gratuite, une vraie rvolution dans l'histoire de l'informatique (je ne


inclus dans le livre, j'espre que davantage de personnes intgreront le cercle de la programmation Java.

dduire la solution.

Prrequis[1]j'ai enlev ceci de la 2me dition : je pense que le langage Python est trs proche de faire exactement cela. Voir http://www.Python.org. #/TIJ_PAGE01# #TIJ_PAGE01#25.04.2001 - Version 0.2 : - Mise en forme du code html (titres-hx[verdana], paragraphesp[Georgia], code-blockquote). 19.08.2000 - Version 0.1 : - Dernire mise jour de la version franaise Traducteur : - Jean-Pierre VIDAL Texte original : - Thinking in Java, 2nd edition, Revision 10 2000 by Bruce Eckel

Ce livre part du principe que le lecteur est un familier de la programmation : il sait qu'un programme est un ensemble d'instructions, il sait ce que sont un sousprogramme, une fonction, une macro-instruction, un ordre de contrle tel que if ainsi qu'une structure de boucle telle que while , etc. Toutefois, il a certainement appris cela de diffrentes faons, par exemple en programmant avec un macrolangage ou bien en utilisant un outil tel que Perl. Si vous faites partie de ceux qui sont l'aise avec les ides de base de la programmation, vous lirez ce livre sans problme. Bien entendu, le livre sera plus facile pour les programmeurs C et encore plus pour les programmeurs C++, mais n'abandonnez pas pour autant si vous n'avez aucune exprience de ces langages (en revanche, prparez-vous travailler dur ; par ailleurs, le CD multimdia fourni avec ce livre vous amnera rapidement comprendre la syntaxe de base du langage C ncessaire l'apprentissage de Java). Je vais introduire les concepts de la programmation oriente objet (POO) et les mcanismes de contrle de base de Java, ainsi le lecteur en aura connaissance, et rencontrera dans les premiers exercices les instructions de base du contrle de flux de programme. Bien qu'il soit souvent fait rfrence aux fonctionnalits des langages C et C++, il ne s'agit pas d'un apart pour initis, mais au contraire d'aider tous les programmeurs mettre Java en perspective avec ces deux langages, qui, aprs tout, sont ses parents. Je vais essayer de simplifier ces rfrences et d'expliquer un programmeur ne connaissant ni C ni C++ tout ce que j'imagine tre peu familier pour lui.

IntroductionTout comme n'importe quel langage humain, Java permet d'exprimer des concepts. S'il y parvient, il deviendra un moyen d'expression considrablement plus simple et plus souple que n'importe quelle alternative, alors mme que les problmes augmentent en taille et en complexit. Il est impossible de considrer Java uniquement sous l'angle d'une collection de fonctionnalits beaucoup de fonctionnalits perdent leur sens hors de leur contexte. On ne peut utiliser la somme des parties que si l'on pense en termes de conception, et non simplement en termes de code. Pour apprhender Java de cette manire, il faut comprendre les problmes qui lui sont propres et ceux qui relvent de la programmation en gnral. Ce livre traite de problmes de programmation, en quoi ce sont des problmes, et quelle est l'approche de Java pour les rsoudre. Ainsi, l'ensemble de fonctionnalits que je prsente dans chaque chapitre est base sur ma manire de rsoudre un certain type de problmes au moyen de ce langage. Par cette dmarche j'espre peu peu amener le lecteur au point o penser Java lui deviendra naturel. Je garderai constamment l'esprit qu'il faut que chacun se construise un modle de pense permettant de dvelopper une profonde connaissance du langage ; lorsqu'il rencontrera un problme ardu il devra tre capable d'en alimenter ce modle et d'en

Apprendre JavaJ'ai commenc enseigner C++ l'poque o tait dit mon premier livre Using C++(Osborne McGraw-Hill, 1989). Enseigner la programmation est devenu ma profession ; depuis 1989 j'ai vu bien des hochements de tte, de visages vides, ainsi que beaucoup d'expressions d'incomprhension chez maint auditoire travers le monde. Lorsque je me mis donner des cours chez moi, pour des groupes plus rduits, je dcouvris que mme ceux qui souriaient et hochaient la tte taient dconcerts face de nombreux problmes. J'ai dcouvert aussi, alors que je prsidais le cursus C++ durant plusieurs annes la Software Development Conference (et plus tard le cursus Java), que moi-mme ainsi que les autres confrenciers avions tendance traiter trop de choses trop rapidement. Finalement, cause des diffrences entre les niveaux de mes auditeurs tout autant que de la manire dont je prsentais mon expos, j'aurais fini par perdre une partie de mon


auditoire. Je me suis pos beaucoup de questions, mais, faisant partie de ceux qui rechignent au cours magistral (et chez beaucoup de gens, je crois qu'une telle attitude ne peut provenir que du souvenir de l'ennui que distillent de tels cours), j'ai voulu faire en sorte que tout le monde reste veill. une certaine priode, je terminais mes diffrents cours sous la pression des besoins. C'est ainsi que j'ai fini par enseigner par essais et erreurs (une technique qui marche bien galement dans la conception des programmes Java), et finalement j'ai ralis un cours qui utilise tout ce que j'ai appris grce mon exprience d'enseignant un cours qu'il me serait agrable de donner durant longtemps. Il consiste s'attaquer au problme de l'apprentissage par touches discrtes et faciles intgrer, et lors d'un sminaire impromptu (la situation idale pour enseigner) chaque courte leon est suivie d'exercices. Je donne maintenant ce cours dans des sminaires Java publics, que l'on peut trouver sur le site http://www.BruceEckel.com. (Le sminaire d'introduction est galement disponible sur le CD ROM, son contenu est disponible sur le mme site Web.) Le retour d'exprience que me procure chaque sminaire m'aide modifier et recentrer mon discours jusqu' ce qu'il devienne un bon moyen d'enseignement. Mais ce livre est plus qu'une simple compilation de notes de sminaires : j'ai tent d'y intgrer autant d'informations que je le pouvais, et je l'ai structur afin que chaque sujet mne droit au suivant. Enfin, plus que tout, le livre est conu pour aider le lecteur solitaire qui se bat avec un nouveau langage de programmation.

magistral, limite qu'il faut imprativement ne pas dpasser. A ce sujet je devrais recevoir quelques critiques pour avoir utilis des exemples jouets , et je les accepte volontiers, avec le prtexte que ce que je prsente est utile, pdagogiquement parlant ; 3. enchaner soigneusement la prsentation des fonctionnalits afin que l'on ne rencontre jamais quoi que ce soit qui n'ait jamais t expos. Bien entendu, ce n'est pas toujours possible, et, dans de telles situations, je donne une brve description en introduction ; 4. montrer ce que je pense tre important concernant la comprhension du langage, plutt qu'exposer tout mon savoir. Je crois que l'information est fortement hirarchise, qu'il est avr que 95 % des programmeurs n'ont pas besoin de tout connatre, et que cela droute tout le monde et ajoute leur impression de complexit du langage. Pour prendre un exemple en C, connaissant par coeur le tableau de priorit des oprateurs (ce qui n'est pas mon cas), il est possible d'crire un code astucieux. Mais en y rflchissant un instant, ceci risque de drouter le lecteur et/ou le mainteneur de ce code. Il est donc prfrable d'oublier la priorit des oprateurs, et d'utiliser des parenthses lorsque les choses ne sont pas claires ; 5. maintenir chaque section assez concentre de telle manire que le temps de lecture - et le temps entre les exercices - soit court. Non seulement cela maintient l'attention et l'implication des auditeurs lors d'un sminaire, mais cela donne au lect

penser_java

Documents

java et linternet

apprendre java

collections et support

collections et itrateurs

efficacit et flexibilit

typographie et style

environnement et dure

base abstraites et interfaces