Penser en Java (Version 2.4)

Thinking in Java, 2nd edition, Revision 12

2000 by Bruce Eckel

Penseren

JavaSeconde dition

Bruce Eckel

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

Table des matires

Prface........................................................................3Prface la 2me dition....................................................................3

Java 2.............................................................................................3Le CD ROM..........................................................................................4

Introduction................................................................4Prrequis.............................................................................................4Apprendre Java...................................................................................5Buts.....................................................................................................5Documentation en ligne......................................................................6Les chapitres.......................................................................................6Exercices.............................................................................................8Le CD ROM Multimdia........................................................................9Le Code Source....................................................................................9

Typographie et style de code..............................................................9Les versions de Java..........................................................................10Seminars and mentoring...................................................................10Errors................................................................................................10 propos de la conception de la couverture du livre..........................10Remerciements.................................................................................11

Collaborateurs Internet....................................................................12

1) Introduction sur les Objets...................................13Les bienfaits de l'abstraction.............................................................13Un objet dispose d'une interface.......................................................14L'implmentation cache...................................................................15Rutilisation de l'implmentation......................................................16Hritage : rutilisation de l'interface.................................................16

Les relations est-un vs. est-comme-un ..............................................18Polymorphisme : des objets interchangeables...................................19

Classes de base abstraites et interfaces..............................................21Environnement et dure de vie des objets.........................................21

Collections et itrateurs...................................................................22La hirarchie de classes unique.........................................................23Bibliothques de collections et support pour l'utilisation aise descollections......................................................................................23

Transtypages descendants vs. patrons gnriques.......................................23Le dilemme du nettoyage : qui en est responsable ?............................24

Ramasse-miettes vs. efficacit et flexibilit.................................................24Traitement des exceptions : grer les erreurs...................................25Multithreading...................................................................................25Persistance........................................................................................26Java et l'Internet...............................................................................26

Qu'est-ce que le Web ?....................................................................26Le concept Client/Serveur.........................................................................26

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

Le Web en tant que serveur gant.............................................................27La programmation ct client............................................................27

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

La programmation ct serveur.........................................................30Une scne spare : les applications..................................................30

Analyse et conception.......................................................................31Phase 0 : Faire un plan....................................................................32

L'expos de la mission..............................................................................32Phase 1 : Que construit-on ?.............................................................32Phase 2 : Comment allons-nous le construire ?....................................34

Les cinq tapes de la conception d'un objet.................................................35Indications quant au dveloppement des objets...........................................36

Phase 3 : Construire le coeur du systme...........................................36Phase 4 : Itrer sur les cas d'utilisation..............................................36Phase 5 : Evolution.........................................................................37Les plans sont payants.....................................................................37

Programmation Extrme...................................................................38Commencer par crire les tests.........................................................38Programmation en binme...............................................................38

Les raisons du succs de Java...........................................................39Les systmes sont plus faciles exprimer et comprendre......................39Puissance maximale grce aux bibliothques.......................................39Traitement des erreurs....................................................................39Mise en oeuvre de gros projets.........................................................39

Stratgies de transition.....................................................................40Rgles de base...............................................................................40

1. Cours.................................................................................................402. Projet faible risque............................................................................403. S'inspirer de bonnes conceptions...........................................................404. Utiliser les bibliothques de classes existantes.........................................405. Ne pas traduire du code existant en Java................................................41

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

Java vs. C++ ?...................................................................................42Rsum.............................................................................................42

2 : Tout est Objet.......................................................44Les objets sont manipuls avec des rfrences.................................44Vous devez crer tous les objets.......................................................44

O rside la mmoire ?....................................................................45Cas particulier : les types primitifs.....................................................45

Nombres de grande prcision....................................................................46

Tableaux en Java............................................................................46Vous n'avez jamais besoin de dtruire un objet................................46

Notion de porte.............................................................................46Porte des objets............................................................................47

Crer de nouveaux types de donnes : class.....................................47Champs et mthodes.......................................................................48

Valeurs par dfaut des membres primitifs...................................................48Mthodes, paramtres et valeurs de retour.......................................49

La liste de paramtres.....................................................................49Construction d'un programme Java...................................................50

Visibilit des noms..........................................................................50Utilisation d'autres composantes.......................................................50Le mot-clef static............................................................................51

Votre premier programme Java.........................................................52Compilation et excution..................................................................52

Commentaires et documentation intgre.........................................53Commentaires de documentation......................................................53Syntaxe.........................................................................................53HTML intgr..................................................................................54@see : faire rfrence aux autres classes...........................................54Class documentation tags.................................................................54

@version................................................................................................54@author.................................................................................................55@since...................................................................................................55

Les onglets de documentation de variables.........................................55Les onglets de documentation de mthodes........................................55

@param.................................................................................................55@return..................................................................................................55@throws.................................................................................................55@deprecated...........................................................................................55

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

3 : Contrle du Flux de Programme...........................57Utilisation des oprateurs Java.........................................................58

Priorit..........................................................................................58L'affectation...................................................................................58

L'aliasing pendant l'appel des mthodes.....................................................59Les oprateurs mathmatiques.........................................................59

Les oprateurs unaires ( un oprande) moins et plus..................................60Incrmentation et dcrmentation automatique...................................60Les oprateurs relationnels...............................................................61

Tester l'quivalence des objets..................................................................61Les oprateurs logiques...................................................................62

Court-circuit .....................................................................................62Les oprateurs bit bit....................................................................63


Les oprateurs de dcalage..............................................................64Oprateur ternaire if-else.................................................................65L'oprateur virgule..........................................................................66L'oprateur + pour les String............................................................66Les piges classiques dans l'utilisation des oprateurs..........................66Les oprateurs de transtypage..........................................................67

Les littraux............................................................................................67La promotion...........................................................................................68

Java n'a pas de sizeof .................................................................68Retour sur la priorit des oprateurs..................................................68Rsum sur les oprateurs...............................................................68

Le Contrle d'excution.....................................................................73true et false...................................................................................73if-else............................................................................................73

return....................................................................................................74Itration........................................................................................74do-while........................................................................................74for................................................................................................75

