Thinking in Java, 3rd ed. Revision 4.0

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 les bases nécessaires à l'apprentissage de Java). Cependant, je vais introduire les concepts de la programmation orientée objet (POO) et les mécanismes de contrôle de base de Java.

Bien qu'il soit souvent fait référence aux fonctionnalités des langages C et C++, il ne s'agit pas de faire un aparté pour initiés, mais au contraire d'aider tous les programmeurs à mettre Java en perspective avec ces deux langages, dont, après tout, il descend. 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.

À peu près au même moment où mon premier livre Using C++ (Osborne/McGraw-Hill, 1989) sortait, j'ai commencé à enseigner ce langage. L'enseignement des langages de programmation est devenu ma profession ; j'ai vu des hochements de tête, des visages vides et des expressions embarrassées dans le public tout autour du monde depuis 1987. Alors que je commençais à donner des formations internes à de plus petits groupes de personnes, j'ai découvert quelque chose durant les exercices. Même les personnes qui souriaient et acquiesçaient étaient perdues sur bien des points. J'ai découvert, en créant et en présidant le cursus C++ à la Software Development Conference durant un certain nombre d'années (et plus tard en créant et présidant le cursus Java), que les autres orateurs et moi-même avions tendance à aborder avec un public classique trop de sujets et trop rapidement. Ainsi, les niveaux disparates des groupes et la manière de présenter les sujets auraient fini par me faire perdre une partie de mon auditoire. Peut-être est-ce trop demander, mais comme je fais partie de ces personnes allergiques aux présentations magistrales (et je crois que, pour bon nombre de personnes, cette allergie est due à l'ennui), j'ai voulu essayer de garder tout le monde au même rythme.

Pendant un certain temps, je créais un grand nombre de présentations différentes dans un délai assez court. J'ai donc fini par apprendre par expérimentations et itérations (une technique qui marche aussi pour la conception des programmes Java). À la longue, j'ai développé un cours en utilisant tout que j'avais appris de mon expérience d'enseignant. L'apprentissage est abordé par étapes distinctes, facilement assimilables, et sous forme de travaux pratiques (la situation idéale pour apprendre) ; chaque leçon est courte et suivie d'exercices. Mon entreprise MindView, Inc donne ce cours, Penser en Java, sous forme de séminaire public ou sur place; c'est notre séminaire principal d'introduction qui fournit les bases nécessaires à nos séminaires plus avancés. Vous trouverez de plus amples informations sur www.MindView.net (Le séminaire d'introduction est aussi disponible sur le cédérom Hands-On Java. Les informations sont disponibles sur le même site web).

Les retours d'expérience que je reçois à chaque séminaire m'aident à modifier et à remettre au point le matériel pédagogique jusqu'à ce que je pense qu'il constitue un bon véhicule d'enseignement. Mais ce livre n'est pas formé que de notes de séminaire ; j'ai essayé de réunir autant d'informations que je pouvais dans ces pages et de les structurer pour vous aider à passer en douceur de sujet en sujet. Plus que tout, ce livre est conçu pour aider le lecteur solitaire qui se débat avec un nouveau langage de programmation.

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.

Dans ce livre, mes objectifs sont de :

• 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. Parfois, 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'il résoud. Il y a également une limite à la quantité de code qui peut être assimilée dans une situation de cours magistral. À ce sujet, je recevrai sans doute 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 un sujet qui n'ait été préalablement expliqué. Bien entendu, ce n'est pas toujours possible, et, dans de telles situations, une brève description est donnée en introduction ;
• montrer ce que je pense être important concernant la compréhension du langage, plutôt qu'exposer tout mon savoir. Je crois qu'il y a une hiérarchie dans l'importance des informations, et qu'il y a des choses que 95 % des programmeurs n'auront jamais besoin de connaître - des détails qui déroutent tout le monde et ajoutent à leur impression de complexité du langage. Pour prendre un exemple en C, si l'on connaît par cœur 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 procurer des bases solides afin que vous compreniez suffisamment la problématique pour suivre un cours ou lire un livre plus difficiles.

Le langage Java et les bibliothèques de Sun Microsystems (en téléchargement libre sur java.sun.com) sont accompagnés d'une documentation sous forme électronique, que l'on peut lire avec un navigateur Web, et pratiquement 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). Vous serez simplement renvoyé vers la documentation du JDK. 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.

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 mes 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 inclus trop de fonctionnalités en une fois, 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 ne pas introduire trop de nouveaux concepts en même temps.

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 qui n'ont pas encore été présentées. De cette manière, il est possible d'assimiler chaque chose dans le contexte de la connaissance actuelle avant d'aller plus loin.

Voici une brève description des chapitres contenus dans le livre, qui correspondent aux leçons et exercices du séminaire Penser en Java.

Chapitre 1: Introduction sur les Objets

(Cours correspondant sur le CD ROM). Ce chapitre est une vue d'ensemble de ce qu'est la programmation orientée objet, y compris en répondant la réponse à la question de base « Qu'est-ce que un objet ?» Il traite de l'interface et à l'opposé de l'implémentation, de l'abstraction et de l'encapsulation, des messages et des méthodes, de l'héritage et de la composition, et du subtil concept du polymorphisme. 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 ramasse-miettes (garbage collector) magique 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. Vous apprendrez ce qui rend Java spécial et pourquoi il a tant de succès.

Chapitre 2: Tout est Objet

(Cours correspondant sur le CD ROM). Avec ce chapitre, vous arrivez au point où vous serez en mesure d'écrire votre premier programme Java. Il commence avec une vue d'ensemble des choses essentielles : le concept de référence à un objet ; comment créer un objet ; une introduction aux types primitifs et aux tableaux ; la manière dont les objets sont détruits par le ramasse miettes (garbage collector) ; comment toute chose est un nouveau type de données en Java (classe) ; les bases pour la création de vos propres classes ; les méthodes, leurs arguments et leur valeur de retour ; la visibilité des noms et l'utilisation de composants issus d'autres librairies ; le mot clef static ; et enfin les commentaires et la documentation incluse.

Chapitre 3: Contrôler le Déroulement du Programme

(Ensemble de cours correspondants sur le CD ROM : Penser en C). Ce chapitre commence par présenter l'ensemble des opérateurs de Java provenant de C et C++. Vous y découvrirez en plus les pièges classiques liés aux opérateurs, le changement de type (casting), la promotion et la priorité. Suivent les opérations de flux de contrôle et de sélection que l'on rencontre dans presque tous les langages : le choix avec if-else, les boucles avec for et while, comment sortir d'une boucle avec break et continue, mais aussi également avec les break et les continue étiquetés (qui représentent le « goto manquant » en Java), et la sélection avec switch. Bien que la majorité de ces fonctionnalités ressemble au code C et C++, il existe des différences.

Chapitre 4: Initialisation & Nettoyage

(Cours correspondant sur le CD ROM). Ce chapitre commence par décrire le constructeur, lequel garantit une initialisation correcte. La définition du constructeur débouche sur le concept de la surcharge de méthode (dans la mesure où plusieurs constructeurs peuvent coexister). Cela est suivi par une discussion sur le processus de nettoyage mémoire, qui n'est pas toujours aussi simple qu'il n'y paraît. Normalement, il suffit d'abandonner un objet lorsque l'on a plus besoin, et le ramasse-miettes finira par libérer la mémoire. Cette partie explore donc le ramasse-miettes ainsi que quelques-unes de ses particularités. Le chapitre se conclue par une vision davantage centrée sur la manière dont les objets sont initialisés : l'initialisation automatique et la spécification de l'initialisation des membres, l'ordre d'initialisation, l'initialisation statique et enfin l'initialisation des tableaux.

Chapitre 5: Masquer l'Implémentation

(Cours correspondant sur le CD ROM). Ce chapitre traite de la manière dont le code est packagé, et la raison pour laquelle certaines parties d'une librairie sont visibles alors que d'autres sont cachés. Il commencera par s'intéresser aux mots clés package et import, qui sont en relation avec le paquetage au niveau fichier et permettent de construire des librairies de classes. Il examine ensuite le problème sous l'angle des chemins de dossiers et des noms de fichiers. Le reste du chapitre traite des mots clés public, private et protected, du concept de l'accès « paquetage » (celui défini par défaut) et ce que signifient les différents niveaux d'accès selon leur utilisation en différents contextes.

Chapitre 6: Réutilisation des Classes

(Cours correspondant sur le CD ROM). La manière la plus simple de réutiliser une classe est d'en embarquer une instance dans votre nouvelle classe grâce à la composition. Cependant, la composition n'est pas l'unique moyen de construire de nouvelles classes à partir de classes existantes. Le concept de l'héritage se retrouve dans presque tous les langages de POO. Il s'agit d'un moyen de prendre une classe existante et d'en étendre les fonctionnalités (mais également de les modifier, c'est d'ailleurs le sujet du chapitre 7). L'héritage est souvent un moyen de réutiliser du code en gardant la « classe de base » à l'identique et en changeant certaines choses çà et là pour obtenir ce que l'on veut. Dans ce chapitre, vous apprendrez donc comment la composition et l'héritage permettent de réutiliser du code en Java et comment les utiliser.

Chapitre 7: Polymorphisme

(Cours correspondant sur le CD ROM). En vous y mettant par vous-même, vous mettriez neuf mois pour découvrir et comprendre le polymorphisme, l'une des pierres angulaires de la POO. À travers des exemples simples et courts, vous verrez comment créer une famille de types avec l'héritage, et comment manipuler des objets de cette famille par l'intermédiaire de leur classe de base commune. 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.

Chapitre 8: Interfaces & Classes Internes

Java fournit un mécanisme spécial pour concevoir et réutiliser les relations: l'interface, qui est une pure abstraction de l'interface d'un objet. L'interface est bien plus qu'une classe abstraite poussée à l'extrême, puisqu'elle vous permet de développer une variante de « l'héritage multiple » du C++, en créer une classe pouvant être transtypée vers plus d'un type de base.

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.

Chapitre 9: Traitement des Erreurs avec les Exceptions

Java a pour philosophie de base que du code mal écrit ne s'exécutera pas. Autant que possible, le compilateur détectera les problèmes, mais parfois certains problèmes - aussi bien une erreur de programmation qu'une condition d'erreur naturelle se produisant 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 dispose d'un mécanisme de traitement d'exceptions pour gérer tout problème survenant pendant que le programme s'exécute. Ce chapitre examine comment fonctionnent en Java les mots clés try, catch, throw, throws et finally, quand lancer des exceptions, et ce qui doit être fait lorsque des exceptions sont interceptées. De plus, vous verrez les exceptions standards de Java, comment créer ses propres exceptions, ce qu'il advient des exceptions dans les constructeurs, et comment sont localisés les codes de traitement d'exception.

Chapitre 10: Détecter les Types

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 le comportement correct pour ce type. Mais de temps en temps, il est très utile de connaitre le type exact de l'objet pour lequel on a seulement une référence de base. Souvent, ces informations permettent d'effectuer plus efficacement des traitements spécifiques. Ce chapitre introduit également le mécanisme d'introspection de Java. Ainsi, vous verrez à quoi servent le RTTI et l'introspection et comment les utiliser, mais également comment s'en débarrasser quand on en a plus besoin.

Chapitre 11: Collections d'Objets

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 librairie de collections fournie par Java pour ranger les objets durant leur existence : les tableaux simples et les conteneurs plus sophistiqués (structures de données) comme ArrayList et HashMap.

Chapitre 12: Le Système d'E/S de Java

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 variable importante de l'équation. Ce chapitre étudie les différentes classes fournies par Java pour lire et écrire des fichiers, des blocs mémoire, ainsi que la console. Les évolutions du framework d'E/S Java ainsi que les « nouvelles » E/S (nio) seront également examinées. De plus, ce chapitre comment vous pouvez prendre un objet, le « sérialiser » (ainsi, il peut être placé sur le disque où envoyer via un réseau), et ensuite le reconstruire, cela est géré pour vous via la sérialisation d'objets Java. Nous traiterons les librairies Java de compression, lesquelles sont utilisées dans le format de fichier Java ARchive (JAR). Enfin, nous expliquerons la nouvelle interface (API) des préférences et les expressions régulières.

Chapitre 13: Concurrence

Java fournit nativement 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 vous donne de solides bases sur les concepts fondamentaux de la programmation concurrente.

Chapitre 14: Créer des Fenêtres et des Applets

Java est livré avec la librairie d'interface graphique utilisateur (GUI) « Swing », qui est un ensemble de classes traitant du fenêtrage d'une manière portable. Ces programmes fenêtrés peuvent être soit des applets soit des applications autonomes. Ce chapitre est une introduction à la création de programmes utilisant Swing. Les Applets signées et Java Web Start y sont également montrés. De chapitre introduit 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).

