浅克隆、深克隆

最新推荐文章于 2022-02-15 13:51:33 发布
最新推荐文章于 2022-02-15 13:51:33 发布
阅读量246 收藏
点赞数
分类专栏： java 文章标签： 对象 浅克隆 深克隆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23038639/article/details/63252328
版权

// ———-1、直接复制对象 ———–


package ninthTestModel;

/*
 * 浅克隆
 * 深克隆
 * 序列化。
 * 区别在于对象有引用对象的时候 一个是指向同一个引用对象 一个是指向不同对象
 */

/*
 *      
 *   【浅克隆】，通常只是对克隆的实例进行复制，但里面的其他子对象，都是共用的。
   *  　【深克隆】，克隆的时候会复制它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。
 * 
 */


// 周报
class WeekdayInformation{
    public String strInformation;   // 事件
    public String strTime;          // 时间
    public String strLocation;      // 地点

    public String getStrInformation() {
        return strInformation;
    }
    public String getStrTime() {
        return strTime;
    }
    public String getStrLocation() {
        return strLocation;
    }
    public void setStrInformation(String strInformation) {
        this.strInformation = strInformation;
    }
    public void setStrTime(String strTime) {
        this.strTime = strTime;
    }
    public void setStrLocation(String strLocation) {
        this.strLocation = strLocation;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub



        return "事件："+strInformation+"\t时间："+strTime+"\t地点："+strLocation;
    }
}


public class CloneModel {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WeekdayInformation weekdayInformation=new WeekdayInformation();
        weekdayInformation.setStrInformation("吃饭");
        weekdayInformation.setStrTime("周一");
        weekdayInformation.setStrLocation("食堂");
        System.out.println(weekdayInformation.toString()); // ninthTestModel.WeekdayInformation@2a139a55

        WeekdayInformation week2=weekdayInformation;
        System.out.println(week2.toString());

        System.out.println("***********************");

        /*
         * weekdayInformation修改信息 则week2的信息也修改
         */
        System.out.println("weekdayInformation修改了信息：");
        weekdayInformation.setStrTime("周二");
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

        System.out.println("***********************");


        /*
         * week2修改信息 则weekdayInformation的信息也修改
         */
        System.out.println("week2修改了信息：");
        week2.setStrTime("周一");
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

    }
}

/*
结果如下：

事件：吃饭   时间：周一   地点：食堂
事件：吃饭   时间：周一   地点：食堂
***********************
weekdayInformation修改了信息：
事件：吃饭   时间：周二   地点：食堂
事件：吃饭   时间：周二   地点：食堂
***********************
week2修改了信息：
事件：吃饭   时间：周一   地点：食堂
事件：吃饭   时间：周一   地点：食堂

*/

// ——–2、浅克隆 里面没有引用对象—

package ninthTestModel;

/*
 * 浅克隆
 * 深克隆
 * 序列化。
 * 区别在于对象有引用对象的时候 一个是指向同一个引用对象 一个是指向不同对象
 */

/*
 *      
 *   【浅克隆】，通常只是对克隆的实例进行复制，但里面的其他子对象，都是共用的。
   *  　【深克隆】，克隆的时候会复制它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。
 * 
 */

// 周报
class WeekdayInformation implements Cloneable{
    public String strInformation;   // 事件
    public String strTime;          // 时间
    public String strLocation;      // 地点

    public String getStrInformation() {
        return strInformation;
    }
    public String getStrTime() {
        return strTime;
    }
    public String getStrLocation() {
        return strLocation;
    }
    public void setStrInformation(String strInformation) {
        this.strInformation = strInformation;
    }
    public void setStrTime(String strTime) {
        this.strTime = strTime;
    }
    public void setStrLocation(String strLocation) {
        this.strLocation = strLocation;
    }

    // 浅克隆
    @Override
    protected WeekdayInformation clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
            Object object=null;

            object=super.clone();
            System.out.println("浅克隆");
            return (WeekdayInformation) object;

            // TODO Auto-generated catch block






    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "事件："+strInformation+"\t时间："+strTime+"\t地点："+strLocation;
    }
}


public class CloneModel {

    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        WeekdayInformation weekdayInformation=new WeekdayInformation();
        weekdayInformation.setStrInformation("吃饭");
        weekdayInformation.setStrTime("周一");
        weekdayInformation.setStrLocation("食堂");
        System.out.println(weekdayInformation.toString()); // ninthTestModel.WeekdayInformation@2a139a55

