Java 问答：终极父类（一）——clone()方法

/*原作者Jeff Friesen分成3部分讲Object类及其相关内容。这里，我将他们翻译并按照内容来发布。这是第一篇，讲的是Object类简介和其中的clone（）方法*/

Java的一些特性会让初学者感到困惑，但在有经验的开发者眼中，却是合情合理的。例如，新手可能不会理解Object类。这篇文章分成三个部分讲跟Object类及其方法有关的问题。

ps:这个系列的翻译已经结束，目录如下：

上帝类

问：什么是Object类？

答：Object类存储在java.lang包中，是所有java类(Object类除外)的终极父类。当然，数组也继承了Object类。然而，接口是不继承Object类的，原因在这里指出：Section 9.6.3.4 of the Java Language Specification:“Object类不作为接口的父类”。 Object类中声明了以下函数，我会在下文中作详细说明。

protected Object clone()
boolean equals(Object obj)
protected void finalize()
Class<?> getClass()
int hashCode()
void notify()
void notifyAll()
String toString()
void wait()
void wait(long timeout)
void wait(long timeout, int nanos)

java的任何类都继承了这些函数，并且可以覆盖不被final修饰的函数。例如，没有final修饰的toString()函数可以被覆盖，但是final wait()函数就不行。

问：可以声明要“继承Object类”吗？

答：可以。在代码中明确地写出继承Object类没有语法错误。参考代码清单1。

import java.lang.Object;

public class Employee extends Object {
    private String name;

    public Employee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public static void main(String[] args) {
        Employee emp = new Employee("John Doe");
        System.out.println(emp.getName());
    }
}

import java.lang.Object;

public class Employee extends Object {

private String name;

public Employee(String name) {

this.name = name;

}

public String getName() {

return name;

}

public static void main(String[] args) {

Employee emp = new Employee("John Doe");

System.out.println(emp.getName());

}

你可以试着编译代码1(javac Employee.java)，然后运行Employee.class(java Employee)，可以看到John Doe 成功的输出了。

因为编译器会自动引入java.lang包中的类型，即import java.lang.Object；没必要声明出来。Java也没有强制声明“继承Object类”。如果这样的话，就不能继承除Object类之外别的类了，因为java不支持多继承。然而，即使不声明出来，也会默认继承了Object类，参考代码清单2。

public class Employee
{
   private String name;

   public Employee(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }

   public static void main(String[] args)
   {
      Employee emp = new Employee("John Doe");
      System.out.println(emp.getName());
   }
}

public class Employee

{

private String name;

public Employee(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

public static void main(String[] args)

{

Employee emp = new Employee("John Doe");

System.out.println(emp.getName());

}

就像代码清单1一样，这里的Employee类继承了Object，所以可以使用它的函数。

克隆`Object`类

问：clone()函数是用来做什么的？

答：clone()可以产生一个相同的类并且返回给调用者。

问：clone()是如何工作的？

答：Object将clone()作为一个本地方法来实现，这意味着它的代码存放在本地的库中。当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。

问：怎样调用clone()来克隆一个对象？

答：用想要克隆的对象来调用clone()，将返回的对象从Object类转换到克隆的对象所属的类，赋给对象的引用。这里用代码清单3作一个示例。

public class CloneDemo implements Cloneable {
    int x;

    public static void main(String[] args) throws CloneNotSupportedException {
        CloneDemo cd = new CloneDemo();
        cd.x = 5;
        System.out.printf("cd.x = %d%n", cd.x);
        CloneDemo cd2 = (CloneDemo) cd.clone();
        System.out.printf("cd2.x = %d%n", cd2.x);
    }
}

public class CloneDemo implements Cloneable {

int x;

public static void main(String[] args) throws CloneNotSupportedException {

CloneDemo cd = new CloneDemo();

cd.x = 5;

System.out.printf("cd.x = %d%n", cd.x);

CloneDemo cd2 = (CloneDemo) cd.clone();

System.out.printf("cd2.x = %d%n", cd2.x);

}

代码清单3声明了一个继承Cloneable接口的CloneDemo类。这个接口必须实现，否则，调用Object的clone()时将会导致抛出异常CloneNotSupportedException。

CloneDemo声明了一个int型变量x和主函数main()来演示这个类。其中，main()声明可能会向外抛出CloneNotSupportedException异常。

Main()先实例化CloneDemo并将x的值初始化为5。然后输出x的值，紧接着调用clone() ，将克隆的对象传回CloneDemo。最后，输出了克隆的x的值。

编译代码清单3(javac CloneDemo.java)然后运行(java CloneDemo)。你可以看到以下运行结果：

cd.x = 5
cd2.x = 5

1 2	cd.x = 5 cd2.x = 5

问：什么情况下需要覆盖clone()方法呢？

答：上面的例子中，调用clone()的代码是位于被克隆的类(即CloneDemo类)里面的，所以就不需要覆盖clone()了。但是，如果调用别的类中的clone()，就需要覆盖clone()了。否则，将会看到“clone在Object中是被保护的”提示，因为clone()在Object中的权限是protected。(译者注：protected权限的成员在不同的包中，只有子类对象可以访问。代码清单3的CloneDemo类和代码清单4的Data类是Object类的子类，所以可以调用clone()，但是代码清单4中的CloneDemo类就不能直接调用Data父类的clone())。代码清单4在代码清单3上稍作修改来演示覆盖clone()。

class Data implements Cloneable {
    int x;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class CloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Data data = new Data();
        data.x = 5;
        System.out.printf("data.x = %d%n", data.x);
        Data data2 = (Data) data.clone();
        System.out.printf("data2.x = %d%n", data2.x);
    }
}

class Data implements Cloneable {

int x;

@Override

public Object clone() throws CloneNotSupportedException {

return super.clone();

}

public class CloneDemo {

public static void main(String[] args) throws CloneNotSupportedException {

Data data = new Data();

data.x = 5;

System.out.printf("data.x = %d%n", data.x);

Data data2 = (Data) data.clone();

System.out.printf("data2.x = %d%n", data2.x);

}

代码清单4声明了一个待克隆的Data类。这个类实现了Cloneable接口来防止调用clone()的时候抛出异常CloneNotSupportedException，声明了int型变量x，覆盖了clone()方法。这个方法通过执行super.clone()来调用父类的clone()(这个例子中是Object的)。通过覆盖来避免抛出CloneNotSupportedException异常。

代码清单4也声明了一个CloneDemo类来实例化Data，并将其初始化，输出示例的值。然后克隆Data的对象，同样将其值输出。

编译代码清单4(javac CloneDemo.java)并运行(java CloneDemo)，你将看到以下运行结果：

data.x = 5
data2.x = 5

1 2	data.x = 5 data2.x = 5

问：什么是浅克隆？

A:浅克隆(也叫做浅拷贝)仅仅复制了这个对象本身的成员变量，该对象如果引用了其他对象的话，也不对其复制。代码清单3和代码清单4演示了浅克隆。新的对象中的数据包含在了这个对象本身中，不涉及对别的对象的引用。

如果一个对象中的所有成员变量都是原始类型，并且其引用了的对象都是不可改变的(大多情况下都是)时，使用浅克隆效果很好！但是，如果其引用了可变的对象，那么这些变化将会影响到该对象和它克隆出的所有对象！代码清单5给出一个示例。

class Employee implements Cloneable {
    private String name;
    private int age;
    private Address address;

    Employee(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    Address getAddress() {
        return address;
    }

    String getName() {
        return name;
    }

    int getAge() {
        return age;
    }
}

class Address {
    private String city;

    Address(String city) {
        this.city = city;
    }

    String getCity() {
        return city;
    }

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

public class CloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Employee e = new Employee("John Doe", 49, new Address("Denver"));
        System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),
                          e.getAddress().getCity());
        Employee e2 = (Employee) e.clone();
        System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),
                          e2.getAddress().getCity());
        e.getAddress().setCity("Chicago");
        System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),
                          e.getAddress().getCity());
        System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),
                          e2.getAddress().getCity());
    }
}

class Employee implements Cloneable {

private String name;

private int age;

private Address address;

Employee(String name, int age, Address address) {

this.name = name;

this.age = age;

this.address = address;

}

@Override

public Object clone() throws CloneNotSupportedException {

return super.clone();

}

Address getAddress() {

return address;

}

String getName() {

return name;

}

int getAge() {

return age;

}

class Address {

private String city;

Address(String city) {

this.city = city;

}

String getCity() {

return city;

}

void setCity(String city) {

this.city = city;

}

public class CloneDemo {

public static void main(String[] args) throws CloneNotSupportedException {

Employee e = new Employee("John Doe", 49, new Address("Denver"));

System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),

e.getAddress().getCity());

Employee e2 = (Employee) e.clone();

System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),

e2.getAddress().getCity());

