Mutable, Immutable, and Cloneable Objects

1. Mutable, Immutable, and Cloneable Objects Chapter 15

2. Chapter Contents • Mutable and Immutable Objects • Companion Classes • Using Inheritance to Form Companion Classes • Cloneable Objects • A Sorted List of Clones • Cloning an Array • Cloning a Chain

3. Mutable and Immutable Objects • A mutable object belongs to a class that has mutator or set methods for its data fields • The client uses set methods to change values of the object's data fields Fig. 15-1 An object and its reference variable chris

4. Mutable and Immutable Objects Done by executing chris.setLast ("Smith"); Fig. 15-2 An object in the list nameList (a) initially; (b) after the reference variable chris is used to change it

5. Mutable and Immutable Objects • Immutable object belongs to a class that does NOT have mutator or set methods • Class said to be read only • Placing immutable objects in a sorted list is a way to prevent the client from destroying the order of the list • Use an immutable object if it will be shared • Use a mutable object if its data will change frequently

6. Companion Classes • If it is necessary to alter an immutable object • Can be accomplished by having a companion class of corresponding mutable objects • Also helpful to have methods that convert an object from one type to another

7. Companion Classes Fig. 15-3 the classes Name and ImmutableName

8. Companion Classes • Java's String class is a read-only class • Instances of String are immutable • Java provides a companion class, StringBuffer • Has a constructor that takes an instance of String as an argument • Has the toString method that converts a mutable instance of StringBuffer to an immutable instance of String

9. Companion Classes • Inheritance can be used to form companion classes • Text shows declaration of ImmutableName • Then uses this to declare the derived class Name • Invokes protected methods of base class • Adds mutator methods • It is best to derive the mutable class from the immutable class

10. Companion Classes Fig. 15-4 The class Name is derived from the class ImmutableName

11. Cloneable Objects • A clone is a copy of an object • The Object class contains a protected method clone that returns a copy of an object • The implementation of any method can invoke clone • Clients cannot invoke clone unless the class overrides it, declares it public public class MyClass implements Cloneable { . . .

12. Cloneable Objects Fig. 15-5 (a) A shallow clone; (b) a deep clone.

13. Cloneable Objects Fig. 15-6 An instance of Name and its shallow clone.

14. Cloneable Objects Fig. 15-7 A clone after one of its data fields is changed.

15. Cloneable Objects • A clone method for class Student that does a deep copy public Object clone(){ try{ Student theCopy = (Student)super.clone(); theCopy.fullName = (Name)fullName.clone();return theCopy; }catch (CloneNotSupportedException e) { throw new Error(e.toString()); }} // end clone

16. Cloneable Objects Fig. 15-8 An instance of Student and its clone, including a deep copy of fullName.

17. Cloneable Objects Fig. 15-9 A shallow copy of fullName.

18. Tasks for a clone Method • Invoke the clone method of the superclass with super.clone() • Enclose call to clone in a try block • Write a catch block to handle exception of CloneNotSupportedException • Skip if super.clone() invokes a public clone method • Clone mutable data fields of object super.clone() returned, when possible • Return the clone

19. A Sorted List of Clones • Recall problem of placing mutable objects in an ADT (such as a sorted list) • If object is cloned before it is added to an ADT • Client could access/change the ADT's data only by using ADT operations • Requires that object added to the ADT be Cloneable

20. A Sorted List of Clones Fig. 15-10 An ADT and its client after the clone of an object is added to the ADT.

21. A Sorted List of Clones Fig. 15-11 The effect of getEntry if it did not return a clone.

22. A Sorted List of Clones Fig. 15-12 The effect of getEntry when it does return a clone.

23. Cloning an Array • To make a deep clone of an array a of cloneable objects • The class must implement Cloneable • Invoke a.clone() • Clone each object in the array Thing[ ] clonedArray = (Thing[ ])myArray.clone(); for (int index = 0; index < myArray.length; index++) clonedArray[index] = (Thing)myArray[index].clone();

24. Cloning a Chain • The ADT list class must implement the interface Cloneable public class LList implements ListInterface, Cloneable {private Node firstNode; // reference to first node private int length; // number of entries in list . . .

25. Cloning a Chain Fig. 15-13 A list that stores its data in a linked chain and its shallow clone.

26. Cloning a Chain Fig. 15-14 A list that stores its data in a linked chain and its deep clone.