        WeekdayInformation week2=weekdayInformation.clone();
        System.out.println(week2.toString());

        System.out.println("***********************");

        /*
         * weekdayInformation修改信息 则week2的信息也修改
         */
        System.out.println("weekdayInformation修改了信息：");
        weekdayInformation.setStrTime("周二。");
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

        System.out.println("***********************");


        /*
         * week2修改信息 则weekdayInformation的信息也修改
         */
        System.out.println("week2修改了信息：");
        week2.setStrTime("周三。");
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

    }

}

结果如下：
/*
    事件：吃饭   时间：周一   地点：食堂
    浅克隆
    事件：吃饭   时间：周一   地点：食堂
    ***********************
    weekdayInformation修改了信息：
    事件：吃饭   时间：周二。  地点：食堂
    事件：吃饭   时间：周一   地点：食堂
    ***********************
    week2修改了信息：
    事件：吃饭   时间：周二。  地点：食堂
    事件：吃饭   时间：周三。  地点：食堂
*/

// ———-3、浅克隆 里面有被引用对象


package ninthTestModel;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.io.Serializable;

import sixTestOop.TestEighthToString;

/*
 * 浅克隆
 * 深克隆
 * 序列化。
 * 区别在于对象有引用对象的时候 一个是指向同一个引用对象 一个是指向不同对象
 */

/*
 *      
 *   【浅克隆】，通常只是对克隆的实例进行复制，但里面的其他子对象，都是共用的。
   *  　【深克隆】，克隆的时候会复制它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。
 *      注：！序列化问题 因为使用了序列化方法实现深克隆 因此类需要继承Serializable 引用类也需要继承
 */

class TestClone implements Serializable{
    public String testString;
    public void setTestString(String testString) {
        this.testString = testString;
    }
    public String getTestString() {
        return testString;
    }

}

// 周报
class WeekdayInformation implements Cloneable,Serializable{
    public String strInformation;   // 事件
    public String strTime;          // 时间
    public String strLocation;      // 地点
    public TestClone strClone;      // 被引用对象 


    public String getStrInformation() {
        return strInformation;
    }
    public String getStrTime() {
        return strTime;
    }
    public String getStrLocation() {
        return strLocation;
    }
    public TestClone getStrClone() {
        return strClone;
    }

    public void setStrInformation(String strInformation) {
        this.strInformation = strInformation;
    }
    public void setStrTime(String strTime) {
        this.strTime = strTime;
    }
    public void setStrLocation(String strLocation) {
        this.strLocation = strLocation;
    }
    public void setStrClone(TestClone strClone) {
        this.strClone = strClone;
    }

    // 浅克隆

    @Override
    protected WeekdayInformation clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        Object object=null;

        object=super.clone();
        System.out.println("浅克隆");
        return (WeekdayInformation) object;

    }



    // 深克隆
    public WeekdayInformation deepClone() throws IOException, ClassNotFoundException,OptionalDataException {
        System.out.println("******深克隆*********\n");

        WeekdayInformation weekdayInformation=null;

        // -- 将对象写入流中
        ByteArrayOutputStream bao=new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);
        oos.writeObject(this);
        oos.close();

        // -- 将对象从流中取出
        ByteArrayInputStream bis=new ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(bis);
        weekdayInformation=(WeekdayInformation) ois.readObject();
        ois.close();


        return weekdayInformation;

    }




    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "事件："+strInformation+"\t时间："+strTime+"\t地点："+strLocation+"\t测试："+strClone.getTestString();
    }
}


public class CloneModel {

