6、原型模式(Prototype Pattern,不常用)

原型模式指通过调用原型实例的Clone方法或其他手段来创建对象。

原型模式属于创建型设计模式,它以当前对象为原型(蓝本)来创建另一个新的对象,而无须知道创建的细节。原型模式在Java中通常使用Clone技术实现,在JavaScript中通常使用对象的原型属性实现。

原型模式的Java实现很简单,只需原型类实现Cloneable接口并覆写clone方法即可。Java中的复制分为浅复制和深复制。

  • 浅复制:Java中的浅复制是通过实现Cloneable接口并覆写其Clone方法实现的。在浅复制的过程中,对象的基本数据类型的变量值会重新被复制和创建,而引用数据类型仍指向原对象的引用。也就是说,浅复制不复制对象的引用类型数据。
    package cn.jaa.prototype_pattern;
    
    /**
     * @Author: Jaa
     * @Description: 浅复制
     * @Date 2023/11/28 22:25
     */
    public class Computer implements Cloneable {
        private String cpu;
        private String memory;
        private String disk;
    
        public Computer(String cpu, String memory, String disk) {
            this.cpu = cpu;
            this.memory = memory;
            this.disk = disk;
        }
    
        @Override
        protected Object clone() { // 浅复制
            try {
                return (Computer) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        @Override
        public String toString() {
            return "Computer{" +
                    "cpu='" + cpu + '\'' +
                    ", memory='" + memory + '\'' +
                    ", disk='" + disk + '\'' +
                    '}';
        }
    }
    
  • 深复制:在深复制的过程中,不论是基本数据类型还是引用数据类型,都会被重新复制和创建。简而言之,深复制彻底复制了对象的数据(包括基本数据类型和引用数据类型),浅复制的复制却并不彻底(忽略了引用数据类型)。
    package cn.jaa.prototype_pattern;
    
    /**
     * @Author: Jaa
     * @Description: 深复制
     * @Date 2023/11/28 22:33
     */
    public class ComputerDetail implements Cloneable {
    
        private String cpu;
        private String memory;
        private Disk disk;
    
        public ComputerDetail(String cpu, String memory, Disk disk) {
            this.cpu = cpu;
            this.memory = memory;
            this.disk = disk;
        }
    
        @Override
        protected Object clone() { // 深复制
            try {
                ComputerDetail computerDetail = (ComputerDetail) super.clone();
                computerDetail.disk = (Disk) this.disk.clone(); // 引用对象深复制
                return computerDetail;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        @Override
        public String toString() {
            return "ComputerDetail{" +
                    "cpu='" + cpu + '\'' +
                    ", memory='" + memory + '\'' +
                    ", disk=" + disk +
                    '}';
        }
    }
    package cn.jaa.prototype_pattern;
    
    /**
     * @Author: Jaa
     * @Description:
     * @Date 2023/11/28 22:34
     */
    public class Disk implements Cloneable {
        private String ssd;
        private String hhd;
    
        public Disk(String ssd, String hhd) {
            this.ssd = ssd;
            this.hhd = hhd;
        }
    
        @Override
        protected Object clone() { // 应用对象深复制
            try {
                return (Disk) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        @Override
        public String toString() {
            return "Disk{" +
                    "ssd='" + ssd + '\'' +
                    ", hhd='" + hhd + '\'' +
                    '}';
        }
    }
    

    浅复制、深复制测试:

    package cn.jaa.prototype_pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * @Author: Jaa
     * @Description: simple and deep clone test
     * @Date 2023/11/28 22:41
     */
    @Slf4j
    public class PrototypeDemoTest {
    
        public static void main(String[] args) {
            // 浅复制
            Computer computer = new Computer("16core", "16G", "1TB");
            log.info("before simple clone: " + computer.toString());
            Computer computerClone = (Computer) computer.clone();
            log.info("after simple clone: " + computerClone.toString());
    
            // 深复制
            Disk disk = new Disk("256G", "1TB");
            ComputerDetail computerDetail = new ComputerDetail("16core", "16G", disk);
            log.info("before deep clone: " + computerDetail.toString());
            ComputerDetail computerDetailClone = (ComputerDetail) computerDetail.clone();
            log.info("after deep clone: " + computerDetailClone.toString());
        }
    }

    运行结果:

你可能感兴趣的:(23种设计模式,原型模式,设计模式)