Java en ligne

José Paumard


Table des matières

Introduction : un peu d'histoire
1. Java : genèse d'un nouveau langage
Programmer en Java
1. Un premier exemple
1.1. Aperçu général, cycle de vie
1.2. Un premier programme
1.3. Programmes, applets, servlets, etc...
2. Une première classe
2.1. Écriture d'une classe
2.2. Instanciation de cette classe
3. Types de base, classes et objets
3.1. Types de base
3.2. Classes et objets
Classes Object et String
1. Introduction
2. La classe Object
2.1. La méthode toString()
2.2. La méthode clone()
2.3. La méthode equals()
2.4. La méthode hashCode()
2.5. La méthode finalize()
2.6. La méthode getClass()
3. La classe String
3.1. Introduction
3.2. Construction d'un objet de type String
3.3. Concaténation, StringBuffer et StringBuilder
3.4. Concaténations de chaînes de caractères depuis Java 8
3.5. Concaténations de chaînes de caractères depuis Java 11
3.6. Extraction d'une sous-chaîne de caractères
3.7. Comparaison de deux chaînes de caractères
3.8. Méthodes de comparaisons lexicographiques
3.9. Méthode de recherche de caractères
3.10. Méthode de modification de chaîne
3.11. Méthode de duplication
3.12. Support de l'unicode, internationalisation
Structure d'une classe
1. Introduction
2. Classes
2.1. Classes publiques
2.2. Classes internes
2.3. Classe membre
2.4. Classes locales
2.5. Classes anonymes
2.6. Le mot-clé this
3. Éléments statiques
3.1. Champ statique
3.2. Cas des constantes
3.3. Bloc statique
3.4. Classe membre statique
4. Membres d'une classe, visibilité
4.1. Bloc non statique
4.2. Accès à un membre, visibilité
4.3. Les champs
4.4. Signature d'une méthode
4.5. Les méthodes
4.6. Getters et Setters
5. Constructeur, instanciation
5.1. Chargement d'une classe
5.2. Constructeurs d'une classe
5.3. Instanciation d'un objet
5.4. Destruction d'objets
5.5. Le mot-clé final
6. Énumérations
6.1. Déclaration d'une énumération
6.2. Classe énumération
6.3. Méthode toString()
6.4. Méthode valueOf()
6.5. Méthode values()
6.6. Méthode ordinal()
6.7. Méthode compareTo()
6.8. Constructeurs privés
6.9. Classe utilitaire : EnumSet
Noms, opérateurs, tableaux
1. Introduction
2. Identificateurs, noms et expressions
2.1. Identificateurs et noms
2.2. Expressions
3. Opérateurs, ordre d'exécution
3.1. Ordre d'exécution
3.2. Les opérateurs
3.3. Les opérateurs ++ et --
3.4. Les opérateurs % et /
3.5. Les opérateurs <<, >> et >>>
3.6. L'opérateur instanceof
3.7. Les opérateurs &, | et ^
3.8. Les opérateurs && et ||
3.9. L'opérateur ? ... :
3.10. Les opérateurs d'affectation
4. Tableaux
4.1. Création d'un tableau
4.2. Initialisation d'un tableau
4.3. Utilisation d'un tableau comme un Object
4.4. Tableaux de tableaux
4.5. Copie de tableaux
5. Blocs, boucles et contrôles
5.1. Blocs
5.2. Mots-clés réservés
5.3. Tests : if et switch
5.4. Boucles : for, while, do ... while
5.5. Commandes continue et break
5.6. Commandes return et goto
Nombres, précision, calculs
1. Introduction
2. Calculs
2.1. Précision
2.2. Codage des nombres flottants
2.3. Le mot-clé strictfp
2.4. Conversion de types
3. Dépassements de capacité
3.1. Cas des entiers
3.2. Cas des flottants
3.3. Bibliothèques BigInteger et BigDecimal
4. Fonctions mathématiques
4.1. Fonctions usuelles
4.2. Générateurs aléatoires
5. Classes enveloppe
5.1. Associer les types de base à des objets
5.2. Auto-boxing
Héritage, abstraction, interfaces
1. Introduction
2. Abstraction et encapsulation
2.1. Abstraction
2.2. Encapsulation
3. Héritage
3.1. Définition de l'héritage
3.2. Conséquences pour les membres
3.3. Polymorphisme
3.4. Empêcher l'héritage
4. Classes abstraites
5. Interfaces
5.1. Introduction
5.2. Définition
5.3. Java 8 et les interfaces
5.4. Utilisation des interfaces
5.5. Définition de constantes dans les interfaces
5.6. Utilité des interfaces
Packages
1. Introduction
2. Notion de paquet
2.1. Déclaration d’appartenance à un paquet
2.2. Chargement d’une classe
2.3. Choix de nom
3. Archives, chemin de recherche, classpath
3.1. Archives
3.2. Variable CLASSPATH
3.3. Notion de classloader
3.4. Bilan sur les classes chargées
3.5. Visibilité
3.6. Conseils d'écriture, bibliothèque standard
Exceptions
1. Introduction
2. Erreurs et Exceptions
2.1. Classe Throwable, notion de stack trace
2.2. Classe Error
2.3. Classe RuntimException
2.4. Classe Exception
3. Déclenchement d'une exception
3.1. Exceptions déclenchées par la JVM
3.2. Exceptions déclenchées par l'application
4. Capter une exception
4.1. Traiter une exception localement
4.2. Code de captage
5. Créer ses propres exceptions
Entrées / sorties
1. Introduction
2. Notion de fichier
2.1. Introduction
2.2. La classe File
2.3. Construction d'une instance de File
2.4. Méthodes exposées
3. Flux de sortie
3.1. Introduction, notion de flux
3.2. Écriture de caractères, classe Writer
3.3. Bufferisation, construction d'un flux sur un autre
3.4. Utilisation de PrintWriter
3.5. Écriture d'octets, OuputStream
3.6. Écriture de types primitifs : DataOutputStream
3.7. Écriture d'objets : ObjectOutputStream
4. Flux d'entrée
4.1. Introduction
4.2. Lecture de caractères, classe Reader
4.3. Bufferisation, lecture ligne par ligne
4.4. Lecture d'octets : InputStream
4.5. Lecture de types primitifs : DataInputStream
4.6. Lecture d'objets : ObjectInputStream
5. Lecture et écriture de flux croisés
5.1. Introduction
5.2. Lire des caractères sur un flux binaire : classe InputStreamReader
5.3. Écrire des caractères sur un flux binaire : classe OutputStreamWriter
5.4. Remarque sur les jeux de caractères
6. Serialization d'objets
6.1. Enjeu de la sérialization d'objets
6.2. Serialization d'un objet
6.3. Sérialization d'une grappe d'objets
6.4. Première surcharge : méthode writeObject() readObject()
6.5. Deuxième surcharge : utilisation d'un externalizer
6.6. Troisième surcharge : utilisation d'un objet proxy
7. Flux compressés
7.1. Introduction
7.2. Flux de type gzip
7.3. Flux de type zip

