Penser en Java - b) Avant-propos- Page 1/2

b) Avant-propos

Texte original

Traducteur : Jean-Pierre VIDAL

Ce chapitre contient 2 pages
1 2

\\\

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 :
- Derni?e mise jour de la version fran?ise
Traducteur :
- Jean-Pierre VIDAL
Texte original :
- Thinking in Java, 2nd edition, Revision 10
? 2000 by Bruce Eckel

Introduction

Like any human language, Java provides a way to express concepts. If successful, this medium of expression will be significantly easier and more flexible than the alternatives as problems grow larger and more complex.

Tout comme n'importe quel langage humain, Java permet d'exprimer des concepts. S'il y parvient, il deviendra un moyen d'expression consid?ablement plus simple et plus souple que n'importe quelle alternative, alors m?e que les probl?es augmentent en taille et en complexit?

You can’t look at Java as just a collection of features—some of the features make no sense in isolation. You can use the sum of the parts only if you are thinking about design, not simply coding. And to understand Java in this way, you must understand the problems with it and with programming in general. This book discusses programming problems, why they are problems, and the approach Java has taken to solve them. Thus, the set of features I explain in each chapter are based on the way I see a particular type of problem being solved with the language. In this way I hope to move you, a little at a time, to the point where the Java mindset becomes your native tongue.

Il est impossible de consid?er Java uniquement sous l'angle d'une collection de fonctionnalit? — beaucoup de fonctionnalit? 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 appr?ender Java de cette mani?e, il faut comprendre les probl?es qui lui sont propres et ceux qui rel?ent de la programmation en g??al. Ce livre traite de probl?es de programmation, en quoi ce sont des probl?es, et quelle est l'approche de Java pour les r?oudre. Ainsi, l'ensemble de fonctionnalit? que je pr?ente dans chaque chapitre est bas? sur ma mani?e de r?oudre un certain type de probl?es au moyen de ce langage. Par cette d?arche j'esp?e peu peu amener le lecteur au point o ? penser Java ? lui deviendra naturel.

Throughout, I’ll be taking the attitude that you want to build a model in your head that allows you to develop a deep understanding of the language; if you encounter a puzzle you’ll be able to feed it to your model and deduce the answer.

Je garderai constamment l'esprit qu'il faut que chacun se construise un mod?e de pens? permettant de d?elopper une profonde connaissance du langage ; lorsqu'il rencontrera un probl?e ardu il devra ?re capable d'en alimenter ce mod?e et d'en d?uire la solution.

Prerequisites

Pr?equis