    public static void main(String[] args) throws CloneNotSupportedException, OptionalDataException, ClassNotFoundException, IOException {
        // TODO Auto-generated method stub
        WeekdayInformation weekdayInformation=new WeekdayInformation();
        TestClone testClone=new TestClone();
        testClone.setTestString("test");
        weekdayInformation.setStrInformation("吃饭");
        weekdayInformation.setStrTime("周一");
        weekdayInformation.setStrLocation("食堂");
        weekdayInformation.setStrClone(testClone);
        System.out.println(weekdayInformation.toString()); //如果没重写toString()方法显示： ninthTestModel.WeekdayInformation@2a139a55


        WeekdayInformation  week2 = weekdayInformation.clone();

        System.out.println("克隆信息如下："+week2+"\n");



        System.out.println("克隆对象是否相同："+(weekdayInformation==week2));//

        //?? 为什么两个都相同了？? 因为指向的同一个对象
        System.out.println("被引用对象TestClone是否相同:"+(weekdayInformation.getStrClone()==week2.getStrClone())); //相同？ --相同
        System.out.println("基本对象String是否相同:"+(weekdayInformation.getStrInformation()==week2.getStrInformation())); //相同？ -- 相同
        System.out.println("***********\n");

        System.out.println(week2.toString());

        System.out.println("***********************");

        /*
         * weekdayInformation修改信息 则week2的信息也修改
         */
        TestClone testClone1=new TestClone();
        testClone1.setTestString("test1");

        System.out.println("weekdayInformation修改了信息：");
        weekdayInformation.setStrTime("周二");
        weekdayInformation.setStrClone(testClone1); 
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

        System.out.println("***********************");


        /*
         * week2修改信息 则weekdayInformation的信息也修改
         */
        TestClone testClone2=new TestClone();
        testClone2.setTestString("test2");
        System.out.println("week2修改了信息：");
        week2.setStrTime("周三");
        week2.setStrClone(testClone2);  
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

    }

}
/*
输出结果如下：

    事件：吃饭   时间：周一   地点：食堂   测试：test
    浅克隆
    克隆信息如下：事件：吃饭    时间：周一   地点：食堂   测试：test

    克隆对象是否相同：false
    被引用对象TestClone是否相同:true
    基本对象String是否相同:true
    ***********

    事件：吃饭   时间：周一   地点：食堂   测试：test
    ***********************
    weekdayInformation修改了信息：
    事件：吃饭   时间：周二   地点：食堂   测试：test1
    事件：吃饭   时间：周一   地点：食堂   测试：test
    ***********************
    week2修改了信息：
    事件：吃饭   时间：周二   地点：食堂   测试：test1
    事件：吃饭   时间：周三   地点：食堂   测试：test2


*/

// ———–4、深克隆 里面有被引用对象———-

package ninthTestModel;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import sixTestOop.TestEighthToString;

/*
 * 浅克隆
 * 深克隆
 * 序列化。
 * 区别在于对象有引用对象的时候 一个是指向同一个引用对象 一个是指向不同对象
 */

/*
 *      
 *   【浅克隆】，通常只是对克隆的实例进行复制，但里面的其他子对象，都是共用的。
   *  　【深克隆】，克隆的时候会复制它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。
 * 
 */

class TestClone{
    public String testString;
    public void setTestString(String testString) {
        this.testString = testString;
    }
    public String getTestString() {
        return testString;
    }

}

// 周报
class WeekdayInformation implements Cloneable{
    public String strInformation;   // 事件
    public String strTime;          // 时间
    public String strLocation;      // 地点
    public TestClone strClone;      // 被引用对象 


    public String getStrInformation() {
        return strInformation;
    }
    public String getStrTime() {
        return strTime;
    }
    public String getStrLocation() {
        return strLocation;
    }
    public TestClone getStrClone() {
        return strClone;
    }

    public void setStrInformation(String strInformation) {
        this.strInformation = strInformation;
    }
    public void setStrTime(String strTime) {
        this.strTime = strTime;
    }
    public void setStrLocation(String strLocation) {
        this.strLocation = strLocation;
    }
    public void setStrClone(TestClone strClone) {
        this.strClone = strClone;
    }

    // 浅克隆

    @Override
    protected WeekdayInformation clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        Object object=null;

        object=super.clone();
        System.out.println("浅克隆");
        return (WeekdayInformation) object;

    }



    // 深克隆
    public WeekdayInformation deepClone() throws IOException, ClassNotFoundException {
        // -- 将对象写入流中
        ByteArrayOutputStream bao=new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);
        oos.writeObject(this);

        // -- 将对象从流中取出
        ByteArrayInputStream bis=new ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(bis);

        return (WeekdayInformation) ois.readObject();


    }




    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "事件："+strInformation+"\t时间："+strTime+"\t地点："+strLocation+"\t测试："+strClone.getTestString();
    }
}


public class CloneModel {

    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        WeekdayInformation weekdayInformation=new WeekdayInformation();
        TestClone testClone=new TestClone();
        testClone.setTestString("test");
        weekdayInformation.setStrInformation("吃饭");
        weekdayInformation.setStrTime("周一");
        weekdayInformation.setStrLocation("食堂");
        weekdayInformation.setStrClone(testClone);
        System.out.println(weekdayInformation.toString()); // 如果没有重写toString()方法会显示：ninthTestModel.WeekdayInformation@2a139a55

