Copy constructors and defensive copying

What is a copy constructor?

Can someone share a small example that can be helpful to understand along with defensive copying principle?

Here's a good example:

class Point {
  final int x;
  final int y;

  Point(int x, int y) {
    this.x = x;
    this.y = y;
  }

  Point(Point p) {
    this(p.x, p.y);
  }

}

Note how the constructor Point(Point p) takes a Point and makes a copy of it - that's a copy constructor.

This is a defensive copy because the original Point is protected from change by taking a copy of it.

So now:

// A simple point.
Point p1 = new Point(3,42);
// A new point at the same place as p1 but a completely different object.
Point p2 = new Point(p1);

Note that this is not necessarily the correct way of creating objects. It is, however, a good way of creating objects that ensures that you never have two references to the same object by accident. Clearly this is only a good thing if that is what you want to achieve.

Copy constructors one often sees in C++ where they are needed for partly hidden, automatically invoked operations.

java java.awt.Point and Rectangle come to mind; also very old, mutable objects.

By using immutable objects, like String, or BigDecimal, simply assigning the object reference will do. In fact, due to the early phase of Java after C++, there still is a silly copy constructor in String:

public class Recipe {
    List<Ingredient> ingredients;

    public Recipe() {
        ingredients = new ArrayList<Ingredient>();
    }

    /** Copy constructor */
    public Recipe(Recipe other) {
        // Not sharing: ingredients = other.ingredients;
        ingredients = new ArrayList<Ingredient>();
        ingredients.addAll(other.ingredients);
    }

    public List<Ingredient> getIngredients() {
        // Defensive copy, so others cannot change this instance.
        return new ArrayList<Ingredient>(ingredients);
        // Often could do:
        // return Collections.immutableList(ingredients);
    }
}

A copy constructor is used to create a new object using the values of an existing object.
One possible use case is to protect original object from being modified while the copied object can be used to work upon.

public class Person  
{  
   private String name;  
   private int age;  
   private int height;  


/** 
 * Copy constructor which creates a Person object identical to p.  
 */  
   public person(Person p)  
   {  
      person = p.person;  
      age = p.age;  
      height = p.height;  
   }  
.
.
. 
}

Related to defensive copy here is a good read

Lakshmi

Copy constructor in java can be used when you need to clone an object

class Copy {
   int a;
   int b;
  public Copy(Copy c1) {
    a=c1.a;
    b=c1.b;
  }
}

In java when you give Copy c2=c1; simply creates a reference to the original object and not the copy so you need to manually copy the object values.

See this:

This is where you create a new object, by passing an old object, copying its values.

Color copiedColor = new Color(oldColor);

instead of :

Color copiedColor = new Color(oldColor.getRed(),
                              oldColor.getGreen(), oldColor.getBlue());

来源：https://stackoverflow.com/questions/15020850/copy-constructors-and-defensive-copying

标签

java

defensive-programming