精华内容
下载资源
问答
  • 如何实现 java clone ?

    2018-12-17 11:34:34
    使用clone方法复制一个对象,clone对象拥有独立地址。 实现clone方式: @Data @ToString class Father implements Cloneable { //1.clone对象需要实现Cloneable接口 private String name; private int age; ...

    Java Clone

    使用clone方法复制一个对象,clone对象拥有独立的地址。

    实现clone的方式:

    @Data
    @ToString
    class Father implements Cloneable { //1.clone的对象需要实现Cloneable接口
        private String name;
        private int age;
    
        public Father(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException { //2.重写父类的clone()方法
            return super.clone();
        }
    }
    

    通常我们实现接口的时候会一并实现接口的方法,可是当我们 implements Cloneable 接口的时候,会发现Cloneable接口根本没有方法。

    Q:clone方法是从哪里来的?

    A:通过源码可以看到,clone()是基类Object的方法,所有对象默认继承Object,也就是说只要是对象就有clone方法。
    clone()源码
    那么,问题来了,既然基类有 clone() 方法,

    Q:为什么要实现 Cloneable 接口?

    A:从源码 clone() 注释可以看到,如果不实现 Cloneable 接口,则会抛出 CloneNotSupportedException 异常,那注释含义是否可以理解为,Cloneable 接口是作为可以clone对象的标识,标志着只有实现了Cloneable 接口的对象才可以克隆对象。

    Q:克隆对象跟引用对象的区别?

    A:
    引用对象:通过对象A赋值得到一个引用对象B,A和B指向的是同一个地址,所以当改变任意一个的值,另一个也会随着改变。
    克隆对象:A对象克隆一个对象B,A和B拥有独立的地址,任意改变一个值,另一个对象不会受影响。

    测试 clone() 对象:

    public class CloneTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            //引用对象
            Father a = new Father("a", 40); //初始化a对象
            Father b = a; //通过a赋值得到一个引用对象b
            b.setName("b"); //b对象改变name值为b
            System.out.println("a : " + a.toString() + " b : " + b.toString());
            //打印结果:a : Father(name=b, age=40)  b : Father(name=b, age=40)
            //通过结果发现,b对象改变name值,影响了a对象的name值,说明a和b指向同一地址
    
            //克隆对象
            a = new Father("a", 40); //初始化a对象
            b = (Father) a.clone(); //a克隆对象b
            b.setName("b"); //b对象改变name值为b
            System.out.println("a : " + a.toString() + " b : " + b.toString());
            //打印结果:a : Father(name=a, age=40)  b : Father(name=b, age=40)
            //通过结果发现,b对象改变name值,没有影响a对象,说明a和b拥有独立的地址
        }
    }
    
    

    Q:浅拷贝和深拷贝的区别?

    A:
    浅拷贝:对象无法clone包含的引用对象,clone() 默认浅拷贝。

    @Data
    @ToString
    class Father implements Cloneable {
        private String name;
        private int age;
        private Child child; //新增child
    
        public Father(String name, int age, Child child) {
            this.name = name;
            this.age = age;
            this.child = child;
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    @Data
    @ToString
    class Child {
        private String childName;
    
        public Child(String childName) {
            this.childName = childName;
        }
    }
    

    Father对象里面新增了一个Child对象。

    浅拷贝代码测试:

    public class CloneTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            Father a = new Father("a", 40, new Child("a.a"));
            Father b = (Father) a.clone();
            b.getChild().setChildName("b.b");
            System.out.println("a == b : " + (a == b));
            //打印结果:a == b : false
            //结果表明实现了Cloneable的Father对象,拥有不同的地址
            System.out.println("a.child == b.child : " + (a.getChild() == b.getChild()));
            //打印结果:a.child == b.child : true
            //结果表明未实现Cloneable的Father.Child对象,即使父类实现了Cloneable,但是Father.Child对象指向的是同一个地址
            System.out.println("a : " + a.toString() + " \nb : " + b.toString());
            //打印结果:a : Father(name=a, age=40, child=Child(childName=b.b)) 
    	   //		  b : Father(name=a, age=40, child=Child(childName=b.b))
            
        }
    }
    

    深拷贝:对象包含的引用对象同步clone。

    @Data
    @ToString
    class Father implements Cloneable {
        private String name;
        private int age;
        private Child child; //1.新增child
    
        public Father(String name, int age, Child child) {
            this.name = name;
            this.age = age;
            this.child = child;
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            Father father = (Father) super.clone();
            father.child = (Child) child.clone(); //3.Father接收Clone的Child对象
            return father;
        }
    }
    
    @Data
    @ToString
    class Child implements Cloneable { //2.Child实现Cloneable
        private String childName;
    
        public Child(String childName) {
            this.childName = childName;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    

    Child对象实现了Cloneable,Father对象里面新增了一个Child对象,Father继承的clone方法接收了clone对象。

    深拷贝代码测试:

    public class CloneTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            Father a = new Father("a", 40, new Child("a.a"));
            Father b = (Father) a.clone();
            b.getChild().setChildName("b.b");
            System.out.println("a == b : " + (a == b));
            //打印结果:a == b : false
            System.out.println("a.child == b.child : " + (a.getChild() == b.getChild()));
            //打印结果:a.child == b.child : false
            //结果表明Father.Child对象也被clone
            System.out.println("a : " + a.toString() + " \nb : " + b.toString());
        }
    }
    
    展开全文
  • 问题阐述在程序开发时,有时可能会遇到以下情况:已经存在一个对象A,现在...那么应该如何实现创建一个与A 对象完全相同B 对象,但是改变B对象属性值时A 对象属性值不变呢?专家解答要实现这一功能,可以使...

    问题阐述

    在程序开发时,有时可能会遇到以下情况:已经存在一个对象A,现在需要一个与A对象完全相同的B 对象,并对B 对象的属性值进行修改,但是A 对象原有的属性值不能改变。这时,如果使用Java 提供的对象赋值语句,当修改B 对象的属性值后,A 对象的属性值也将被修改。那么应该如何实现创建一个与A 对象完全相同的B 对象,但是改变B对象的属性值时A 对象的属性值不变呢?

    专家解答

    要实现这一功能,可以使用Object 类中的clone()方法。clone()方法可以用来完成对象的浅克隆。所谓浅克隆就是说被克隆的对象各个属性都是基本类型,而不是引用类型。如果存在引用类型的属性,则需要进行深克隆。下面对这两种克隆方式进行举例说明。

    1.浅克隆(1)编写Address 类,首先在该类中定义state(表示国家)、province(表示省)和city(表示市)3 个域,然后在构造方法中初始化这3 个域,并提供getter()和setter()方法用于获得和修改这3 个域,最后重写toString()方法方便输出该类的对象,代码如下:

    9dc91f616cae26799a690e37afd8533c.png

    (2)编写Employee 类,首先在该类中定义name(表示姓名)、age(表示年龄)和address(表示地址)3 个域,然后在构造方法中初始化这3 个域,并提供getter()和setter()方法用于获得和修改这3 个域,再重写toString()方法方便输出该类的对象,最后重写clone()方法来提供克隆的功能,代码如下:

    024d624d3e578b77122f63f7f472384f.png

    说明:

    在Java 5.0 以上版本中,支持重写方法时返回协变类型,因此可以返回Employee 对象。

    (3)编写类Test 进行测试,在该类中,首先创建address 对象并对其初始化,然后创建employee1 对象并对其初始化,再使用employee1 的克隆方法创建employee2 对象,并修改employee2 的address 属性,最后将两个employee 对象输出,代码如下:

    3c986c19dbd3fe6c9f39a9a5ec7ae0a3.png

    6ef3f2740ee76071cf8349702fe49668.png

    代码的运行结果如图7.7 所示。

    ad69b052c9de52470338b25bce780507.png

    说明:

    从图7.7 中可以看到,对于引用类型并没有克隆成功。

    2.深克隆(1)编写类Address1,在该类中首先定义state(表示国家)、province(表示省)和city(表示市)3 个域,然后在构造方法中初始化这3 个域,并提供了getter()和setter()方法用于获得和修改这3 个域,再重写toString()方法方便输出该类的对象,最后重写clone()方法提供克隆的功能,关键代码如下:

    572aa490cc98f9c8146dba8cbc5b3fb3.png

    f0eada715a4933036ce26f4addf26e1a.png

    说明:

    Address 类的域不是基本类型就是不可变类型,所以可以直接使用浅克隆。

    (2)编写Employee1 类,首先在该类中定义name(表示姓名)、age(表示年龄)和address(表示地址)3 个域,然后在构造方法中初始化这3 个域,并提供getter()和setter()方法用于获得和修改这3 个域,再重写toString()方法方便输出该类的对象,最后重写clone()方法来提供克隆的功能。代码如下:

    7a6fe61166a38179aadc6c0bae678273.png

    cb0e359af1db5746b2c63879eedb22ba.png

    (3)编写类Test1 进行测试,在该类中,首先创建了address 对象并对其进行初始化,然后创建employee1 对象并对其进行初始化,再使用employee1 的克隆方法创建employee2对象,并修改employee2 的address 属性,最后将两个employee 对象输出,代码如下:

    f6d85a69244c8b2ceab1814ba0194140.png

    上面代码的运行结果如图7.8 所示。

    c0a1499c1b241ebe75f01f11972c650c.png

    专家点评

    如果需要克隆的对象的域包含引用类型,则需要使用深克隆;反之,可以直接使用Object 类提供的clone()方法进行浅克隆。

    展开全文
  • java 对象的克隆一、对象的浅克隆(1)需要克隆类需要重写Object类的clone方法,并且实现Cloneable接口(标识接口,无需实现任何方法)(2)当需要克隆的对象中维护着另外一个引用对象,浅克隆不会克隆另外一个引用对下,...

    java 对象的克隆

    一、对象的浅克隆

    (1)需要克隆类需要重写Object类的clone方法,并且实现Cloneable接口(标识接口,无需实现任何方法)

    (2)当需要克隆的对象中维护着另外一个引用对象,浅克隆不会克隆另外一个引用对下,而是直接复制维护的另外一个引用对象的地址。

    (3)对象的浅克隆也不会调用到构造方法。

    以下为对象的浅克隆的一个例子:

    package com.clone;

    import java.io.Serializable;

    /**

    * Description:

    * 实现了Cloneable接口,并重写Object类的clone方法。

    *

    * @author lee

    * */

    public class CloneDemo1 implements Cloneable,Serializable{

    //该克隆类封装的信息

    public int id;

    public String name;

    public Address address;

    /**

    * Desciption:

    * 默认构造器

    *

    * */

    public CloneDemo1(){}

    /**

    * Description:

    * 初始化id,name的构造器

    *

    * @param id id

    * @param name 名字

    * @param address 地址

    * */

    public CloneDemo1(int id, String name, Address address){

    this.id=id;

    this.name=name;

    this.address = address;

    }

    /**

    * Descriptin:

    * 重写Object类的clone方法。

    * if the object's class does not support the Cloneable interface.

    * Subclasses that override the clone method can also throw this exception

    * to indicate that an instance cannot be cloned.

    *

    * @throws CloneNotSupportedException

    * */

    @Override

    public Object clone() throws CloneNotSupportedException{

    return super.clone();

    }

    /**

    * Description:

    * 重写toString方法

    *

    * @return "id="+id+", name="+name

    * */

    @Override

    public String toString(){

    return "id="+id+", name="+name+", address:"+address.getAddress();

    }

    /**

    * Description:

    * 主方法

    *

    * */

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

    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));

    //c2 复制了c1的地址,并没有复制整个c1对象

    CloneDemo1 c2 = c1;

    //c3 对象的浅克隆,复制了整个对象

    CloneDemo1 c3 = (CloneDemo1)c1.clone();

    //当对象c1改变其name或者id的时候,c2也会自动改变。

    //因为c2只是复制了c1的地址,并非复制了c1的整个对象。

    //相应的c3则不会随着c1改变而改变,意味着c3将c1整个对象克隆一份出来。

    //当是,对象的浅克隆不会克隆被克隆对象当中的引用对象。

    //因此c1改变其中的Address的引用对象时,c2,c3也会跟着改变。

    c1.setName("cc");

    c1.address.setAddress("上海");

    System.out.println(c1+"n"+c2+"n"+c3);

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    /**

    * Description:

    * 一个封装着地址的类

    *

    * @author lee

    * */

    class Address implements Serializable{

    public String address;

    /**

    * Description:

    * 默认构造器

    *

    * */

    public Address(){}

    /**

    * Description:

    * 初试化address

    *

    * @param address 地址

    * */

    public Address(String address){

    this.address = address;

    }

    //address的set和get方法

    public String getAddress() {

    return address;

    }

    public void setAddress(String address) {

    this.address = address;

    }

    }

    二、对象的深克隆

    就是利用对象的输入输出流把对象写到文件上,再读取对象的信息,这就是对象的深克隆。

    由于对象的浅克隆不会克隆被克隆对象其中的引用对象,而是直接复制其地址。因此,要克隆被克隆对象当中的引用类型则需要对象的深克隆。

    而对象的深克隆使用的的对象序列化输入输出。

    代码如下:

    package com.clone;

    import java.io.FileInputStream;

    import java.io.FileOutputStream;

    import java.io.IOException;

    import java.io.ObjectInputStream;

    import java.io.ObjectOutputStream;

    /**

    * Description:

    * 实现对象的深克隆

    *

    * @author lee

    * */

    public class CloneDemo2 {

    /**

    * Description:

    * 将对象输出到一个文件当中。

    *

    * @param c 需要被写到文件当中的对象。

    * */

    public static void writeObject(CloneDemo1 c){

    ObjectOutputStream out = null;

    try{

    //将对象输出在一个object.txt文件当中

    out = new ObjectOutputStream(new FileOutputStream("./object.txt"));

    out.writeObject(c);

    }catch(IOException e){

    System.out.println("写入对象的时候发生了错误。");

    e.printStackTrace();

    }finally{

    //关闭资源

    try{

    out.close();

    }catch(IOException e){

    e.printStackTrace();

    }

    }

    }

    /**

    * Description:

    * 从文件中读取出一个对象来,并返回。

    *

    * @return c 返回一个对象。

    * */

    public static CloneDemo1 readObject(){

    CloneDemo1 c = null;

    ObjectInputStream input = null;

    try{

    //从object.txt文件中读取一个对象出来

    input = new ObjectInputStream(new FileInputStream("./object.txt"));

    c = (CloneDemo1)input.readObject();

    }catch(IOException | ClassNotFoundException e){

    e.printStackTrace();

    System.out.println("读取对象的时候发生了错误。");

    }finally{

    //关闭资源

    try{

    input.close();

    }catch(IOException e){

    e.printStackTrace();

    }

    }

    return c;

    }

    /**

    * Description:

    * 主方法

    *

    * @throws CloneNotSupportedException

    * */

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

    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));

    //c2 对象的浅克隆

    CloneDemo1 c2 = (CloneDemo1)c1.clone();

    //c3对象的深克隆

    writeObject(c1);

    CloneDemo1 c3 = readObject();

    //因为对象的深克隆同时也克隆了被克隆对象维护的另外一个对象

    //所以,当c1改变其当中的维护的另外一个对象的时候,c3不会随之改变。

    //而c2位浅克隆,其维护的另外一个对象只是复制了c1维护的对象的地址,因此会随着c1的改变而改变。

    c1.address.setAddress("上海");

    System.out.println(c1+"n"+c2+"n"+c3);

    }

    }

    对象的序列化,是需要实现Serializable接口的。

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • JAVA的clone

    2018-11-01 15:53:13
    1.为什么要克隆? 这无非就是比较克隆对象与new...这种形式代码复制是引用,即对象在内存中地址,a和b对象仍然指向了同一个对象,而通过clone方法赋值对象跟原来对象时同时独立存在。 2.如何实现克...

    1.为什么要克隆?

    这无非就是比较克隆的对象与new的对象之间的区别,首先克隆的对象包含一些已经修改过的属性,而new出来的对象的属性都还是初始化时候的值;其次我们以前用过Object a=new Object();Object b=a;这种形式的代码复制的是引用,即对象在内存中的地址,a和b对象仍然指向了同一个对象,而通过clone方法赋值的对象跟原来的对象时同时独立存在的。

    2.如何实现克隆? 

    java的clone分为浅克隆和深克隆。而它们两者的主要区别在于 :是否支持引用类型的成员变量的复制。我们先来看浅克隆,浅克隆的一般步骤如下:

    1. 被复制的类需要实现Clonenable接口;
               2. 覆盖clone()方法,访问修饰符设为public,方法中调用super.clone()方法得到需要的复制对象。

    现在我们按照上面的步骤,写个Demo,代码如下:

    public class Student implements Cloneable{
        private int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    public class TestClone {
        public static void main(String[] args) throws CloneNotSupportedException {
            Student stu1=new Student();
            stu1.setAge(20);
            Student stu2=(Student) stu1.clone();
            stu2.setAge(10);
            Student stu3=stu1;
            System.out.println(stu1.getAge()+" "+stu2.getAge());
            stu3.setAge(18);
            System.out.println(stu1.getAge()+" "+stu3.getAge());
            System.out.println(stu1==stu2);
            System.out.println(stu3==stu1);
        }
    }
    

    运行上面的代码,结果如下:

    那我们在Student 类加个Pen类成员变量,看看浅克隆会不会复制引用类型的成员变量,代码如下:

    public class Pen {
        private int price;
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    }

    public class TestClone {
        public static void main(String[] args) throws CloneNotSupportedException {
            Student stu1=new Student();
            stu1.setPen(new Pen());
            stu1.getPen().setPrice(10);
            Student stu2=(Student) stu1.clone();
            stu2.getPen().setPrice(18);
            System.out.println(stu1.getPen().getPrice()+" "+stu2.getPen().getPrice());
        }
    }

    运行上面的代码,结果如下:

    从上面的结果可知,浅克隆不复制引用类型的成员变量,那我们来看下深克隆怎么解决这个问题,代码如下:

    public class Pen implements Cloneable{
        private int price;
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    

    再次运行代码,结果如下:

            

           从上面的结果可知,深克隆复制引用类型的成员变量 。如果引用类型里面又有许多引用类型,那实现深克隆比较麻烦,这时候可以序列化实现对象的深克隆(可以参考上篇的序列化文章)。

    展开全文
  • clone()是java.lang.Object类下面一个很难处理的方法clone()作用很简单,提供一种克隆机制创建对象副本,对于如何实现它已成为一个棘手事,同时还长期被广受批评。不管怎样,我们不去争论历史,现在我们将...
  • clone()是java.lang.Object类下面一个很难处理的方法clone()作用很简单,提供一种克隆机制创建对象副本,对于如何实现它已成为一个棘手事,同时还长期被广受批评。不管怎样,我们不去争论历史,现在我们将...
  • clone()是java.lang.Object类下面一个很难处理的方法clone()作用很简单,提供一种克隆机制创建对象副本,对于如何实现它已成为一个棘手事,同时还长期被广受批评。不管怎样,我们不去争论历史,现在我们将...
  • 下面我就不一步步测试给大家看了,我就直接贴出来正确的clone方法了。 首先,我们有这样一个子对象类Hand,自己实现了clone方法。 package tt.vo; public class Hand implements Cloneable { ...
  • 在选择是否原创时,我选择了原创,当然这些内容是我们高博...equals方法,在比较数据是否相同时,只能比较引用类型,所在Object类类中,equals方法实现,是比较内存直至,如果我们想要比较对象值,必须重写e...
  • 在程序开发中,有时可能好会遇到下列情况:已经存在一个对象A,现在需要一个与对象A完全相同的B对象,并对B对象的值进行修改,但是A对象的原有的属性值不能...要实现这一功能,可以使用Object类中的clone方法。cl...
  • 如何实现浅拷贝?Object类 是所有类直接或间接父类,Object中存在clone方法,如下protected native Object clone() throws CloneNotSupportedException;如果想要使一个类对象能够调用clone方法 ,则需要实现...
  • 1.首先,你要知道怎么实现克隆:实现Cloneable接口,在bean里面重写...这个也就是我们在没了解清楚这个Java的clone的时候,会出现的问题。看完代码,我再说明这个时候的问题。先看我要克隆的学生bean的代码:pac...
  • java为什么要 对象克隆:在程序开发时,有时可能会遇到以下情况:已经存在一个对象A,现在需要一个...那么应该如何实现创建一个与A 对象完全相同B 对象,但是改变B对象属性值时A 对象属性值不变呢?专家解答要...
  • Object类提供了protected关键字修饰的clone()方法,所有类都是Object类的子类,所以自定义类可以直接使用clone()方法拷贝一个初始状态和自己一样的对象。但是这样是存在局限性的。想想看Object类如何实现clone。它...
  • java为什么要 对象克隆: 在程序开发时,有时可能会遇到以下情况:已经存在一个对象A,现在需要一个与A对象...那么应该如何实现创建一个与A 对象完全相同B 对象,但是改变B对象属性值时A 对象属性值不变呢?...
  • Cloneable 接口的目的是作为对象的一个mixin接口,表明这样的对象允许克隆。但是他缺少clone方法,object的clone方法是受保护的。...那么如何实现一个行为良好的clone方法?如果一个类实现了cloneable,obje
  • 前言这也是昨天面试题。当时只说了深拷贝以及浅拷贝,面试官问了两遍还有吗,我很肯定说就这两种了,面试结束之后查了一下,啪啪打脸。正文JAVA实现克隆有两种形式...浅克隆实现实现Cloneable接口重写clone方法...
  • 创建对象的三种方式: 使用new创建对象 [将地址值存储到堆中,会出现OOM] 使用反射的方式创建对象 [不安全] 使用Object类中自带的clone方法如何使用clone呢?第一步在对象类中实现Cloneable接口 [标识符]第二步在对象类...
  • Java Clone研究

    2017-06-26 22:26:57
    1、Clone出处 Object中方法:protected nativeObject clone() throws ...(1)实现Cloneable接口(必须,否则调用clone方法报异常CloneNotSupportedException) (2)重写Object类的clone()方法,内部调用O
  • 更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题...
  • 此方法是实现克隆的唯一方法,所有类的对象只有调用此方法才可以进行克隆,但是此方法本身使用了protected权限,这样当不同的包产生对象是将无法调用object类中的clone方法,因此就需要子类来覆写clo...
  • 实现深克隆的方法有三种:一、重写clone方法,clone中嵌套clone这种...实际的操作上就是改写源对象的clone方法,在其内部嵌套克隆方法。首先让源对象调用克隆方法获得克隆的对象,然后获得被克隆对象的引用类型的...
  • [size=large]java对象复制[/size] [size=large]方式1:clone[/size] 所需操作:实现Cloneable接口,重写clone()方法如何调用:原对象.clone(); 得到复制对象 方式2:通过序列化 所需操作:需要实现...
  • 今天遇到一道面试题,询问深拷贝两种方法。主要就是clone方法和...clone方法例1:我们不妨建立一个Exam对象考试类Exam.java文件public class Exam implements Cloneable {private int examId;private String exa...
  • 一、为什么要使用clone? 主要应用于:实际开发中,A,B两个对象之间值拷贝,A为原对象,后面对B改动不会影响到A. 二、clone对象使用 1.复制对象和复制引用区别: ...clone方法是浅拷贝 ...
  • 3.类一代码:编写类一中具体代码其中有各种构造方法,和继承了克隆相关接口,重载了clone方法,代码如下:class Address implements Cloneable{private String state;private String province;private String ...
  • 1.为什么要用clone? 在实际编程过程中,我们常常要遇到这种情况: 有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能会需要一个和 A ...要满足这种需求虽然有很多途径,但实现clone()方法是其中最简单,...
  • 深入clone方法

    2010-12-06 13:12:44
    预备知识 为什么要clone Object...为了理解java的clone,有必要先温习以下的知识。 java的类型,java的类型分为两大类,一类为primitive,如int,另一类为引用类型,如String,Object等等。 java引用类型的存储,java...
  • 3、深拷贝还是浅拷贝,取决于如何重写Object的clone()方法。4、原对象和克隆对象的关系:深拷贝:阳关道和独木桥;浅拷贝:藕断丝连。上面的第二点解释一下,如果没有实现Cloneable就调用clone()方法,会抛出异常。...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 329
精华内容 131
关键字:

java的clone方法如何实现

java 订阅