e.getAddress().setCity("Chicago");

System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),

e.getAddress().getCity());

System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),

e2.getAddress().getCity());

}

代码清单5给出了Employee、Address和CloneDemo类。Employee声明了name、age、address成员变量，是可以被克隆的类；Address声明了一个城市的地址并且其值是可变的。CloneDemo类驱动这个程序。

CloneDemo的主函数main()创建了一个Employee对象并且对其进行克隆，然后，改变了原来的Employee对象中address值城市的名字。因为原来的Employee对象和其克隆出来的对象引用了相同的Address对象，所以两者都会提现出这个变化。

编译 (javac CloneDemo.java) 并运行 (java CloneDemo)代码清单5，你将会看到如下输出结果：

John Doe: 49: Denver
John Doe: 49: Denver
John Doe: 49: Chicago
John Doe: 49: Chicago

John Doe: 49: Denver

John Doe: 49: Chicago

问：什么是深克隆？

答：深克隆(也叫做深复制)会复制这个对象和它所引用的对象的成员变量，如果该对象引用了其他对象，深克隆也会对其复制。例如，代码清单6在代码清单5上稍作修改演示深克隆。同时，这段代码也演示了协变返回类型和一种更为灵活的克隆方式。

class Employee implements Cloneable
{
   private String name;
   private int age;
   private Address address;

   Employee(String name, int age, Address address)
   {
      this.name = name;
      this.age = age;
      this.address = address;
   }

   @Override
   public Employee clone() throws CloneNotSupportedException
   {
      Employee e = (Employee) super.clone();
      e.address = address.clone();
      return e;
   }

   Address getAddress()
   {
      return address;
   }

   String getName()
   {
      return name;
   }

   int getAge()
   {
      return age;
   }
}

class Address
{
   private String city;

   Address(String city)
   {
      this.city = city;
   }

   @Override
   public Address clone()
   {
      return new Address(new String(city));
   }

   String getCity()
   {
      return city;
   }

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

public class CloneDemo
{
   public static void main(String[] args) throws CloneNotSupportedException
   {
      Employee e = new Employee("John Doe", 49, new Address("Denver"));
      System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(), 
                        e.getAddress().getCity());
      Employee e2 = (Employee) e.clone();
      System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(), 
                        e2.getAddress().getCity());
      e.getAddress().setCity("Chicago");
      System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(), 
                        e.getAddress().getCity());
      System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(), 
                        e2.getAddress().getCity());
   }
}

class Employee implements Cloneable

{

private String name;

private int age;

private Address address;

Employee(String name, int age, Address address)

{

this.name = name;

this.age = age;

this.address = address;

}

@Override

public Employee clone() throws CloneNotSupportedException

{

Employee e = (Employee) super.clone();

e.address = address.clone();

return e;

}

Address getAddress()

{

return address;

}

String getName()

{

return name;

}

int getAge()

{

return age;

}

class Address

{

private String city;

Address(String city)

{

this.city = city;

}

@Override

public Address clone()

{

return new Address(new String(city));

}

String getCity()

{

return city;

}

void setCity(String city)

{

this.city = city;

}

public class CloneDemo

{

public static void main(String[] args) throws CloneNotSupportedException

{

Employee e = new Employee("John Doe", 49, new Address("Denver"));

System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),

e.getAddress().getCity());

Employee e2 = (Employee) e.clone();

System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),

e2.getAddress().getCity());

e.getAddress().setCity("Chicago");

System.out.printf("%s: %d: %s%n", e.getName(), e.getAge(),

e.getAddress().getCity());

System.out.printf("%s: %d: %s%n", e2.getName(), e2.getAge(),

e2.getAddress().getCity());

}

Java支持协变返回类型，代码清单6利用这个特性，在Employee类中覆盖父类clone()方法时，将返回类型从Object类的对象改为Employee类型。这样做的好处就是，Employee类之外的代码可以不用将这个类转换为Employee类型就可以对其进行复制。

Employee类的clone()方法首先调用super().clone()，对name,age,address这些成员变量进行浅克隆。然后，调用成员变量Address对象的clone()来对其引用Address对象进行克隆。

从Address类中的clone()函数可以看出，这个clone()和我们之前写的clone()有些不同：