Chapitre 15 : Découvrir les Problèmes

Les mécanismes de vérification de syntaxe montrent leur limite dans le développement d'un programme fonctionnant correctement. Ce chapitre présente des outils pour résoudre des problèmes que le compilateur ne peut détecter. L'un des plus grands pas en avant dans la programmation fut l'incorporation des tests unitaires automatisés. Pour ce livre, j'ai développé un système personnalisé de tests pour pouvoir s'assurer de la validité des données en sortie des programmes, cependant, le système de tests Junit, devenu standard de fait, est également présenté. La construction automatique d'applications sera montrée avec l'outil open source standard Ant, et pour le travail en équipe, les bases de CVS seront expliquées. Pour des problèmes relevés à l'exécution, ce chapitre introduit le mécanisme des assertions Java (utilisées dans la Programmation par Contrats), l'API de traces (logging), les débogueurs, les outils de profilage, et même les doclets (qui peuvent aider à découvrir des problèmes dans le code source).

Chapitre 16: Analyse et Conception

Le paradigme orienté objet est une manière différente et nouvelle de concevoir des programmes, et beaucoup de gens ont du mal au départ à savoir comment aborder un projet de POO. Une fois le concept de l'objet compris et tant que vous vous efforcerez à réfléchir davantage dans un modèle orienté objet, vous commencerez à faire une « bonne » conception et tirer avantage de tous les bénéfices qu'offre la POO. Ce chapitre présente les idées d'analyse, de conception et des moyens d'aborder les problèmes du développement de bons programmes orientés objet en un temps raisonnable. Sont inclus également dans ce chapitre les diagrammes UML (Unified Modeling Language) et toute la méthodologie associée, les cas d'utilisation, les cartes de Collaboration-Responsabilité des Classes (CRC), le développement itératif, l'Extreme Programming (XP), les façons de développer et de faire évoluer du code réutilisable ainsi que les stratégies de transitions vers la programmation orientée objet.

