let's suppose there are two objects of class abc
abc obj = new abc(10,20); // setting the values of two var. say x and y
abc obj1 = obj; // pointing to same memory so same values
But if there is a way where I can assign the values of one object to another, both having diff. memory. Simply said I want the values to copied not the address. Any operator or something can do that ?
You can use the clone() method (assuming the subclass implements the java.lang.Cloneable interface)
abc obj1 = obj.clone()
Bear in mind the default behavior of clone() is to return a shallow copy of the object. This means that the values of all of the original object’s fields are copied to the fields of the new object(it will not go through the entire graph of other objects).
I you want to "deep-copy" the object you can serialize and deserialize it.
A deep copy makes a distinct copy of each of the object’s fields, recursing through the entire graph of other objects referenced by the object being copied
more info at:
http://javatechniques.com/blog/faster-deep-copies-of-java-objects/
In case of using clone() method you have to implement Cloneable interface and write your own implementation for this method. I think that better to create a copy constructor in your class and use it.
For example:
public class YourClass() {
private int prop1;
private int prop2;
...
// Getters and setters for properties.
...
// Default constructor
public YourClass() {
}
// Copy constructor
public YourClass(YourClass instance) {
this.prop1 = instance.getProp1();
this.prop2 = instance.getProp2();
// The same for other methods
}
}
Here is good post about clonning vs copy costructors vs factory methods on StackOverflow.
Use deep cloning .Implement Cloneable Interface in class abc and implement clone()
abc obj = new abc(10,20); // setting the values of two var. say x and y
abc obj1 = obj.clone();
Cloning depends on your class structure .If you consider below simple class like your example.
class ABC implements Cloneable {
private int a;
private int b;
public int getA() {
return a;
}
public ABC(int a, int b) {
super();
this.a = a;
this.b = b;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
Test it in main will return false.
public static void main(String[] args) throws CloneNotSupportedException {
ABC a = new ABC(1, 2);
ABC b = (ABC) a.clone();
System.out.println(a == b);
}
You'll have to construct a new object.
As others point out, you can achieve this by implementing Cloneable and clone(), but you might as well might the new object explicit by implementing a Constructor or factory method that creates your new object out of the data held by the original.
The implementations won't differ much, yet I find the explicit instantiation less error prone to implement.
Josh Bloch comments on this in length in Effective Java. Depending on your edition, it is item 10 or item 11 in Chapter 3.
Try using 'operator overloading'. I know, I know, Java doesn't have it, but that doesn't stop you from 'using' it.
All you need to do is:
obj1.copy(obj2);
And inside the declaration of abc
public void copy(abc other) {
var1 = other.var1;
var2 = other.var2;
}
I wish to stress, that this is merely from memory and untested, but I see no reason why it shouldn't work.
Alternative, you can use 'clone()', but be aware that 'references' within your class would get cloned over. Better to do it manually, really.
By overwriting 'copy', you can also make sure, that your subclasses are copied properly.
Use the clone method of Object class.
MyClass mobj = new MyClass("Vivek");
MyClass mobj1 = mobj.clone();
But for deep cloning try to use Serialization and Deserialization
You'll have to use clone method. The default behavior of clone is shallow copy.