Address类没有实现Cloneable接口。因为只有在Object类中的clone()被调用时才需要实现，而Address是不会调用clone()的，所以没有实现Cloneable()的必要。
这个clone()函数没有声明抛出CloneNotSupportedException。这个检查异常只可能在调用Object类clone()的时候抛出。clone()是不会被调用的，因此这个异常也就没有被处理或者传回调用处的必要了。
Object类的clone()没有被调用(这里没有调用super.clone())。因为这不是对Address的对象进行浅克隆——只是一个成员变量复制而已。

为了克隆Address的对象，需要创建一个新的Address对象并对其成员进行初始化操作。最后将新创建的Address对象返回。

编译(javac CloneDemo.java)代码清单6并且运行这个程序，你将会看到如下输出结果(java CloneDemo)：

John Doe: 49: Denver
John Doe: 49: Denver
John Doe: 49: Chicago
John Doe: 49: Denver

John Doe: 49: Denver

John Doe: 49: Chicago

John Doe: 49: Denver

Q:如何克隆一个数组？

A:对数组类型进行浅克隆可以利用clone()方法。对数组使用clone()时，不必将clone()的返回值类型转换为数组类型，代码清单7示范了数组克隆。

class City {
    private String name;

    City(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    void setName(String name) {
        this.name = name;
    }
}

public class CloneDemo {
    public static void main(String[] args) {
        double[] temps = { 98.6, 32.0, 100.0, 212.0, 53.5 };
        for (double temp : temps)
            System.out.printf("%.1f ", temp);
        System.out.println();
        double[] temps2 = temps.clone();
        for (double temp : temps2)
            System.out.printf("%.1f ", temp);
        System.out.println();

        System.out.println();

        City[] cities = { new City("Denver"), new City("Chicago") };
        for (City city : cities)
            System.out.printf("%s ", city.getName());
        System.out.println();
        City[] cities2 = cities.clone();
        for (City city : cities2)
            System.out.printf("%s ", city.getName());
        System.out.println();

        cities[0].setName("Dallas");
        for (City city : cities2)
            System.out.printf("%s ", city.getName());
        System.out.println();
    }
}

class City {

private String name;

City(String name) {

this.name = name;

}

String getName() {

return name;

}

void setName(String name) {

this.name = name;

}

public class CloneDemo {

public static void main(String[] args) {

double[] temps = { 98.6, 32.0, 100.0, 212.0, 53.5 };

for (double temp : temps)

System.out.printf("%.1f ", temp);

System.out.println();

double[] temps2 = temps.clone();

for (double temp : temps2)

System.out.printf("%.1f ", temp);

System.out.println();

City[] cities = { new City("Denver"), new City("Chicago") };

for (City city : cities)

System.out.printf("%s ", city.getName());

System.out.println();

City[] cities2 = cities.clone();

for (City city : cities2)

System.out.printf("%s ", city.getName());

System.out.println();

cities[0].setName("Dallas");

for (City city : cities2)

System.out.printf("%s ", city.getName());

System.out.println();

}

代码清单7声明了一个City类存储名字，还有一些有关城市的数据(比如人口)。CloneDemo类提供了主函数main()来演示数组克隆。

main()函数首先声明了一个双精度浮点型数组来表示温度。在输出数组的值之后，克隆这个数组——注意没有运算符。之后，输出克隆的完全相同的数据。

紧接着，main()声明了一个City对象的数组，输出城市的名字，克隆这个数组，输出克隆的这个数组中城市的名字。为了证明浅克隆完成(比如，这两个数组引用了相同的City对象)，main()最后改变了原来的数组中第一个城市的名字，输出第二个数组中所有城市的名字。我们马上就可以看到，第二个数组中的名字也改变了。

编译 (javac CloneDemo.java)并运行 (java CloneDemo)代码清单7，你将会看到如下输出结果：

98.6 32.0 100.0 212.0 53.5 
98.6 32.0 100.0 212.0 53.5 

Denver Chicago 
Denver Chicago 
Dallas Chicago

98.6 32.0 100.0 212.0 53.5

Denver Chicago

Dallas Chicago

英文原文由Jeff Friesen首次发表在Java World，译文由赖信涛首次发表在Importnew。

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

Java 问答：终极父类（一）——clone()方法

上帝类

克隆`Object`类

相关文章:

“Java 问答：终极父类（一）——clone()方法”已经有2条评论

Leave a comment 取消回复

上帝类

克隆Object类

相关文章:

“Java 问答：终极父类（一）——clone()方法”已经有2条评论

Leave a comment 取消回复

克隆`Object`类