Java設計模式中的原型模式怎么實現

本篇內容介紹了“Java設計模式中的原型模式怎么實現”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

原型模式

在Java中,原型模式是一種創建型設計模式,它允許通過復制一個現有對象來創建一個新對象,而不是通過創建新的對象來初始化一個對象,原型模式是一種基于克隆的設計模式,通過復制現有對象的數據來創建新的對象.

原型模式需要實現Cloneable接口并重寫Object類中的clone()方法,在重謝clone()方法時,需要調用super.clone()方法來創建一個新的對象,并復制原始對象中的所有屬性.默認情況下,Java中的Object類提供的clone()方法會執行淺拷貝,如果原始對象中包含引用類型的成員變量,則需要進行深拷貝操作,以確保新對象中所有成員變量都是獨立的.

深拷貝與淺拷貝

淺拷貝(Shallow Copy)會創建一個新的對象,該對象具有與原始對象相同的屬性值.但是,如果原始對象包含對其他對象的引用,則新對象也將包含對相同對象的引用.換句話說,新對象僅僅是原始對象的一個副本,而不是獨立的對象.

深拷貝(Deep Copy)則是創建一個新的對象,該對象具有與原始對象相同的屬性值,但是它會遞歸的復制對象圖中所有的對象,而不是只復制引用.換句話說,深拷貝會創建一個完全獨立的新對象,該對象與原始對象沒有任何關聯.

區別:

• 對于基本數據類型,淺拷貝和深拷貝沒有區別,因為基本數據類型在內存中儲存為值.但是對于引用類型,淺拷貝和深拷貝會有不同的行為.淺拷貝只復制對象本身以及其中的基本數據類型成員,而不會復制引用類型成員.因此,如果原始對象中包含引用類型成員,淺拷貝得到的對象中的引用類型成員與原始對象中的相同,即兩者指向同一塊內存地址.而深拷貝則會遞歸的復制所有的引用類型成員,因此得到的對象中的引用類型成員與原始對象中的不同,即兩者指向不同的內存地址.

• 淺拷貝速度相對較快,因為它只復制了對象本身以及其中的基本數據類型成員.而深拷貝速度相對較慢,因為它需要遞歸的復制所有引用類型成員.

應用場景:

• 淺拷貝通常用于快速創建對象副本,且原始對象中不包含引用類型成員的情況下,可以使用淺拷貝.比如,當需要多個對象共享某些狀態時,可以使用淺拷貝來快速創建副本

• 深拷貝通常用于創建完全獨立的對象,且原始對象中包含引用類型成員的情況下,可以使用深拷貝

淺拷貝示例代碼

@Data
public class Person implements Cloneable{
    private String name;
    private int age;
    private Address address;
    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
@Data
public class Address {
    private String city;
    private String street;
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
}

測試淺拷貝

package com.fanqiechaodan.prototype.copy.shollow;
import com.alibaba.fastjson.JSON;
/**
 * @Classname Demo
 * @Description 淺拷貝
 */
public class Demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("張三", 18, new Address("上海", "南京路"));
        Person person2 = (Person) person1.clone();
        System.out.println(JSON.toJSONString(person1));
        System.out.println(JSON.toJSONString(person2));
        System.out.println("淺拷貝后:");
        person1.getAddress().setCity("南京");
        System.out.println(JSON.toJSONString(person1));
        System.out.println(JSON.toJSONString(person2));
    }
}

深拷貝示例代碼

@Data
public class Person implements Serializable {
    private String name;
    private int age;
    private Address address;
    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    @Override
    protected Object clone() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}
@Data
public class Address implements Serializable {
    private String city;
    private String street;
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
}

測試深拷貝

package com.fanqiechaodan.prototype.copy.deep;
import com.alibaba.fastjson.JSON;
import org.springframework.util.SerializationUtils;
import java.io.IOException;
/**
 * @Classname Demo
 * @Description 深拷貝
 */
public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person person1 = new Person("張三", 18, new Address("上海", "南京路"));
        // 重寫clone完成深拷貝
        Person person2 = (Person) person1.clone();
        // 使用工具類完成深拷貝
        Person person3 = (Person) SerializationUtils.deserialize(SerializationUtils.serialize(person1));
        System.out.println(JSON.toJSONString(person1));
        System.out.println(JSON.toJSONString(person2));
        System.out.println(JSON.toJSONString(person3));
        System.out.println("深拷貝后:");
        person1.getAddress().setCity("南京");
        System.out.println(JSON.toJSONString(person1));
        System.out.println(JSON.toJSONString(person2));
        System.out.println(JSON.toJSONString(person3));
    }
}

原型模式代碼

原型類代碼

@Data
public class Person implements Cloneable{
    private String name;
    private int age;
    private Address address;
    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
@Data
public class Address {
    private String city;
    private String street;
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
}

測試

package com.fanqiechaodan.prototype;
import com.alibaba.fastjson.JSON;
/**
 * @Classname Demo
 * @Description
 */
public class Demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("張三", 18, new Address("北京", "青年路"));
        Person person2 = (Person) person1.clone();
        System.out.println(JSON.toJSONString(person1));
        System.out.println(JSON.toJSONString(person2));
    }
}

需要注意的是,在使用Cloneable接口實現原型模式時,需要注意以下幾點:

• 要使用克隆方法,必須確保該對象實現了Cloneable接口.否則,在調用clone方法時會拋出CloneNotSupportedException異常

• 調用clone方法返回的是一個淺拷貝對象,如果對象包含了引用類型的成員變量,那么這些成員變量依然會被多個對象共享.

• 在實現clone方法時,需要注意對成員變量的處理,特別是對引用類型的成員變量的處理.如果需要實現深拷貝,可以通過重寫clone方法來實現.

“Java設計模式中的原型模式怎么實現”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！