对象拷贝-深拷贝

 1 package com.yj.fenghao.clone;
 2 //深拷贝的简单测试
 3 import java.util.Date;
 4
 5 public class Employee implements Cloneable{
 6
 7     private String name;
 8     private String age;
 9     private String salary;
10     private String career;
11     private Date date;
12     public String getName() {
13         return name;
14     }
15     public void setName(String name) {
16         this.name = name;
17     }
18     public String getAge() {
19         return age;
20     }
21     public void setAge(String age) {
22         this.age = age;
23     }
24     public String getSalary() {
25         return salary;
26     }
27     public void setSalary(String salary) {
28         this.salary = salary;
29     }
30     public String getCareer() {
31         return career;
32     }
33     public void setCareer(String career) {
34         this.career = career;
35     }
36     public Date getDate() {
37         return date;
38     }
39     public void setDate(Date date) {
40         this.date = date;
41     }
42     public Employee(String name, String age, String salary, String career, Date date) {
43         super();
44         this.name = name;
45         this.age = age;
46         this.salary = salary;
47         this.career = career;
48         this.date = date;
49     }
50     public Employee() {
51         super();
52     }
53 //    /**
54 //     * 如果对象中含有其他的对象,调用超类的克隆方法是浅克隆
55 //     */
56 //    @Override
57 //    protected Object clone() throws CloneNotSupportedException {
58 //        return super.clone();
59 //    }
60
61     /**
62      * 如果对象中含有其他的对象,其他的对象也需要克隆,即使深拷贝
63      */
64     @Override
65     protected Employee clone() throws CloneNotSupportedException {
66         Employee emply = (Employee)super.clone();
67         emply.date= (Date)date.clone();
68         return emply;
69     }
70     @Override
71     public String toString() {
72         return "{\"name\":"+name+",\"age\":"+age+",\"salary\":"+salary+",\"career\":"+career+",\"date\":+"+date+"}";
73     }
74
75
76 }
 1 package com.yj.fenghao.clone;
 2
 3 import java.text.ParseException;
 4 import java.text.SimpleDateFormat;
 5 import java.util.Date;
 6
 7
 8
 9 public class CloneableTest {
10
11
12     public static void main(String[] args) throws CloneNotSupportedException, ParseException {
13         SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
14         Employee em=new Employee();
15         em.setDate(new Date());
16         em.setName("fenghao");
17         em.setAge("25");
18         em.setSalary("1000");
19         em.setCareer("111");
20         Employee clone = em.clone();
21         clone.setDate(format.parse("2015-01-01 12:00:00"));
22         clone.setName("xuxiaoxiao");
23         System.out.println(em.toString());
24         System.out.println(clone.toString());
25     }
26
27 }

运行结果:

{"name":fenghao,"age":25,"salary":1000,"career":111,"date":+Fri Apr 07 08:29:29 CST 2017}
{"name":xuxiaoxiao,"age":25,"salary":1000,"career":111,"date":+Thu Jan 01 12:00:00 CST 2015}
时间: 2024-10-11 20:38:45

对象拷贝-深拷贝的相关文章

Python对象拷贝——深拷贝与浅拷贝

对象赋值 浅拷贝 深拷贝 1. 对象赋值 对象的赋值实际上是对对象的引用.也就是说当把一个对象赋值给另一个对象时,只是拷贝了引用.如: >>> t1 = tuple('furzoom') >>> t2 = t1 >>> id(t1),id(t2) (139792198303936, 139792198303936) 上面t1和t2代表的是同一个对象. 2. 浅拷贝 除了上面将一个对象直接赋值给另一个对象外,还有两种常用的方法对对象进行拷贝:使用切片操作

Python 拷贝对象(深拷贝deepcopy与浅拷贝copy)

http://www.jb51.net/article/15714.htm 1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象.2. copy.deepcopy 深拷贝 拷贝对象及其子对象 一个很好的例子: 1 import copy 2 a = [1, 2, 3, 4, ['a', 'b']] #原始对象 3 4 b = a #赋值,传对象的引用 5 c = copy.copy(a) #对象拷贝,浅拷贝 6 d = copy.deepcopy(a) #对象拷贝,深拷贝

iOS 深拷贝、浅拷贝、自定义对象拷贝简介

copy语法的目的:改变副本的时候,不会影响到源对象: 深拷贝:内容拷贝,会产生新的对象.新对象计数器置为1,源对象计数器不变. 浅拷贝:指针拷贝,不会产生新的对象.源对象计数器+1. 拷贝有下面两个方法实现拷贝: - (id)copy; - (id)mutableCopy; 对象要实现copy,必须实现<NSCopying>协议数组,字典,字符串都已经实现了<NSCopying>协议,以下以字符串为例: 1.不可变字符串调用copy实现拷(浅拷贝) NSString *strin

C#对象的深拷贝与浅拷贝

转载自:http://blog.163.com/hr_msn/blog/static/21549405120132250396584/ 深拷贝是指源对象与拷贝对象互相独立,其中任何一个对象的改动都不会对另外一个对象造成影响.举个例子,一个人名叫张三,后来用他克隆(假设法律允许)了另外一个人,叫李四,不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人.比较典型的就是Value(值)对象,如预定义类型Int32,Double,以及结构(struct),枚举(Enum)等. 考虑以下写法 in

JAVA 对象拷贝

原文链接: http://blog.csdn.net/jdluojing/article/details/6963112 1.java里的clone分为: A:浅复制(浅克隆): 浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. b:深复制(深克隆):深复制把要复制的对象所引用的对象都复制了一遍. Java中对象的克隆,为了获取对象的一份拷贝,我们可以利用Object类的clone()方法.必须要遵循下面三点 1.在派生类中覆盖基类的clone()方法,并声明为public[Object类中

python中的对象拷贝

python中无论参数传递还是函数返回值,都是进行引用传递.那如何拷贝对象呢,标准库的copy模块提供了两个方法:copy和deepcopy方法. 1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 见下例: import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象 e = a[:] #利用分片操作进行拷贝(浅拷贝) b = a <span style="white-

也说Javascript对象拷贝及疑问

也说Javascript对象拷贝及疑问 一.浅拷贝 当我们需要将一个对象拷贝至另一个对象时,我们一般会这么实现 function shadowCopy(source,target){ var target=target||{}; for(var i in source) { target[i]=source[i]; } return target; } var a={name:'Lily',age:19}; var b=shadowCopy(a);//b={name:'Lily',age:19}

Java学习笔记 对象拷贝

1.Java里的clone分为: A:浅复制(浅克隆): 浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. b:深复制(深克隆):深复制把要复制的对象所引用的对象都复制了一遍. Java中对象的克隆,为了获取对象的一份拷贝,我们可以利用Object类的clone()方法.必须要遵循下面三点 1.在派生类中覆盖基类的clone()方法,并声明为public[Object类中的clone()方法为protected的]. 2.在派生类的clone()方法中,调用super.clone(). 3.

map对象拷贝问题

map对象赋值: HashMap<String,Object> hm = new HashMap(); HashMap<String,Object> hmCopy = new HashMap(); hm.put("123", 123); System.out.println(hm.get("123")); hmCopy = hm; hmCopy.remove("123"); System.out.println(hm.ge