Les solutions aux exercices choisis peuvent être trouvées dans le document
électronique The Thinking in Java Annotated Solution Guide, disponible pour une modeste
somme à l'adresse www.BruceEckel.com.
- Créez une classe avec un constructeur par défaut (c'est à dire sans
argument) qui imprime un message. Créez un objet de cette classe.
- Ajoutez à la classe de l'exercice 1 un constructeur surchargé qui prend
une String en argument et qui l'imprime avec votre message.
- Créez un tableau de références sur des objets de la classe que vous avez
créée à l'exercice 2. Mais ne créez pas les objets eux-même. Quand le programme s'exécute, voyez si
les messages d'initialisation du constructeur sont imprimés.
- Terminez l'exercice 3 en créeant les objets pour remplir le tableau de
références.
- Créez un tableau d'objets String et affectez une chaîne
de caractères à chaque élément. Imprimez le tableau en utilisant une boucle
for.
- Créez une classe Dog avec une méthode
bark( ) (NDT: to bark = aboyer) surchargée. Cette méthode sera surchargée en
utilisant divers types primitifs de données et devra imprimer différent types d'aboiement,
hurlement, ... suivant la version surchargée qui est appelée. Ecrivez également une méthode
main( ) qui appellera toutes les versions.
- Modifiez l'exercice 6 pour que deux des méthodes surchargées aient deux
paramètres (de deux types différents), mais dans l'ordre inverse l'une par rapport à l'autre.
Vérifiez que cela fonctionne.
- Créez une classe sans constructeur et créez ensuite un objet de cette
classe dans main( ) pour vérifier que le constructeur par défaut est
construit automatiquement.
- Créez une classe avec deux méthodes. Dans la première méthode, appelez la
seconde méthode deux fois : la première fois sans utiliser this et la seconde
fois en l'utilisant.
- Créez une classe avec deux constructeurs (surchargés). En utilisant
this, appelez le second constructeur dans le premier.
- Créez une classe avec une méthode finalize( ) qui
imprime un message. Dans main( ), créez un objet de cette classe. Expliquez
le comportement de ce programme.
- Modifiez l'exercice 11 pour que votre finalize( )
soit toujours appelé.
- Créez une classe Tank (NDT: citerne) qui peut être
remplie et vidée et qui a une death condition qui est que la citerne doit être vide quand
l'objet est nettoyé. Ecrivez une méthode finalize( ) qui vérifie cette death
condition. Dans main( ), testez tous les scénarii possibles d'utilisation de
Tank.
- Créez une classe contenant un int et un
char non initialisés et imprimez leurs valeurs pour vérifier que Java effectue
leurs initialisations par défaut.
- Créez une classe contenant une référence non-initialisée à une
String. Montrez que cette référence est initialisée à null par
Java.
- Créez une classe avec un champ String qui est initialisé
à l'endroit de sa définition et un autre qui est initialisé par le constructeur. Quelle est la
différence entre les deux approches ?
- Créez une classe avec un champ static String qui est
initialisé à l'endroit de la définition et un autre qui est initialisé par un bloc
static. Ajoutez une méthode statique qui imprime les deux champs et montre qu'ils
sont initialisés avant d'être utilisés.
- Créez une classe avec un champ String qui est initialisé
par une « initialisation d'instance ». Décrire une utilisation de cette fonctionnalité (autre que
celle spécifiée dans cet ouvrage).
- Ecrivez une méthode qui crée et initialise un tableau de
double à deux dimensions. La taille de ce tableau est déterminée par les arguments
de la méthode. Les valeurs d'initialisation sont un intervalle déterminé par des valeurs de début
et de fin également donné en paramètres de la méthode. Créez une deuxième méthode qui imprimera le
tableau généré par la première. Dans main( ), testez les méthodes en créeant
et en imprimant plusieurs tableaux de différentes tailles.
- Recommencez l'exercice 19 pour un tableau à trois dimensions.
- Mettez en commentaire la ligne marquée (1) dans
ExplicitStatic.java et vérifiez que la clause d'initialisation statique n'est pas
appelée. Maintenant décommentez une des lignes marquées (2) et vérifiez que la clause
d'initialisation statique est appelée. Décommentez maintenant l'autre ligne marquée (2) et
vérifiez que l'initialisation statique n'est effectuée qu'une fois.
- Faites des expériences avec Garbage.java en exécutant le
programme avec les arguments « gc », « finalize, » ou « all ». Recommencez le processus et voyez si vous
détectez des motifs répétitifs dans la sortie écran. Modifiez le code pour que
System.runFinalization( ) soit appelé avant
System.gc( ) et regardez les résultats.
[27] Dans certains articles
écrits par Sun relatifs à Java, il est plutôt fait référence au terme maladroit bien que descriptif
« no-arg constructors ». Le terme « constructeur par défaut » est utilisé depuis des années et c'est
donc celui que j'utiliserai.
[28] Le seul cas dans lequel
cela est possible, est si l'on passe une référence à un objet dans la méthode
statique. Ensuite, en utilisant la référence (qui est en fait
this maintenant), on peut appeler des méthodes non-statiques et
accéder à des champs non-statiques. Mais, en général, lorsque l'on veut faire
quelque chose comme cela, on crée tout simplement un méthode non-statique.
[29] Un terme créé par Bill
Venners (www.artima.com) pendant le séminaire que lui et moi avons donné ensemble.
[30] En comparaison, C++ possède
la liste d'initialisation du constructeur qui déclenche l'initialisation avant d'entrer
dans le corps du constructeur. Voir Thinking in C++, 2nde édition (disponible
sur le CDROM de cet ouvrage et à www.BruceEckel.com).
[31] Voir Thinking in C++,
2nde édition pour une description complète de l'initialisation par agrégat en
C++.