L'oprateur virgule...................................................................................75break et continue............................................................................75

L'infme goto ....................................................................................76switch...........................................................................................78

Dtails de calcul :....................................................................................79Rsum.............................................................................................80Exercices...........................................................................................81

4: Initialisation & Nettoyage.....................................81Garantie d'initialisation grce au constructeur..................................82Surcharge de mthodes.....................................................................83

Diffrencier les mthodes surcharges...............................................84Surcharge avec types de base...........................................................84Surcharge sur la valeur de retour......................................................86Constructeurs par dfaut..................................................................86Le mot-cl this...............................................................................86

Appeler un constructeur depuis un autre constructeur..................................87La signification de static............................................................................88

Nettoyage : finalisation et ramasse-miettes......................................88A quoi sert finalize( ) ?.....................................................................89Le nettoyage est impratif................................................................89La death condition.......................................................................91Comment fonctionne un ramasse-miettes ?.........................................91

Initialisation de membre...................................................................93Spcifier une initialisation.................................................................94Initialisation par constructeur...........................................................95

Ordre d'initialisation.................................................................................95Initialisation de donnes statiques..............................................................95Initialisation statique explicite....................................................................97Initialisation d'instance non statique...........................................................97

Initialisation des tableaux.................................................................98Tableaux multidimensionels............................................................100

Rsum...........................................................................................101Exercices.........................................................................................101

5 : Cacher l'Implmentation....................................103package : l'unit de bibliothque.....................................................103

Crer des noms de packages uniques...............................................104Collisions..............................................................................................106

Une bibliothque d'outils personnalise............................................106Utilisation des imports pour modifier le comportement........................107Avertissement sur les packages.......................................................108

Les spcificateurs d'accs Java.......................................................108 Friendly .................................................................................108public : accs d'interface................................................................108

Le package par dfaut............................................................................109private : ne pas toucher !...............................................................109protected : sorte d'amical ........................................................110

Interface et implmentation............................................................111L'accs aux classes..........................................................................111Rsum...........................................................................................113Exercices.........................................................................................113

6 : Rutiliser les classes..........................................114Syntaxe de composition..................................................................115La syntaxe de l'hritage..................................................................116

Initialiser la classe de base.............................................................117Constructeurs avec paramtres................................................................118Attraper les exceptions du constructeur de base........................................118

Combiner composition et hritage...................................................119Garantir un nettoyage propre..........................................................119

L'ordre du ramasse-miettes.....................................................................121Cacher les noms............................................................................121

Choisir la composition la place de l'hritage.................................121protected.........................................................................................122Dveloppement incrmental............................................................122Transtypage ascendant...................................................................123

Pourquoi le transtypage ascendant ? ...............................................123Composition la place de l'hritage revisit..............................................123

Le mot cl final................................................................................124Donnes finales.............................................................................124

Finals sans initialisation...........................................................................125Arguments final.....................................................................................125

Mthodes final..............................................................................126final et private.......................................................................................126

Classes final.................................................................................127Attention finale.............................................................................127

Initialisation et chargement de classes...........................................128Initialisation avec hritage..............................................................128


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

7: Polymorphisme....................................................130Upcasting........................................................................................130

Pourquoi utiliser l'upcast?...............................................................131The twist.........................................................................................132

Liaison de l'appel de mthode.........................................................132Produire le bon comportement........................................................132Extensibilit..................................................................................134

Redfinition et Surcharge................................................................135Classes et mthodes abstraites.......................................................136Constructeurs et polymorphisme.....................................................138

Ordre d'appel des constructeurs......................................................138La mthode finalize() et l'hritage...................................................139Comportement des mthodes polymorphes dans lesconstructeursname="Index722">....................................................141

Concevoir avec l'hritage................................................................142Hritage pur contre extensionname="Index739">..............................142Downcasting et identification du type l'excution.............................143

Rsum...........................................................................................144Exercices.........................................................................................145

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

Hritage multiple en Java..........................................................147Combinaison d'interfaces et collisions de noms .........................................149

Etendre une interface avec l'hritage................................................149Groupes de constantes...................................................................150Initialisation des donnes membres des interfaces.............................150Interfaces imbriques....................................................................151

Classes internes..............................................................................152Classes internes et transtypage ascendant........................................153Classes internes dfinies dans des mthodes et autres portes............154Classes internes anonymes.............................................................155Lien vers la classe externe..............................................................157Classes internes static....................................................................158Se rfrer l'objet de la classe externe............................................159Classe interne plusieurs niveaux d'imbrication.................................159Driver une classe interne..............................................................159Les classes internes peuvent-elles redfinies ?...................................160Identifiants des classes internes......................................................161Raison d'tre des classes internes....................................................161

Fermetures & callbacks...........................................................................162Classes internes & structures de contrle..........................................163

Rsum...........................................................................................167Exercices.........................................................................................167

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

Les tableaux....................................................................................169Les tableaux sont des objets...........................................................169

Conteneurs de scalaires..........................................................................171Renvoyer un tableau......................................................................171La classe Arrays............................................................................172Remplir un tableau........................................................................177Copier un tableau..........................................................................177Comparer des tableaux..................................................................178Comparaison d'lments de tableau.................................................178Trier un tableau............................................................................179Effectuer une recherche sur un tableau tri.......................................180Rsum sur les tableaux.................................................................181

Introduction sur les conteneurs.....................................................181Imprimer les conteneurs................................................................182Remplir les conteneurs...................................................................183

L'inconvnient des conteneurs : le type est inconnu........................186Quelquefois a marche quand mme................................................187Crer une ArrayList consciente du type.............................................187

Types paramtrs..................................................................................188Itrateurs........................................................................................188

Rcursion indsirable..............................................................................189Classification des conteneurs..........................................................190Fonctionnalits des Collections........................................................192Fonctionnalits des Lists.................................................................193

Raliser une pile partir d'une LinkedList.........................................195Raliser une file partir d'une LinkedList..........................................195

Fonctionnalits des Sets..................................................................196Sets tris : les SortedSets..............................................................197