This book assumes that you have some programming familiarity: you understand that a program is a collection of statements, the idea of a subroutine/function/macro, control statements such as “if” and looping constructs such as “while,” etc. However, you might have learned this in many places, such as programming with a macro language or working with a tool like Perl. As long as you’ve programmed to the point where you feel comfortable with the basic ideas of programming, you’ll be able to work through this book. Of course, the book will be easier for the C programmers and more so for the C++ programmers, but don’t count yourself out if you’re not experienced with those languages (but come willing to work hard; also, the multimedia CD that accompanies this book will bring you up to speed on the basic C syntax necessary to learn Java). I’ll be introducing the concepts of object-oriented programming (OOP) and Java’s basic control mechanisms, so you’ll be exposed to those, and the first exercises will involve the basic control-flow statements.

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 sous-programme, une fonction, une macro-instruction, un ordre de contr?e tel que ? if ? ainsi qu'une structure de boucle telle que ? while ?, etc. Toutefois, il a certainement appris cela de diff?entes fa?ns, par exemple en programmant avec un macro-langage ou bien en utilisant un outil tel que Perl. Si vous faites partie de ceux qui sont l'aise avec les id?s de base de la programmation, vous lirez ce livre sans probl?e. 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 exp?ience de ces langages (en revanche, pr?arez-vous travailler dur ; par ailleurs, le CD multim?ia fourni avec ce livre vous am?era rapidement comprendre la syntaxe de base du langage C n?essaire l'apprentissage de Java). Je vais introduire les concepts de la programmation orient? objet (POO) et les m?anismes de contr?e de base de Java, ainsi le lecteur en aura connaissance, et rencontrera dans les premiers exercices les instructions de base du contr?e de flux de programme.

Although references will often be made to C and C++ language features, these are not intended to be insider comments, but instead to help all programmers put Java in perspective with those languages, from which, after all, Java is descended. I will attempt to make these references simple and to explain anything that I think a non- C/C++ programmer would not be familiar with.

Bien qu'il soit souvent fait r??ence aux fonctionnalit? des langages C et C++, il ne s'agit pas d'un apart pour initi?, mais au contraire d'aider tous les programmeurs mettre Java en perspective avec ces deux langages, qui, apr? tout, sont ses parents. Je vais essayer de simplifier ces r??ences et d'expliquer un programmeur ne connaissant ni C ni C++ tout ce que j'imagine ?re peu familier pour lui.

Learning Java

Apprendre Java

At about the same time that my first book Using C++ (Osborne/McGraw-Hill, 1989) came out, I began teaching that language. Teaching programming languages has become my profession; I’ve seen nodding heads, blank faces, and puzzled expressions in audiences all over the world since 1989. As I began giving in-house training with smaller groups of people, I discovered something during the exercises. Even those people who were smiling and nodding were confused about many issues. I found out, by chairing the C++ track at the Software Development Conference for a number of years (and later the Java track), that I and other speakers tended to give the typical audience too many topics too fast. So eventually, through both variety in the audience level and the way that I presented the material, I would end up losing some portion of the audience. Maybe it’s asking too much, but because I am one of those people resistant to traditional lecturing (and for most people, I believe, such resistance results from boredom), I wanted to try to keep everyone up to speed.

J'ai commenc enseigner C++ l'?oque o ?ait ?it 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 t?e, de visages vides, ainsi que beaucoup d'expressions d'incompr?ension chez maint auditoire travers le monde. Lorsque je me mis donner des cours chez moi, pour des groupes plus r?uits, je d?ouvris que m?e ceux qui souriaient et hochaient la t?e ?aient d?oncert? face de nombreux probl?es. J'ai d?ouvert aussi, alors que je pr?idais le cursus C++ durant plusieurs ann?s la Software Development Conference (et plus tard le cursus Java), que moi-m?e ainsi que les autres conf?enciers avions tendance traiter trop de choses trop rapidement. Finalement, cause des diff?ences entre les niveaux de mes auditeurs tout autant que de la mani?e dont je pr?entais 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 ?eill?

For a time, I was creating a number of different presentations in fairly short order. Thus, I ended up learning by experiment and iteration (a technique that also works well in Java program design). Eventually I developed a course using everything I had learned from my teaching experience—one that I would be happy giving for a long time. It tackles the learning problem in discrete, easy-to-digest steps, and in a hands-on seminar (the ideal learning situation) there are exercises following each of the short lessons. I now give this course in public Java seminars, which you can find out about at www.BruceEckel.com. (The introductory seminar is also available as a CD ROM. Information is available at the same Web site.)

? une certaine p?iode, je terminais mes diff?ents cours sous la pression des besoins. C'est ainsi que j'ai fini par enseigner par essais et erreurs (une technique qui marche bien ?alement dans la conception des programmes Java), et finalement j'ai r?lis un cours qui utilise tout ce que j'ai appris gr?e mon exp?ience d'enseignant — un cours qu'il me serait agr?ble de donner durant longtemps. Il consiste s'attaquer au probl?e de l'apprentissage par touches discr?es et faciles int?rer, et lors d'un s?inaire impromptu (la situation id?le pour enseigner) chaque courte le?n est suivie d'exercices. Je donne maintenant ce cours dans des s?inaires Java publics, que l'on peut trouver sur le site http://www.BruceEckel.com. (Le s?inaire d'introduction est ?alement disponible sur le CD ROM, son contenu est disponible sur le m?e site Web.)

The feedback that I get from each seminar helps me change and refocus the material until I think it works well as a teaching medium. But this book isn’t just seminar notes—I tried to pack as much information as I could within these pages, and structured it to draw you through onto the next subject. More than anything, the book is designed to serve the solitary reader who is struggling with a new programming language.

Le retour d'exp?ience que me procure chaque s?inaire 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 s?inaires : j'ai tent d'y int?rer autant d'informations que je le pouvais, et je l'ai structur afin que chaque sujet m?e droit au suivant. Enfin, plus que tout, le livre est con? pour aider le lecteur solitaire qui se bat avec un nouveau langage de programmation.

Goals

Buts

Like my previous book Thinking in C++, this book has come to be structured around the process of teaching the language. In particular, my motivation is to create something that provides me with a way to teach the language in my own seminars. When I think of a chapter in the book, I think in terms of what makes a good lesson during a seminar. My goal is to get bite-sized pieces that can be taught in a reasonable amount of time, followed by exercises that are feasible to accomplish in a classroom situation.

Comme mon pr??ent livre Thinking in C++, celui-ci a ? structur pour enseigner le langage. En particulier, ma motivation est de faire en sorte qu'il puisse me servir pour enseigner le langage dans mes propres s?inaires. Lorsque je pense un chapitre du livre, je me demande s'il pourrait faire l'objet d'une bonne le?n lors d'un s?inaire. Mon but est d'avoir des chapitres courts pouvant ?re expos? en un temps raisonnable, suivis par des exercices r?lisables dans une situation de salle de classe.

