Langage Java : les fondamentaux

Auteur(s) :

Amade, Bernard Découvrir l'auteur

Résumé

Une méthode pour comprendre les axes fondamentaux et maîtriser pas à pas la programmation en langage Java. Avec de nombreux exercices pour explorer ses différents concepts. ©Electre 2021

Éditeur(s)
- MA éditions
Date
- DL 2021
Langues
- Français
Description matérielle
- 1 vol. (495 p.) : ill. ; 21 cm
Collections
- Le guide complet
Sujet(s)
ISBN
- 978-2-8224-0707-6
Indice
- 681.225(07) Java. Manuels
Quatrième de couverture
- Langage Java
  Les fondamentaux
  Cet ouvrage présente les aspects fondamentaux du langage de programmation Java (dans sa version « Standard Edition » 15).
  Les leçons y sont découpées par niveaux (allant de « ceinture blanche » à « ceinture noire ») et cela permet des parcours différenciés de lecture et d'apprentissage.
  Issu de nombreuses expérimentations le contenu intéressera :
  
  Des débutants qui veulent s'initier à la programmation Java.
  La progression et la pertinence des exemples permettent de comprendre et d'assimiler une conception s'appuyant sur cet outil.
  Elles permettent ainsi de stimuler une démarche qui s'inscrive dans la philosophie même du langage.
  
  Des programmeurs expérimentés qui y trouveront un aide-mémoire pratique et des précisions techniques fines sur des sujets parfois délicats.
  
  Des formateurs qui y trouveront un cheminement pédagogique qui a été testé sur des centaines d'élèves de profils fort différents.