        WeekdayInformation week2=weekdayInformation.deepClone();// 这里调用深克隆实现
        System.out.println("被引用对象是否相同:"+(weekdayInformation.getStrClone()==week2.getStrClone())); //相同？ 不同 
        System.out.println("是否相同:"+(weekdayInformation.getStrInformation()==week2.getStrInformation())); //相同？ 不同

        System.out.println(week2.toString());

        System.out.println("***********************");

        /*
         * weekdayInformation修改信息 则week2的信息也修改
         */
        TestClone testClone1=new TestClone();
        testClone1.setTestString("test1");

        System.out.println("weekdayInformation修改了信息：");
        weekdayInformation.setStrTime("周二");
        weekdayInformation.setStrClone(testClone1); 
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());


        System.out.println("***********************");


        /*
         * week2修改信息 则weekdayInformation的信息也修改
         */
        TestClone testClone2=new TestClone();
        testClone2.setTestString("test2");
        System.out.println("week2修改了信息：");
        week2.setStrTime("周三");
        week2.setStrClone(testClone2);  
        System.out.println(weekdayInformation.toString());
        System.out.println(week2.toString());

    }

}
/*      
输出结果如下：

        事件：吃饭   时间：周一   地点：食堂   测试：test
        浅克隆
        克隆信息如下：事件：吃饭    时间：周一   地点：食堂   测试：test

        克隆对象是否相同：false
        被引用对象TestClone是否相同:true
        基本对象String是否相同:true
        ***********

        事件：吃饭   时间：周一   地点：食堂   测试：test
        ***********************
        weekdayInformation修改了信息：
        事件：吃饭   时间：周二   地点：食堂   测试：test1
        事件：吃饭   时间：周一   地点：食堂   测试：test
        ***********************
        week2修改了信息：
        事件：吃饭   时间：周二   地点：食堂   测试：test1
        事件：吃饭   时间：周三   地点：食堂   测试：test2

*/
自我理解：

对象一 对象二=对象一的复制/浅克隆/深克隆

复制：对象一=对象二 二者完全值得同一个 如果对象一修改 对象二则跟着修改

浅克隆:对象一、二不同，但是对于被引用对象指向的会是同一个对象，

深克隆：对象一、二不同，是完全的创建出了一个新的对象,
对于被引用对象也不同,如这里我所用到的引用对象testClone。

问题：

但是有个问题我没搞懂，浅克隆的时候为什么String类型的对象也指向的同一个?

也就是在例子三中

被引用对象TestClone是否相同:true //–这个应该是true

基本对象String是否相同:true //– 这个不应该是false嘛？怎么回事true

源码：

System.out.println("被引用对象TestClone是否相同:"+(weekdayInformation.getStrClone()==week2.getStrClone())); //相同？
System.out.println("基本对象String是否相同:"+(weekdayInformation.getStrInformation()==week2.getStrInformation())); //相同？

– 以上如果有错，欢迎指出。