Fonctionnalits des Maps................................................................197Maps tries : les SortedMaps..........................................................199Hachage et codes de hachage.........................................................200

Comprendre hashCode().........................................................................201Facteurs de performance d'un HashMap....................................................203

Redfinir hashCode().....................................................................204Stocker des rfrences....................................................................205

Le WeakHashMap..........................................................................206Les itrateurs revisits....................................................................207Choisir une implmentation.............................................................207

Choisir entre les Lists.....................................................................208Choisir entre les Sets.....................................................................209Choisir entre les Maps....................................................................210

Trier et rechercher dans les Lists....................................................211Utilitaires........................................................................................212

Rendre une Collection ou une Map non-modifiable..............................212Synchroniser une Collection ou une Map...........................................213

Echec rapide..........................................................................................213Oprations non supportes..............................................................214


Les conteneurs Java 1.0 / 1.1.........................................................215Vector & Enumeration....................................................................215Hashtable.....................................................................................215Stack...........................................................................................216BitSet..........................................................................................216

Rsum...........................................................................................217Exercices.........................................................................................217

Gestion des erreurs avec les exceptions .................220Les exceptions de base ...................................................................220

Les paramtres des Exceptions .......................................................221Attraper une exception ...................................................................221

Le bloc try ...................................................................................221Les gestionnaires d'exceptions .......................................................221

Terminaison contre Restauration .............................................................222Crez vos propres Exceptions .........................................................222

Spcifier des Exceptions .................................................................224Attraper n'importe quelle exception .................................................225Relancer une exception .................................................................225

Les exceptions Java standard .........................................................227Le cas particulier RuntimeException ................................................228

Faire le mnage avec finally ...........................................................228 Quoi sert le finally ? ...................................................................229Le dfaut : l'exception perdue ........................................................230

Restriction d'Exceptions .................................................................231Les constructeurs ...........................................................................232Indication d'Exception ....................................................................234

Recommandations pour les exceptions ............................................235Rsum ..........................................................................................235Exercices ........................................................................................235

11: Le systme d'E/S de Java..................................237La classe File...................................................................................237

Lister un rpertoire........................................................................237Les classes internes anonymes................................................................238

Vrification et cration de rpertoires...............................................239Entre et sortie...............................................................................240

Les types d'InputStream................................................................240Les types d'OutputStream..............................................................241

Ajouter des attributs et des interfaces utiles...................................242Lire depuis un InputStream avec FilterInputStream............................242crire vers un OutputStream avec FilterOutputStream........................243

Lecteurs & crivains [ Loaders & Writers ]......................................244Les sources et les rceptacles de donnes.........................................244Modifier le comportement du flux.....................................................244Les classes inchanges...................................................................245

Et bien sr : L'accs alatoire aux fichiers (RandomAccessFile)......245L'usage typique des flux d'E/S........................................................246

Flux d'Entre................................................................................2471. Entre en tampon du fichier [Buffered input file]....................................2472. Entre depuis la mmoire....................................................................2473. Entre de mmoire formate...............................................................2474. Sortie de Fichier.................................................................................247

Flux de sortie................................................................................2485. Stocker et rcuprer des donnes........................................................2486. Accs alatoire en lecture et criture aux fichiers...................................248

Un bogue ?...................................................................................248Flux Piped....................................................................................249

Standard E/S...................................................................................249Lire depuis une entre standard......................................................249Modifier System.out en un PrintWriter..............................................249Rorienter l'E/S standard................................................................250

Compression....................................................................................250Compression simple avec GZIP........................................................251Stockage de fichiers multiples avec Zip.............................................251ARchives Java (JARs).....................................................................252

La srialisation objet.......................................................................253Trouver la classe...........................................................................255Contrler la srialisation.................................................................256

Le mot-cl transient .........................................................................258Une alternative Externalizable...............................................................259Versioning.............................................................................................260

Utiliser la persistence.....................................................................260Tokenizer l'entre...........................................................................264

StreamTokenizer...........................................................................264StringTokenizer.............................................................................265Vrifier le style de capitalization......................................................266

Rsum...........................................................................................270Exercices.........................................................................................271

12: Identification dynamique de type......................272Le besoin de RTTI............................................................................272

L'objet Class.................................................................................273Les littraux Class..................................................................................274

Vrifier avant de transtyper............................................................274Utiliser les littraux de classe...................................................................276Un instanceof dynamique........................................................................277instanceof vs. quivalence de classe.........................................................277

La syntaxe du RTTI..........................................................................278Rflexion : information de classe dynamique .................................279

Un extracteur de mthodes de classe...............................................280Rsum...........................................................................................282Exercices.........................................................................................283

13: Cration de Fentres et Applets........................284L'applet de base..............................................................................285

Les restrictions des applets.............................................................285


Les avantages d'une applet.............................................................285Les squelettes d'applications...........................................................286Excuter des applets dans un navigateur Web...................................286Utilisation de Appletviewer..............................................................287Tester les applets..........................................................................288

Excuter des applets depuis la ligne de commande.........................288Un squelette d'affichage.................................................................289Utilisation de l'Explorateur Windows.................................................290

Cration d'un bouton.......................................................................291Capture d'un vnement.................................................................291Zones de texte.................................................................................293Contrle de la disposition................................................................293

BorderLayout................................................................................294FlowLayout...................................................................................294GridLayout...................................................................................294GridBagLayout..............................................................................295Positionnement absolu...................................................................295BoxLayout....................................................................................295La meilleure approche ?.................................................................297

Le modle d'vnements de Swing..................................................297Evnements et types de listeners.....................................................298

Utilisation de listener adapters pour simplifier............................................300Surveiller plusieurs vnements......................................................301

Un catalogue de composants Swing.................................................302Boutons.......................................................................................302

