how Immutable class is created having mutable object as refernce

Question

I am asking very basis question about 'How to make immutable Object in java'.

So I have one Address class from third party which does not inherit any Cloneable interface and its mutable class. It looks like this

public class Address {

    private String city;
    private String address;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

Now I have another immutable class called Person which implements Cloneable interface and also override clone method.Class Looks like this

public class Person implements Cloneable {

    private String name;
    private Address address;

    public Person() {

    }

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
        //this.address = (Address) address.clone();
    }

    public String getName() {
        return name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person = (Person) super.clone();
        return super.clone();
    }

    public Address getAddress() {
        return address;
    }

    @Override
    public String toString() {
        return "name:" + name + ", address" + address.getAddress() + ", city="
                + address.getCity();
    }

}

Now my question is, surely I can clone the Person class object but how can address class instance be cloned. I also read some article about shallow cloning and deep cloning. But I could not understand the how deep cloning can be done with thirty party API. Or correct me if I understood something wrong about cloning.

The `Address` class is simple enough, so you can create your own class that extends Address and implements Cloneable. That being said, I am in agreement with Raedwald here. Please take a look at this answer on SO: http://stackoverflow.com/a/1067437/1011791 — Chthonic Project, Jul 22 '15 at 15:02
Watch out: your `clone()` method currently always returns `super.clone()`. Use `return person` instead! — slartidan, Jul 22 '15 at 15:09
so I have to write Wrapper for every class who does not implement Clonable interface and can be referenced into Immutable Object. Will it be good idea? — keepmoving, Jul 22 '15 at 15:10
**Cloning is painful**. Avoid it, if possible. Do you really *need* cloning? What do you want to use it for? — slartidan, Jul 22 '15 at 15:12
so here i can write one dedicated method which will create a new instance and copy all the attributes using prototype design pattern. — keepmoving, Jul 22 '15 at 15:15

Marko Topolnik · Accepted Answer · 2015-07-22T15:29:52.740

4

I think you understand very well: clone is a bad mechanism and there's actually a complete list of things wrong with it (check out Effective Java). Particularly relevant to your case, you cannot deep-clone an object with final fields.

Instead choose a custom mechanism for copying objects, such as copy-constructors or dedicated methods.

There is also a trick with in-memory serialize-deserialize cycle, but I wouldn't really recommend it unless performance and efficiency are not high on your list.

edited Jul 22 '15 at 15:29

answered Jul 22 '15 at 15:03

Marko Topolnik

195,646
29
319
436

You are right. But If i write something like this. Address address = new Address(); address.setCity("Noida"); address.setAddress("J-75"); Person person = new Person("naveen", address); System.out.println(person.toString()); address.setCity("Noida Extenstion"); System.out.println(person.toString()); – keepmoving Jul 22 '15 at 15:17
Then actually it breaks the contract of immutable Object. – keepmoving Jul 22 '15 at 15:17

score 0 · Answer 2 · answered Jul 22 '15 at 15:44

One of the many problems with the Cloneable facility is that after calling super.clone() there can be fields whose state you need to go back and -fix- before returning the cloned value. This prevents you from making those fields final in your class and is at odds with the principle of an immutable class. Moreover, the facility can introduce security vulnerabilities into your class chiefly because it relies on an extralinguistic mechanism for object creation.

A good rule of thumb is if you can avoid implementing Cloneable in your classes, then avoid it.

As Marko mentioned, copy constructors of copy factory methods are usually superior strategies that do not rely upon a flawed, extralinguistic mechanism for object creation. The only good time to use the clone() method of which I am aware is when obtaining defensive copies of arrays of immutable values such as primitives or Strings.

how Immutable class is created having mutable object as refernce

2 Answers2