Liste des exemples

1. J'écris Bonjour le monde en Java !
2. Une première version de la classe Marin
3. Les méthodes de la classe Object
4. Surcharge de toString() dans la classe Marin
5. Surcharge de clone() dans la classe Marin
6. Surcharge de equals() dans la classe Marin
7. Surcharge de hashCode() dans la classe Marin
8. Construction d'un objet String
9. Concaténation de deux String
10. Concaténation de deux String avec StringBuilder
11. Concaténation de String et d'objets quelconques
12. Concaténation d'une liste de String en utilisant String.join()
13. Concaténation d'une liste de String en utilisant la classe StringJoiner
14. Extraction d'une sous-chaîne
15. Extraction d'une sous-chaîne : code exécuté
16. Code de la méthode hashCode() de la classe String
17. Code de la méthode equals() de la classe String
18. Recherche d'un caractère dans une chaîne
19. Exemple d'une classe publique
20. Exemple d'une classe interne
21. Classes membre de la classe Character
22. Exemple d'une classe locale
23. Exemple d'une classe anonyme locale
24. Utilisation de this pour lever l'ambiguïté entre un champ et un paramètre
25. Utilisation d'un champ statique
26. Déclaration d'une constante
27. Déclaration d'un bloc statique
28. Classe Marin pour les exemples de visibilité
29. Erreur de compilation due à une valeur de retour non toujours définie
30. Types de retour correctement définis
31. Getters et setters de la classe Marin
32. Exécution des blocs statiques lors du chargement d'une classe
33. Constructeur vide par défaut - 1
34. Constructeur vide par défaut - 2
35. Constructeur vide par défaut - 3
36. Appels explicites de constructeurs
37. Exemple d'une instanciation complexe
38. Une première énumération
39. Déclaration d'une énumération
40. Énumération : constructeurs privés
41. Création d'un EnumSet sur une énumération
42. Équivalence opérateur ternaire et tests normaux
43. Déclaration d'un tableau
44. Création d'un tableau, initialisation dans une boucle for
45. Parcours d'un tableau dans une boucle foreach
46. Initialisation d'un tableau de types de base
47. Initialisation d'un tableau d'objets
48. Déclaration d'un tableau bidimensionnel
49. Initialisation d'un tableau bidimensionnel
50. Initialisation d'un tableau bidimensionnel - bis
51. Un tableau bizarre
52. Copie de tableau par System.arraycopy
53. Exemples de blocs
54. Utilisation de switch
55. Utilisation de switch avec une énumération
56. Utilisation de switch avec break
57. Boucles for
58. Utilisation de break sur un label
59. Imprécision des flottants - 1
60. Imprécision sur les flottants - 2
61. Tester l'égalité de deux flottants
62. Utilisation de strictfp
63. Conversion d'un long en int
64. Addition d'un int à un byte
65. Plus grandes valeurs de la classe Integer
66. Cas de la division par 0
67. Limites de codage des Float et Double
68. Test si un nombre vaut NaN
69. Exemple de division par 0 en flottant
70. Utilisation de BigInteger
71. Utilisation de la classe Math
72. Première utilisation de la classe Random (incorrecte !)
73. Mise en évidence d'une mauvaise utilisation de Random
74. Utilisation correcte de Random
75. Construction d'un Integer
76. Conversion d'une chaîne de caractères en nombre
77. Conversion d'un nombre en chaîne de caractères - 1
78. Conversion d'un nombre en chaîne de caractères - 2
79. Importance de l'immutabilité des classes wrapper
80. Auto-boxing et auto-unboxing
81. Une classe qui hérite d'une autre classe
82. Accès aux champs d'une super-classe - 1
83. Accès aux champs d'une super-classe - 2
84. Overloading et overriding
85. Utilisation du mot-clé final
86. Classe abstraite
87. Extension d'une classe abstraite - 1
88. Extension d'une classe abstraite - 2
89. Les classes "moyen de locomotion"
90. Méthode faireLePlein(...) - 1
91. Interface Motorise
92. Ecriture de StationService avec Motorise
93. Une interface
94. Implémentation d'une interface
95. Méthode statique dans une interface
96. Méthode par défaut dans une interface
97. Héritage multiple de type sur la classe String
98. Héritage multiple d'implémentation
99. Héritage multiple d'implémentation
100. Constante définie dans une interface
101. Déclaration d'un paquet dans une classe
102. Rangement d'une classe dans un sous-paquet
103. Directive import sur un package complet
104. Directive import sur une classe particulière
105. Utilisation de deux classes portant le même nom dans le même fichier
106. Déclenchement d'exceptions par la JVM
107. Déclenchement manuel d'une exception
108. Propagation d'un exception
109. Capter une exception
110. Création d'une nouvelle classe d'exception
111. Utilisation de File.separator
112. Lecture du répertoire courant
113. Utilisation de listFiles(FileFilter)
114. Utilisation de File.listRoots()
115. Utilisation de FileWriter, première version
116. Utilisation de FileWriter, , version corrigée
117. Utilisation d'un buffer d'écriture
118. Utilisation de PrintWriter
119. Utilisation de FileOutputStream
120. Utilisation de DataOutputStream
121. Utilisation de FileReader
122. Lecture d'un fichier ligne par ligne : LineNumberReader
123. Utilisation de FileInputStream
124. Propriété file.encoding
125. Champ transient
126. Classe Marin sérializable
127. Sérialization d'un objet
128. Désérialization d'un objet
129. Utilisation de readObject() et writeObject()
130. Sérialization par objet proxy : classe proxy
131. Sérialization par objet proxy : classe à sérializer
132. Utilisation de flux GZip
133. Création d'un fichier Zip
134. Lecture d'un fichier Zip
Java langage & API
Retour au blog Java le soir
Cours & Tutoriaux