«

Java设计模式中的原型模式怎么实现

时间:2024-8-6 09:04     作者:韩俊     分类: 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

    热门推荐