Identifiant
Mot de passe
Loading...
Mot de passe oublié ?
Je m'inscris ! (gratuit)
Forums
Tutoriels
FAQ
Blogs
Chat
Newsletter
Emploi
Études
Droit
Club
DI/DSI Solutions d'entreprise
DI/DSI Solutions d'entreprise
ABBYY
Big Data
BPM
Business Intelligence
Data Science
ERP / PGI
CRM
SAS
SAP
Microsoft BizTalk Server
Talend
Droit informatique et entreprise
OnlyOffice
Cloud
Cloud Computing
Oracle
Azure
IBM Cloud
IA
Intelligence artificielle
ALM
ALM
Agile
Merise
UML
Microsoft
Microsoft
.NET
Microsoft Office
Visual Studio
Windows
ASP.NET
TypeScript
C#
VB.NET
Azure
Java
Java
Java Web
Spring
Android
Eclipse
NetBeans
Dév. Web
Développement et hébergement Web
AJAX
Apache
ASP
CSS
Dart
Flash / Flex
JavaScript
NodeJS
PHP
Ruby & Rails
TypeScript
Web sémantique
Webmarketing
(X)HTML
EDI
EDI
4D
Delphi
Eclipse
JetBrains
LabVIEW
NetBeans
MATLAB
Scilab
Visual Studio
WinDev
Visual Basic 6
Lazarus
Qt Creator
Programmation
Programmation
Débuter - Algorithmique
2D - 3D - Jeux
Assembleur
C
C++
C#
D
Go
Kotlin
Objective C
Pascal
Perl
Python
Rust
Swift
Qt
XML
Autres
SGBD
SGBD & SQL
4D
Access
Big Data
Data Science
DB2
Firebird
InterBase
MySQL
NoSQL
PostgreSQL
Oracle
Sybase
SQL-Server
MongoDB
Office
Microsoft Office
Access
Excel
Word
Outlook
PowerPoint
SharePoint
Microsoft Project
OpenOffice & LibreOffice
OnlyOffice
Mobiles
Mobiles
Android
iOS
Systèmes
Systèmes
Windows
Linux
Arduino
Sécurité
Hardware
HPC
Mac
Raspberry Pi
Réseau
Green IT
Systèmes embarqués
Virtualisation
Java
Java Web
Spring
Android
Eclipse
NetBeans
Forums Java
FAQ Java
Tutoriels Java
Livres Java
Vidéos Java
Sources Java
Outils, EDI & API Java
JavaSearch
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
Table des matières
Préface
Préface à la 2ème édition
Java 2
Le CD ROM
Introduction
Prérequis
Apprendre Java
Buts
Documentation en ligne
Les chapitres
Exercices
Le CD ROM Multimédia
Le Code Source
Typographie et style de code
Les versions de Java
Seminars and mentoring
Errors
À propos de la conception de la couverture du livre
Remerciements
Collaborateurs Internet
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
Transtypages descendants vs. patrons génériques
Le dilemme du nettoyage : qui en est responsable ?
Ramasse-miettes vs. efficacité et flexibilité
Traitement des exceptions : gérer les erreurs
Multithreading
Persistance
Java et l'Internet
Qu'est-ce que le Web ?
Le concept Client/Serveur
Le Web en tant que serveur géant
La programmation côté client
Les plug-ins
Les langages de script
Java
ActiveX
La sécurité
Internet vs. intranet
La programmation côté serveur
Une scène séparée : les applications
Analyse et conception
Phase 0 : Faire un plan
L'exposé de la mission
Phase 1 : Que construit-on ?
Phase 2 : Comment allons-nous le construire ?
Les cinq étapes de la conception d'un objet
Indications quant au développement des objets
Phase 3 : Construire le coeur du système
Phase 4 : Itérer sur les cas d'utilisation
Phase 5 : Evolution
Les plans sont payants
Programmation Extrême
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
1. Cours
2. Projet à faible risque
3. S'inspirer de bonnes conceptions
4. Utiliser les bibliothèques de classes existantes
5. Ne pas traduire du code existant en Java
Les obstacles au niveau du management
Coûts de mise en oeuvre
Problèmes de performances
Erreurs classiques de conception
Java vs. C++ ?
Résumé
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
Nombres de grande précision
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
Champs et méthodes
Valeurs par défaut des membres primitifs
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
@version
@author
@since
Les onglets de documentation de variables
Les onglets de documentation de méthodes
@param
@return
@throws
@deprecated
Exemple de documentation
Style de programmation
Sommaire
Exercices
3 : Contrôle du Flux de Programme
Utilisation des opérateurs Java
Priorité
L'affectation
L'aliasing pendant l'appel des méthodes
Les opérateurs mathématiques
Les opérateurs unaires (à un opérande) moins et plus
Incrémentation et décrémentation automatique
Les opérateurs relationnels
Tester l'équivalence des objets
Les opérateurs logiques
« Court-circuit »
Les opérateurs bit à bit
Les opérateurs de décalage
Opérateur ternaire if-else
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
Les littéraux
La promotion
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
return
Itération
do-while
for
L'opérateur virgule
break et continue
L'infâme « goto »
switch
Détails de calcul :
Résumé
Exercices
4: Initialisation & Nettoyage
Garantie d'initialisation grâce au constructeur
Surcharge de méthodes
Différencier les méthodes surchargées
Surcharge avec types de base
Surcharge sur la valeur de retour
Constructeurs par défaut
Le mot-clé this
Appeler un constructeur depuis un autre constructeur
La signification de static
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
Ordre d'initialisation
Initialisation de données statiques
Initialisation statique explicite
Initialisation d'instance non statique
Initialisation des tableaux
Tableaux multidimensionels
Résumé
Exercices
5 : Cacher l'Implémentation
package : l'unité de bibliothèque
Créer des noms de packages uniques
Collisions
Une bibliothèque d'outils personnalisée
Utilisation des imports pour modifier le comportement
Avertissement sur les packages
Les spécificateurs d'accès Java
« Friendly »
public : accès d'interface
Le package par défaut
private : ne pas toucher !
protected : « sorte d'amical »
Interface et implémentation
L'accès aux classes
Résumé
Exercices
6 : Réutiliser les classes
Syntaxe de composition
La syntaxe de l'héritage
Initialiser la classe de base
Constructeurs avec paramètres
Attraper les exceptions du constructeur de base.
Combiner composition et héritage.
Garantir un nettoyage propre
L'ordre du ramasse-miettes
Cacher les noms
Choisir la composition à la place de l'héritage
protected
Développement incrémental
Transtypage ascendant
Pourquoi le transtypage ascendant ?
Composition à la place de l'héritage revisité
Le mot clé final
Données finales
Finals sans initialisation
Arguments final
Méthodes final
final et private
Classes final
Attention finale
Initialisation et chargement de classes
Initialisation avec héritage
Résumé
Exercices
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 constructeursname="Index722">
Concevoir avec l'héritage
Héritage pur contre extensionname="Index739">
Downcasting et identification du type à l'exécution
Résumé
Exercices
8 : Interfaces & Classes Internes
Interfaces
« Héritage multiple » en Java
Combinaison d'interfaces et collisions de noms
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
Fermetures & callbacks
Classes internes & structures de contrôle
Résumé
Exercices
9 : Stockage des objets
Les tableaux
Les tableaux sont des objets
Conteneurs de scalaires
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
Types paramétrés
Itérateurs
Récursion indésirable
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
Maps triées : les SortedMaps
Hachage et codes de hachage
Comprendre hashCode()
Facteurs de performance d'un HashMap
Redéfinir hashCode()
Stocker des références
Le WeakHashMap
Les itérateurs revisités
Choisir une implémentation
Choisir entre les Lists
Choisir entre les Sets
Choisir entre les Maps
Trier et rechercher dans les Lists
Utilitaires
Rendre une Collection ou une Map non-modifiable
Synchroniser une Collection ou une Map
Echec rapide
Opérations non supportées
Les conteneurs Java 1.0 / 1.1
Vector & Enumeration
Hashtable
Stack
BitSet
Résumé
Exercices
11: Le système d'E/S de Java
La classe File
Lister un répertoire
Les classes internes anonymes
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
1. Entrée en tampon du fichier [Buffered input file]
2. Entrée depuis la mémoire
3. Entrée de mémoire formatée
4. Sortie de Fichier
Flux de sortie
5. Stocker et récupérer des données
6. Accés aléatoire en lecture et écriture aux fichiers
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
Stockage de fichiers multiples avec Zip
ARchives Java (JARs)
La sérialisation objet
Trouver la classe
Contrôler la sérialisation
Le mot-clé « transient »
Une alternative à Externalizable
Versioning
Utiliser la persistence
Tokenizer l'entrée
StreamTokenizer
StringTokenizer
Vérifier le style de capitalization
Résumé
Exercices
12: Identification dynamique de type
Le besoin de RTTI
L'objet Class
Les littéraux Class
Vérifier avant de transtyper
Utiliser les littéraux de classe
Un instanceof dynamique
instanceof vs. équivalence de classe
La syntaxe du RTTI
Réflexion : information de classe dynamique
Un extracteur de méthodes de classe
Résumé
Exercices
13: Création de Fenêtres et 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
Utilisation de listener adapters pour simplifier
Surveiller plusieurs événements
Un catalogue de composants Swing
Boutons
Groupes de 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
Séparation entre la logique applicative [business logic] et la logique de l'interface utilisateur [UI logic]
Une forme canonique
Programmation visuelle et Beans
Qu'est-ce qu'un Bean ?
Extraction des informations sur les Beans [BeanInfo] à l'aide de l'introspecteur [Introspector]
Un Bean plus complexe
Empaquetage d'un Bean
Un support des Beans plus sophistiqué
Davantage sur les Beans
Résumé
Exercices
14) Les Threads multiples
Interfaces utilisateurs dynamiques [Responsive user interfaces]
Héritage de Thread
Threading pour une une interface réactive
Combiner le thread avec la classe principale
Créer plusieurs threads
Threads démons
Partager des ressources limitées
Des ressources accédées improprement
Comment Java partage les ressources
Synchroniser les compteurs
Efficacité de la synchronisation
JavaBeans revisités
Blocage [Blocking]
Passer à l'état bloqué
Dormant (Sleeping)
Suspension et reprise
Attendre et notifier
Bloqué sur I/O
Tester
Interblocage [Deadlock]
La dépréciation de stop(), suspend(), resume(), et destroy() en Java 2
Priorités
Lire et changer les priorités
Les groupes de threads
Controller les groupes de threads
Runnable revisité
Trop de threads
Résumé
Exercices
15 : Informatique Distribuée
La programmation réseau
Identifier une machine
Serveurs et clients
Tester les programmes hors réseau
Les Ports : un emplacement unique dans la machine
Les sockets
Un serveur et un client vraiment simples
Servir des clients multiples
Les Datagrammes
Utiliser des URLs depuis un applet
Lire un fichier depuis un serveur
En savoir plus sur le travail en réseau
Se connecter aux bases de données : Java Database Connectivity (JDBC)
Faire fonctionner l'exemple
Étape 1 : Trouver le Driver JDBC
Étape 2 : Configurer la base de données
Étape 3 : Tester la configuration
Étape 4 : Générer votre requête SQL
Étape 5 : Modifier et insérer votre requête
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
La classe Cookie
La classe Session
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
Mise en place du registre
Création des stubs et des skeletons
Utilisation de l'objet distant
Introduction à CORBA
Principes de base de CORBA
CORBA Interface Definition Language (IDL - Langage de Définition d'Interface)
Le service de nommage (naming service)
Un exemple
Écrire le source IDL
Création des stubs et des skeletons
Implémentation du serveur et du client
Quelques services CORBA
Activation du processus du service de nommage
Activation du serveur et du client
Les Applets Java et CORBA
CORBA face à RMI
Enterprise Java Beans
JavaBeans contre EJBs
Que définit la spécification des EJBs ?
Les rôles
Composants EJB
Conteneur d'EJB
Serveur EJB
Java Naming and Directory Interface (JNDI)
Java Transaction API / Java Transaction Service (JTA/JTS)
CORBA et RMI/IIOP
Qu'est-ce qui compose un composant EJB ?
Enterprise Bean
Interface Home
Interface Remote
Descripteur de Déploiement
Fichier EJB-Jar
Comment travaille un EJB ?
Types d'EJBs
Session Beans
Les Session Beans non-persistants
Les Session Beans persistants
Entity Beans
Gestion de la persistance par le conteneur (CMP - Container Managed Persistence)
Gestion de la persistence par le Bean (BMP - Bean Managed Persistence)
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 jonction
Le processus de recherche
Séparation de l'interface et de l'implémentation
Abstraction des systèmes distribués
Résumé
Exercices
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
Utilisation d'une astuce avec protected
Implémenter l'interface Cloneable
Pour un clonage réussi
Le mécanisme de Object.clone( )
Cloner un objet composé
Copie profonde d'une ArrayList
Copie profonde via la sérialisation
Supporter le clonage plus bas dans la hiérarchie
Pourquoi cet étrange design ?
Contrôler la clonabilité
Le constructeur de copie
Pourquoi cela fonctionne-t-il en C++ et pas en Java ?
Classes en lecture seule
Créer des classes en lecture seule
L'inconvénient de l'immuabilité
Chaînes immuables
Constantes implicites
Surcharge de l'opérateur « + » et les StringBuffer
Les classes String et StringBuffer
Les Strings sont spéciales
Résumé
Exercises
B: L'Interface Native Java [Java Native Interface] (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
C : Conseils pour une programmation stylée en Java
Conception
Implémentation
D : Ressources
Logicielles
Livres
Analyse & conception
Python
La liste de mes livres
Ce livre a été écrit par
Bruce Eckel
groupe de traduction
télécharger la version francaise (PDF)
|
Commandez le livre en version anglaise (amazon)
|
télécharger la version anglaise
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