My goals in this book are to:

Dans ce livre je me suis donn comme buts :

Present the material one simple step at a time so that you can easily digest each concept before moving on.
Use examples that are as simple and short as possible. This sometimes prevents me from tackling “real world” problems, but I’ve found that beginners are usually happier when they can understand every detail of an example rather than being impressed by the scope of the problem it solves. Also, there’s a severe limit to the amount of code that can be absorbed in a classroom situation. For this I will no doubt receive criticism for using “toy examples,” but I’m willing to accept that in favor of producing something pedagogically useful.
Carefully sequence the presentation of features so that you aren’t seeing something that you haven’t been exposed to. Of course, this isn’t always possible; in those situations, a brief introductory description is given.
Give you what I think is important for you to understand about the language, rather than everything I know. I believe there is an information importance hierarchy, and that there are some facts that 95 percent of programmers will never need to know and that just confuse people and adds to their perception of the complexity of the language. To take an example from C, if you memorize the operator precedence table (I never did), you can write clever code. But if you need to think about it, it will also confuse the reader/maintainer of that code. So forget about precedence, and use parentheses when things aren’t clear.
Keep each section focused enough so that the lecture time—and the time between exercise periods—is small. Not only does this keep the audience’s minds more active and involved during a hands-on seminar, but it gives the reader a greater sense of accomplishment.
Provide you with a solid foundation so that you can understand the issues well enough to move on to more difficult coursework and books.

