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ère mise à jour de la version française
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érablement plus simple et plus souple que n'importe quelle alternative, alors même que les problèmes 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érer Java uniquement sous l'angle d'une collection de fonctionnalités — beaucoup de fonctionnalités 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éhender Java de cette manière, il faut comprendre les problèmes qui lui sont propres et ceux qui relèvent de la programmation en général. Ce livre traite de problèmes de programmation, en quoi ce sont des problèmes, et quelle est l'approche de Java pour les résoudre. Ainsi, l'ensemble de fonctionnalités que je présente dans chaque chapitre est basée sur ma manière de résoudre un certain type de problèmes au moyen de ce langage. Par cette démarche j'espère 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èle de pensée permettant de développer une profonde connaissance du langage ; lorsqu'il rencontrera un problème ardu il devra être capable d'en alimenter ce modèle et d'en déduire la solution.

Prerequisites

Prérequis

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ôle tel que « if » ainsi qu'une structure de boucle telle que « while », etc. Toutefois, il a certainement appris cela de différentes façons, 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ées de base de la programmation, vous lirez ce livre sans problème. 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érience de ces langages (en revanche, préparez-vous à travailler dur ; par ailleurs, le CD multimédia fourni avec ce livre vous amènera rapidement à comprendre la syntaxe de base du langage C nécessaire à l'apprentissage de Java). Je vais introduire les concepts de la programmation orientée objet (POO) et les mécanismes de contrôle de base de Java, ainsi le lecteur en aura connaissance, et rencontrera dans les premiers exercices les instructions de base du contrôle 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éférence aux fonctionnalités des langages C et C++, il ne s'agit pas d'un aparté pour initiés, mais au contraire d'aider tous les programmeurs à mettre Java en perspective avec ces deux langages, qui, après tout, sont ses parents. Je vais essayer de simplifier ces références et d'expliquer à un programmeur ne connaissant ni C ni C++ tout ce que j'imagine être 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'époque où était édité mon premier livre Using C++(Osborne McGraw-Hill, 1989). Enseigner la programmation est devenu ma profession ; depuis 1989 j'ai vu bien des hochements de tête, de visages vides, ainsi que beaucoup d'expressions d'incompréhension chez maint auditoire à travers le monde. Lorsque je me mis à donner des cours chez moi, pour des groupes plus réduits, je découvris que même ceux qui souriaient et hochaient la tête étaient déconcertés face à de nombreux problèmes. J'ai découvert aussi, alors que je présidais le cursus C++ durant plusieurs années à la Software Development Conference (et plus tard le cursus Java), que moi-même ainsi que les autres conférenciers avions tendance à traiter trop de choses trop rapidement. Finalement, à cause des différences entre les niveaux de mes auditeurs tout autant que de la manière dont je présentais mon exposé, j'aurais fini par perdre une partie de mon auditoire. Je me suis posé beaucoup de questions, mais, faisant partie de ceux qui rechignent au cours magistral (et chez beaucoup de gens, je crois qu'une telle attitude ne peut provenir que du souvenir de l'ennui que distillent de tels cours), j'ai voulu faire en sorte que tout le monde reste éveillé.

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ériode, je terminais mes différents cours sous la pression des besoins. C'est ainsi que j'ai fini par enseigner par essais et erreurs (une technique qui marche bien également dans la conception des programmes Java), et finalement j'ai réalisé un cours qui utilise tout ce que j'ai appris grâce à mon expérience d'enseignant — un cours qu'il me serait agréable de donner durant longtemps. Il consiste à s'attaquer au problème de l'apprentissage par touches discrètes et faciles à intégrer, et lors d'un séminaire impromptu (la situation idéale pour enseigner) chaque courte leçon est suivie d'exercices. Je donne maintenant ce cours dans des séminaires Java publics, que l'on peut trouver sur le site http://www.BruceEckel.com. (Le séminaire d'introduction est également disponible sur le CD ROM, son contenu est disponible sur le même 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érience que me procure chaque séminaire 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éminaires : j'ai tenté d'y intégrer autant d'informations que je le pouvais, et je l'ai structuré afin que chaque sujet mène droit au suivant. Enfin, plus que tout, le livre est conçu 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écédent livre Thinking in C++, celui-ci a été 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éminaires. Lorsque je pense à un chapitre du livre, je me demande s'il pourrait faire l'objet d'une bonne leçon lors d'un séminaire. Mon but est d'avoir des chapitres courts pouvant être exposés en un temps raisonnable, suivis par des exercices réalisables 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ésenter 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étournera des problèmes « du monde réel », mais j'ai remarqué que les débutants sont généralement plus satisfaits de comprendre chaque détail d'un exemple qu'ils ne sont impressionnés par la portée du problème qu'ils cherchent à résoudre. Il y a également une limite à la taille du code qui peut être assimilé dans une situation de cours magistral, limite qu'il faut impérativement ne pas dépasser. A ce sujet je devrais recevoir quelques critiques pour avoir utilisé des « exemples jouets », et je les accepte volontiers, avec le prétexte que ce que je présente est utile, pédagogiquement parlant ;
enchaîner soigneusement la présentation des fonctionnalités afin que l'on ne rencontre jamais quoi que ce soit qui n'ait jamais été exposé. Bien entendu, ce n'est pas toujours possible, et, dans de telles situations, je donne une brève description en introduction ;
montrer ce que je pense être important concernant la compréhension du langage, plutôt qu'exposer tout mon savoir. Je crois que l'information est fortement hiérarchisée, qu'il est avéré que 95 % des programmeurs n'ont pas besoin de tout connaître, et que cela déroute 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érateurs (ce qui n'est pas mon cas), il est possible d'écrire un code astucieux. Mais en y réfléchissant un instant, ceci risque de dérouter le lecteur et/ou le mainteneur de ce code. Il est donc préférable d'oublier la priorité des opérateurs, et d'utiliser des parenthèses lorsque les choses ne sont pas claires ;
maintenir chaque section assez concentrée de telle manière 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éminaire, 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èques de Sun Microsystems (en téléchargement libre) sont accompagnés d'une documentation sous forme électronique, que l'on peut lire avec un navigateur Web, et en pratique chaque implémentation tierce de Java possède un système de documentation équivalent. La plupart des livres publiés à propos de Java dupliquent cette documentation. Soit vous l'avez déjà, soit vous pouvez la télécharger, et donc ce livre ne la reprendra pas, excepté lorsque c'est nécessaire, parce qu'il sera généralement plus rapide de trouver la description d'une classe au moyen d'un navigateur plutôt que dans le livre (de plus, la documentation en ligne sera probablement davantage à jour). Ce livre fournira certaines descriptions de classes supplémentaires lorsqu'il sera nécessaire de compléter 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 été conçu en gardant une seule chose à l'esprit : la manière dont les gens apprennent le langage Java. Le retour d'information des auditeurs de séminaires m'a aidé à découvrir les parties difficiles qui justifient un autre éclairage. Dans les domaines où je fus ambitieux, où j'ai ajouté trop de fonctionnalités dans un même temps, j'ai fini par comprendre - au travers du processus d'enseignement - que si l'on ajoute de nouvelles fonctionnalités, on doit les expliquer complètement, et que cela peut dérouter les étudiants. Je me suis donc donné beaucoup de mal pour introduire aussi peu que possible de nouveaux concepts en un même 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és associées, en évitant les liaisons avec des fonctionnalités supplémentaires. De cette manière, 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ève description des chapitres contenus dans le livre, qui correspondent aux leçons et exercices de mes séminaires.

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ée objet, y compris la réponse à la question de base « Qu'est-ce qu'un objet », ce que sont une interface et une implémentation, l'abstraction et l'encapsulation, les messages et les fonctions, l'héritage et la composition, ainsi que le polymorphisme qui est d'une très haute importance. On y trouve également une vue d'ensemble de la manière 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étruit tous les objets devenus inutiles. D'autres questions seront abordées, comme le traitement des erreurs par les exceptions, le multithreading pour des interfaces utilisateur réactives, la programmation réseau et l'Internet. On y apprendra ce qui rend Java spécial, pourquoi il a tant de succès, ainsi que l'analyse et la conception orientées 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 écrire un premier programme Java. Il doit donc donner une vision d'ensemble des choses essentielles, entre autres : le concept de référence à un objet ; comment créer un objet ; une introduction aux types primitifs et aux tableaux ; comment ils sont détruits par le ramasse-miettes ; comment toute chose est en Java un nouveau type de données (class) et comment créer 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èques ; le mot clef static ; les commentaires et la documentation intégrée.

Chapter 3: Controlling Program Flow

Chapitre 3 : Contrôler le Déroulement 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érateurs provenant de C et C++. On y découvre les pièges classiques des opérateurs, le changement de type, la promotion et la priorité. Suivent le classique contrôle de flux de programme, les instructions de rupture de séquence déjà connues pour avoir été rencontrées 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 étiquetés et les continue étiquetés (qui représentent le « goto manquant » en java) ; la sélection avec switch. Bien que la majorité de ces fonctionnalités ressemblent au code C et C++, il existe certaines différences. De plus, tous les exemples sont écrits en pur Java, afin de mieux montrer à quoi ressemble le langage.

Chapter 4: Initialization & Cleanup

Chapitre 4 : Initialisation et Nettoyage Mémoire

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écrire le constructeur, lequel garantit une initialisation correcte. La définition du constructeur débouche 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émoire, 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érer la mémoire. Cette partie explore le ramasse-miettes ainsi que quelques-unes de ses particularités. Le chapitre se termine par une vision plus centrée sur l'initialisation : initialisation automatique des membres, spécification de l'initialisation des membres, ordre d'initialisation, initialisation static et initialisation des tableaux.

Chapter 5: Hiding the Implementation

Chapitre 5 : Cacher l'Implémentation

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ère dont le code est mis en paquetages, et pourquoi certaines parties d'une bibliothèque sont visibles alors que d'autres sont cachées. Il s'intéresse 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èques de classes. Il examine ensuite le problème 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ès « amical » (accès par défaut, NdT), et de ce que signifient les différents niveaux de contrôle d'accès utilisés dans divers contextes.

Chapter 6: Reusing Classes

Chapitre 6 : Réutilisation 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éritage se retrouve dans pratiquement tous les langages de POO. Il s'agit de prendre une classe existante et d'étendre ses fonctionnalités (ou tout aussi bien les modifier, c'est le sujet du chapitre 7). L'héritage consiste toujours à réutiliser du code en gardant la même « classe de base », et en modifiant simplement certaines choses çà et là afin d'obtenir ce que l'on veut. Toutefois, l'héritage n'est pas la seule manière de créer de nouvelles classes à partir de classes existantes. Il est également possible d'encapsuler un objet dans une nouvelle classe au moyen de la composition. Ce chapitre explique ces deux méthodes de réutilisation 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ême, il vous faudrait neuf mois pour découvrir et comprendre le polymorphisme, l'une des pierres angulaires de la POO. Des exemples simples et courts montreront comment créer une famille de types au moyen de l'héritage et comment manipuler les objets dans cette famille par l'intermédiaire de leur classe de base. Le polymorphisme de Java permet de traiter de manière générique tout objet d'une famille, ce qui signifie que la plus grande partie du code n'est pas liée à une information spécifique sur le type. Ceci rend les programmes extensibles, et donc leur développement et leur maintenance plus simples et moins onéreux.

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ème voie pour la réutilisation 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ême, puisqu'il vous permet de développer une variation sur l'« héritage multiple » du C++, en créant une classe qui peut être transtypée 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écanisme permettant de cacher le code : on place des classes à l'intérieur d'autres classes. Vous apprendrez toutefois que la classe interne fait plus que cela - elle connaît la classe enveloppante et peut communiquer avec elle - et il est certain que le style de code que l'on écrit au moyen des classes internes est plus élégant et plus clair, bien que cela représente pour la plupart d'entre vous une nouvelle fonctionnalité nécessitant un certain temps d'apprentissage avant d'être maîtrisée.

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ée de vie est connue ne peut être que clair et très simple. Mais généralement, les programmes créent de nouveaux objets à différents moments, qui ne seront connus que lors de l'exécution. De plus, avant l'exécution, on ne connaît ni le nombre ni parfois le type exact des objets qui seront nécessaires. Afin de résoudre ce problème général de la programmation, nous devons pouvoir créer n'importe quel nombre d'objets, à n'importe quel moment, n'importe où. Ce chapitre explore en profondeur la bibliothèque fournie par Java 2 pour ranger les objets durant leur existence : les tableaux simples et les conteneurs plus sophistiqués (structures de données) 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 écrit ne sera jamais exécuté. Autant que possible, le compilateur repère les problèmes, mais parfois les problèmes - aussi bien une erreur de programmation qu'une condition d'erreur naturelle survenant lors de l'exécution normale du programme - ne peuvent être détectés et traités qu'au moment de l'exécution. Java possède un traitement des erreurs par les exceptions pour s'occuper de tout problème survenant pendant l'exécution. 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éer vos propres exceptions, ce qu'il advient des exceptions dans les constructeurs, et comment sont localisés les codes de traitement d'exception.

Chapter 11: The Java I/O System

Chapitre 11 : le Système 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éorie, on peut diviser n'importe quel programme en trois parties : entrée, traitement, et sortie des données. Ceci suggère que les E/S (entrées/sorties) représentent une part importante de n'importe quel problème. Ce chapitre étudie les différentes classes fournies par Java pour lire et écrire des fichiers, des blocs mémoire, ainsi que la console. Il montre la distinction entre E/S « vieux style » et E/S « nouveau style » Java. Il examine également le processus consistant à prendre un objet, le transformer en flux (de manière à pouvoir le ranger sur disque ou l'envoyer à travers un réseau) puis le reconstruire, ce qui est pris en charge par la sérialisation des objets de Java. Il présente également les bibliothèques de compression de Java, utilisées 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ître le type exact d'un objet à partir d'une référence sur le type de base. Habituellement, on préfère ignorer intentionnellement le type exact d'un objet et laisser au mécanisme de liaison dynamique de Java (polymorphisme) le soin d'implémenter la signification correcte pour ce type. Mais de temps en temps il est très utile de connaître le type réel d'un objet pour lequel on n'a qu'une référence sur le type de base. Souvent cette information permet d'implémenter plus efficacement un traitement spécial. Ce chapitre explique à quoi sert la RTTI, comment l'utiliser, et comment s'en débarrasser lorsqu'on n'en a plus besoin. Enfin, il introduit le mécanisme de réflexion de Java.

Chapter 13: Creating Windows and Applets

Chapitre 13 : Créer des Fenêtres 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èque GUI « Swing », qui est un ensemble de classes traitant du fenêtrage d'une manière portable (NdT : sur différentes plates-formes). Ces programmes fenêtrés peuvent être soit des applets soit des applications autonomes. Ce chapitre est une introduction à Swing et à la création d'applets pour le World Wide Web. Il introduit aussi l'importante technologie des « JavaBeans », fondamentale pour la création d'outils de développement de programmes destinés au Développement 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éer de multiples sous-tâches concurrentes, appelées threads, s'exécutant dans le contexte d'un même programme (mis à part le cas où la machine possède plus d'un processeur, ceci n'a que l'apparence de sous-tâches multiples). Bien qu'on puisse les utiliser n'importe où, l'utilisation des threads est plus évidente lorsqu'il s'agit de créer une interface utilisateur réactive comme, par exemple, lorsqu'un certain processus gourmand en ressources système en cours d'exécution empêche un utilisateur d'utiliser un bouton ou d'entrer des données. Ce chapitre examine la syntaxe et la sémantique du multithreading en Java.

Chapter 15: Distributed Computing

Chapitre 15 : Informatique Distribuée

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és et bibliothèques de Java semblent vraiment faites les unes pour les autres lorsqu'on commence à écrire des programmes qui travaillent en réseau. Ce chapitre explore la communication au travers des réseaux et sur l'Internet, ainsi que les classes fournies par Java pour faciliter cela. Il introduit les concepts très importants de Servlets et des JSPs (pour la programmation « côté serveur »), ainsi que la connectivité aux bases de données, Java DataBase Connectivity (JDBC), et l'invocation de méthodes 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éférences permettent d'appréhender les objets, le concept de « passer un objet à une fonction » et celui de « retourner un objet depuis une fonction » ont quelques conséquences intéressantes. Cette annexe explique ce qu'il faut savoir afin de gérer les objets à l'entrée et à la sortie d'une fonction, et montre également la classe String, qui utilise une approche différente du problème.

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èrement portable a de sérieux inconvénients : la vitesse, et l'incapacité d'accéder à des services spécifiques de la plate-forme. Connaissant la plate-forme sur laquelle sera exécuté le programme, il est possible d'accélérer spectaculairement certaines opérations en les transformant en méthodes natives, qui sont des fonctions écrites dans un autre langage de programmation (actuellement, seuls C/C++ sont supportés). Cette annexe procure une courte introduction à cette fonctionnalité, suffisante pour qu'on puisse créer des exemples simples utilisant cette interface avec un code autre que Java.

Haut de page

///