精华内容
下载资源
问答
  • 1.介绍Java 中的拷贝构造方法是一种使用该类的一个对象构造另外一个对象的构造方法。当需要拷贝一个带有多个成员变量的复杂对象或者想构造已存在对象的深拷贝对象时非常有用。译者注:本文内容很简单,但是很实用。...

    1.介绍

    Java 中的拷贝构造方法是一种使用该类的一个对象构造另外一个对象的构造方法。

    当需要拷贝一个带有多个成员变量的复杂对象或者想构造已存在对象的深拷贝对象时非常有用。

    译者注:本文内容很简单,但是很实用。拷贝构造方法实战中用虽然用的不多,但是是一个非常不错的技巧。

    2.如何创造拷贝构造方法

    要创建拷贝构造方法,首先需要声明带有和本类相同类型的参数构造函数:

    public class Employee {

    private int id;

    private String name;

    public Employee(Employee employee) {

    }

    }

    然后,将参数对象的每个属性都复制给新的实例。

    public class Employee {

    private int id;

    private String name;

    public Employee(Employee employee) {

    this.id = employee.id;

    this.name = employee.name;

    }

    }

    上面的做法属于浅拷贝。

    上面定义的属性不是int 就是 String, 只包含基本类型和不可变类型,因此使用前拷贝就没问题。

    但是如果类中包含可变类型就要通过该构造函数实现深拷贝。

    为了实现深拷贝,我们需要根据原始可变对象类型构造新的实例。

    public class Employee {

    private int id;

    private String name;

    private Date startDate;

    public Employee(Employee employee) {

    this.id = employee.id;

    this.name = employee.name;

    this.startDate = new Date(employee.startDate.getTime());

    }

    }

    3.拷贝构造方法 VS Clone

    在 Java 中,我们还可以使用 clone 方法实现根据已有对象创建新对象。

    但是拷贝构造方法更有优势:

    拷贝构造方法实现更简单。不需要实现 Cloneable 接口,也不需要处理 CloneNotSupportedException

    clone 函数返回一个普通的 Object 类型的引用。还需要转成特定的类型。

    在 clone 方法中不能为 final 属性赋值,但是在拷贝构造方法中就可以。

    4.继承问题

    Java 中的拷贝构造方法不会被子类继承。

    因此,如果我们尝试初始化一个带有父类引用的子类对象,就会面临着类型转换问题。

    为了更好地说明这个问题,我们首先创建 Employee的子类型和拷贝构造方法。

    public class Manager extends Employee {

    private List directReports;

    // ... 其他构造方法

    public Manager(Manager manager) {

    super(manager.id, manager.name, manager.startDate);

    this.directReports = directReports.stream()

    .collect(Collectors.toList());

    }

    }

    然后,我们声明一个 Employee 类型的引用指向通过 Manager 构造方法构造的 Manager 实例。

    Employee source = new Manager(1, "Baeldung Manager", startDate, directReports);

    由于引用类型为 Employee, 如果我们想使用 Manager 的拷贝构造函数就必须将 source 强转为 Manager 类型。

    Employee clone = new Manager((Manager) source);

    如果参数不是 Manager 类型,运行时会抛出 ClassCastException。

    其中一种避免使用拷贝构造方法时类型转换的方法是创建一个继承的拷贝函数:

    public class Employee {

    public Employee copy() {

    return new Employee(this);

    }

    }

    public class Manager extends Employee {

    @Override

    public Employee copy() {

    return new Manager(this);

    }

    }

    在每个类的拷贝函数中调用自己类型的拷贝构造函数即可。

    这样就保证了生成的对象和调用的对象类型相同。

    Employee clone = source.copy();

    5.结论

    本文介绍了拷贝构造方法,给出了避免使用 clone 函数的原因。

    如果引用类型为父类型而实际对象类型为子类型时,使用子类型的拷贝构造函数需要将父类型强制类型转换为子类型,容易出现转换问题。本文也针对这个问题提供了解决方案。

    如果你觉得本文对你有帮助,欢迎点赞、转发、评论,你的支持是我创作的最大动力。

    另外想学习,更多开发和避坑技巧,少走弯路,请关注我的专栏:《阿里巴巴Java 开发手册》详解专栏

    展开全文
  • java拷贝构造函数

    2016-08-15 09:47:00
    浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。...如果支持拷贝构造函数的类型,则是深拷贝 不支持 自定义类型 浅拷贝 取决于实现 取决于实现 ...

    浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。

    深拷贝就是两个对象的值相等,但是互相独立。

    构造函数的参数是该类的一个实例。

      Operator = 拷贝构造函数 clone方法
    预定义非集合类型 深拷贝 如果支持拷贝构造函数的类型,则是深拷贝 不支持
    自定义类型 浅拷贝 取决于实现 取决于实现
    预定义集合类型 浅拷贝 会逐个调用每个元素的operator=方法
    会逐个调用每个元素的operator=方法

    转载于:https://www.cnblogs.com/newcoder/p/5771840.html

    展开全文
  • java中执行这个语句,只是开辟了一块内存空间,并没初始化和赋值对象, 必须用new关键字,来进行初始化和赋值 ———————————————— 版权声明:本文为CSDN博主「鱼包子Ray」的原创文章,遵循 CC ...
  • 复制(克隆) :被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,复制把要复制的...

    浅复制(浅克隆) :被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。

    深复制(深克隆) :被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍。

     

     1 package com.itinfo;
     2 
     3 /**
     4  * 测试实体类
     5  *
     6  * @author Wáng Chéng Dá
     7  * @create 2017-02-24 10:41
     8  */
     9 public class PersonT {
    10 
    11     private String name;
    12 
    13     private int age;
    14 
    15     private String sex;
    16 
    17     public PersonT() {
    18     }
    19 
    20     public PersonT(String name, int age, String sex) {
    21         this.name = name;
    22         this.age = age;
    23         this.sex = sex;
    24     }
    25 
    26     public PersonT(PersonT personT) {
    27         this.name = personT.name;
    28         this.age = personT.age;
    29         this.sex = personT.sex;
    30     }
    31 
    32     public String getName() {
    33         return name;
    34     }
    35 
    36     public void setName(String name) {
    37         this.name = name;
    38     }
    39 
    40     public int getAge() {
    41         return age;
    42     }
    43 
    44     public void setAge(int age) {
    45         this.age = age;
    46     }
    47 
    48     public String getSex() {
    49         return sex;
    50     }
    51 
    52     public void setSex(String sex) {
    53         this.sex = sex;
    54     }
    55 
    56     @Override
    57     public String toString() {
    58         return "PersonT{" +
    59                 "name='" + name + '\'' +
    60                 ", age=" + age +
    61                 ", sex='" + sex + '\'' +
    62                 '}';
    63     }
    64 }

     

    深拷贝:

      1 package com.itinfo;
      2 
      3 /**
      4  * 浅析浅拷贝和深拷贝
      5  *
      6  * @author Wáng Chéng Dá
      7  * @create 2017-02-24 8:22
      8  */
      9 public class Asian {
     10     private String skin;
     11     private PersonT person;
     12 
     13     public Asian() {
     14     }
     15 
     16     public Asian(String skin, PersonT person) {
     17         this.skin = skin;
     18         this.person = person;
     19     }
     20 
     21     public Asian(Asian asian) {
     22         this.skin = asian.skin;
     23         this.person = new PersonT(asian.person);
     24     }
     25 
     26 //    public Asian(Asian asian) {
     27 //        this(asian.skin, asian.person);
     28 //    }
     29 
     30     public String getSkin() {
     31         return skin;
     32     }
     33 
     34     public void setSkin(String skin) {
     35         this.skin = skin;
     36     }
     37 
     38     public PersonT getPerson() {
     39         return person;
     40     }
     41 
     42     public void setPerson(PersonT person) {
     43         this.person = person;
     44     }
     45 
     46     @Override
     47     public String toString() {
     48         return "Asian{" +
     49                 "skin='" + skin + '\'' +
     50                 ", person=" + person.toString() +
     51                 '}';
     52     }
     53 
     54 
     55     public static void main(String[] args) {
     56         PersonT p1 = new PersonT("张三", 14, "男");
     57         PersonT p2 = new PersonT(p1);
     58         System.out.println(p1.toString());
     59         System.out.println(p2.toString());
     60 
     61         //修改p1
     62         System.out.println("---------修改p1----------");
     63         p1.setName("李四");
     64         p1.setAge(19);
     65         p1.setSex("女");
     66         System.out.println(p1.toString());
     67         System.out.println(p2.toString());
     68 
     69         //修改p2
     70         System.out.println("---------修改p2----------");
     71         p2.setName("王二");
     72         p2.setAge(23);
     73         p2.setSex("男");
     74         System.out.println(p1.toString());
     75         System.out.println(p2.toString());
     76 
     77 
     78         System.out.println("-------------------------");
     79         Asian a1 = new Asian("yellow", p1);
     80         Asian a2 = new Asian(a1);
     81         System.out.println(a1.toString());
     82         System.out.println(a2.toString());
     83 
     84         //修改a1
     85         System.out.println("---------修改a1----------");
     86         a1.setSkin("back");
     87         a1.getPerson().setName("麻子");
     88         a1.getPerson().setAge(28);
     89         a1.getPerson().setSex("男");
     90         System.out.println(a1.toString());
     91         System.out.println(a2.toString());
     92 
     93         //修改a2
     94         System.out.println("---------修改a2----------");
     95         a2.setSkin("red");
     96         a2.getPerson().setName("诗诗");
     97         a2.getPerson().setAge(25);
     98         a2.getPerson().setSex("女");
     99         System.out.println(a1.toString());
    100         System.out.println(a2.toString());
    101 
    102     }
    103 }

     

    控制台输出:

    PersonT{name='张三', age=14, sex='男'}
    PersonT{name='张三', age=14, sex='男'}
    ---------修改p1----------
    PersonT{name='李四', age=19, sex='女'}
    PersonT{name='张三', age=14, sex='男'}
    ---------修改p2----------
    PersonT{name='李四', age=19, sex='女'}
    PersonT{name='王二', age=23, sex='男'}
    -------------------------
    Asian{skin='yellow', person=PersonT{name='李四', age=19, sex='女'}}
    Asian{skin='yellow', person=PersonT{name='李四', age=19, sex='女'}}
    ---------修改a1----------
    Asian{skin='back', person=PersonT{name='麻子', age=28, sex='男'}}
    Asian{skin='yellow', person=PersonT{name='李四', age=19, sex='女'}}
    ---------修改a2----------
    Asian{skin='back', person=PersonT{name='麻子', age=28, sex='男'}}
    Asian{skin='red', person=PersonT{name='诗诗', age=25, sex='女'}}

     

    内存分析:

     

    浅拷贝:

      1 package com.itinfo;
      2 
      3 /**
      4  * 浅析浅拷贝和深拷贝
      5  *
      6  * @author Wáng Chéng Dá
      7  * @create 2017-02-24 8:22
      8  */
      9 public class Asian {
     10     private String skin;
     11     private PersonT person;
     12 
     13     public Asian() {
     14     }
     15 
     16     public Asian(String skin, PersonT person) {
     17         this.skin = skin;
     18         this.person = person;
     19     }
     20 
     21 //    public Asian(Asian asian) {
     22 //        this.skin = asian.skin;
     23 //        this.person = new PersonT(asian.person);
     24 //    }
     25 
     26     public Asian(Asian asian) {
     27         this(asian.skin, asian.person);
     28     }
     29 
     30     public String getSkin() {
     31         return skin;
     32     }
     33 
     34     public void setSkin(String skin) {
     35         this.skin = skin;
     36     }
     37 
     38     public PersonT getPerson() {
     39         return person;
     40     }
     41 
     42     public void setPerson(PersonT person) {
     43         this.person = person;
     44     }
     45 
     46     @Override
     47     public String toString() {
     48         return "Asian{" +
     49                 "skin='" + skin + '\'' +
     50                 ", person=" + person.toString() +
     51                 '}';
     52     }
     53 
     54 
     55     public static void main(String[] args) {
     56         PersonT p1 = new PersonT("张三", 14, "男");
     57         PersonT p2 = new PersonT(p1);
     58         System.out.println(p1.toString());
     59         System.out.println(p2.toString());
     60 
     61         //修改p1
     62         System.out.println("---------修改p1----------");
     63         p1.setName("李四");
     64         p1.setAge(19);
     65         p1.setSex("女");
     66         System.out.println(p1.toString());
     67         System.out.println(p2.toString());
     68 
     69         //修改p2
     70         System.out.println("---------修改p2----------");
     71         p2.setName("王二");
     72         p2.setAge(23);
     73         p2.setSex("男");
     74         System.out.println(p1.toString());
     75         System.out.println(p2.toString());
     76 
     77 
     78         System.out.println("-------------------------");
     79         Asian a1 = new Asian("yellow", p1);
     80         Asian a2 = new Asian(a1);
     81         System.out.println(a1.toString());
     82         System.out.println(a2.toString());
     83 
     84         //修改a1
     85         System.out.println("---------修改a1----------");
     86         a1.setSkin("back");
     87         a1.getPerson().setName("麻子");
     88         a1.getPerson().setAge(28);
     89         a1.getPerson().setSex("男");
     90         System.out.println(a1.toString());
     91         System.out.println(a2.toString());
     92 
     93         //修改a2
     94         System.out.println("---------修改a2----------");
     95         a2.setSkin("red");
     96         a2.getPerson().setName("诗诗");
     97         a2.getPerson().setAge(25);
     98         a2.getPerson().setSex("女");
     99         System.out.println(a1.toString());
    100         System.out.println(a2.toString());
    101 
    102     }
    103 }

     

    控制台输出:

    PersonT{name='张三', age=14, sex='男'}
    PersonT{name='张三', age=14, sex='男'}
    ---------修改p1----------
    PersonT{name='李四', age=19, sex='女'}
    PersonT{name='张三', age=14, sex='男'}
    ---------修改p2----------
    PersonT{name='李四', age=19, sex='女'}
    PersonT{name='王二', age=23, sex='男'}
    -------------------------
    Asian{skin='yellow', person=PersonT{name='李四', age=19, sex='女'}}
    Asian{skin='yellow', person=PersonT{name='李四', age=19, sex='女'}}
    ---------修改a1----------
    Asian{skin='back', person=PersonT{name='麻子', age=28, sex='男'}}
    Asian{skin='yellow', person=PersonT{name='麻子', age=28, sex='男'}}
    ---------修改a2----------
    Asian{skin='back', person=PersonT{name='诗诗', age=25, sex='女'}}
    Asian{skin='red', person=PersonT{name='诗诗', age=25, sex='女'}}

     

    内存分析:

     

    转载于:https://www.cnblogs.com/goodcheap/p/6438365.html

    展开全文
  • 浅拷贝与深拷贝浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。...拷贝构造函数大家应该很熟悉,如果我们要使自己定义的对象能够深拷贝,就改写从 Object继承...

    浅拷贝与深拷贝

    浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。深拷贝就是两个对象的值相等,但是互相独立。

    Java中常用的拷贝操作有三个,operator =、拷贝构造函数和 clone()方法。由于Java不支持运算符重载,我们无法在自己的自定义类型中定义operator=。拷贝构造函数大家应该很熟悉,如果我们要使自己定义的对象能够深拷贝,就改写从 Object继承而来的 clone方法,使它的访问权限为 public,因为为了防止意外的支持 clone操作,Object的 clone方法是 protected权限。

    f605243a8c82aa6c4670412a17ceb5a2.gif

    浅拷贝:

    深拷贝:

    利用序列化来做深复制,把对象写到流里的过程是序列化(Serilization)过程,而把对象从流中读出来的过程则叫做反序列化(Deserialization)过程。应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面。,利用这个特性,可以做深拷贝

    java序列化

    Java平台允许我们在内存中创建可复用的Java对象,但一般情况下,只有当JVM处于运行时,这些对象才可能存在,这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中,就可能要求在JVM停止运行之后能够保存(持久化)指定的对象,并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。除了在持久化对象时会用到对象序列化之外,当使用RMI(远程方法调用),或在网络中传递对象时,都会用到对象序列化。

    使用Java对象序列化,在保存对象时,会把其状态保存为一组字节,在未来,再将这些字节组装成对象。必须注意地是,对象序列化保存的是对象的"状态",即它的成员变量。由此可知,对象序列化不会关注类中的静态变量。

    如果被写对象的类型是String,或数组,或Enum,或Serializable,那么就可以对该对象进行序列化,否则将抛出NotSerializableException。

    如果仅仅只是让某个类实现Serializable接口,而没有其它任何处理的话,则就是使用默认序列化机制。使用默认机制,在序列化对象时,不仅会序列化当前对象本身,还会对该对象引用的其它对象也进行序列化,同样地,这些其它对象引用的另外对象也将被序列化,以此类推。所以,如果一个对象包含的成员变量是容器类对象,而这些容器所含有的元素也是容器类对象,那么这个序列化的过程就会较复杂,开销也较大

    无论是实现Serializable接口,或是Externalizable接口,当从I/O流中读取对象时,readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。如果是单例模式下的话,可以在readResolve中直接返回单例对象。

    展开全文
  • 1.预定义非集合类型--拷贝构造函数 public class TestA { public static void main(String[] args) { Integer a = 1; Integer b = new Integer(a); b = 2; if (!a.equals(b)) { System.out....
  • 这个概念估计懂C++的人不会陌生,但是很多朋友并不了解,概括起来...java中常见的拷贝操作有三种:operator、拷贝构造函数和clone()方法。但是java不支持运算符重载,所以在自定义类型中无法定义operator=,拷贝构造...
  • java 深拷贝 浅拷贝

    2013-12-11 10:10:57
    由于Java不支持运算符重载,我们无法在自定义类型中定义operator=,所以使用operator=获取的对象都是浅拷贝,若要实现深拷贝那只能借助于拷贝构造函数和clone方法。 这里我们先看一个基本的原则关系图,掌握了这些...
  • Java深拷贝浅拷贝

    2013-11-09 16:29:00
    首先,Java中常用的拷贝操作有三个,operator=、拷贝构造函数和clone()方法。由于Java不支持运算符重载,我们无法在自己的自定义类型中定义operator=。拷贝构造函数大家应该很熟悉,现在看一下如何支持clone方法: ...
  • C++的语法之特别,连其构造方法都有三个:构造函数、析构函数、拷贝构造函数,与Java相比确实有其独到之处。 构造函数:声明的时候就会调用 class Teacher{ private: char *name; int age; public: //无参构造...
  • Java深拷贝与浅拷贝

    2020-10-23 14:55:47
    即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。 特点 简而言之,当浅拷贝的对象是基本类型时,和复制没有太大的区别,但是如果浅拷贝的对象是一个引用,比如将...
  • Java 中的拷贝构造方法

    千次阅读 多人点赞 2019-12-20 23:21:24
    Java 中的拷贝构造方法是一种使用该类的一个对象构造另外一个对象的构造方法。 当需要拷贝一个带有多个成员变量的复杂对象或者想构造已存在对象的深拷贝对象时非常有用。 译者注:本文内容很简单,但是很实用。拷贝...
  • java深拷贝、浅拷贝

    2019-11-19 15:23:54
    浅拷贝: 浅拷贝是按位拷贝对象,它会创建一个新对象,这...即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。 特点:(1) 对于基本数据类型的成员对象,因为基础数据...
  • java深拷贝

    2017-06-06 11:13:40
    clone方法介绍clone是复制还是浅复制clone跳过构造函数最佳实践复制构造函数或者自定义Copyable接口 序列化实现复制 为什么使用序列化复制的实现序列化存在的问题 使用相关第三方库 前段时间...
  • Java 浅拷贝和深拷贝

    2020-12-09 10:54:50
    一、拷贝分类 根据对对象属性的拷贝程度(基本数据类和引用类型),会分为两种: 浅拷贝 (Shallow Copy) ...即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。
  • java 深拷贝解析

    2017-03-03 12:00:32
    我们知道,java隐藏了指针的概念,内部对象的传递... 但是,‘=’赋值的机制是值传递,而java类中包含其他类引用时,与c++相异,此属性不会自动分配内存空间,需要调用构造函数才行。因此我们在拷贝引用对象时,如果用
  • java浅拷贝和深拷贝

    2020-05-04 14:34:55
    浅拷贝 浅拷贝是按位拷贝对象,它会创建一个新对象,...即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。 浅拷贝特点 对于基本数据类型的成员对象,因为基础数据类...
  • 常用的拷贝操作有三个: = 、拷贝构造函数 和 clone()方法。 图片转载自:传送门 预定义非集合类型: int, Integer, String 这种,用 = 赋值就是深拷贝。 自定义类型: 自己写的类 预定义集合类型:List, Set, Map...
  • 须要记住的是,Java集合的拷贝构造函数只提供浅拷贝而不是深拷贝,这意味着存储在原始List和克隆List中的对象是相同的,指向Java堆内存中相同的位置。增长了这个误解的缘由之一是对于不可变对象集合的浅克隆。因为不...
  • 浅拷贝和深拷贝都是对一个已有对象的操作,编译系统会自动调用一种构造函数——拷贝构造函数,如果用户未定义拷贝构造函数,则会调用默认拷贝构造函。 在java中,一般使用=好做赋值操作的时候,对于基本数据类型
  • Java深拷贝和浅拷贝

    2015-10-30 10:14:14
    浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。深拷贝就是两个对象的值相等,但是互相独立...拷贝构造函数大家应该很熟悉,如果我们要使自己定义的对象能够深拷贝,就改写从 Obje
  • 浅拷贝 浅拷贝介绍 浅拷贝是按位拷贝对象,它会创建一个新对象,...即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝),即只复制对象空间而不复制资源。 浅拷贝特点 (1) 对于基本数据类型...
  • Java中创建对象有两种方式: 通过new操作符创建一个对象 通过clone方法来复制一个对象 ...第一种方法,通过new操作符来创建一个对象,分配内存,调用构造函数来填充各个域,这是我们最熟悉的;第二种clo...
  • ArrayList的拷贝方法有很多,其中大部分都是浅拷贝,例如通过构造函数方法拷贝,1 List l2 = new ArrayList<>(l1);或者addAll方法:1 List l2 = new ArrayList<>();2 l2.addAll(l1);这些都是...
  • Java中创建对象有两种方式: 通过new操作符创建一个对象 通过clone方法来复制...第一种方法,通过new操作符来创建一个对象,分配内存,调用构造函数来填充各个域,这是我们最熟悉的;第二种clone也是分配内存,分...
  • Java中,没有提供类似的C++的拷贝构造函数,但是提供了默认的”克隆”接口 Clonable。如果我们要对一个只包含基础类型(int / long /String)的对象进行克隆,只需要实现Clonable并实现clone()函数即可。如下:...
  • 1: Java中浅拷贝和深拷贝的定义:  浅拷贝:就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。... (2)拷贝构造函数拷贝构造函数就是构造函数的参数的类型是该构造
  • c)是浅拷贝还是深拷贝,当时一下子也没反应过来,就写了一个单元测试验证了一下,结果是浅拷贝,代码如下:(浅拷贝的原理可以参考这篇文章《java浅拷贝和深拷贝》) public void testAr(){ List<BeanDemo>...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

java深拷贝构造函数

java 订阅