A constructor for copying an object of the same : Constructor « Class « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Class » ConstructorScreenshots 
A constructor for copying an object of the same
A constructor for copying an object of the same
 
// : appendixa:CopyConstructor.java
// A constructor for copying an object of the same
// type, as an attempt to create a local copy.
// From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
// www.BruceEckel.com. See copyright notice in CopyRight.txt.

import java.lang.reflect.Constructor;

class FruitQualities {
  private int weight;

  private int color;

  private int firmness;

  private int ripeness;

  private int smell;

  // etc.
  public FruitQualities() { // Default constructor
    // Do something meaningful...
  }

  // Other constructors:
  // ...
  // Copy constructor:
  public FruitQualities(FruitQualities f) {
    weight = f.weight;
    color = f.color;
    firmness = f.firmness;
    ripeness = f.ripeness;
    smell = f.smell;
    // etc.
  }
}

class Seed {
  // Members...
  public Seed() { /* Default constructor */
  }

  public Seed(Seed s) { /* Copy constructor */
  }
}

class Fruit {
  private FruitQualities fq;

  private int seeds;

  private Seed[] s;

  public Fruit(FruitQualities q, int seedCount) {
    fq = q;
    seeds = seedCount;
    s = new Seed[seeds];
    for (int i = 0; i < seeds; i++)
      s[inew Seed();
  }

  // Other constructors:
  // ...
  // Copy constructor:
  public Fruit(Fruit f) {
    fq = new FruitQualities(f.fq);
    seeds = f.seeds;
    s = new Seed[seeds];
    // Call all Seed copy-constructors:
    for (int i = 0; i < seeds; i++)
      s[inew Seed(f.s[i]);
    // Other copy-construction activities...
  }

  // To allow derived constructors (or other
  // methods) to put in different qualities:
  protected void addQualities(FruitQualities q) {
    fq = q;
  }

  protected FruitQualities getQualities() {
    return fq;
  }
}

class Tomato extends Fruit {
  public Tomato() {
    super(new FruitQualities()100);
  }

  public Tomato(Tomato t) { // Copy-constructor
    super(t)// Upcast for base copy-constructor
    // Other copy-construction activities...
  }
}

class ZebraQualities extends FruitQualities {
  private int stripedness;

  public ZebraQualities() { // Default constructor
    super();
    // do something meaningful...
  }

  public ZebraQualities(ZebraQualities z) {
    super(z);
    stripedness = z.stripedness;
  }
}

class GreenZebra extends Tomato {
  public GreenZebra() {
    addQualities(new ZebraQualities());
  }

  public GreenZebra(GreenZebra g) {
    super(g)// Calls Tomato(Tomato)
    // Restore the right qualities:
    addQualities(new ZebraQualities());
  }

  public void evaluate() {
    ZebraQualities zq = (ZebraQualitiesgetQualities();
    // Do something with the qualities
    // ...
  }
}

public class CopyConstructor {

  public static void ripen(Tomato t) {
    // Use the "copy constructor":
    t = new Tomato(t);
    System.out.println("In ripen, t is a " + t.getClass().getName());
  }

  public static void slice(Fruit f) {
    f = new Fruit(f)// Hmmm... will this work?
    System.out.println("In slice, f is a " + f.getClass().getName());
  }

  public static void ripen2(Tomato t) {
    try {
      Class c = t.getClass();
      // Use the "copy constructor":
      Constructor ct = c.getConstructor(new Class[] { });
      Object obj = ct.newInstance(new Object[] { });
      System.out.println("In ripen2, t is a " + obj.getClass().getName());
    catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void slice2(Fruit f) {
    try {
      Class c = f.getClass();
      Constructor ct = c.getConstructor(new Class[] { });
      Object obj = ct.newInstance(new Object[] { });
      System.out.println("In slice2, f is a " + obj.getClass().getName());
    catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) {
    Tomato tomato = new Tomato();
    ripen(tomato)// OK
    slice(tomato)// OOPS!
    ripen2(tomato)// OK
    slice2(tomato)// OK
    GreenZebra g = new GreenZebra();
    ripen(g)// OOPS!
    slice(g)// OOPS!
    ripen2(g)// OK
    slice2(g)// OK
    g.evaluate();

  }
///:~



           
         
  
Related examples in the same category
1.Paying attention to exceptions in constructorsPaying attention to exceptions in constructors
2.Order of constructor callsOrder of constructor calls
3.Constructors and polymorphism don't produce what you might expectConstructors and polymorphism don't produce what you might expect
4.Constructor initialization with compositionConstructor initialization with composition
5.Demonstration of a simple constructorDemonstration of a simple constructor
6.Constructors can have argumentsConstructors can have arguments
7.Show Constructors conflicting
8.Show that if your class has no constructors, your superclass constructors still get calledShow that if your class has no constructors, your superclass constructors still get called
9.Constructor calls during inheritanceConstructor calls during inheritance
10.Create a new instance of a class by calling a constructor with arguments
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.