Groupes de boutons...............................................................................303Icones.........................................................................................304Infobulles [Tooltips].......................................................................305Champs de texte [Text Fields].........................................................305Bordures......................................................................................306JScrollPanes.................................................................................306Un mini-diteur.............................................................................307Botes cocher [Check boxes].........................................................308Boutons radio...............................................................................309Botes combo (listes ouverture vers le bas) [combo boxes (drop-downlists)]..........................................................................................309Listes [List boxes].........................................................................310Panneaux tabulations [Tabbed panes]............................................311Botes de messages.......................................................................311Menus.........................................................................................312Menus pop-up...............................................................................315Dessiner......................................................................................316Botes de dialogue.........................................................................317Dialogues pour les fichiers [File dialogs] ..........................................319HTML sur des composants Swing ....................................................320Curseurs [sliders] et barres de progression [progress bars].................321Arbres [Trees]..............................................................................321

Tables.........................................................................................323Slection de l'aspect de l'interface [Look & Feel]................................324Le presse-papier [clipboard]...........................................................325

Empaquetage d'une applet dans un fichier JAR ..............................326Techniques de programmation........................................................326

Lier des vnements dynamiquement...............................................326Sparation entre la logique applicative [business logic] et la logique del'interface utilisateur [UI logic] .......................................................327Une forme canonique.....................................................................329

Programmation visuelle et Beans....................................................329Qu'est-ce qu'un Bean ?..................................................................330Extraction des informations sur les Beans [BeanInfo] l'aide del'introspecteur [Introspector]..........................................................331Un Bean plus complexe..................................................................333Empaquetage d'un Bean.................................................................335Un support des Beans plus sophistiqu.............................................336Davantage sur les Beans................................................................336

Rsum...........................................................................................337Exercices.........................................................................................337

14) Les Threads multiples.......................................339Interfaces utilisateurs dynamiques [Responsive user interfaces]. . .339

Hritage de Thread........................................................................340Threading pour une une interface ractive........................................341Combiner le thread avec la classe principale......................................342Crer plusieurs threads..................................................................343Threads dmons............................................................................345

Partager des ressources limites.....................................................346Des ressources accdes improprement............................................346Comment Java partage les ressources..............................................348

Synchroniser les compteurs.....................................................................348Efficacit de la synchronisation................................................................350

JavaBeans revisits.......................................................................351Blocage [Blocking]..........................................................................353

Passer l'tat bloqu.....................................................................353Dormant (Sleeping)................................................................................354Suspension et reprise.............................................................................355Attendre et notifier.................................................................................355Bloqu sur I/O.......................................................................................357Tester...................................................................................................357

Interblocage [Deadlock].................................................................358La dprciation de stop(), suspend(), resume(), et destroy() en Java 2........358

Priorits..........................................................................................360Lire et changer les priorits............................................................360Les groupes de threads..................................................................362

Controller les groupes de threads.............................................................363Runnable revisit............................................................................366

Trop de threads............................................................................367


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

15 : Informatique Distribue...................................370La programmation rseau...............................................................371

Identifier une machine...................................................................371Serveurs et clients.................................................................................372Tester les programmes hors rseau..........................................................372Les Ports : un emplacement unique dans la machine.................................373

Les sockets..................................................................................373Un serveur et un client vraiment simples...................................................374

Servir des clients multiples.............................................................376Les Datagrammes.........................................................................379Utiliser des URLs depuis un applet...................................................379

Lire un fichier depuis un serveur..............................................................380En savoir plus sur le travail en rseau..............................................380

Se connecter aux bases de donnes : Java Database Connectivity(JDBC).............................................................................................380

Faire fonctionner l'exemple.............................................................382tape 1 : Trouver le Driver JDBC.............................................................382tape 2 : Configurer la base de donnes...................................................382tape 3 : Tester la configuration..............................................................383tape 4 : Gnrer votre requte SQL.......................................................383tape 5 : Modifier et insrer votre requte................................................384

Une version GUI du programme de recherche....................................384Pourquoi l'API JDBC parat si complexe.............................................385Un exemple plus sophistiqu...........................................................385

Les Servlets.....................................................................................389Le servlet de base.........................................................................389Les Servlets et le multithreading.....................................................391Grer des sessions avec les servlets.................................................392

La classe Cookie....................................................................................392La classe Session...................................................................................392

Faire fonctionner les exemples de servlet..........................................394Les Pages Java Serveur - Java Server Pages...................................394

Les objets implicites......................................................................395Les directives JSP..........................................................................395Les lments de scripting JSP.........................................................396Extraire des champs et des valeurs..................................................397Attributs et visibilit d'une page JSP.................................................397Manipuler les sessions en JSP..........................................................398Crer et modifier des cookies..........................................................399Rsum sur les JSP........................................................................399

RMI (Remote Method Invocation) : Invocation de mthodes distantes.400

Interfaces Remote.........................................................................400Implmenter l'interface distante......................................................400

Mise en place du registre........................................................................401Cration des stubs et des skeletons.................................................402

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

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

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

Les Applets Java et CORBA.............................................................406CORBA face RMI.........................................................................407

Enterprise Java Beans.....................................................................407JavaBeans contre EJBs...................................................................408Que dfinit la spcification des EJBs ?...............................................408

Les rles...............................................................................................408Composants EJB....................................................................................408

Conteneur d'EJB................................................................................408Serveur EJB......................................................................................409Java Naming and Directory Interface (JNDI).........................................409Java Transaction API / Java Transaction Service (JTA/JTS).....................409CORBA et RMI/IIOP...........................................................................409

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

Comment travaille un EJB ?............................................................410Types d'EJBs.................................................................................410

Session Beans.......................................................................................410Les Session Beans non-persistants......................................................410Les Session Beans persistants.............................................................410

Entity Beans..........................................................................................410Gestion de la persistance par le conteneur (CMP - Container ManagedPersistence).....................................................................................410Gestion de la persistence par le Bean (BMP - Bean Managed Persistence).411

Dvelopper un Enterprise Java Bean................................................411En rsum....................................................................................413

Jini : services distribus..................................................................413Contexte de Jini............................................................................413Qu'est-ce que Jini ?.......................................................................414Comment fonctionne Jini................................................................414Le processus de dcouverte............................................................414Le processus de jonction................................................................415Le processus de recherche..............................................................415Sparation de l'interface et de l'implmentation.................................415


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

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

Aliasing........................................................................................418Cration de copies locales...............................................................419