pr?enter le cours pas pas afin que le lecteur assimile chaque concept avant d'aller plus avant ;
utiliser des exemples qui soient aussi simples et courts que possible. De temps en temps, cela me d?ournera des probl?es ? du monde r?l ?, mais j'ai remarqu que les d?utants sont g??alement plus satisfaits de comprendre chaque d?ail d'un exemple qu'ils ne sont impressionn? par la port? du probl?e qu'ils cherchent r?oudre. Il y a ?alement une limite la taille du code qui peut ?re assimil dans une situation de cours magistral, limite qu'il faut imp?ativement ne pas d?asser. A ce sujet je devrais recevoir quelques critiques pour avoir utilis des ? exemples jouets ?, et je les accepte volontiers, avec le pr?exte que ce que je pr?ente est utile, p?agogiquement parlant ;
encha?er soigneusement la pr?entation des fonctionnalit? afin que l'on ne rencontre jamais quoi que ce soit qui n'ait jamais ? expos? Bien entendu, ce n'est pas toujours possible, et, dans de telles situations, je donne une br?e description en introduction ;
montrer ce que je pense ?re important concernant la compr?ension du langage, plut? qu'exposer tout mon savoir. Je crois que l'information est fortement hi?archis?, qu'il est av? que 95 % des programmeurs n'ont pas besoin de tout conna?re, et que cela d?oute 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 op?ateurs (ce qui n'est pas mon cas), il est possible d'?rire un code astucieux. Mais en y r?l?hissant un instant, ceci risque de d?outer le lecteur et/ou le mainteneur de ce code. Il est donc pr??able d'oublier la priorit des op?ateurs, et d'utiliser des parenth?es lorsque les choses ne sont pas claires ;
maintenir chaque section assez concentr? de telle mani?e 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 s?inaire, mais cela donne au lecteur une plus grande impression de travail bien fait ;
vous munir de bases solides afin que votre connaissance soit suffisante avant de suivre un cours ou lire un livre plus difficiles.

Online documentation

Documentation en ligne

The Java language and libraries from Sun Microsystems (a free download) come with documentation in electronic form, readable using a Web browser, and virtually every third party implementation of Java has this or an equivalent documentation system. Almost all the books published on Java have duplicated this documentation. So you either already have it or you can download it, and unless necessary, this book will not repeat that documentation because it’s usually much faster if you find the class descriptions with your Web browser than if you look them up in a book (and the on-line documentation is probably more up-to-date). This book will provide extra descriptions of the classes only when it’s necessary to supplement the documentation so you can understand a particular example.

Le langage Java et les biblioth?ues de Sun Microsystems (en t??hargement libre) sont accompagn? d'une documentation sous forme ?ectronique, que l'on peut lire avec un navigateur Web, et en pratique chaque impl?entation tierce de Java poss?e un syst?e de documentation ?uivalent. La plupart des livres publi? propos de Java dupliquent cette documentation. Soit vous l'avez d?? soit vous pouvez la t??harger, et donc ce livre ne la reprendra pas, except lorsque c'est n?essaire, parce qu'il sera g??alement plus rapide de trouver la description d'une classe au moyen d'un navigateur plut? que dans le livre (de plus, la documentation en ligne sera probablement davantage jour). Ce livre fournira certaines descriptions de classes suppl?entaires lorsqu'il sera n?essaire de compl?er la documentation afin de comprendre un exemple particulier.

Chapters

Les chapitres

This book was designed with one thing in mind: the way people learn the Java language. Seminar audience feedback helped me understand the difficult parts that needed illumination. In the areas where I got ambitious and included too many features all at once, I came to know—through the process of presenting the material—that if you include a lot of new features, you need to explain them all, and this easily compounds the student’s confusion. As a result, I’ve taken a great deal of trouble to introduce the features as few at a time as possible.

Ce livre a ? con? en gardant une seule chose l'esprit : la mani?e dont les gens apprennent le langage Java. Le retour d'information des auditeurs de s?inaires m'a aid d?ouvrir les parties difficiles qui justifient un autre ?lairage. Dans les domaines o je fus ambitieux, o j'ai ajout trop de fonctionnalit? dans un m?e temps, j'ai fini par comprendre - au travers du processus d'enseignement - que si l'on ajoute de nouvelles fonctionnalit?, on doit les expliquer compl?ement, et que cela peut d?outer les ?udiants. Je me suis donc donn beaucoup de mal pour introduire aussi peu que possible de nouveaux concepts en un m?e temps.

The goal, then, is for each chapter to teach a single feature, or a small group of associated features, without relying on additional features. That way you can digest each piece in the context of your current knowledge before moving on.

Le but est donc d'enseigner une seule fonctionnalit par chapitre, ou la rigueur un petit ensemble de fonctionnalit? associ?s, en ?itant les liaisons avec des fonctionnalit? suppl?entaires. De cette mani?e, il est possible d'assimiler chaque chose dans le contexte de la connaissance actuelle avant d'aller plus loin.

Here is a brief description of the chapters contained in the book, which correspond to lectures and exercise periods in my hands-on seminars.

Voici une br?e description des chapitres contenus dans le livre, qui correspondent aux le?ns et exercices de mes s?inaires.

Chapter 1: Introduction to Objects

Chapitre 1 : Introduction sur les Objets

This chapter is an overview of what object-oriented programming is all about, including the answer to the basic question “What’s an object?”, interface vs. implementation, abstraction and encapsulation, messages and functions, inheritance and composition, and the all-important polymorphism. You’ll also get an overview of issues of object creation such as constructors, where the objects live, where to put them once they’re created, and the magical garbage collector that cleans up the objects that are no longer needed. Other issues will be introduced, including error handling with exceptions, multithreading for responsive user interfaces, and networking and the Internet. You’ll learn what makes Java special, why it’s been so successful, and about object-oriented analysis and design.

Ce chapitre est une vue d'ensemble de ce qu'est la programmation orient? objet, y compris la r?onse la question de base ? Qu'est-ce qu'un objet ?, ce que sont une interface et une impl?entation, l'abstraction et l'encapsulation, les messages et les fonctions, l'h?itage et la composition, ainsi que le polymorphisme qui est d'une tr? haute importance. On y trouve ?alement une vue d'ensemble de la mani?e dont les objets sont cr?s avec les constructeurs, o se trouvent les objets, o les ranger une fois cr?s, ainsi que le magique ramasse-miettes (garbage collector) qui d?ruit tous les objets devenus inutiles. D'autres questions seront abord?s, comme le traitement des erreurs par les exceptions, le multithreading pour des interfaces utilisateur r?ctives, la programmation r?eau et l'Internet. On y apprendra ce qui rend Java sp?ial, pourquoi il a tant de succ?, ainsi que l'analyse et la conception orient?s objet.

Chapter 2: Everything is an Object

Chapitre 2 : Tout est Objet

This chapter moves you to the point where you can write your first Java program, so it must give an overview of the essentials, including the concept of a reference to an object; how to create an object; an introduction to primitive types and arrays; scoping and the way objects are destroyed by the garbage collector; how everything in Java is a new data type (class) and how to create your own classes; functions, arguments, and return values; name visibility and using components from other libraries; the static keyword; and comments and embedded documentation.

Avec ce chapitre on arrive au point o l'on peut ?rire un premier programme Java. Il doit donc donner une vision d'ensemble des choses essentielles, entre autres : le concept de r??ence un objet ; comment cr?r un objet ; une introduction aux types primitifs et aux tableaux ; comment ils sont d?ruits par le ramasse-miettes ; comment toute chose est en Java un nouveau type de donn?s (class) et comment cr?r vos propres classes ; les fonctions, leurs arguments et leur valeur de retour ; la visibilit des noms et l'utilisation de composants provenant d'autres biblioth?ues ; le mot clef static ; les commentaires et la documentation int?r?.

Chapter 3: Controlling Program Flow

Chapitre 3 : Contr?er le D?oulement du Programme

This chapter begins with all of the operators that come to Java from C and C++. In addition, you’ll discover common operator pitfalls, casting, promotion, and precedence. This is followed by the basic control-flow and selection operations that you get with virtually any programming language: choice with if-else; looping with for and while; quitting a loop with break and continue as well as Java’s labeled break and labeled continue (which account for the “missing goto” in Java); and selection using switch. Although much of this material has common threads with C and C++ code, there are some differences. In addition, all the examples will be full Java examples so you’ll get more comfortable with what Java looks like.

Ce chapitre commence avec tous les op?ateurs provenant de C et C++. On y d?ouvre les pi?es classiques des op?ateurs, le changement de type, la promotion et la priorit? Suivent le classique contr?e de flux de programme, les instructions de rupture de s?uence d? connues pour avoir ? rencontr?s dans d'autres langages de programmation : le choix avec if-else, la boucle avec for et while ; comment sortir d'une boucle avec break et continue aussi bien qu'avec les break ?iquet? et les continue ?iquet? (qui repr?entent le ? goto manquant ? en java) ; la s?ection avec switch. Bien que la majorit de ces fonctionnalit? ressemblent au code C et C++, il existe certaines diff?ences. De plus, tous les exemples sont ?rits en pur Java, afin de mieux montrer quoi ressemble le langage.

Chapter 4: Initialization & Cleanup

Chapitre 4 : Initialisation et Nettoyage M?oire

This chapter begins by introducing the constructor, which guarantees proper initialization. The definition of the constructor leads into the concept of function overloading (since you might want several constructors). This is followed by a discussion of the process of cleanup, which is not always as simple as it seems. Normally, you just drop an object when you’re done with it and the garbage collector eventually comes along and releases the memory. This portion explores the garbage collector and some of its idiosyncrasies. The chapter concludes with a closer look at how things are initialized: automatic member initialization, specifying member initialization, the order of initialization, static initialization and array initialization.

Ce chapitre commence par d?rire le constructeur, lequel garantit une initialisation correcte. La d?inition du constructeur d?ouche sur le concept de surcharge de fonction (dans la mesure o plusieurs constructeurs peuvent coexister). La suite est une discussion sur le processus de nettoyage m?oire, qui n'est pas toujours aussi simple qu'il semblerait. Normalement, il suffit simplement d'abandonner un objet lorsqu'on n'en a plus besoin, et le ramasse-miettes finira par lib?er la m?oire. Cette partie explore le ramasse-miettes ainsi que quelques-unes de ses particularit?. Le chapitre se termine par une vision plus centr? sur l'initialisation : initialisation automatique des membres, sp?ification de l'initialisation des membres, ordre d'initialisation, initialisation static et initialisation des tableaux.

Chapter 5: Hiding the Implementation

Chapitre 5 : Cacher l'Impl?entation

This chapter covers the way that code is packaged together, and why some parts of a library are exposed while other parts are hidden. It begins by looking at the package and import keywords, which perform file-level packaging and allow you to build libraries of classes. It then examines subject of directory paths and file names. The remainder of the chapter looks at the public, private, and protected keywords, the concept of “friendly” access, and what the different levels of access control mean when used in various contexts.

Ce chapitre traite de la mani?e dont le code est mis en paquetages, et pourquoi certaines parties d'une biblioth?ue sont visibles alors que d'autres sont cach?s. Il s'int?esse tout d'abord aux mots clefs package et import, qui sont en relation avec la gestion des paquetages au niveau fichier et permettent de construire des biblioth?ues de classes. Il examine ensuite le probl?e sous l'angle des chemins de dossier et des noms de fichiers. Le reste du chapitre traite des mots clefs public, private et protected, du concept de l'acc? ? amical ? (acc? par d?aut, NdT), et de ce que signifient les diff?ents niveaux de contr?e d'acc? utilis? dans divers contextes.

Chapter 6: Reusing Classes

Chapitre 6 : R?tilisation des Classes

The concept of inheritance is standard in virtually all OOP languages. It’s a way to take an existing class and add to its functionality (as well as change it, the subject of Chapter 7). Inheritance is often a way to reuse code by leaving the “base class” the same, and just patching things here and there to produce what you want. However, inheritance isn’t the only way to make new classes from existing ones. You can also embed an object inside your new class with composition. In this chapter you’ll learn about these two ways to reuse code in Java, and how to apply them.

Le concept d'h?itage se retrouve dans pratiquement tous les langages de POO. Il s'agit de prendre une classe existante et d'?endre ses fonctionnalit? (ou tout aussi bien les modifier, c'est le sujet du chapitre 7). L'h?itage consiste toujours r?tiliser du code en gardant la m?e ? classe de base ?, et en modifiant simplement certaines choses ? et l afin d'obtenir ce que l'on veut. Toutefois, l'h?itage n'est pas la seule mani?e de cr?r de nouvelles classes partir de classes existantes. Il est ?alement possible d'encapsuler un objet dans une nouvelle classe au moyen de la composition. Ce chapitre explique ces deux m?hodes de r?tilisation du code en Java, et comment les utiliser.

