欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

java對象克隆實現方法詳解

 更新時間：2023年06月26日 11:17:54   作者：暴走的小帥  
這篇文章主要給大家介紹了關于java對象克隆實現的相關資料,克隆就是復制一個對象的副本,Java支持我們對一個對象進行克隆,通常用在裝飾模式和原型模式中,需要的朋友可以參考下

概述:

當我們new一個對象時,其中的屬性就會被初始化, 那么想要保存剛開始初始化的值就靠clone方法來實現, 平時我們最常見的是一個對象的引用指向另一個對象,并不是創(chuàng)建了兩個對象.

 Person p1 = new Person(100,"jim");
        Person p2 = p1;
        System.out.println(p1==p2);//true

克隆肯定是創(chuàng)建了兩個對象

 Person p1 = new Person(100,"jim");
        Person p2 =p1.clone();//克隆的新對象
        System.out.println(p1==p2);//false

克隆分為淺克隆(ShallowClone)和深克隆(DeepClone)。

在 Java 語言中，數據類型分為值類型（基本數據類型）和引用類型，值類型包括 int、double、byte、boolean、char 等簡單數據類型，引用類型包括類、接口、數組等復雜類型。基本類型的值可以直接復制,引用類型只能復制引用地址。所以淺克隆和深克隆的主要區(qū)別在于是否支持引用類型的成員變量的復

制.

淺克隆

在淺克隆中，如果原型對象的成員變量是值類型，將復制一份給克隆對象；如果原型對象的成員變量是引用類型，則將引用對象的地址復制一份給克隆對象，也就是說原型對象和克隆對象的成員變量指向相同的內存地址。簡單來說，在淺克隆中，當對象被復制時只復制它本身和其中包含的值類型的成員變量，而引用類型的成員對象并沒有復制。

實現方式:

1.在 Java 語言中，通過覆蓋 Object 類的 clone()方法可以實現淺克隆。

2.在 spring 框架中提供 BeanUtils.copyProperties(source,target);

這里我們主要演示通過重寫object中clone方法來實現

1.首先定義一個類(需要被克隆的類)

public class Person implements  Cloneable{
     int num;
     String name;
     Address address;
    public Person() {
    }
    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person = (Person)super.clone();
        return person;
    }
    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

2.可以看到Person類關聯著Address類,也寫出來

public class Address  {
     String  address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

3.寫一個Test類進行測試

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address();
                address.setAddress("漢中");
        Person p1 = new  Person(100,"jim");
               p1.setAddress(address);
        Person p2 =p1.clone();
               p2.setName("tom");
               address.setAddress("西安");
        System.out.println(p1); // jim   西安
        System.out.println(p2);// tom    西安
    }
}

首先看name屬性,p1的name為jim,克隆出另一個對象p2,將name改成了tom,因為是兩個對象,所以輸出的結果分別都不同.

再看關聯對象, 首先將有漢中信息的address加入到了p1中,所以目前p1中的address是漢中,經過克隆出p2后,其實對于address來說只克隆了地址,所以說p1和p2指向的都是同一個address,所以都是漢中,再經過一次修改成了西安,所以都是西安.

所以說淺克隆只是克隆了引用類型變量的地址.

深克隆

在深克隆中，無論原型對象的成員變量是值類型還是引用類型，都將復制一份給克隆對象，深克隆將原型對象的所有引用對象也復制一份給克隆對象。簡單來說，在深克隆中，除了對象本身被復制外，對象所包含的所有成員變量也將復制

在 Java 語言中，如果需要實現深克隆，可以通過覆蓋 Object 類的 clone()方法實現，也可以通過序列化(Serialization)等方式來實現。序列化就是將對象寫到流的過程，寫到流中的對象是原有對象的一個拷貝，而原對象仍然存在于內存中。通過序列化實現的拷貝不僅可以復制對象本身，而且可以復制其引用的成員對象，因此通過序列化將對象寫到一個流中，再從流里將其讀出來，可以實現深克隆。需要注意的是能夠實現序列化的對象其類必須實現Serializable 接口，否則無法實現序列化操作

1.重寫Object類中的clone方法

1.首先定義一個類(需要被克隆的類),相比于上面的淺克隆增加了一行克隆address對象的代碼

public class Person implements  Cloneable{
     int num;
     String name;
     Address address;
    public Person() {
    }
    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person = (Person)super.clone();
        person.address = (Address)address.clone();   //深度復制  聯同person中關聯的對象也一同克隆.
        return person;
    }
    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

2.Address寫出來,相比于上面淺克隆多了一個重寫Object類的clone方法

public class Address  {
     String  address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
   @Override
    protected Address clone() throws CloneNotSupportedException {
        return (Address)super.clone();
    }
}

3.還是Test測試類

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address();
                address.setAddress("漢中");
        Person p1 = new  Person(100,"jim");
               p1.setAddress(address);
        Person p2 =p1.clone();
               p2.setName("tom");
               address.setAddress("西安");
        System.out.println(p1); // jim   西安
        System.out.println(p2);// tom    漢中
    }
}

這次的結果會有所不同, 因為深克隆不僅克隆了自己, 還克隆了關聯著的類的對象, 所以說原來的p1存儲的漢中被克隆在了p2中,而最后一行更改為西安的是原來的address對象, p2中已經克隆了原來的address并且保存了下來

2.序列化(Serialization)的方式

如果需要被克隆的類中關聯的其他類的對象太多, 那么繼續(xù)用深克隆的話需要耗費大量的時間去一個一個克隆關聯著的對象, 而序列化的方式可以將該類中所有關聯的對象化成流從而高校的進行克隆.

1.還是創(chuàng)建一個關聯著被克隆的類的對象

public class Address  implements Serializable {
     String  address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

2.Person類,里面寫一個自己的序列化方式的克隆方法

public class Person implements Serializable {
     int num;
     String name;
     Address address;
    public Person() {
    }
    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    /**
     * 自定義克隆方法
     * @return
     */
    public Person myclone() {
            Person person = null;
              try { // 將該對象序列化成流,因為寫在流里的是對象的一個拷貝，而原對象仍然存在于JVM里面。所以利用這個特性可以實現對象的深拷貝
                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
                      ObjectOutputStream oos = new ObjectOutputStream(baos);
                      oos.writeObject(this);
            // 將流序列化成對象
                    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                     ObjectInputStream ois = new ObjectInputStream(bais);
                     person = (Person) ois.readObject();
                  } catch (IOException e) {
                     e.printStackTrace();
                  } catch (ClassNotFoundException e) {
                     e.printStackTrace();
                 }
             return person;
          }
    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

3.Test類測試

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address();
                address.setAddress("漢中");
        Person p1 = new  Person(100,"jim");
        p1.setAddress(address);
        Person p2 =p1.myclone();
               p2.setName("tom");
               address.setAddress("西安");
        System.out.println(p1);jim   西安
        System.out.println(p2);tom   漢中
    }
}

所以說, 得看具體情況進行選擇

總結

到此這篇關于java對象克隆實現的文章就介紹到這了,更多相關java對象克隆內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

最新評論