Passage par valeur........................................................................420Clonage d'objets...........................................................................420Rendre une classe cloneable...........................................................421

Utilisation d'une astuce avec protected.....................................................421Implmenter l'interface Cloneable............................................................421

Pour un clonage russi...................................................................421Le mcanisme de Object.clone( ).....................................................423Cloner un objet compos................................................................424Copie profonde d'une ArrayList........................................................424Copie profonde via la srialisation....................................................425Supporter le clonage plus bas dans la hirarchie................................426Pourquoi cet trange design ?.........................................................427

Contrler la clonabilit....................................................................427Le constructeur de copie................................................................429

Pourquoi cela fonctionne-t-il en C++ et pas en Java ?................................431Classes en lecture seule..................................................................431

Crer des classes en lecture seule....................................................432L'inconvnient de l'immuabilit........................................................432Chanes immuables........................................................................433

Constantes implicites..............................................................................434Surcharge de l'oprateur + et les StringBuffer.....................................434

Les classes String et StringBuffer.....................................................435Les Strings sont spciales...............................................................437

Rsum...........................................................................................437Exercises.........................................................................................437

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

Appeler une mthode native............................................................439Le gnrateur d'entte [ header file generator] : javah.......................439Les conventions de nommage [name mangling]et les signatures defonctions......................................................................................440Implmenter votre DLL..................................................................440

Accder des fonctions JNI : l'argument JNIEnv............................441Accder des chanes Java.............................................................441Passer et utiliser des objets Java....................................................441JNI et les exceptions Java...............................................................442JNI et le threading..........................................................................443Utiliser une base de code prexistantes..........................................443Information complmentaire...........................................................443

C : Conseils pour une programmation style en Java....444

Conception......................................................................................444Implmentation...............................................................................446

D : Ressources.........................................................449Logicielles.......................................................................................449Livres..............................................................................................450

Analyse & conception.....................................................................450Python.........................................................................................451La liste de mes livres.....................................................................451

#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 VIDALTexte original : - Thinking in Java, 2nd edition, Revision 10 2000 by Bruce Eckel

Prface

J'ai suggr mon frre Todd, qui est en train de migrer duhardware vers le software, que la prochaine grandervolution serait l'ingnierie gntique.Nous crerons bientt des organismes ddis la fabrication de nourriture, decarburant, de plastique ; ils digreront la pollution et, de manire gnrale, nouspermettront de matriser la manipulation du monde rel, ceci pour un cot minimecompar celui d'aujourd'hui. J'ai prtendu que la rvolution informatique seraitvraiment peu de chose au regard de cela.

