Penser en Java - A) Passage et Retour d'Objets- Page 6/6

A) Passage et Retour d'Objets

Texte original

Traducteur : Jérome QUELIN

///

Ce chapitre contient 6 pages
1 2 3 4 5 6

Exercises

Solutions to selected exercises can be found in the electronic document The Thinking in Java Annotated Solution Guide, available for a small fee from www.BruceEckel.com.

Les solutions aux exercices sélectionnés peuvent être trouvées dans le document électronique The Thinking in Java Annotated Solution Guide, disponible pour une faible somme sur www.BruceEckel.com.

Demonstrate a second level of aliasing. Create a method that takes a reference to an object but doesn’t modify that reference’s object. However, the method calls a second method, passing it the reference, and this second method does modify the object.
Create a class myString containing a String object that you initialize in the constructor using the constructor’s argument. Add a toString( ) method and a method concatenate( ) that appends a String object to your internal string. Implement clone( ) in myString. Create two static methods that each take a myString x reference as an argument and call x.concatenate("test"), but in the second method call clone( ) first. Test the two methods and show the different effects.
Create a class called Battery containing an int that is a battery number (as a unique identifier). Make it cloneable and give it a toString( ) method. Now create a class called Toy that contains an array of Battery and a toString( ) that prints out all the batteries. Write a clone( ) for Toy that automatically clones all of its Battery objects. Test this by cloning Toy and printing the result.
Change CheckCloneable.java so that all of the clone( ) methods catch the CloneNotSupportedException rather than passing it to the caller.
Using the mutable-companion-class technique, make an immutable class containing an int, a double and an array of char.
Modify Compete.java to add more member objects to classes Thing2 and Thing4 and see if you can determine how the timings vary with complexity—whether it’s a simple linear relationship or if it seems more complicated.
Starting with Snake.java, create a deep-copy version of the snake.
Inherit an ArrayList and make its clone( ) perform a deep copy.

Démontrer un second niveau d'aliasing. Créer une méthode qui crée une référence sur un objet mais ne modifie pas cet objet. Par contre, la méthode appelle une seconde méthode, lui passant la référence, et cette seconde méthode modifie l'objet.
Créer une classe myString contenant un objet String qu'on initialisera dans le constructeur en utilisant l'argument du constructeur. Ajouter une méthode toString() et une méthode concatenate() qui ajoute un objet String à la chaîne interne. Implémenter clone() dans myString. Créer deux méthodes static acceptant chacune une référence myString x comme argument et appellant x.concatenate("test"), mais la seconde méthode appelle clone() d'abord. Tester les deux méthodes et montrer les différents effets.
Créer une classe Battery contenant un int qui est un numéro de batterie (comme identifiant unique). La rendre cloneable et lui donner une méthode toString(). Créer maintenant une classe Toy qui contienne un tableau de Battery et une méthode toString() qui affiche toutes les Battery. Ecrire une méthode clone() pour la classe Toy qui clone automatiquement tous ses objets Battery. Tester cette méthode en clonant Toy et en affichant le résultat.
Changer CheckCloneable.java afin que toutes les méthodes clone() interceptent l'exception CloneNotSupportedException plutôt que de la faire suivre à l'appelant.
En utilisant la technique de la classe compagnon modifiable, créer une classe immuable contenant un int, un double et un tableau de char.
Modifier Compete.java pour ajouter de nouveaux objets membres aux classes Thing2 et Thing4, et voyez si vous pouvez déterminer comment le minutage varie avec la complexité - si c'est une simple relation linéaire ou si cela semble plus compliqué.
En reprenant Snake.java, créer une version du serpent qui supporte la copie profonde.
Hériter d'une ArrayList et faire que sa méthode clone() réalise une opération de copie profonde.

[79] In C, which generally handles small bits of data, the default is pass-by-value. C++ had to follow this form, but with objects pass-by-value isn’t usually the most efficient way. In addition, coding classes to support pass-by-value in C++ is a big headache.

[79]En C, qui généralement gère des données de petite taille, le passage d'arguments par défaut se fait par valeur. C++ a dû suivre cette norme, mais avec les objets, le passage par valeur n'est pas la façon de faire la plus efficace. De plus, coder une classer afin qu'elle supporte le passage par valeur en C++ est un gros casse-tête.

[80] This is not the dictionary spelling of the word, but it’s what is used in the Java library, so I’ve used it here, too, in some hopes of reducing confusion.

[80]Ce n'est pas l'orthographe correcte du mot clonable (N.d.T. : en français comme en anglais), mais c'est de cette manière qu'il est utilisé dans la bibliothèque Java ; j'ai donc décidé de l'utiliser ainsi ici aussi, dans l'espoir de réduire la confusion.

[81] You can apparently create a simple counter-example to this statement, like this:

[81]On peut apparemment créer un simple contre-exemple de cette affirmation, comme ceci :

public class Cloneit implements Cloneable {
  public static void main (String[] args)
  throws CloneNotSupportedException {
    Cloneit a = new Cloneit();
    Cloneit b = (Cloneit)a.clone();
  }
}

However, this only works because main( ) is a method of Cloneit and thus has permission to call the protected base-class method clone( ). If you call it from a different class, it won’t compile.

Toutefois, ceci ne marche que parce que main( ) est une méthode de Cloneit et donc a la permission d'appeler la méthode protected clone() de la classe de base. Si on l'appelle depuis une autre classe, la compilation générera des erreurs.

[82] Except for the poor avocado, which has been reclassified to simply “fat.”

[82]L'avocat excepté, qui a été reclassifié en « aliment gras ».

[83] C++ allows the programmer to overload operators at will. Because this can often be a complicated process (see Chapter 10 of Thinking in C++, 2nd edition, Prentice-Hall, 2000), the Java designers deemed it a “bad” feature that shouldn’t be included in Java. It wasn’t so bad that they didn’t end up doing it themselves, and ironically enough, operator overloading would be much easier to use in Java than in C++. This can be seen in Python (see www.Python.org) which has garbage collection and straightforward operator overloading.

[83]C++ permet au programmeur de surcharger les opérateurs comme il l'entend. Comme ceci se révèle souvent être un processus compliqué (voir le Chapitre 10 de Thinking in C++, 2nd edition, Prentice-Hall, 2000), les concepteurs de Java ont jugé une telle fonctionnalité « non souhaitable » qui ne devait pas donc pas être intégrée dans Java. Elle n'était apparemment pas si indésirable que cela, puisqu'eux-mêmes l'ont finalement utilisée, et ironiquement, la surcharge d'opérateurs devrait être bien plus facile à utiliser en Java qu'en C++. On peut le voir dans Python (voir www.python.org) qui dispose d'un ramasse-miettes et d'un mécanisme de surcharge d'opérateurs très simple à mettre en oeuvre.

[84] Doug Lea, who was helpful in resolving this issue, suggested this to me, saying that he simply creates a function called duplicate( ) for each class. [ Previous Chapter ] [ Short TOC ] [ Table of Contents ] [ Index ] [ Next Chapter ] Last Update:04/24/2000

[84]Doug Lea, qui m'a été d'une aide précieuse sur ce sujet, m'a suggéré ceci, me disant qu'il créait simplement une fonction duplicate() pour chaque classe.

\\\

Haut de page