Chapter 7: Polymorphism

Chapitre 7 : Le Polymorphisme

On your own, you might take nine months to discover and understand polymorphism, a cornerstone of OOP. Through small, simple examples you’ll see how to create a family of types with inheritance and manipulate objects in that family through their common base class. Java’s polymorphism allows you to treat all objects in this family generically, which means the bulk of your code doesn’t rely on specific type information. This makes your programs extensible, so building programs and code maintenance is easier and cheaper.

Si vous appreniez par vous-m?e, il vous faudrait neuf mois pour d?ouvrir et comprendre le polymorphisme, l'une des pierres angulaires de la POO. Des exemples simples et courts montreront comment cr?r une famille de types au moyen de l'h?itage et comment manipuler les objets dans cette famille par l'interm?iaire de leur classe de base. Le polymorphisme de Java permet de traiter de mani?e g??ique tout objet d'une famille, ce qui signifie que la plus grande partie du code n'est pas li? une information sp?ifique sur le type. Ceci rend les programmes extensibles, et donc leur d?eloppement et leur maintenance plus simples et moins on?eux.

Chapter 8: Interfaces & Inner Classes

Chapitre 8 : Interfaces & Classes Internes

Java provides a third way to set up a reuse relationship, through the interface, which is a pure abstraction of the interface of an object. The interface is more than just an abstract class taken to the extreme, since it allows you to perform a variation on C++’s “multiple inheritance,” by creating a class that can be upcast to more than one base type.