Puis j'ai ralis que j'tais en train de commettre une erreur triviale chez les auteursde science-fiction : oublier le propos de la technologie (ce qui est videmment trsfacile faire en science-fiction). Un crivain expriment sait qu'on ne racontejamais une histoire propos de choses, mais de gens. La gntique aura un trsgrand impact sur nos vies, mais je ne suis pas persuad qu'elle clipsera larvolution informatique (qui d'ailleurs rend possible la rvolution gntique) ou


au moins la rvolution de l'information. L'information, c'est essentiellement separler les uns les autres : bien entendu, les voitures, les chaussures, et surtout lesmaladies gntiques sont importantes, mais en dfinitive ce ne sont que des faux-semblants. La vrai question est notre relation au monde. Ainsi en est-il de lacommunication.

Ce livre est un cas. Une majorit d'amis pensa que j'tais soit vraiment hardi soitlgrement drang pour mettre tout cela sur le Web. Pourquoi quelqu'unvoudrait-il l'acheter ? me disaient-ils. Si j'avais eu un temprament plusconservateur, je ne m'y serais pas pris de cette manire ; en ralit je ne voulais pascrire un livre supplmentaire de style traditionnel sur les ordinateurs. Je ne savaisce qui en aurait rsult si je n'avais pas agi ainsi, mais en tout cas ce fut la meilleurechose que j'ai jamais ralise avec un livre.

Tout d'abord, chacun commena m'envoyer des correctifs. Ce fut un processus trsamusant, parce que mes amis avaient furet dans chaque coin et recoin et repr leserreurs techniques aussi bien que grammaticales, ce qui me permit d'liminer lesfautes de toutes sortes que j'aurais laiss passer sans cela. Dans ce travail, ils ont ttout simplement formidables, commenant trs souvent par me dire bon, je ne dispas a pour critiquer... pour me mettre ensuite sous le nez un ensemble d'erreursque je n'aurais jamais t capable de trouver par moi-mme. Je crois que ce fut uneespce de travail de groupe, et cela a rellement ajout quelque chose de spcial celivre.

Mais ensuite, j'ai commenc entendre ceci : OK, trs bien, c'est bien gentil vousavez fait une version lectronique, mais moi j'aurais prfr une version complteimprime chez un vrai diteur . Alors j'ai beaucoup travaill afin que chacun puissel'imprimer dans un format adquat, mais cela n'a pas suffi rsorber la demanded'un livre publi . La plupart des gens n'ont pas envie de lire le livre l'crandans son intgralit, et l'ide de transporter un paquet de feuilles volantes, mmeimpeccablement imprimes, ne leur conviendrait pas davantage (de plus, je penseque ce n'est pas forcment conomique en terme de toner). Aprs tout il sembleraitque la rvolution informatique ne risque pas de mettre les diteurs au chmage. Untudiant suggra toutefois que cela pourrait servir de modle pour l'dition dufutur : les livres seraient d'abord publis sur le Web, et, condition qu'ilsrencontrent un certain intrt, on les coucherait sur papier. Actuellement, unegrande majorit de livres reprsentent des dsastres financiers, et cette nouvelleapproche pourrait peut-tre rendre l'industrie de l'dition plus rentable.

Ce livre a t par ailleurs une exprience enrichissante pour moi. Ma premireapproche de Java fut juste un nouveau langage de programmation , ce qu'il est defait par ailleurs. Mais, le temps passant, et au fur et mesure que je l'tudiais plusen profondeur, je commenais m'apercevoir que son propos fondamental taitdiffrent 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. Jevoudrais maintenant dire que, de tous les langages de programmation que jeconnaisse, aucun n'a t conu pour grer la complexit du dveloppement et de lamaintenance 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 ontsurgi qui furent considrs comme essentiels et par suite intgrs la mixture.Fatalement, ces nouveaux problmes furent de ceux qui envoyrent finalement lesprogrammeurs droit dans le mur avec ce langage. Par exemple, C++ se devait depossder une compatibilit ascendante avec C (afin de favoriser la migration desprogrammeurs C), ainsi qu'une certaine efficacit. Ces deux buts taient trs utiles etont grandement particip au succs de C++, mais dans le mme temps ils ont gnrune complexit supplmentaire qui a eu pour rsultat d'empcher certains projetsd'arriver terme (bien entendu, vous pouvez toujours vous en prendre laresponsabilit des programmeurs et/ou de leur encadrement, mais, si un langagepouvait vous aider reprer vos erreurs, pourquoi ne le ferait-il pas ?). Autreexemple, Visual Basic (VB) tait li BASIC, lequel n'tait pas vraiment conucomme un langage extensible, et par suite toutes les extensions superposes VB sesont traduites par une syntaxe vraiment horrible et impossible maintenir. Perl aune compatibilit ascendante avec Awk, Sed, Grep ainsi que d'autres outils Unixqu'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 quelquesmois plus tard). D'un autre ct, C++, VB, Perl, et d'autres langages commeSmalltalk, de par leur conception, ont abord le problme de la complexit, et par lse rvlent remarquablement efficaces dans la rsolution de certains types deproblmes.

Ce qui m'a le plus frapp alors que je commenais comprendre Java est quelquechose qui s'apparente l'incroyable finalit de diminuer la complexit pour leprogrammeur. Un peu comme si l'on disait rien n'est important, mis partrduire le temps et la difficult pour produire un code robuste . Dans les premiresversions 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) maisil 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 quivalenten C++. Ce seul rsultat pourrait dj se traduire par une incroyable conomie detemps et d'argent, mais Java ne s'arrte pas l. Il s'attache encapsuler toutes lestches complexes qui ont pris de l'importance, comme le multithreading et laprogrammation rseau, au moyen de fonctionnalits du langage ou de bibliothquesrendant parfois ces tches triviales. Et pour finir, il traite quelques problmes d'unerelle complexit : programmes multi-plate-forme, changements dynamiques decode, sans oublier la scurit, chacun d'entre eux pouvant s'adapter votre gammede difficults, depuis un obstacle jusqu' un point bloquant . Ainsi, malgr les


problmes de performance que nous avons vus, les promesses de Java sontnormes : 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 atoujours t difficile, et Java la rend facile (et les concepteurs du langage Javatravaillent la rendre encore plus facile). La programmation rseau, c'est ce qui faitque nous parlons entre nous de manire plus pertinente et meilleur march quenous ne l'avons jamais fait avec le tlphone (l'email lui seul a rvolutionn biendes entreprises). Alors que nous nous parlons de plus en plus, des chosessensationnelles commencent merger, peut-tre plus incroyables que cellespromises par l'ingnierie gntique.

Dans tous les cas en crant des programmes, en travaillant en groupe pour crerdes programmes, en concevant des interfaces utilisateur permettant auxprogrammes de dialoguer avec l'utilisateur, en faisant tourner des programmes surdiffrents types de machine, en crivant facilement des programmes quicommuniquent au travers de l'Internet Java accrot la bande passante de lacommunication entre les gens. Je pense que le but de la rvolution de lacommunication n'est certainement pas de transmettre de grandes quantits de bits ;la vraie rvolution sera l lorsque nous serons tous capables de nous parler plusfacilement : de personne personne, mais aussi en groupe, et, pourquoi pas, sur laplante entire. J'ai entendu dire que la prochaine rvolution verra l'mergenced'une espce d'esprit global associant un grand nombre de personnes un grandnombre d'interconnexions. Il se peut que Java soit, ou pas, l'outil de cettervolution, mais en tout cas cette possibilit m'a fait comprendre qu'il n'tait pasinsens de tenter d'enseigner ce langage.

Prface la 2me ditionLes lecteurs de la premire dition de ce livre ont fait normment de commentaireslogieux son propos, ce qui m'a t trs agrable. Toutefois de temps autres l'unou 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'estune faible critique (on se souvient de l'empereur d'Autriche se plaignant du travailde Mozart : trop de notes ! , mais n'allez pas penser que je cherche d'une manireou d'une autre me comparer Mozart). De plus, je peux seulement supposerqu'une telle demande provient d'une personne qui en est encore prendreconscience de l'tendue du langage Java lui-mme, et qui n'a pas encore vu ou lu lesautres livres traitant du sujet par exemple, ma rfrence favorite, Core Java deCay Horstmann & Gary Cornell (Prentice-Hall), qui a tellement grossi qu'on a d lescinder en deux volumes. Malgr cela, une des choses que j'ai essay de faire danscette 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 siteWeb ainsi que sur le CD ROM qui accompagne ce livre, sous la forme de la premire

dition du livre, librement tlchargeable (http://www.BruceEckel.com). Si c'estl'ancienne version qui vous intresse, elle existe encore, et ceci est un merveilleuxsoulagement pour un auteur. Par exemple, vous pouvez remarquer que le dernierchapitre de l'dition originale, Projects , a disparu ; deux des projets ont intgrd'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 (galementtlchargeable 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, eten particulier l'extension de l'API qui nous promet de nous procurer une interfacestandard pour tout ce que nous pourrions imaginer (et je ne serais pas surpris devoir paratre une API JCafetiere pour couronner le tout). Le propos de ce livren'est certainement pas de parler de ces API, d'autres auteurs se chargeront de cettetche, mais certaines questions ne peuvent tre ignores. Parmi les plusimportantes, Java ct serveur (principalement les Servlets et les Java ServerPages, ou JSP), qui reprsentent rellement une excellente solution au problme duWorld Wide Web, pour lequel nous avons dcouvert que les divers navigateurs Webne sont pas suffisamment consistants pour traiter la programmation ct client. Enoutre, un problme reste entier, celui de crer facilement des applications qui seconnectent des bases de donnes, qui supervisent des transactions, qui grent lascurit, etc., ce que traitent les Enterprise Java Beans (EJBs). Ces sujets seretrouvent dans le chapitre anciennement nomm Programmation Rseau ,appel maintenant Informatique Distribue , un sujet qui est en passe de deveniressentiel. 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 unetechnologie de pointe permettant de concevoir diffremment les interconnexionsentre applications. Et, bien entendu, le livre a volu pour utiliser tout au long desexemples la bibliothque de composants graphiques Swing (GUI, Graphics UserInterface, Interface Graphique Utilisateur, NdT). Ici aussi, si vous vous intressezaux anciennes versions Java 1.0/1.1, vous les trouverez dans le livre que vous pouveztlcharger gratuitement http://www.BruceEckel.com (et qui est galement inclusdans le CD ROM fourni avec cette nouvelle dition ; vous en saurez davantage cesujet un peu plus tard).

Outre les quelques nouvelles fonctionnalits du langage Java 2 et les correctionseffectues dans tout le livre, un autre changement majeur est le chapitre sur lescollections (chapitre 9), qui met maintenant l'accent sur les collections Java 2utilises tout au long du livre. J'ai galement amlior ce chapitre pour traiter plusen profondeur certaines facettes des collections, entre autres expliquer commentfonctionne une fonction de hashing (afin que vous sachiez comment en crer uneconvenablement). Il y a eu d'autres changements, tels que la rcriture du Chapitre1, la suppression de quelques appendices ainsi que d'autres parties qui ne meparaissent plus indispensables pour le livre imprim, mais ce fut le plus gros des


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 laforme lectronique de la premire dition), de traiter les modifications, etd'amliorer tout ce qui pouvait l'tre. Comme le langage continue d'voluer maistoutefois pas la mme allure vertigineuse qu'auparavant il ne fait pas de douteque de nouvelles ditions de ce livre verront le jour.

Je dois m'excuser auprs de ceux qui persistent dans leur critique propos de lataille du livre. Que vous me croyiez ou non, j'ai travaill dur pour le rendre plusmince. 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 leCD ROM accompagnant ce livre), ainsi lorsque vous prenez votre ordinateurportable vous pouvez galement emporter le livre sans supplment de poids. Si voustes rellement partisan de la minceur, il existe des versions Palm Pilot (quelqu'unm'a dit qu'il lirait le livre au lit sur l'cran rtro-clair de son Palm afin de ne pasdranger sa femme. Je ne peux qu'esprer que cela l'aidera glisser dans les bras deMorphe). Si vous le prfrez sur papier, je connais des personnes qui impriment unchapitre la fois et l'emmnent dans leur attach-case afin de le lire dans le train.