hao_小子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实例分析java对象中浅克隆和深克隆
08-26
在本篇文章中我们给大家分享了关于java对象中浅克隆和深克隆的相关知识点和相关代码内容，有兴趣的朋友们学习下。
java 深克隆 浅克隆
11-28
java 深克隆 浅克隆
java的浅克隆_java 浅克隆 深克隆
weixin_36384964的博客
02-25 226
对象的克隆是java的一项高级技术，他可以根据给定的对象，获得与其完全相同的另一个对象。1.浅克隆主要是复制对象的值2.深克隆：当类存在聚合关系的时候，克隆就必须考虑聚合对象的克隆，可以复制引用类型的字段。一、常见的错误：Employee 类package text1;public classEmployee {privateString name;publicString getName() {...
java中浅克隆与深克隆解析
1+1=王的博客
12-10 3704
文章目录简介浅克隆深克隆嵌套使用clone()方法序列化方式浅克隆和深克隆的比较 简介 所谓克隆，就是指依照已存在的数据，复制出一份一样的数据。 java中的克隆有浅克隆和深克隆之分，造成这种区别是因为java中对于基本数据类型和引用类型类型的存储是不一样的，基本数据类型存储在栈中，而引用数据类型存储在堆中，因此造成了在克隆时的不同操作。 实现克隆的方法可以按照三步进行： 实现Clonable接口； 重写clone()方法。 调用clone()方法克隆对象。 浅克隆 package test; imp
浅克隆和深克隆
ChineseSoftware的博客
02-15 4066
一、浅克隆(ShallowClone) 在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。 简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。 二、深克隆(DeepClone) 在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对
Java浅克隆深克隆
林竹清_清清清
06-14 376
1． ⑴浅复制（浅克隆） 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 ⑵深复制（深克隆） 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用
深克隆和浅克隆
qq_44236958的博客
06-02 187
深克隆和浅克隆区别?实现的方式有? 感谢拉勾教育 文章目录深克隆和浅克隆区别?实现的方式有?浅克隆深克隆考点java.lang.Object 中对 clone() 方法的约定有哪些？Arrays.copyOf()深克隆实现方式汇总克隆设计理念猜想 浅克隆 是把原型对象中成员变量为值类型的属性都复制给克隆对象,把原型对象中成员变量为引用类型的引用地址也复制给克隆对象,也就是原型对象中如果有成员变量为引用对象，则此引用对象的地址是共享给原型对象和克隆对象的。 简单来说就是浅克隆只会复制原型对象，但不会复制它
java 深克隆与浅克隆
09-11
学习java深克隆与浅克隆，希望对你有用
java 对象的克隆（浅克隆和深克隆）
08-29
主要介绍了java 对象的克隆的相关资料,这里对浅克隆和深克隆进行了实例分析需要的朋友可以参考下
Java浅克隆与深克隆
12-22
浅克隆： package testclone; public class ShallowClone implements Cloneable { public String name; public String[] name2; public ShallowClone() { name2 = new String[2]; } public Object clone() {...
2024-2030全球与中国低脂凝乳奶酪市场现状及未来发展趋势.docx
04-30
2024-2030全球与中国低脂凝乳奶酪市场现状及未来发展趋势
毕业设计：vue+springboot乌鲁木齐南山冰雪旅游服务网站（源码 + 数据库 + 说明文档）
04-30
毕业设计：vue+springboot乌鲁木齐南山冰雪旅游服务网站（源码 + 数据库 + 说明文档） 2 开发工具及技术 2 2.1 B/S结构的介绍 2 2.2 JSP及SpringBoot技术的介绍 2 2.3 HTML及Vue技术的介绍 2 2.4 MYSQL数据库的介绍 3 2.5 开发环境的介绍 3 3 需求分析 4 3.1 可行性分析 4 3.2 功能需求分析 4 3.3 非功能需求分析 4 4 总体设计 6 4.1 系统总体结构设计 6 4.2 系统的数据库设计 6 5 系统功能实现 6 5.1 注册用户 6 5.2 管理员用户 6 6 系统测试 6 6.1 测试目的 6 6.2 测试内容 6 6.3 测试总结 6
C# 超简单的离线人脸识别库 ( 基于 SeetaFace6 ).zip
04-30
c
华为数字化转型实践28个精华问答.docx
04-30
华为数字化转型实践28个精华问答.docx
2024年全球二极管阵列光谱仪行业总体规模、主要企业国内外市场占有率及排名.docx
04-30
2024年全球二极管阵列光谱仪行业总体规模、主要企业国内外市场占有率及排名
基于AT89C51单片机的温度上下限自动控制检报警设计.zip-06
04-30
基于51单片机的温度检测调节系统 由STC89C51单片机+液晶1602显示+DS18B20温度传感器+继电器+报警模块构成 具体功能： 1、采用DS18B20温度传感器测温并用LCD1602显示； 2、按键为设置按键、加键和减键。可设置上下限温度控制范围； 3、当温度超过设定的上或下限时，相应的指示灯亮，同时相应的继电器吸合，继电器可以驱动负载工作； 4、温度测量范围0到99.9摄氏度，精度为0.1摄氏度。
2024年中国高量子效率传感器行业研究报告.docx
04-30
2024年中国高量子效率传感器行业研究报告
基于C++14语法的任务链.zip
04-30
基于C++14语法的任务链.zip
企业级业务架构设计方法论qy.pptx
最新发布
04-30
企业级业务架构设计方法论qy.pptx
java深克隆和浅克隆
05-10
在 Java 中，对象的克隆分为深克隆和浅克隆两种方式。 浅克隆是指将对象复制一份，但仅复制对象本身和其中的基本类型数据，而不复制对象中的引用类型数据。这意味着，如果原对象中有引用类型的数据，那么复制出来的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值