Java fournit une troisi?e voie pour la r?tilisation du code, avec l'interface, qui est une pure abstraction de l'interface d'un objet. L'interface est bien plus qu'une simple classe abstraite dont on aurait pouss l'abstraction l'extr?e, puisqu'il vous permet de d?elopper une variation sur l'? h?itage multiple ? du C++, en cr?nt une classe qui peut ?re transtyp? vers plus d'un type de base.

At first, inner classes look like a simple code hiding mechanism: you place classes inside other classes. You’ll learn, however, that the inner class does more than that—it knows about and can communicate with the surrounding class—and that the kind of code you can write with inner classes is more elegant and clear, although it is a new concept to most and takes some time to become comfortable with design using inner classes.

Au premier abord, les classes internes ressemblent un simple m?anisme permettant de cacher le code : on place des classes l'int?ieur d'autres classes. Vous apprendrez toutefois que la classe interne fait plus que cela - elle conna? la classe enveloppante et peut communiquer avec elle - et il est certain que le style de code que l'on ?rit au moyen des classes internes est plus ??ant et plus clair, bien que cela repr?ente pour la plupart d'entre vous une nouvelle fonctionnalit n?essitant un certain temps d'apprentissage avant d'?re ma?ris?.

Chapter 9: Holding your Objects

Chapitre 9 : Stockage des Objets

It’s a fairly simple program that has only a fixed quantity of objects with known lifetimes. In general, your programs will always be creating new objects at a variety of times that will be known only while the program is running. In addition, you won’t know until run-time the quantity or even the exact type of the objects you need. To solve the general programming problem, you need to create any number of objects, anytime, anywhere. This chapter explores in depth the container library that Java 2 supplies to hold objects while you’re working with them: the simple arrays and more sophisticated containers (data structures) such as ArrayList and HashMap.

Un programme qui manipule un nombre fixe d'objets dont la dur? de vie est connue ne peut ?re que clair et tr? simple. Mais g??alement, les programmes cr?nt de nouveaux objets diff?ents moments, qui ne seront connus que lors de l'ex?ution. De plus, avant l'ex?ution, on ne conna? ni le nombre ni parfois le type exact des objets qui seront n?essaires. Afin de r?oudre ce probl?e g??al de la programmation, nous devons pouvoir cr?r n'importe quel nombre d'objets, n'importe quel moment, n'importe o? Ce chapitre explore en profondeur la biblioth?ue fournie par Java 2 pour ranger les objets durant leur existence : les tableaux simples et les conteneurs plus sophistiqu? (structures de donn?s) comme ArrayList et HashMap.

Chapter 10: Error Handling with Exceptions

Chapitre 10 : Traitement des Erreurs au Moyen des Exceptions