Tables des matières
- - Langage Java
  - Les Fondamentaux
  - Bernard Amade
  - Chapitre 1 Types primitifs, variables25
  - 1.1. Valeurs entières27
  - Opérations27
  - Limites28
  - 1.2. Nombres « flottants »31
  - Opérations32
  - Limites33
  - 1.3. Variables34
  - 1.4. Les types primitifs numériques36
  - Les types entiers36
  - Les « littéraux » (valeurs entières)36
  - Compatibilités entre types entiers37
  - Numériques en virgule flottante38
  - Les valeurs « littérales » des nombres flottants38
  - Compatibilités entre types numériques39
  - 1.5. Affectations optimisées39
  - 1.6. Valeurs logiques41
  - Expressions logiques41
  - Connecteurs41
  - Aiguilleur d'évaluation42
  - Opérateurs bit à bit43
  - 1.7. Caractères et chaînes de caractères43
  - Type caractère43
  - Chaînes de caractères (String)44
  - Blocs de chaîne45
  - Chapitre 2 Formes fonctionnelles47
  - 2.1. Codes appelants, codes réalisants50
  - Chapitre 3 La technologie java : généralités53
  - 3.1. Du code source au code binaire55
  - Compilation55
  - Code Source55
  - Code binaire56
  - Un exemple d'une petite application java : les Applets57
  - Un exemple sur le Web58
  - Principes Architecturaux59
  - 3.2. Caractéristiques remarquables de Java59
  - La (J.V.M.)60
  - Origines et objectifs du langage61
  - 3.3. Pourquoi Java ?62
  - 3.4. La documentation Java63
  - Les logithèques standard63
  - Chapitre 4 Introduction aux types composites65
  - 4.1. Agrégats de données67
  - 4.2. Les données en mémoire68
  - Manipulation de données, gestion de la mémoire68
  - Valeurs scalaires dans la mémoire70
  - Allocations des objets dans la mémoire71
  - 4.3. Constructeurs71
  - 4.4. Initialisations de l'état des objets73
  - 4.5. « Valeurs » (Value Objects)74
  - 4.6. Méthodes d'instance : introduction75
  - 4.7. Méthodes statiques76
  - Méthodes d'instance/méthodes statiques ; un exemple76
  - 4.8. Champs statiques77
  - 4.9. Tableaux78
  - Tableaux de tableaux80
  - Compatibilités entre types tableaux81
  - 4.10. Types énumérés (enums)82
  - Chapitre 5 Syntaxe, structure du code85
  - 5.1. Structure générale d'un code (simplifiée)87
  - Déclarations des variables membres87
  - Déclaration de méthodes88
  - Déclaration de constructeurs89
  - 5.2. Principes de la syntaxe89
  - 5.3. Commentaires90
  - 5.4. Identificateurs91
  - Conventions de codage92
  - 5.5. Mots-clefs93
  - 5.6. Blocs, portée des noms94
  - Typage implicite de variables locales95
  - 5.7. La référence this96
  - 5.8. if/else97
  - 5.9. switch99
  - Expressions switch100
  - 5.10. while/do-while101
  - 5.11. boucles for102
  - 5.12. break, continue103
  - 5.13. Arguments en nombre variable104
  - Chapitre 6 Programmation orientée objet en Java107
  - 6.1. Les types définis par le programmeur109
  - L'encapsulation110
  - Les conventions « Accesseur/Mutateur »111
  - Accesseurs, mutateurs et autres méthodes113
  - 6.2. Les « cercles » de responsabilité114
  - Private114
  - Public115
  - « friendly »116
  - 6.3. Packages116
  - Directives import118
  - Import static119
  - 6.4. Introduction aux modules119
  - 6.5. L'organisation et les répertoires en pratique120
  - 6.6. Les chemins d'accès aux classes124
  - 6.7. Organisation simplifiée, module par défaut125
  - 6.8. Synthèse des rôles de programmation127
  - 6.9. Les architectures modulaires129
  - Dépendances explicites129
  - Dépendances dynamiques129
  - Chapitre 7 Composition, association, héritage131
  - 7.1. Définition d'un objet à partir d'autres objets : composition, association133
  - 7.2. Définition d'un objet à partir d'un autre objet : délégation134
  - 7.3. Définition d'un objet à partir d'un autre objet : définition différentielle (héritage)135
  - 7.4. Définition d'une sous-classe136
  - Constructeurs dans une sous-classe137
  - 7.5. Polymorphisme139
  - 7.6. La classe Object140
  - Spécialisation des méthodes d'Object141
  - Spécialisation de toString()141
  - Spécialisation d'equals142
  - Transtypage implicite143
  - Record143
  - 7.7. Modificateur de portée protected144
  - Final et l'héritage146
  - Dérivations limitées (sealed classes)146
  - Chapitre 8 Exceptions147
  - 8.1 Ce qu'il ne faudrait pas faire en cas d'incident149
  - 8.2. Catégories d'incidents151
  - 8.3. Le mécanisme des exceptions152
  - 8.4. try/catch153
  - 8.5. Exceptions standard154
  - 8.6. Définir une Exception155
  - 8.7. Déclenchement d'une Exception156
  - 8.8. blocs catch hiérarchisés157
  - 8.9. blocs finally157
  - 8.10. La règle « propager ou traiter »160
  - 8.11. Exception de runtime ou exception contrôlée ?162
  - 8.12. Modèle d'une signature163
  - 8.13. Différences entre exceptions et rapports164
  - Notes sur les exceptions165
  - 8.14. Assertions166
  - Chapitre 9 Abstraction, généralisation, structuration169
  - 9.1. Types abstraits171
  - Méthodes abstraites et classes abstraites171
  - Interfaces175
  - Déclaration d'une interface177
  - Documentation d'une interface177
  - Réalisations conformes à une interface178
  - Conception avec des interfaces, découplage178
  - Découplage architectural179
  - Découplage de code180
  - Extension des interfaces181
  - Héritage d'interface181
  - Extensions par méthodes concrètes183
  - 9.2. Introduction aux types paramétrés (au travers des Collections)185
  - Collections avec Object et le problème du typage185
  - Contrôle de type par réalisation d'une classe spécifique186
  - 9.3. Contrôle de type avec un type paramétré187
  - Enchaînement des contrôles de compile time188
  - Définition d'un type paramétré189
  - Variable-type propre à une méthode190
  - 9.4. Invariance190
  - 9.5. Encapsulation et types paramétrés191
  - Chapitre 10 Mise en pratique : quelques logithèques classiques193
  - 10.1. Principes de disposition des IHM195
  - 10.2. Les librairies graphiques196
  - 10.3. Composants et containers197
  - 10.4. Disposition198
  - Gestionnaire de disposition FlowLayout199
  - Gestionnaire de disposition BorderLayout200
  - Autres gestionnaires de disposition202
  - Combinaisons de dispositions202
  - 10.5. Gestion des interactions graphiques204
  - Les objets « événement »204
  - L'objet réflexe (call back pattern)205
  - Interfaces de veille et « adaptateurs »206
  - 10.6. Considérations architecturales liées à la gestion des événements : un exemple207
  - Considérations architecturales ; veilleur dans une classe distincte207
  - Considérations architecturales : veille depuis la classe courante208
  - Considérations architecturales : veille depuis une classe interne209
  - Considérations architecturales ; veille depuis une classe anonyme210
  - Considérations architecturales : transfert vers du code applicatif211
  - 10.7. « flots » d'entrée/sortie211
  - Le modèle des « flots »212
  - Flots associés à une ressource (node streams)212
  - Filtres213
  - flots d'octets : InputStream, OutputStream213
  - Flots de caractères : Reader, Writer214
  - Comparaison des flots par ressource214
  - Conversions octets/caractères215
  - Utilisation de filtres215
  - 10.8. Usage simple des Paths216
  - 10.9. Introduction à la programmation réseau217
  - Principes généraux des échanges Client-Serveur sous TCP217
  - Modalités d'établissement de la connexion en JAVA218
  - 10.10. E/S objets221
  - ObjectInputStream, ObjectOutputStream221
  - Les objets dans un flot222
  - Effets de la linéarisation223
  - Modifications des opérations liées aux objets Serializable224
  - 10.11, Le package java,nio225
  - Mise en ouvre de Buffers225
  - Un exemple de mise en ouvre de Buffers226
  - Ventilation des lectures/écritures dans des Buffers227
  - E/S asynchrones, sélecteurs228
  - 10.12, Expressions régulières230
  - Chapitre 11 L'exécution231
  - 11.1, L'exécution de Java233
  - 11.2, Les exécuteurs : évolutions de la technologie233
  - La J.V.M : chargement et exécution des codes234
  - Compile time, load time, run time235
  - La J,V.M, : gestion de la mémoire237
  - Les performances237
  - La J.V.M, : gestion de la sécurité238
  - Chapitre 12 Unités d'exécution (Threads)239
  - 12.1, Multitâche : processus et « fils d'exécution » (threads)241
  - Création et exécution d'unThread242
  - 12.2, Interactions avec l'ordonnanceur243
  - S'effacer devant d'autresThreads243
  - Mise en narcose244
  - Attente d'une fin d'exécution244
  - Interruption245
  - Etats d'une exécution (version 1)246
  - 12.3, Le « modèle mémoire » de Java246
  - 12.4, Synchronisations de mémoires249
  - 12.5, Blocs synchronized250
  - Contention, blocs synchronized251
  - Moniteurs multiples251
  - 12.6, Attente de condition252
  - « Micro-Attente » optimisée253
  - 12.7, Etats d'une exécution (version 2)254
  - Chapitre 13 Autres aspects de la programmation java, approfondissements255
  - 13.1. Types enchâssés257
  - Types membres de classe (nested types)257
  - Types membres d'instance (inner types)258
  - Classes anonymes260
  - 13.2. Compléments sur les types paramétrés261
  - Covariance261
  - Contravariance263
  - Autres exemples264
  - Comment fonctionnent les types paramétrés ?
  - Compatibilités264
  - Utilisation des variables-type265
  - Utilisation des variables types dans des types paramétrés266
  - Chapitre 14 Lambda-expressions, fermetures, références de codes267
  - 14.1. Principes des lambda-expressions270
  - Java.util.function271
  - 14.2. Fermetures (Closures)272
  - Problématique des effets de bord273
  - Références de codes274
  - 14.3. Programmation « au fil de l'eau » (streams)275
  - Chapitre 15 Déploiements et Services281
  - 15.1. Déploiement des codes283
  - 15.2. Les ClassLoaders283
  - 15.3. Quels réceptacles pour entreposer les codes ?284
  - Création des archives jar sans modules286
  - Création des archives jar avec modules288
  - Lancement direct d'une application non modulaire depuis une archive jar289
  - Lancement d'une application modulaire avec des archives jar289
  - Déploiement d'archives jar290
  - 15.4. Création d'une image applicative (Jlink)292
  - 15.5. Codes de déploiement, services293
  - 15.6. Codes de déploiement : chargement explicite294
  - Codes hors modules294
  - Codes avec modules295
  - 15.7. Déploiement standard de services295
  - Déploiement de services en portée locale296
  - Déploiement de service avec des modules297
  - Variantes architecturales298
  - 15.8. Scripts enchâssés299
  - 15.9. Ressources299
  - Arguments de la commande de lancement300
  - Propriétés nommées300
  - Fichier de configuration301
  - Déploiement en portée locale302
  - Déploiement de ressources avec des modules303
  - Contenu de fichier Properties305
  - URL de ressources306
  - 15.10. Internationalisation309
  - Contextes culturels : Locale309
  - Locale : constructeurs, constantes309
  - Contexte culturel : obtention, mise en place310
  - Paramétrage de ressources : Resourcebundle311
  - Où se trouvent les ressources ?311
  - Nommage du service de Bundle en architecture modulaire312
  - Réalisation du service dans un module313
  - ListResourceBundle313
  - PropertyResourceBundle314
  - Classes de mise en forme/analyse314
  - Numériques avec instructions de formatage315
  - Autres formats316
  - 15.11. Rapports, traces, journalisations317
  - Émettre un rapport318
  - Les services de logging319
  - Utilisation de java.util.logging321
  - Qu'est ce qui détermine le comportement des Loggers ?321
  - Raccordements des gestionnaires de rapports (handlers)322
  - Architecture de configuration323
  - Définition d'un Handler324
  - Définition d'un Formatter325
  - 15.12. Préférences326
  - Principes326
  - Contextes de nommage327
  - Obtention d'un contexte328
  - Consultation dans un contexte328
  - Enregistrement d'une valeur329
  - Harmonisation avec le système de rémanence330
  - 15.13. Applications autonomes « packagées »330
  - 15.14. JavaWebstart331
  - Chapitre 16 De quelques bonnes pratiques333
  - 16.1. Algorithmes en Java335
  - Les tris336
  - Les recherches336
  - Tables de hachage337
  - Les compromis mémoire/performance338
  - 16.2. Composants « architecturaux » : introduction aux design patterns340
  - Modèle/Vue341
  - Enregistrement/rappel (call-back)342
  - Enregistrements multiples, diffusion343
  - Programmation réactive avec Flow345
  - Modèle, Vue, Contrôleur347
  - Singleton348
  - Méthodes « fabriques »348
  - Un exemple plus complexe ; le « décorateur »349
  - Introduction : combinaison héritage/délégation349
  - Introduction : un cas particulier d'héritage/délégation350
  - Un arbre d'héritage complexe351
  - Application du pattern « décorateur » aux E/S en Java352
  - Chapitre 17 Programmation dynamique, annotations, liens vers d'autres formalismes353
  - 17.1. La programmation dynamique355
  - La classe Class et ses méthodes fondamentales de découverte356
  - Obtention de l'objet Class356
  - Obtention des informations sur la classe358
  - Le package java.lang.reflect359
  - Les constructeurs359
  - Les méthodes360
  - Les champs360
  - Les tableaux361
  - 17.2. Le package java.lang.invoke361
  - Les combinaisons de type362
  - Invocation de constructeurs363
  - Invocation de méthodes363
  - 17.3. Mandataires dynamiques364
  - 17.4. Utilisation de la programmation dynamique par d'autres formalismes367
  - 17.5. Les annotations367
  - Structures de données368
  - Rétention des données369
  - Entités annotables369
  - Quelques annotations standard370
  - Définition des annotations371
  - Utilisation de la structure de données371
  - Les méta-annotations372
  - Déclarations simplifiées372
  - Consultation par introspection373
  - Chapitre 18 Liens vers d'autres formalismes375
  - 18.1. Utilisation de code natif377
  - Pourquoi réaliser du code natif ?377
  - Un exemple : « Hello World » en C378
  - Résumé des phases378
  - Ecriture du code JAVA379
  - Création des binaires JAVA de référence379
  - Génération du fichier d'inclusion C/C++380
  - Ecriture du code natif381
  - Création d'une librairie dynamique381
  - Exécution381
  - Présentation de JNI382
  - JNI : types, accès aux membres, création d'objets382
  - Références sur des objets JAVA385
  - Exceptions385
  - 18.2. Liens vers d'autres langages386
  - 18.3. Liens vers des formalismes textuels387
  - Chapitre 19 Aspects programmatiques avancés389
  - 19.1. Programmation parallèle et accès concurrents391
  - Informations de pile391
  - Les packages Java.util.concurrent391
  - Sémaphores392
  - Verrous393
  - Rendez-vous, passages de témoin394
  - Trames d'exécution et promesses395
  - Enchaînements de promesses396
  - Accès atomiques :398
  - Collections optimisées399
  - Traitements parallélisables399
  - Fork/join400
  - 19.2. Les références distantes (R.M.I.)400
  - La notion de service distant401
  - La définition d'un service distant401
  - Principe de la communication entre objets distants402
  - Exportation d'un objet403
  - Le comportement des mandataires404
  - Annuaire d'objets distants405
  - Le serveur : enregistrement auprès du Registry406
  - Le client ; demande à l'annuaire406
  - Check-list pour une mise en oeuvre simple407
  - Compléments407
  - Téléchargement dynamique des codes de classe407
  - Contexte de sécurité408
  - Mise en place du téléchargement des classes408
  - Personnalisation des mécanismes sous-jacents à RMI409
  - Serveurs dormants, serveurs résilients409
  - 19.3. Références faibles410
  - Problématiques des caches mémoire410
  - Les objets références411
  - SoftReference412
  - WeakReference413
  - Opérations liées à l'abandon d'un objet, finaliseurs,
  - PhantomReferences414
  - Chapitre 20 Aspects architecturaux avancés417
  - 20.1. Strates et conteneurs419
  - Les ClassLoaders419
  - Les strates de modules420
  - Les conteneurs421
  - Chapitre 21 Les modules441
  - Chapitre 22 Syntaxe : principes des déclarations de premier niveau445
  - 22.1. Plan d'ensemble d'une déclaration de classe448
  - Les packages : nommage, directive d'appartenance449
  - Le fichier package-info.java450
  - Directives import451
  - Import static452
  - 22.2. Déclaration de classe453
  - Champs : variables membres d'instance455
  - Champs : variables partagées et constantes457
  - Constructeurs458
  - Méthodes d'instance461
  - Méthodes de classe464
  - Arguments en nombre variable465
  - Blocs spéciaux467
  - Bloc statique467
  - (Instance initializers)467
  - Types définis dans une classe468
  - Chapitre 23 Syntaxe : les codes469
  - 23.1. Déclarations locales472
  - If/else473
  - Switch474
  - Expressions switch476
  - While/do-while476
  - Boucles for477
  - Boucle foreach478
  - Break, continue479
  - Etiquettes480
  - 23.2. Syntaxe : l'encapsulation automatique (autoboxing)481
  - Caches sur les valeurs encapsulées485
  - Chapitre 24 Outils487
  - 24.1. Les utilitaires standard de Java489
  - 24.2. Cas particulier de l'accessibilité490
  - 24.3. Remarques sur d'autres outils490
Origine de la notice:
- Electre