Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more ➡
Download
Standard view
Full view
of .
Add note
Save to My Library
Sync to mobile
Look up keyword or section
Like this
5Activity
×

Table Of Contents

Préface
Préface à la 2ème édition
Java 2
Le CD ROM
Avant-propos
Pré requis
Apprendre Java
Buts
Documentation en ligne
Les chapitres
Le CD ROM Multimédia
Le Code Source
Typographie et style de code
Les versions de Java
Seminars and mentoring
Errors
Remerciements
Collaborateurs Internet
Chapitre 1 - Introduction sur les « objets »
Les bienfaits de l'abstraction
Un objet dispose d'une interface
L'implémentation cachée
Réutilisation de l'implémentation
Héritage : réutilisation de l'interface
Les relations est-un vs. est-comme-un
Polymorphisme : des objets interchangeables
Classes de base abstraites et interfaces
Environnement et durée de vie des objets
Collections et itérateurs
La hiérarchie de classes unique
Bibliothèques de collections et support pour l'utilisation aisée des collections
Le dilemme du nettoyage : qui en est responsable ?
Traitement des exceptions : gérer les erreurs
Multithreading
Persistance
Java et l'Internet
Qu'est-ce que le Web ?
La programmation côté client
La programmation côté serveur
Une scène séparée : les applications
Analyse et conception
Phase 0 : Faire un plan
Phase 1 : Que construit-on ?
Phase 2 : Comment allons-nous le construire ?
Phase 3 : Construire le coeur du système
Phase 4 : Itérer sur les cas d'utilisation
Phase 5 : Évolution
Les plans sont payants
Commencer par écrire les tests
Programmation en binôme
Les raisons du succès de Java
Les systèmes sont plus faciles à exprimer et comprendre
Puissance maximale grâce aux bibliothèques
Traitement des erreurs
Mise en oeuvre de gros projets
Stratégies de transition
Règles de base
Les obstacles au niveau du management
Chapitre 2 - Tout est « objet »
Les objets sont manipulés avec des références
Vous devez créer tous les objets
Où réside la mémoire ?
Cas particulier : les types primitifs
Tableaux en Java
Vous n'avez jamais besoin de détruire un objet
Notion de portée
Portée des objets
Créer de nouveaux types de données : class
Méthodes, paramètres et valeurs de retour
La liste de paramètres
Construction d'un programme Java
Visibilité des noms
Utilisation d'autres composantes
Le mot-clef static
Votre premier programme Java
Compilation et exécution
Commentaires et documentation intégrée
Commentaires de documentation
Syntaxe
HTML intégré
@see : faire référence aux autres classes
Class documentation tags
Les onglets de documentation de variables
Les onglets de documentation de méthodes
Exemple de documentation
Style de programmation
Chapitre 3 - Contrôle du flux du programme
Utilisation des opérateurs Java
Priorité
L'affectation
Les opérateurs mathématiques
Incrémentation et décrémentation automatique
Les opérateurs relationnels
Les opérateurs logiques
Les opérateurs bit à bit
Les opérateurs de décalage
L'opérateur virgule
L'opérateur + pour les String
Les pièges classiques dans l'utilisation des opérateurs
Les opérateurs de transtypage
Java n'a pas de « sizeof »
Retour sur la priorité des opérateurs
Résumé sur les opérateurs
Le Contrôle d'exécution
true et false
if-else
Itération
do-while
break et continue
Constructeurs par défaut
Le mot-clé this
Nettoyage : finalisation et ramasse-miettes
A quoi sert finalize( ) ?
Le nettoyage est impératif
La «death condition»
Comment fonctionne un ramasse-miettes ?
Initialisation de membre
Spécifier une initialisation
Initialisation par constructeur
Initialisation des tableaux
Tableaux multidimensionnels
Chapitre 5 - Cacher l'implémentation
package : l'unité de bibliothèque
Créer des noms de packages uniques
Une bibliothèque d'outils personnalisée
Avertissement sur les packages
Les spécificateurs d'accès Java
« Friendly »
public : accès d'interface
private : ne pas toucher !
protected : « sorte d'amical »
L'accès aux classes
Chapitre 6 - Réutiliser les classes
Syntaxe de composition
La syntaxe de l'héritage
Initialiser la classe de base
Combiner composition et héritage
Garantir un nettoyage propre
Cacher les noms
Choisir la composition à la place de l'héritage
protected
Développement incrémental
Transtypage ascendant
Pourquoi le transtypage ascendant ?
Le mot clé final
Données finales
Méthodes final
Classes final
Attention finale
Initialisation et chargement de classes
Initialisation avec héritage
Chapitre 7 - Polymorphisme
Upcasting
Pourquoi utiliser l'upcast?
The twist
Liaison de l'appel de méthode
Produire le bon comportement
Extensibilité
Redéfinition et Surcharge
Classes et méthodes abstraites
Constructeurs et polymorphisme
Ordre d'appel des constructeurs
La méthode finalize() et l'héritage
Comportement des méthodes polymorphes dans les constructeurs
Concevoir avec l'héritage
Héritage pur contre extensionname="Index739">
Downcasting et identification du type à l'exécution
Chapitre 8 - Interfaces et classes internes
Interfaces
« Héritage multiple » en Java
Etendre une interface avec l'héritage
Groupes de constantes
Initialisation des données membres des interfaces
Interfaces imbriquées
Classes internes
Classes internes et transtypage ascendant
Classes internes définies dans des méthodes et autres portées
Classes internes anonymes
Lien vers la classe externe
Classes internes static
Se référer à l'objet de la classe externe
Classe interne à plusieurs niveaux d'imbrication
Dériver une classe interne
Les classes internes peuvent-elles redéfinies ?
Identifiants des classes internes
Raison d'être des classes internes
Classes internes & structures de contrôle
Chapitre 9 - Stockage des objets
Les tableaux
Les tableaux sont des objets
Renvoyer un tableau
La classe Arrays
Remplir un tableau
Copier un tableau
Comparer des tableaux
Comparaison d'éléments de tableau
Trier un tableau
Effectuer une recherche sur un tableau trié
Résumé sur les tableaux
Introduction sur les conteneurs
Imprimer les conteneurs
Remplir les conteneurs
L'inconvénient des conteneurs : le type est inconnu
Quelquefois ça marche quand même
Créer une ArrayList consciente du type
Itérateurs
Classification des conteneurs
Fonctionnalités des Collections
Fonctionnalités des Lists
Réaliser une pile à partir d'une LinkedList
Réaliser une file à partir d'une LinkedList
Fonctionnalités des Sets
Sets triés : les SortedSets
Fonctionnalités des Maps
Choisir entre les Lists
Choisir entre les Sets
Trier et rechercher dans les Lists
Utilitaires
Rendre une Collection ou une Map non-modifiable
Synchroniser une Collection ou une Map
Les conteneurs Java 1.0 / 1.1
Vector & Enumeration
Hashtable
Stack
BitSet
Chapitre 10 - Gestion des erreurs avec les exceptions
Les exceptions de base
Attraper une exception
Le bloc try
Les gestionnaires d'exceptions
Créez vos propres Exceptions
Spécifier des Exceptions
Attraper n'importe quelle exception
Relancer une exception
Les exceptions Java standard
Le cas particulier RuntimeException
Faire le ménage avec finally
À Quoi sert le finally ?
Le défaut : l'exception perdue
Vérification et création de répertoires
Entrée et sortie
Les types d'InputStream
Les types d'OutputStream
Ajouter des attributs et des interfaces utiles
Lire depuis un InputStream avec FilterInputStream
Écrire vers un OutputStream avec FilterOutputStream
Lecteurs & écrivains [ Loaders & Writers ]
Les sources et les réceptacles de données
Modifier le comportement du flux
Les classes inchangées
Et bien sûr : L'accès aléatoire aux fichiers (RandomAccessFile)
L'usage typique des flux d'E/S
Flux d'Entrée
Flux de sortie
Un bogue ?
Flux Piped
Standard E/S
Lire depuis une entrée standard
Modifier System.out en un PrintWriter
Réorienter l'E/S standard
Compression
Compression simple avec GZIP
ARchives Java (JARs)
La sérialisation objet
Trouver la classe
Contrôler la sérialisation
Utiliser la persistence
Tokenizer l'entrée
StreamTokenizer
StringTokenizer
Vérifier le style de capitalization
Chapitre 12 - Identification dynamique de type
Le besoin de RTTI
L'objet Class
Vérifier avant de transtyper
La syntaxe du RTTI
Réflexion : information de classe dynamique
Un extracteur de méthodes de classe
Chapitre 13 - Création de fenêtres & d'Applets
L'applet de base
Les restrictions des applets
Les avantages d'une applet
Les squelettes d'applications
Exécuter des applets dans un navigateur Web
Utilisation de Appletviewer
Tester les applets
Exécuter des applets depuis la ligne de commande
Un squelette d'affichage
Utilisation de l'Explorateur Windows
Création d'un bouton
Capture d'un événement
Zones de texte
Contrôle de la disposition
BorderLayout
FlowLayout
GridLayout
GridBagLayout
Positionnement absolu
BoxLayout
La meilleure approche ?
Le modèle d'événements de Swing
Evénements et types de listeners
Surveiller plusieurs événements
Un catalogue de composants Swing
Boutons
Icones
Infobulles [Tooltips]
Champs de texte [Text Fields]
Bordures
JScrollPanes
Un mini-éditeur
Boîtes à cocher [Check boxes]
Boutons radio
Boîtes combo (listes à ouverture vers le bas) [combo boxes (drop-down lists)]
Listes [List boxes]
Panneaux à tabulations [Tabbed panes]
Boîtes de messages
Menus
Menus pop-up
Dessiner
Boîtes de dialogue
Dialogues pour les fichiers [File dialogs]
HTML sur des composants Swing
Curseurs [sliders] et barres de progression [progress bars]
Arbres [Trees]
Tables
Sélection de l'aspect de l'interface [Look & Feel]
Le presse-papier [clipboard]
Empaquetage d'une applet dans un fichier JAR
Techniques de programmation
Lier des événements dynamiquement
Une forme canonique
Qu'est-ce qu'un Bean ?
Un Bean plus complexe
Empaquetage d'un Bean
Un support des Beans plus sophistiqué
Davantage sur les Beans
exercices
Chapitre 14 - Les Threads multiples
Interfaces utilisateurs dynamiques [Responsive user interfaces]
Héritage de Thread
Threading pour une une interface réactive
Créer plusieurs threads
Threads démons
Partager des ressources limitées
Comment Java partage les ressources
JavaBeans revisités
Blocage [Blocking]
Passer à l'état bloqué
Interblocage [Deadlock]
Lire et changer les priorités
Les groupes de threads
Runnable revisité
Trop de threads
Chapitre 15 - Informatique distribuée
La programmation réseau
Identifier une machine
Les sockets
Une version GUI du programme de recherche
Pourquoi l'API JDBC paraît si complexe
Un exemple plus sophistiqué
Les Servlets
Le servlet de base
Les Servlets et le multithreading
Gérer des sessions avec les servlets
Faire fonctionner les exemples de servlet
Les Pages Java Serveur - Java Server Pages
Les objets implicites
Les directives JSP
Les éléments de scripting JSP
Extraire des champs et des valeurs
Attributs et visibilité d'une page JSP
Manipuler les sessions en JSP
Créer et modifier des cookies
Résumé sur les JSP
RMI (Remote Method Invocation) : Invocation de méthodes distantes
Interfaces Remote
Implémenter l'interface distante
Utilisation de l'objet distant
Introduction à CORBA
Principes de base de CORBA
Un exemple
Les Applets Java et CORBA
CORBA face à RMI
Enterprise Java Beans
JavaBeans contre EJBs
Que définit la spécification des EJBs ?
Qu'est-ce qui compose un composant EJB ?
Comment travaille un EJB ?
Types d'EJBs
Développer un Enterprise Java Bean
En résumé
Jini : services distribués
Contexte de Jini
Qu'est-ce que Jini ?
Comment fonctionne Jini
Le processus de découverte
Le processus de recherche
Séparation de l'interface et de l'implémentation
Abstraction des systèmes distribués
Annexe A- Passage et Retour d'Objets
Passage de références
Aliasing
Création de copies locales
Passage par valeur
Clonage d'objets
Rendre une classe cloneable
Le mécanisme de Object.clone( )
Cloner un objet composé
Copie profonde d'une ArrayList
Supporter le clonage plus bas dans la hiérarchie
Pourquoi cet étrange design ?
Contrôler la clonabilité
Le constructeur de copie
Classes en lecture seule
Créer des classes en lecture seule
L'inconvénient de l'immuabilité
Chaines immuables
Constantes implicites
Surcharge de l'opérateur « + » et les StringBuffer
Les classes String et StringBuffer
Les Strings sont spéciales
Annexe B - L'Interface Java Natif (JNI)
Appeler une méthode native
Le générateur d'entête [ header file generator] : javah
Les conventions de nommage [name mangling]et les signatures de fonctions
Implémenter votre DLL
Accéder à des fonctions JNI : l'argument JNIEnv
Accéder à des chaînes Java
Passer et utiliser des objets Java
JNI et les exceptions Java
JNI et le threading
Utiliser une base de code préexistantes
Information complémentaire
Conception
Implémentation
Annexe D - Resources
Logicielles
Livres
0 of .
Results for:
No results containing your search query
P. 1
PenserEnJava

PenserEnJava

Ratings: (0)|Views: 16,977|Likes:
Published by Benny Aimar

More info:

Published by: Benny Aimar on Oct 06, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See More
See less

05/07/2013

pdf

text

original

You're Reading a Free Preview
Pages 17 to 131 are not shown in this preview.
You're Reading a Free Preview
Pages 148 to 355 are not shown in this preview.
You're Reading a Free Preview
Pages 372 to 412 are not shown in this preview.
You're Reading a Free Preview
Pages 429 to 672 are not shown in this preview.
You're Reading a Free Preview
Pages 689 to 807 are not shown in this preview.

You're Reading a Free Preview

Download
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->