Java高级特性：clone()方法

标签：ringbuf   his   硬件   throws   port   protect   序列化   ext   this   

源码

public class Objcet{
    protected native Object clone() throws CloneNotSupportedException();
}

由源码可知。

• 第一：Objcet类的clone()方法是一个native方法。native方法的执行效率一般远高于Java中的非native方法(一般不是java语言所写)。这也解释了为什么要用Object的clone()方法，而不是先new一个类，然后把原始对象复制到新对象中，虽然这样也能实现clone功能。(JNI是Java Native Interface的 缩写。从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java 虚拟机实现下。)
• 第二：Object类中的clone()方法被protected修饰符修饰。(关于protected修饰符见我的其它文章。)这意味着clone()方法只对java.util.lang包可见，和继承了Object类的子类可见。当然所有类都是继承了Object类。
  • 为什么要用protected修饰呢？
    为了安全，安全性从两方面考虑。首先我们要clone一个Employee对象，应该只有Employee类能够克隆Employee对象。使用protected修饰符保证了其它不相关的类无法克隆Employee对象。其次是Object对要复制的对象一无所知，它只会逐域进行复制，如果对象中的所有数据域都是数值或其他基本类型，拷贝这些域没有任何问题。但是如果对象包含子对象的引用，拷贝域就会得到相同子对象的另一个引用，这样原对象和克隆的对象还会共享一些信息。所以默认的拷贝都是浅拷贝。要想在任何地方都使用clone方法，我们必须将它改为public类型，并且实现Cloneable接口。如果一开始就是public，我们就分不清到底是浅拷贝还是深拷贝了。使用protected和Cloneable就约束了类设计者要了解自己的克隆过程。
    Cloneable接口是标记接口，它不包含任何需要实现的方法。如果一个对象请求克隆，但没有实现这个接口，就会产生一个受检查异常，因为clone方法默认实现中有使用instanceof进行接口判断。
    这里给出代码

//cloneTest.java
package com.testbase.clone;

public class cloneTest {
    public static void main(String[] args){
        // 虽然我们已经实现了Cloneable接口，不会产生异常
        // 但是编译器并不知道，会报错，所以这里要捕获异常
        try
        {
            Employee tobin = new Employee(30000);
            int salary = tobin.getSalary();
            System.out.println(salary);
            Employee shengsheng = tobin.clone();
            int shengSalary = shengsheng.getSalary();
            System.out.println(shengSalary);
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
    }
}
//Employee.java
package com.testbase.clone;

public class Employee implements Cloneable
{
    private int salary;
    public Employee()
    {

    }
    public Employee(int asalary)
    {
        salary = asalary;
    }
    @Override
    public Employee clone() throws CloneNotSupportedException
    {
        Employee cloned = (Employee) super.clone();
        return cloned;
    }

    public int getSalary() {
        return salary;
    }
}

• 第三：Object.clone()方法返回一个Object对象。我们必须进行强制转换才能得到我们需要的类型。（强制转换一定能成功吗？如果重写了clone方法一定成功。但是如果没有重写，不能转换。clone的是父类Object，无法向下造型，子类重写了clone方法，拷贝就是当前类的对象，暂时转为Object，还可以通过强制类型转换回来）
  给出一段错误代码。在Employee.java中拷贝是因为在其它类中拷贝一定不成功。因为Object类clone方法的protected特性。只有继承了它的子类和java.util.lang包可以调用clone()方法。所以选择在子类Employee中测试。

package com.testbase.clone;

public class Employee implements Cloneable
{
    private int salary;
    public Employee()
    {

    }
    public Employee(int asalary)
    {
        salary = asalary;
    }
//    @Override
//    public Employee clone() throws CloneNotSupportedException
//    {
//        Employee cloned = (Employee) super.clone();
//        return cloned;
//    }

    public int getSalary() {
        return salary;
    }

