对象的克隆

想回家种地的码农 lv.1

发布时间：2023-11-27 05:52:37 256

相关标签：

对象的克隆

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

对象浅克隆要注意的细节：

1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。

2.Cloneable接口只不过是一个标识接口而已，没有任何方法。

3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象克隆一份。

4.对象的浅克隆也不会调用到构造方法。

对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的信息这个过程就称作为对象的深克隆。

①对象的浅克隆demo：

package com.cn.clone;
/**
* Author：Liu Zhiyong
* Version：Version_1
* Date：2016年8月19日17:26:05
* Desc：
对象的克隆
  对象的浅克隆：浅复制(浅克隆)被复制对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然只指向原来的对象，换言之，浅复制仅仅复制锁考虑的对象，而不复制它所引用的对象。
  对象浅克隆要注意的细节：
    1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
    2.Cloneable接口只不过是一个标识接口而已，没有任何方法。 
    3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象克隆一份。
    4.对象的浅克隆也不会调用到构造方法。
*/
public class Demo1 {
  public static void main(String[] args) throws CloneNotSupportedException {
    Address address = new Address("香港");
    Person p1 = new Person(110, "木先森", address);
    Person p2 = p1; //这属于对象的地址引用
    
    /*System.out.println("p1和p2是同一个对象吗：" + (p1==p2));
    p2.address.city = "黄冈";
    System.out.println("p1" + p1);
    System.out.println("p2" + p2);
    System.out.println("============================================");*/
    
    Person p3 = (Person)p1.clone();//克隆了一个对象
    p3.name = "哈哈";
    p3.address.city = "澳门";
    System.out.println(p1);
    System.out.println(p3);
    System.out.println("p1和p3是同一个对象吗：" + (p1==p3));
    
  }
}

package com.cn.clone;
import java.io.Serializable;
class Address implements Serializable{
  String city;
  public Address(String city) {
    super();
    this.city = city;
  }
  
  @Override
  public String toString() {
    // TODO Auto-generated method stub
    return this.city;
  }
}
public class Person implements Cloneable, Serializable{
  int id;
  String name;
  Address address;
  
  public Person(int id, String name, Address address) {
    super();
    this.id = id;
    this.name = name;
    this.address = address;
    System.out.println("构造方法调用了");
  }
  @Override
  public String toString() {
    return "编号：" + this.id + "\t姓名：" + this.name + "\t地址：" + this.address;
  }
  
  @Override
  public Object clone() throws CloneNotSupportedException {
    // TODO Auto-generated method stub
    return super.clone();
  }
}

对象的浅克隆demo结果：

对象的克隆_对象的克隆

对象的浅克隆demo分析：

对象的克隆_对象的克隆_02

对象的深克隆demo：

package com.cn.clone;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
/**
* Author：Liu Zhiyong
* Version：Version_1
* Date：2016年8月25日18:09:40
* Desc：
对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的信息这个过程就称作为对象的深克隆。
*/
public class Demo2 {
  public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    Address address = new Address("香港");
    Person p1 = new Person(110, "木先森", address);
    System.out.println(p1);
    //把对象写到文件上去
    writeObj(p1);
    //读取文件上的文件
    Person p2 = readObj();
    p2.address.city =  "黄冈";
    System.out.println(p2);
  }
  
  //先要把对象写到文件上
  public static void writeObj(Person p) throws FileNotFoundException, IOException{
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("f:/obj.txt")));
    objectOutputStream.writeObject(p);
    //关闭资源
    objectOutputStream.close();
  }
  
  //再从文件中读取信息
  public static Person readObj() throws FileNotFoundException, IOException, ClassNotFoundException{
    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("f:/obj.txt")));
    return (Person)objectInputStream.readObject();
  }
}

对象的深克隆demo结果：

对象的克隆_浅克隆_03

文章来源： https://blog.51cto.com/u_15769923/5854380

特别声明：以上内容（图片及文字）均为互联网收集或者用户上传发布，本站仅提供信息存储服务！如有侵权或有涉及法律问题请联系我们。