Java 2

Alors que j'cris ceci, la sortie de la version 1.3 du Java Development Kit (JDK) deSun 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 standardde se rfrer une version du JDK 1.2 ou suprieur est de l'appeler Java 2 . Cecisouligne les modifications significatives entre le vieux Java qui possdebeaucoup de verrues, ce que je critiquais dans la premire version de ce livre et lanouvelle version du langage, amliore et plus moderne, comportant bien moins deverrues 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 den'crire que pour le nouveau langage amlior, parce que l'ancienne informationexiste encore dans la 1re dition sur le Web et sur le CD ROM (ce qui reprsentevotre source d'information si vous utilisez une version antrieure Java 2). D'autrepart, et parce que n'importe qui peut librement tlcharger le JDK depuisjava.sun.com, cela signifie qu'en crivant sur Java 2 je n'oblige personne unecontrainte budgtaire leve en lui imposant une mise jour.

Il y a toutefois une nuance. JDK 1.3 possde quelques amliorations que j'aimeraisrellement utiliser, mais la version de Java actuellement fournie pour Linux est leJDK 1.2.2. Le systme Linux (voir http://www.Linux.org) est un dveloppement trsimportant en conjonction avec Java, parce qu'il est en train de devenir rapidementla plus importante plate-forme serveur rapide, fiable, robuste, scurise, bienmaintenue, et gratuite, une vraie rvolution dans l'histoire de l'informatique (je ne

me souviens pas avoir jamais rencontr l'ensemble de ces fonctionnalits dansaucun outil auparavant). Et Java a trouv une trs importante niche dans laprogrammation ct serveur sous la forme des Servlets, une technologie qui est unenorme amlioration de la programmation CGI traditionnelle (ceci est dcrit dans lechapitre Informatique Distribue ).

Aussi, malgr le fait que j'aimerais n'utiliser que les toutes nouvelles fonctionnalitsde Java, il est essentiel que l'ensemble puisse tre compil sous Linux, et donc quelorsque vous installerez le code source et que vous le compilerez sous cet OS (avec ledernier 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 duJDK 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 cetnorme CD n'tait pas justifi, et prfr cela que les gens le tlchargent depuismon site Web. Cependant, vous allez voir tout de suite que ce CD ROM reprsenteautre chose.

Le CD contient le code source que l'on trouve dans le livre, mais il contient aussil'intgralit du livre, sous diffrents formats lectroniques. Mon prfr est le formatHTML, parce qu'il est rapide et compltement index vous cliquez simplementsur une entre de l'index ou de la table des matires et vous vous retrouvezimmdiatement l'endroit voulu dans le livre.

Toutefois la plus grande partie des 300 Mo du CD consiste en un ensemblemultimdia complet nomm Thinking in C : Foundations for C++ & Java. Al'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 secondesditions de Thinking in C++ et de Thinking in Java aprs avoir vcu, lors d'unsminaire, l'arrive de personnes dpourvues de connaissances suffisantes enlangage C. Leur propos tait apparemment je suis un bon programmeur et je n'aipas envie d'apprendre le C, mais plutt C++ ou Java, c'est pourquoi je comptepasser rapidement sur C pour aller directement C++/Java . Peu aprs leur arriveau sminaire, ils prennent conscience que le prrequis de la connaissance de lasyntaxe du C se trouve l pour d'excellentes raisons. En incluant le CD ROM dans lelivre, nous nous assurons que chaque participant un sminaire a une prparationsuffisante.

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 provenantdu langage C, le CD est une introduction en douceur, et l'inverse du livre supposede la part de l'tudiant une moindre connaissance de la programmation. Le CD tant


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

[1]j'ai enlev ceci de la 2me dition : je pense que le langage Python est trs prochede 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], paragraphes-p[Georgia], code-blockquote).19.08.2000 - Version 0.1 : - Dernire mise jour de la version franaiseTraducteur : - Jean-Pierre VIDALTexte original : - Thinking in Java, 2nd edition, Revision 10 2000 by Bruce Eckel

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 etplus souple que n'importe quelle alternative, alors mme que les problmesaugmentent en taille et en complexit.

Il est impossible de considrer Java uniquement sous l'angle d'une collection defonctionnalits beaucoup de fonctionnalits perdent leur sens hors de leurcontexte. On ne peut utiliser la somme des parties que si l'on pense en termes deconception, et non simplement en termes de code. Pour apprhender Java de cettemanire, il faut comprendre les problmes qui lui sont propres et ceux qui relventde la programmation en gnral. Ce livre traite de problmes de programmation, enquoi 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 mamanire de rsoudre un certain type de problmes au moyen de ce langage. Par cettedmarche j'espre peu peu amener le lecteur au point o penser Java luideviendra naturel.

Je garderai constamment l'esprit qu'il faut que chacun se construise un modle depense permettant de dvelopper une profonde connaissance du langage ; lorsqu'ilrencontrera un problme ardu il devra tre capable d'en alimenter ce modle et d'en

dduire la solution.

PrrequisCe livre part du principe que le lecteur est un familier de la programmation : il saitqu'un programme est un ensemble d'instructions, il sait ce que sont un sous-programme, 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 certainementappris cela de diffrentes faons, par exemple en programmant avec un macro-langage ou bien en utilisant un outil tel que Perl. Si vous faites partie de ceux quisont l'aise avec les ides de base de la programmation, vous lirez ce livre sansproblme. Bien entendu, le livre sera plus facile pour les programmeurs C et encoreplus pour les programmeurs C++, mais n'abandonnez pas pour autant si vous n'avezaucune exprience de ces langages (en revanche, prparez-vous travailler dur ; parailleurs, 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 lesmcanismes de contrle de base de Java, ainsi le lecteur en aura connaissance, etrencontrera dans les premiers exercices les instructions de base du contrle de fluxde programme.

Bien qu'il soit souvent fait rfrence aux fonctionnalits des langages C et C++, il nes'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 sesparents. Je vais essayer de simplifier ces rfrences et d'expliquer unprogrammeur ne connaissant ni C ni C++ tout ce que j'imagine tre peu familierpour lui.

Apprendre JavaJ'ai commenc enseigner C++ l'poque o tait dit mon premier livre UsingC++(Osborne McGraw-Hill, 1989). Enseigner la programmation est devenu maprofession ; depuis 1989 j'ai vu bien des hochements de tte, de visages vides, ainsique beaucoup d'expressions d'incomprhension chez maint auditoire travers lemonde. Lorsque je me mis donner des cours chez moi, pour des groupes plusrduits, je dcouvris que mme ceux qui souriaient et hochaient la tte taientdconcerts face de nombreux problmes. J'ai dcouvert aussi, alors que jeprsidais le cursus C++ durant plusieurs annes la Software DevelopmentConference (et plus tard le cursus Java), que moi-mme ainsi que les autresconfrenciers avions tendance traiter trop de choses trop rapidement. Finalement, cause des diffrences entre les niveaux de mes auditeurs tout autant que de lamanire 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 quirechignent au cours magistral (et chez beaucoup de gens, je crois qu'une telleattitude ne peut provenir que du souvenir de l'ennui que distillent de tels cours), j'aivoulu faire en sorte que tout le monde reste veill.

une certaine priode, je terminais mes diffrents cours sous la pression desbesoins. C'est ainsi que j'ai fini par enseigner par essais et erreurs (une technique quimarche bien galement dans la conception des programmes Java), et finalement j'airalis un cours qui utilise tout ce que j'ai appris grce mon exprienced'enseignant un cours qu'il me serait agrable de donner durant longtemps. Ilconsiste s'attaquer au problme de l'apprentissage par touches discrtes et faciles intgrer, et lors d'un sminaire impromptu (la situation idale pourenseigner) chaque courte leon est suivie d'exercices. Je donne maintenant ce coursdans des sminaires Java publics, que l'on peut trouver sur le sitehttp://www.BruceEckel.com. (Le sminaire d'introduction est galement disponiblesur le CD ROM, son contenu est disponible sur le mme site Web.)

Le retour d'exprience que me procure chaque sminaire m'aide modifier etrecentrer 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 tentd'y intgrer autant d'informations que je le pouvais, et je l'ai structur afin quechaque sujet mne droit au suivant. Enfin, plus que tout, le livre est conu pouraider le lecteur solitaire qui se bat avec un nouveau langage de programmation.

ButsComme mon prcdent livre Thinking in C++, celui-ci a t structur pour enseignerle langage. En particulier, ma motivation est de faire en sorte qu'il puisse me servirpour enseigner le langage dans mes propres sminaires. Lorsque je pense unchapitre du livre, je me demande s'il pourrait faire l'objet d'une bonne leon lorsd'un sminaire. Mon but est d'avoir des chapitres courts pouvant tre exposs en untemps raisonnable, suivis par des exercices ralisables dans une situation de salle declasse.

Dans ce livre je me suis donn comme buts :

1. prsenter le cours pas pas afin que le lecteur assimile chaque conceptavant d'aller plus avant ;

2. utiliser des exemples qui soient aussi simples et courts que possible. Detemps en temps, cela me dtournera des problmes du monde rel , maisj'ai remarqu que les dbutants sont gnralement plus satisfaits

Penser en Java (Version 2.4)

Documents

Transcript of Penser en Java (Version 2.4)