The basic philosophy of Java is that badly-formed code will not be run. As much as possible, the compiler catches problems, but sometimes the problems—either programmer error or a natural error condition that occurs as part of the normal execution of the program—can be detected and dealt with only at run-time. Java has exception handling to deal with any problems that arise while the program is running. This chapter examines how the keywords try, catch, throw, throws, and finally work in Java; when you should throw exceptions and what to do when you catch them. In addition, you’ll see Java’s standard exceptions, how to create your own, what happens with exceptions in constructors, and how exception handlers are located.

Java a pour philosophie de base qu'un code mal ?rit ne sera jamais ex?ut? Autant que possible, le compilateur rep?e les probl?es, mais parfois les probl?es - aussi bien une erreur de programmation qu'une condition d'erreur naturelle survenant lors de l'ex?ution normale du programme - ne peuvent ?re d?ect? et trait? qu'au moment de l'ex?ution. Java poss?e un traitement des erreurs par les exceptions pour s'occuper de tout probl?e survenant pendant l'ex?ution. Ce chapitre examine comment fonctionnent en Java les mots clefs try, catch, throw, throws, et finally ; quand lancer des exceptions ; et ce que l'on doit faire si on les intercepte. Il expose aussi les exceptions standard de Java, comment cr?r vos propres exceptions, ce qu'il advient des exceptions dans les constructeurs, et comment sont localis? les codes de traitement d'exception.

Chapter 11: The Java I/O System

Chapitre 11 : le Syst?e d'E/S de Java

Theoretically, you can divide any program into three parts: input, process, and output. This implies that I/O (input/output) is an important part of the equation. In this chapter you’ll learn about the different classes that Java provides for reading and writing files, blocks of memory, and the console. The distinction between “old” I/O and “new” Java I/O will be shown. In addition, this chapter examines the process of taking an object, “streaming” it (so that it can be placed on disk or sent across a network) and reconstructing it, which is handled for you with Java’s object serialization. Also, Java’s compression libraries, which are used in the Java ARchive file format (JAR), are examined.