Annexe A: Passage & Retour d'Objets

Étant 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.

Annexe B: Conseils pour la programmation Java

Cette annexe contient des suggestions que j'ai rassemblées et collectées au long des années pour aider à vous guider pendant la réalisation de la conception et de l'écriture de programmes de bas niveau.

Annexe C: Suppléments

Description de sources additionnelles d'apprentissage disponible sur MindView:
1. Le CR ROM au dos de ce livre, qui contient le support CD de la conférence Bases de Java, pour vous préparer à ce livre. 2. Le CD ROM Prise en Mains de Java, 3e Édition, disponible sur www.MindView.net. Un support de conférence basé sur le contenu de ce livre. 3. La Conférence Penser en Java. La conférence d'introduction principale sur Java basée sur le contenu de ce livre. Le programme et les pages d'inscription peuvent être trouvés sur www.MindView.net. 4. Penser en Java Entreprise, un livre qui couvre les aspects plus avancés de Java, appropriés pour la programmation d'entreprise. 5. La Conférence J2EE. Présente le développement de réelles applications distribuées, adaptées au Web. Consultez le site www.MindView.net. 6. La Conférence Conception d'Objets et de Systèmes. Techniques d'analyse de conceptions et d'implémentations orientées objet. 7. Penser en Schémas de Conception (avec Java), qui couvre les aspects les plus avancés de Java sur les schémas de conception et les techniques de résolution de problèmes. Consultez le site www.MindView.net. 8. La Conférence Penser en Schémas de Conception. Une conférence basée sur le livre précédent. Le programme et les pages d'inscription peuvent être trouvés sur www.MindView.net. 9. Les Consultations et Revues de Conception. Une assistance pour vous aider à garder votre projet dans une bonne forme.

