IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Penser en Java 2nde édition - Sommaire |  Préface |  Avant-propos | Chapitre : 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15 |  Annexe : A B C D  | Tables des matières - Thinking in Java

  b) Avant-propos

pages : 1 2 

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é.

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.

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.

Prérequis

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.

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.

Apprendre Java

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é.

À 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.)

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.

Buts

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 je me suis donné comme buts :

  1. présenter le cours pas à pas afin que le lecteur assimile chaque concept avant d'aller plus avant ;
  2. 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 ;
  3. 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 ;
  4. 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 ;
  5. 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 ;
  6. vous munir de bases solides afin que votre connaissance soit suffisante avant de suivre un cours ou lire un livre plus difficiles.

Documentation en ligne

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.

Les chapitres

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.

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.

Voici une brève description des chapitres contenus dans le livre, qui correspondent aux leçons et exercices de mes séminaires.

Chapitre 1 : Introduction sur les Objets

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.

Chapitre 2 : Tout est Objet

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.

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

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.

Chapitre 4 : Initialisation et Nettoyage Mémoire

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.

Chapitre 5 : Cacher l'Implémentation

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.

Chapitre 6 : Réutilisation des Classes

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.

Chapitre 7 : Le Polymorphisme

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.

Chapitre 8 : Interfaces & Classes Internes

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.

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 : Stockage des 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 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.

Chapitre 10 : Traitement des Erreurs au Moyen des Exceptions

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.

Chapitre 11 : 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 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).

Chapitre 12 : Identification Dynamique de Type 

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.

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

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).

Chapitre 14 : Les Threads Multiples

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.

Chapitre 15 : Informatique Distribuée

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).

Annexe A : Passage & Retour d'Objets

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.

Annexe B : L'interface Java Natif (JNI)

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.

Ce livre a été écrit par Bruce Eckel ( télécharger la version anglaise : Thinking in java )
Ce chapitre a été traduit par Jean-Pierre Vidal ( groupe de traduction )
télécharger la version francaise (PDF) | Commandez le livre en version anglaise (amazon) | télécharger la version anglaise
pages : 1 2 
Penser en Java 2nde édition - Sommaire |  Préface |  Avant-propos | Chapitre : 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15 |  Annexe : A B C D  | Tables des matières - Thinking in Java