    public static void main(String[] args){
        try
        {
            Employee tobin = new Employee(30000);
            int salary = tobin.getSalary();
            System.out.println(salary);
            Object shengsheng = tobin.clone(); //这里不能强制类型转换
            int shengSalary = shengsheng.getSalary();//这里报错，因为Object没有getSalary方法
            System.out.println(shengSalary);
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
    }
}

深拷贝和浅拷贝

浅拷贝：拷贝引用，但是不拷贝引用指向的对象，对拷贝引用的对象进行修改，两份拷贝都会被修改。如果源对象和浅拷贝对象所共享的子对象都是不可变的，那么这种共享就是安全的。比如String类。或者在对象的生命周期内，子对象一直包含着不变的常量，没有更改器方法会改变它，也没有方法会生成它的引用，这种情况同样是安全的。
深拷贝：可能会更改的子对象也进行了拷贝。要进行深拷贝，需要一层层地重写clone方法。

• 数组是深拷贝。所有数组类型都有一个public的clone()方法，可以用这个方法建立一个新数组。

int[] a = {1,2,3,4};
int[] cloned = a.clone();
cloned[0]=11;

对象串行化实现拷贝

常见面试题

1.为什么进行拷贝

• 因为我们某个对象实例现在需要保存一些有效值，我们希望生成一个和原来一样的对象，对这个对象的修改不改变原对象的属性。

2.深拷贝和浅拷贝的区别

• 浅拷贝对基本数据类型生成一份新的拷贝，对引用类型，只是复制了引用，引用所指向的那块内存空间并没有拷贝
• 深拷贝对引用指向的那块内存空间也拷贝了一份(新内存空间)。换言之深拷贝要把复制的对象所引用的对象也都拷贝了一遍。

3.String克隆的特殊性在那里？StringBuffer和StringBuilder呢?

• 对基本数据类型都能自动实现深拷贝。而对引用类型是浅拷贝。String是引用类型的特例。因为String是不允许修改的。所以相当于进行了深拷贝，是安全的。由于String是不可变类，对String类中的很多修改操作都是通过new对象复制处理的。所以当我们修改clone前后对象里面String属性的值时，实际上就指向了新的内存空间。自然对clone前的源对象没有影响，类似于深拷贝。虽然它是引用类型，但是不影响我们深拷贝的使用。
  而对于StringBuffer和StringBuilder，需要主动进行clone重写。否则就是浅拷贝。

4.实现对象克隆的常见方式有哪些，具体怎么做？
常用的方式有三种。

• 通过自己写一个clone方法，new一个同样的对象，赋值实现深度克隆，繁琐容易出错。
• 通过实现Cloneable接口并重写Object类的clone方法，分为深浅两种方式。
• 通过Serializable接口并用对象的序列化和反序列化来实现真正的深拷贝。

代码，主要是第2和第3个方法。
通过实现 Cloneable 接口并重写 Object 类的 clone() 方法实现浅克隆做法：Object 类中 clone 方法的默认实现最终是一个 native 方法（如果 clone 类没有实现 Cloneable 接口并调用了 Object 的 clone 方法就会抛出 CloneNotSupportedException 异常，因为 clone 方法默认实现中有使用 instanceof 进行接口判断），相对来说效率高些，默认实现是先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容，对基本数据类型就是值复制，而对非基本类型变量保存的仅仅是对象的引用，所以会导致 clone 后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。
浅拷贝。

class Employee implements Clonealbe{
    public Employee clone() throws CloneNotSupportedException
    {
        return (Employee) super.clone();
    }        
}

深拷贝

class Employee implements Clonealbe{
    public Employee clone() throws CloneNotSupportedException
    {
        Employee cloned = (Employee) super.clone();
        cloned.hireDay = (Date) hireDay.clone();
        return cloned();
    }        
}

通过Serializable接口并用对象的序列化和反序列化来实现真正的深拷贝。(还未学到)

class CloneUtil {  
   public static <T extends Serializable> T clone(T obj) {  
       T cloneObj = null;
       try {
           ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
           ObjectOutputStream objOut = new ObjectOutputStream(byteOut);
           objOut.writeObject(obj);  
           objOut.close();  
           ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray()); 
           ObjectInputStream objIn = new ObjectInputStream(byteIn);  
           cloneObj = (T) objIn.readObject();  
           objIn.close();
       } catch (IOException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }  
       return cloneObj;  
   }
}
 
 
class InfoBean implements Serializable {  
   public String name;
   public int age;
}
 
 
class PeopleBean implements Serializable {  
   public String vipId;
   public InfoBean infoBean;
 
   public Object clone() {
       return CloneUtil.clone(this);
   }  
}

参考文章：
https://www.cnblogs.com/gw811/archive/2012/10/07/2712252.html
https://blog.csdn.net/qq_26857649/article/details/84316081

Java高级特性：clone()方法

标签：ringbuf   his   硬件   throws   port   protect   序列化   ext   this   

原文地址：https://www.cnblogs.com/zuotongbin/p/11723346.html