mutable immutable and cloneable objects n.
Skip this Video
Loading SlideShow in 5 Seconds..
Mutable, Immutable, and Cloneable Objects PowerPoint Presentation
Download Presentation
Mutable, Immutable, and Cloneable Objects

Loading in 2 Seconds...

play fullscreen
1 / 26

Mutable, Immutable, and Cloneable Objects - PowerPoint PPT Presentation

Download Presentation
Mutable, Immutable, and Cloneable Objects
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  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.