Annexe D: Ressources

Une liste des livres sur Java que j'ai trouvés particulièrement utiles.

Je me suis aperçu que des exercices simples sont très utiles pour consolider la compréhension des étudiants lors d'un séminaire, on en trouvera donc un ensemble à la fin de chaque chapitre.

La plupart des exercices sont conçus de façon à être assez simples pour être réalisés dans un temps raisonnable dans le contexte d'une salle de classe, pendant que l'instructeur vérifie que tous les étudiants ont assimilé le sujet de la leçon. Quelques-uns présentent des difficultés, mais jamais de difficulté majeure. (Je présume que vous les trouverez par vous-même - ou plutôt qu'ils vous trouveront).

Les solutions des exercices sélectionnés se trouvent dans le document électronique The Thinking in Java Annotated Solution Guide, disponible pour un faible coût sur http://www.BruceEckel.com.

Un autre bonus de cette édition est le CD ROM que vous trouverez à la fin du livre. J'ai naguère rejeté cette idée, pensant que mettre quelques Ko de code source sur cet énorme CD représentait un coût supplémentaire injustifié, et préféré à cela que les gens le téléchargent depuis mon site Web. Cependant, vous verrez bientôt que ce CD est différent.

Le CD ne contient pas le code source du livre, mais, au lieu de cela, il comporte un lien vers le code source sur www.MindView.net (vous n'avez bien sûr pas besoin du lien sur le CD pour obtenir le code source. Vous pouvez simplement aller sur le site et le trouver de cette façon). Il y a 2 raisons à cela : le code n'était pas terminé à temps pour le pressage du CD et, de plus, cette approche permet au code d'évoluer et d'être corrigé si le moindre problème surgit.

Comme le livre a significativement changé durant les 3 éditions, le CD en comporte la première et la seconde éditions au format HTML, y compris les sections qui, pour des raisons mentionnées ci-dessus, ont été enlevées des éditions postérieures, mais qui peuvent dans certains cas vous être utiles. De plus, vous pouvez également télécharger la version HTML de ce livre (troisième édition) sur www.MindView.net, qui contiendra les corrections quand celles-ci seront faites. L'un des avantages de la version HTML est que l'index est composé d'hyperliens, ce qui rend la navigation beaucoup plus simple.

Toutefois, la plus grande partie des 400 mégaoctets du CD consiste en un cours multimédia complet nommé Bases pour Java. Celui-ci inclut le séminaire Penser en C qui introduit la syntaxe C, les opérateurs et les fonctions sur lesquels la syntaxe de Java est basée. De plus, il inclut les sept premiers cours de la seconde édition de la conférence sur CD-ROM Prise en Main de Java que j'ai créée et que je présente. Bien qu'à la base, le CD-ROM complet Prise en Main de Java soit seulement vendu séparément (c'est également le cas avec la troisième édition du CD Prise en Main de Java qui devrait être disponible quand vous lirez ces lignes - allez voir le site www.MindView.net), j'ai décidé d'inclure les sept premiers cours de la seconde édition parce qu'ils n'auraient pas beaucoup changé par rapport à la troisième édition de ce livre, ainsi ils vous fourniront non seulement une base pour ce livre (avec Penser en C), mais en plus j'espère que cela vous donnera un avant-gout de la qualité et de la valeur de Prise en Main de Java, ^3e édition.

À l'origine, j'avais demandé à Chuck Allison la création de la partie Penser en C de ce « séminaire sur CD ROM » en tant que produit à part entière, puis j'ai décidé de l'inclure dans les secondes éditions de Penser en C++ et de Penser en Java après avoir vécu, lors d'un séminaire, l'arrivée de personnes dépourvues de connaissances suffisantes en langage C. Leur propos était apparemment « je suis un bon programmeur et je n'ai pas envie d'apprendre le C, mais plutôt C++ ou Java, c'est pourquoi je compte passer rapidement sur C pour aller directement à C++/Java ». Peu après leur arrivée au séminaire, ils prirent lentement conscience que la connaissance prérequise de la syntaxe du C avait d'excellentes raisons d'être. En incluant le CD ROM dans le livre, nous nous assurons que chaque participant à un séminaire a une préparation suffisante.

Le CD permet également au livre d'intéresser une plus large audience. Bien que le chapitre 3 (Contrôler le Déroulement du Programme) couvre les principes fondamentaux des parties de Java provenant de C, le CD est une introduction plus simple et requiert moins de bases en programmation de la part de l'étudiant que le livre. Et parcourir le contenu des sept premiers chapitres par l'intermédiaire de la seconde édition du CD Prise en Main de Java devrait vous aider à mieux prendre pied dans Java. J'ai l'espoir qu'en incluant le CD, plus de gens pourront entrer dans le cercle de la programmation Java. La ^3e édition du CD ROM Prise en Main de Java est disponible seulement en commande directe sur le site web www.BruceEckel.com.

L'ensemble du code source de ce livre est disponible en freeware sous copyright, en une seule archive, en visitant le site Web www.BruceEckel.com. Afin que vous soyez certains d'obtenir la dernière version, cette adresse est celle du site officiel pour la distribution du code et de la version électronique du livre. Il existe des versions miroir du livre électronique et du code sur d'autres sites (dont certains sont référencés sur le site www.BruceEckel.com), mais il est préférable de rendre visite au site officiel afin de s'assurer que la version miroir est la plus récente. Vous êtes autorisés à distribuer le code à des fins d'enseignement ou d'éducation.

Le but essentiel du copyright est d'assurer que la source du code soit correctement citée, et d'éviter que le code soit utilisé sans autorisation dans un média imprimé. (Tant que la source est citée, l'utilisation d'exemples provenant du livre ne pose généralement pas problème).

Chaque code source contient une référence à l'annonce de copyright suivante :

This computer source code is Copyright ©2003 MindView, Inc.
All Rights Reserved.

Permission to use, copy, modify, and distribute <b>this</b>
computer source code (Source Code) and its documentation
without fee and without a written agreement <b>for</b> the
purposes set forth below is hereby granted, provided that
the above copyright notice, <b>this</b> paragraph and the
following five numbered paragraphs appear in all copies.

1. Permission is granted to compile the Source Code and to
include the compiled code, in executable format only, in
personal and commercial software programs.

2. Permission is granted to use the Source Code without
modification in classroom situations, including in
presentation materials, provided that the book "Thinking in
Java" is cited as the origin.

3. Permission to incorporate the Source Code into printed
media may be obtained by contacting

MindView, Inc. 5343 Valle Vista La Mesa, California 91941
Wayne@MindView.net

4. The Source Code and documentation are copyrighted by
MindView, Inc. The Source code is provided without express
or implied warranty of any kind, including any implied
warranty of merchantability, fitness <b>for</b> a particular
purpose or non-infringement. MindView, Inc. does not
warrant that the operation of any program that includes the
Source Code will be uninterrupted or error- free. MindView,
Inc. makes no representation about the suitability of the
Source Code or of any software that includes the Source
Code <b>for</b> any purpose. The entire risk as to the quality
and performance of any program that includes the Source
code is with the user of the Source Code. The user
understands that the Source Code was developed <b>for</b> research
and instructional purposes and is advised not to rely
exclusively <b>for</b> any reason on the Source Code or any
program that includes the Source Code. Should the Source
Code or any resulting software prove defective, the user
assumes the cost of all necessary servicing, repair, or
correction.

5. IN NO EVENT SHALL MINDVIEW, INC., OR ITS PUBLISHER BE
LIABLE TO ANY PARTY UNDER ANY LEGAL THEORY FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
INCLUDING LOST PROFITS, BUSINESS INTERRUPTION, LOSS OF
BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS, OR FOR
PERSONAL INJURIES, ARISING OUT OF THE USE OF THIS SOURCE
CODE AND ITS DOCUMENTATION, OR ARISING OUT OF THE INABILITY
TO USE ANY RESULTING PROGRAM, EVEN IF MINDVIEW, INC., OR
ITS PUBLISHER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE. MINDVIEW, INC. SPECIFICALLY DISCLAIMS ANY
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE SOURCE CODE AND DOCUMENTATION PROVIDED
HEREUNDER IS ON AN <b>"AS IS"</b> BASIS, WITHOUT ANY ACCOMPANYING
SERVICES FROM MINDVIEW, INC., AND MINDVIEW, INC. HAS NO
OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.

Please note that MindView, Inc. maintains a web site which
is the sole distribution point <b>for</b> electronic copies of the
Source Code, http:<b><i>//www.BruceEckel.com (and official mirror</i></b>
sites), where it is freely available under the terms stated
above.

If you think you've found an error in the Source Code,
please submit a correction using the URL marked <i>"feedback"</i>
in the electronic version of the book, nearest the error
you've found.

Vous êtes autorisés à utiliser le code pour vos projets ainsi qu'à des fins d'éducation (ceci incluant vos cours) à la condition de conserver le copyright inclus dans chaque fichier source.

Dans ce livre, les identificateurs (de fonction, de variable, de nom de classe) sont écrits en gras. La plupart des mots clefs sont également en gras, à l'exception de ceux qui sont si souvent utilisés, tels que « class », que cela en deviendrait ennuyeux.

J'utilise un style de code particulier pour les exemples de ce livre. Ce style suit les règles que Sun utilise lui-même dans pratiquement tous les codes que l'on peut trouver sur son site (voir java.sun.com/docs/codeconv/index.html), et semble être pris en compte par la plupart des environnements de développement Java. Si vous avez lu mes autres livres, vous avez pu remarquer que le style de codage de Sun coïncide avec le mien - ce qui me fait évidemment plaisir, bien que je n'y sois pour rien. Le sujet du style de format demanderait des heures de débat assez chaud, aussi je vais simplement dire que je ne prétends pas imposer un style correct au travers de mes exemples, j'ai seulement mes propres motivations pour faire ainsi. Puisque Java est un langage de programmation indépendant de la forme, vous pouvez continuer à utiliser le style qui vous convient.

Les programmes de ce livre sont des fichiers directement inclus, au moyen du traitement de texte, depuis des fichiers ayant déjà subi une compilation. Par suite, le code imprimé dans le livre ne doit pas provoquer d'erreurs de compilation. Les erreurs qui pourraient entraîner des messages d'erreur lors de la compilation sont mises en commentaire au moyen de //! de manière à être facilement repérées et testées par des moyens automatiques. Les erreurs découvertes et rapportées à l'auteur feront d'abord l'objet d'une modification du code source distribué, puis, plus tard, d'une révision du livre (qui sera également disponible sur le site Web http://www.BruceEckel.com).

Je me réfère généralement à l'implémentation Sun de Java pour déterminer la démarche correcte.

Ce livre parle et est testé sur Java 2, JDK 1.4. Si vous désirez apprendre les versions antérieures du langage non couvertes par cette édition, la première et la deuxième éditions de ce livre sont librement téléchargeables à l'adresse URL : http://www.BruceEckel.com, vous la trouverez également dans le CD livré avec ce livre.

Quelles que soient les ficelles qu'un auteur utilise pour détecter les erreurs, il y en a toujours qui s'introduisent et elles sautent aux yeux à la première lecture.

Comme le feedback fourni par de fins lecteurs a été très précieux pour moi, j'ai développé plusieurs versions d'un système de feedback appelé BackTalk (conçu avec l'aide de Bill Venners et implémenté avec l'aide de nombreuses autres personnes en utilisant différentes technologies). Dans la version électronique de ce livre, librement téléchargeable à partir du site www.BruceEckel.com,chaque paragraphe du texte possède une URL propre unique. Elle génère un courriel qui enregistre votre commentaire pour le paragraphe en question dans le système BackTalk. De cette façon, il est très simple de suivre et de mettre à jour les corrections. Si vous découvrez quelque chose qui vous semble être une erreur, veuillez utiliser le système BackTalk pour soumettre l'erreur ainsi que la correction que vous suggérez. Votre aide sera grandement appréciée.

La couverture de Penser en Java est inspirée du mouvement américain Arts & Crafts qui vit le jour au tournant du siècle et atteignit son zénith entre 1900 et 1920. Il commença en Angleterre en réaction à la production mécanique de la Révolution Industrielle et au style hautement ornemental de l'ère victorienne. Arts & Crafts mettait l'accent sur une conception dénudée, des formes naturelles comme celles qu'on peut voir dans le mouvement Art Nouveau, le travail manuel et l'importance de l'artisan en tant qu'individu, mais il ne rejetait pas l'utilisation d'outils modernes. Ceci fait grandement écho à la situation que nous vivons aujourd'hui : le tournant du siècle, l'évolution de la révolution informatique de ses débuts bruts à quelque chose de plus raffiné et de plus parlant pour les individus, et l'accent mis sur l'art du logiciel plutôt que sur la simple production de code.

Je vois Java de la même façon : une tentative d'élever le programmeur du rang de mécanicien d'un système d'exploitation à celui d'un « artisan de logiciel ».

L'auteur et le concepteur du livre et de la couverture (qui sont amis depuis l'enfance) ont tous deux trouvé l'inspiration dans ce mouvement, et possèdent tous deux des meubles, des lampes et d'autres pièces originales ou inspirées de cette période.

L'autre thème de cette couverture suggère un cadre de collection qu'un naturaliste pourrait utiliser pour montrer les spécimens d'insectes qu'il a préservés. Ces insectes sont des objets placés à l'intérieur des objets cadres. Les objets cadres sont eux-mêmes placés dans l'« objet couverture », ce qui illustre le concept d'agrégation dans la programmation orientée objet. Naturellement, un programmeur ne pourra s'empêcher de faire l'association avec les « bogues » (NDT : l'anglais bug signifie punaise) ; ici, les punaises ont été capturées et probablement tuées dans une fiole à spécimen, puis finalement confinées dans un petit présentoir ; comme si on avait voulu suggérer les capacités de Java à rechercher, afficher et maîtriser les bogues (ce qui est vraiment un de ses plus puissants attributs).