En th?rie, on peut diviser n'importe quel programme en trois parties : entr?, traitement, et sortie des donn?s. Ceci sugg?e que les E/S (entr?s/sorties) repr?entent une part importante de n'importe quel probl?e. Ce chapitre ?udie les diff?entes classes fournies par Java pour lire et ?rire des fichiers, des blocs m?oire, ainsi que la console. Il montre la distinction entre E/S ? vieux style ? et E/S ? nouveau style ? Java. Il examine ?alement le processus consistant prendre un objet, le transformer en flux (de mani?e pouvoir le ranger sur disque ou l'envoyer travers un r?eau) puis le reconstruire, ce qui est pris en charge par la s?ialisation des objets de Java. Il pr?ente ?alement les biblioth?ues de compression de Java, utilis?s dans le format de fichier Java ARchive (JAR).

Chapter 12: Run-Time Type Identification

Chapitre 12 : Identification Dynamique de Type

Java run-time type identification (RTTI) lets you find the exact type of an object when you have a reference to only the base type. Normally, you’ll want to intentionally ignore the exact type of an object and let Java’s dynamic binding mechanism (polymorphism) implement the correct behavior for that type. But occasionally it is very helpful to know the exact type of an object for which you have only a base reference. Often this information allows you to perform a special-case operation more efficiently. This chapter explains what RTTI is for, how to use it, and how to get rid of it when it doesn’t belong there. In addition, this chapter introduces the Java reflection mechanism.

L'identification dynamique de type de Java (Run-Time Type Identification, RTTI) permet de conna?re le type exact d'un objet partir d'une r??ence sur le type de base. Habituellement, on pr??e ignorer intentionnellement le type exact d'un objet et laisser au m?anisme de liaison dynamique de Java (polymorphisme) le soin d'impl?enter la signification correcte pour ce type. Mais de temps en temps il est tr? utile de conna?re le type r?l d'un objet pour lequel on n'a qu'une r??ence sur le type de base. Souvent cette information permet d'impl?enter plus efficacement un traitement sp?ial. Ce chapitre explique quoi sert la RTTI, comment l'utiliser, et comment s'en d?arrasser lorsqu'on n'en a plus besoin. Enfin, il introduit le m?anisme de r?lexion de Java.

Chapter 13: Creating Windows and Applets

Chapitre 13 : Cr?r des Fen?res et des Applets

Java comes with the “Swing” GUI library, which is a set of classes that handle windowing in a portable fashion. These windowed programs can either be applets or stand-alone applications. This chapter is an introduction to Swing and the creation of World Wide Web applets. The important “JavaBeans” technology is introduced. This is fundamental for the creation of Rapid-Application Development (RAD) program-building tools.

Java est livr avec la biblioth?ue GUI ? Swing ?, qui est un ensemble de classes traitant du fen?rage d'une mani?e portable (NdT : sur diff?entes plates-formes). Ces programmes fen?r? peuvent ?re soit des applets soit des applications autonomes. Ce chapitre est une introduction Swing et la cr?tion d'applets pour le World Wide Web. Il introduit aussi l'importante technologie des ? JavaBeans ?, fondamentale pour la cr?tion d'outils de d?eloppement de programmes destin? au D?eloppement Rapide d'Applications (RAD, Rapid-Application Development).

Chapter 14: Multiple Threads

Chapitre 14 : Les Threads Multiples

Java provides a built-in facility to support multiple concurrent subtasks, called threads, running within a single program. (Unless you have multiple processors on your machine, this is only the appearance of multiple subtasks.) Although these can be used anywhere, threads are most apparent when trying to create a responsive user interface so, for example, a user isn’t prevented from pressing a button or entering data while some processing is going on. This chapter looks at the syntax and semantics of multithreading in Java.

Java fournit un moyen de cr?r de multiples sous-t?hes concurrentes, appel?s threads, s'ex?utant dans le contexte d'un m?e programme (mis part le cas o la machine poss?e plus d'un processeur, ceci n'a que l'apparence de sous-t?hes multiples). Bien qu'on puisse les utiliser n'importe o? l'utilisation des threads est plus ?idente lorsqu'il s'agit de cr?r une interface utilisateur r?ctive comme, par exemple, lorsqu'un certain processus gourmand en ressources syst?e en cours d'ex?ution emp?he un utilisateur d'utiliser un bouton ou d'entrer des donn?s. Ce chapitre examine la syntaxe et la s?antique du multithreading en Java.

Chapter 15: Distributed Computing

Chapitre 15 : Informatique Distribu?

All the Java features and libraries seem to really come together when you start writing programs to work across networks. This chapter explores communication across networks and the Internet, and the classes that Java provides to make this easier. It introduces the very important concepts of Servlets and JSPs (for server-side programming), along with Java DataBase Connectivity (JDBC), and Remote Method Invocation (RMI). Finally, there’s an introduction to the new technologies of JINI, JavaSpaces, and Enterprise JavaBeans (EJBs).

Toutes les fonctionnalit? et biblioth?ues de Java semblent vraiment faites les unes pour les autres lorsqu'on commence ?rire des programmes qui travaillent en r?eau. Ce chapitre explore la communication au travers des r?eaux et sur l'Internet, ainsi que les classes fournies par Java pour faciliter cela. Il introduit les concepts tr? importants de Servlets et des JSPs (pour la programmation ? c? serveur ?), ainsi que la connectivit aux bases de donn?s, Java DataBase Connectivity (JDBC), et l'invocation de m?hodes distantes, Remote Method Invocation (RMI). Et, pour finir, une introduction aux nouvelles technologies JINI, JavaSpaces, et Enterprise JavaBeans (EJB).

Appendix A: Passing & Returning Objects

Annexe A : Passage & Retour d'Objets

Since the only way you talk to objects in Java is through references, the concepts of passing an object into a function and returning an object from a function have some interesting consequences. This appendix explains what you need to know to manage objects when you’re moving in and out of functions, and also shows the String class, which uses a different approach to the problem.

Etant donn qu'en Java seules les r??ences permettent d'appr?ender les objets, le concept de ? passer un objet une fonction ? et celui de ? retourner un objet depuis une fonction ? ont quelques cons?uences int?essantes. Cette annexe explique ce qu'il faut savoir afin de g?er les objets l'entr? et la sortie d'une fonction, et montre ?alement la classe String, qui utilise une approche diff?ente du probl?e.

Appendix B: The Java Native Interface (JNI)

Annexe B : L'interface Java Natif (JNI)

A totally portable Java program has serious drawbacks: speed and the inability to access platform-specific services. When you know the platform that you’re running on, it’s possible to dramatically speed up certain operations by making them native methods, which are functions that are written in another programming language (currently, only C/C++ is supported). This appendix gives you enough of an introduction to this feature that you should be able to create simple examples that interface with non-Java code.

Un programme Java enti?ement portable a de s?ieux inconv?ients : la vitesse, et l'incapacit d'acc?er des services sp?ifiques de la plate-forme. Connaissant la plate-forme sur laquelle sera ex?ut le programme, il est possible d'acc??er spectaculairement certaines op?ations en les transformant en m?hodes natives, qui sont des fonctions ?rites dans un autre langage de programmation (actuellement, seuls C/C++ sont support?). Cette annexe procure une courte introduction cette fonctionnalit? suffisante pour qu'on puisse cr?r des exemples simples utilisant cette interface avec un code autre que Java.

Haut de page

///