En premier, merci aux associés qui ont travaillé avec moi pour encadrer des séminaires, faire du consulting, et développer des projets éducatifs : Andrea Provaglio, Dave Bartlett, Bill Venners, Chuck Allison, Jeremy Meyer, et Larry O'Brien. J'apprécie votre patience alors que j'essaie en permanence de développer le meilleur modèle permettant à des personnes indépendantes comme nous de travailler ensemble.

Récemment, sans aucun doute grâce à l'Internet, je suis devenu associé avec un nombre étonnamment grand de personnes qui m'assistent dans mes tentatives, travaillant habituellement de leur propre bureau à domicile. Par le passé, j'aurais eu à payer un assez grand espace de travail pour accueillir tous ces gens, mais grâce au NET, à Fedex et occasionnellement le téléphone, je peux bénéficier de leur aide sans coûts supplémentaires. Dans mes tentatives pour apprendre au mieux comment « jouer avec les autres », vous avez tous été serviables, et j'espère continuer à apprendre comment mieux faire mon propre travail grâce aux efforts des autres. Paula Steuer a été inestimable en prenant en charge mes pratiques commerciales désordonnées et en les rendant raisonnables (merci de m'avoir poussé quand je ne voulais pas faire quelque chose, Paula). Jonathan Wilcox, Esq., a passé au crible la structure de ma société et retourné chaque pierre possible qui pouvait cacher des scorpions, et nous a emmené à travers le processus de mettre toutes les choses à plat et légalement. Merci pour ton attention et ton obstination. Sharlynn Cobaugh (qui a découvert Paula) s'est révélée une experte en traitement du son et un élément essentiel pour la création des CD-ROM d'entraînement multimédia, tout en s'attaquant à d'autres problèmes. Merci de ta persévérance face à d'intraitables problèmes d'informatique. Evan Cofsky (Evan@TheUnixMan.com) est devenu une partie essentielle de mon processus de développement, à l'aise avec le langage de programmation Python comme un poisson dans l'eau (hmm, une telle métaphore pourrait produire un Python bien gras) et résolvant toutes sortes de problèmes difficiles, comprenant la réarchitecture (finale ?) de BackTalk en une base de données XML pilotée par email. Les personnes à Amaio à Prague m'ont aidé sur plusieurs projets. Daniel Will-Harris fût l'inspirateur original du travail par Internet, et il est bien sûr, fondamental à toutes mes solutions de conception.

Pour ce projet, j'ai pris une autre voie qui germait dans le fond de mon esprit depuis un moment. Pendant l'été 2002, j'ai créé un stage à Crested Butte, Colorado, initialement je recherchais deux stagiaires et j'ai fini avec 5 (deux volontaires). Non seulement ils ont contribué au livre, mais ils m'ont aidé à rester concentré sur le projet. Merci à JJ Badri, Ben Hindman, Mihajlo Jovanovic, Mark Welsh. Chintan Thakker a pu rester pour un second stage jusqu'à la fin du développement du livre et au-delà, et puisque je devais de toute façon louer un bureau à Mount Crested Butte, nous avons fait de la publicité pour des volontaires et nous avons retenu Mike Levin, Mike Shea, et Ian Phillips, qui ont tous fait des contributions. Un jour il se pourrait que je fasse un autre stage ; visitez www.MindView.net pour des nouvelles.

Merci aussi à la « Doyle Street Cohousing Community » de m'avoir supporté durant les deux années nécessaires à la rédaction de cette première édition (ainsi que pour m'avoir supporté dans l'absolu). Bien des remerciements à Kevin et Sonda Donovan pour m'avoir sous-loué leur magnifique habitation à Crested Butte, dans le Colorado, l'été où je travaillais sur la première édition du livre (et à Kevin pour tous les travaux chez moi à CB). Merci aussi à tous les amis résidents de « Crested Butte » et au « Rocky Mountain Biological Laboratory » qui m'ont si bien accueilli. Mes professeurs de Yoga à CB, Maria et Brenda, m'ont permis de rester sain pendant le développement de la 3e édition.

Camp4 Coffee à Crested Butte est devenu le bar habituel quand les enseignants viennent donner des séminaires, et pendant les pauses c'est la meilleure et la plus économique restauration que j'aie jamais eue. Merci à mon pote Al Smith de l'avoir créé et d'en avoir fait un tel endroit, et d'être une si intéressante et amusante partie de l'expérience de Crested Butte.

Merci également à Claudette Moore de « Moore Literary Agency » pour son énorme patience et sa constance à m'obtenir exactement ce je désirais. Merci à Paul Petralia de Prentice Hall de continuer à me donner ce que je désire, et de se démener pour que tout tourne rond pour moi (et pour satisfaire toutes mes demandes spécifiques).

Mes deux premiers livres ont été publiés sous la houlette de l'éditeur Jeff Pepper aux éditions Osborne/McGraw-Hill. Jeff est arrivé au bon endroit et au bon moment à Prentice-Hall pour poser les fondations pour ces livres, avant de passer les responsabilités à Paul. Merci, Jeff.

Merci à Rolf André Klaedtke (Suisse) ; Martin Vlcek, Vlada & Pavel Lahoda (Prague) ; ainsi que Marco Cantu (Italie) pour m'avoir hébergé lors de ma première tournée de conférences improvisées en Europe.

Merci à Gen Kiyooka et sa compagnie Digigami, qui m'ont gracieusement fourni un serveur Web les premières années. Cela a représenté pour moi une aide inestimable.

Je remercie spécialement Larry et Tina O'Brien, qui m'ont aidé à mettre mon séminaire sur le CD ROM de la première édition de Hands-On Java (vous en saurez davantage sur http://www.BruceEckel.com).

Certains outils open source se sont avérés inestimables pendant mon processus de développement et je suis très reconnaissant envers leurs créateurs chaque fois que je les utilise. Cygwin (http://www.cygwin.com) a résolu d'innombrables problèmes que Windows ne peut/pourra jamais gérer, et je deviens plus attaché à ce logiciel chaque jour (si seulement je l'avais eu il y a 15 ans quand mon cerveau était encore très attaché à Gnu Emacs). CVS et Ant sont devenus essentiels pour mon processus de développement en Java et je ne pourrais pas revenir en arrière maintenant. J'apprécie également JUnit (http://www.junit.org) maintenant qu'ils en ont réellement fait « la chose la plus simple qui puisse fonctionner ». Eclipse, d'IBM (http://www.eclipse.org) est une contribution vraiment incroyable à la communauté du développement, et je m'attends à en voir de grandes choses puisqu'il continue d'évoluer (comment IBM est devenu branché ? Je dois avoir loupé une note). Linux a été utilisé quotidiennement pendant le processus de développement, spécialement par les stagiaires. Et bien sûr, si je ne le dis pas assez ailleurs, j'utilise Python (www.Python.org) constamment pour résoudre des problèmes, les idées de mon pote Guido Van Rossum et les génies bêtes comme leurs pieds à PythonLabs avec qui j'ai passé quelques journées formidables à faire de l'XP sur Zop 3 (Tim, j'ai maintenant encadré cette souris que tu as empruntée, officiellement appelée la « TimMouse »). Vous autres avez besoin de trouver des endroits plus sains pour déjeuner (merci aussi, à l'ensemble de la communauté Python, un impressionnant groupe de personnes).

Beaucoup de gens m'ont envoyé des correctifs et je reste en dette avec eux, mais je dois remercier particulièrement (pour la première édition) : Kevin Raulerson (qui a repéré des tonnes d'énormes bugs), Bob Resendes (tout simplement incroyable), John Pinto, Joe Dante, Joe Sharp (tous trois ont été fabuleux), David Combs (beaucoup de corrections grammaticales et d'éclaircissements), Dr. Robert Stephenson, John Cook, Franklin Chen, Zev Griner, David Karr, Leander A. Stroschein, Steve Clark, Charles A. Lee, Austin Maher, Dennis P. Roth, Roque Oliveira, Douglas Dunn, Dejan Ristic, Neil Galarneau, David B. Malkovsky, Steve Wilkinson, ainsi qu'une foule d'autres. Prof. Ir. Marc Meurrens a déployé beaucoup d'efforts pour promouvoir et rendre disponible la version électronique de la première édition du livre en Europe.

Merci à ceux qui m'ont aidé à récrire les exemples pour utiliser la bibliothèque Swing (pour la 2e édition), et pour d'autres aides : Jon Shvarts, Thomas Kirsch, Rahim Adatia, Rajesh Jain, Ravi Manthena, Banu Rajamani, Jens Brandt, Nitin Shivaram, Malcolm Davis, et tous ceux qui m'ont témoigné leur soutien.

J'ai rencontré dans ma vie une avalanche de personnes très techniques et très intelligentes qui sont devenues des amis, mais qui étaient également peu communes et qui m'ont influencé en ce qu'elles pratiquaient le yoga ainsi que d'autres formes de spiritualité, que je trouve instruisantes et inspirantes. Ce sont Kraig Brockschmidt, Gen Kiyooka, et Andrea Provaglio (qui aide à la compréhension de Java et de la programmation en général en Italie, et maintenant aux États-Unis, en tant qu'associée de l'équipe MindView).

Ce ne fut pas une grande surprise pour moi de découvrir que ma connaissance de Delphi m'a aidé à comprendre Java, car ces deux langages ont beaucoup de concepts et de décisions de conception de langage en commun. Des amis fanatiques de Delphi m'ont aidé à mieux comprendre ce merveilleux environnement de programmation. Ce sont Marco Cantu (un autre italien - il se pourrait qu'être imprégné de culture latine donne certaines aptitudes pour la programmation ?), Neil Rubenking (qui se nourrissait de culture yoga/végétarienne/Zen avant de découvrir les ordinateurs), et bien entendu Zack Urlocker (directeur de produit chez Delphi), un vieux copain avec qui j'ai parcouru le monde.

Les éclaircissements et l'aide de mon ami Richard Hale Shaw m'ont été fort utiles (ceux de Kim également). Richard et moi avons passé ensemble beaucoup de mois à donner des séminaires et à tenter de trouver l'enseignement parfait pour les auditeurs.

La conception du livre, de la couverture, ainsi que la photo de couverture sont dues à mon ami Will-Harris, auteur et concepteur connu (www.Will-Harris.com), qui jouait au collège avec des lettres transfert en attendant l'invention de la publication assistée par ordinateur, tout en se plaignant de mes grognements à propos de mes problèmes d'algèbre. Toutefois, j'ai produit moi-même mes pages prêtes à imprimer, et donc j'assume mes erreurs de frappe. Microsoft^® Word XP pour Windows a été utilisé pour écrire le livre et Adobe Acrobat pour créer les pages offset ; le livre est sorti directement des fichiers PDF d'Acrobat. Pour rendre hommage à l'ère électronique, je me trouvais outre-mer les deux fois où la version finale du livre fût produite - la première édition fût envoyée depuis Le Cap en Afrique du Sud et la seconde depuis Prague. La troisième l'a été depuis Crested Buttle, dans le Colorado. Les polices de caractères sont Georgia pour le corps du texte et Verdana pour les titres. La police de couverture est ITC Rennie Mackintosh.

Je remercie particulièrement tous mes maîtres et tous mes étudiants (qui furent en même temps mes maîtres). Le plus plaisant de mes maîtres en écriture fut Gabrielle Rico (auteur de Writing the Natural Way, Putnam, 1983). Je garderai précieusement le souvenir d'une formidable semaine à Esalen.

Ma douce Dawn McGee a pris la photo de la couverture arrière, et me fait sourire de cette façon.

Liste non exhaustive de mes collaborateurs : Andrew Binstock, Steve Sinofsky, JD Hildebrandt, Tom Keffer, Brian McElhinney, Brinkley Barr, Bill Gates au Midnight Engineering Magazine, Larry Constantine et Lucy Lockwood, Greg Perry, Dan Putterman, Christi Westphal, Gene Wang, Dave Mayer, David Intersimone, Andrea Rosenfield, Claire Sawyers, d'autres italiens (Laura Fallai, Corrado, Ilsa, et Cristina Giustozzi), Chris et Laura Strand, les Almquists, Brad Jerbic, Marilyn Cvitanic, les Mabrys, les Haflingers, les Pollocks, Peter Vinci, la famille Robbins, la famille Moelter (ainsi que les McMillans), Michael Wilk, Dave Stoner, Laurie Adams, les Cranstons, Larry Fogg, Mike et Karen Sequeira, Gary Entsminger et Allison Brody, Kevin Donovan et Sonda Eastlack, Chester et Shannon Andersen, Joe Lordi, Dave et Brenda Bartlett, Patti Gast, les Rentschlers, les Sudeks, Dick, Patty, et Lee Eckel, Lynn et Todd, et leurs familles. Et, bien entendu, Maman et Papa.