design_pattern

设计模式

1.单例模式：保证系统中，应用该模式的类只有一个对象实例

1.1懒汉模式

/**
 * @className SingletonLzay
 * @Description TODO
 * @Author DuGu 1181755282@qq.com
 * @Date 2024-04-07 10:12
 * @Version 1.0
 */
public class SingletonLzay {

    private static volatile SingletonLzay instance;

    /**
     * 构造函数私有化:防止外界创建类
     */
    private SingletonLzay(){}

    /**
     * 对外暴漏一个方法获取类的对象
     * instance=new SingletonLzay() 不安全；并不是原子操作，分为3步
     * 1、分配空间给对象
     * 2、在空间内创建对象
     * 3、将对象赋值给引用instance
     * 为防止创建对象的时候发生指令重排,需要加上volatile
     * @return
     */
    public static  SingletonLzay getInstance(){
        if (instance==null){ //只有在初始化的时候才会出现很多线程竞争一把锁
            synchronized (SingletonLzay.class){
                if (instance==null){ //防止重复创建对象
                    instance=new SingletonLzay();
                }
            }
        }
        return instance;
    }
}

1.2 饿汉模式

/**
 * @className SingletonHungry
 * @Description TODO
 * @Author DuGu 1181755282@qq.com
 * @Date 2024-04-07 11:50
 * @Version 1.0
 */
public class SingletonHungry {

    private static SingletonHungry instance=new SingletonHungry();

    private SingletonHungry(){}

    public static SingletonHungry getInstance(){
        return instance;
    }
}

1.3 懒汉模式、饿汉模式选择问题

• 对象刚开始需要使用----->饿汉模式
• 对象不大、且创建不复杂----->饿汉模式
• 其余情况----->懒汉模式

2 工厂模式

2.1 简单工厂模式:只将产品抽象为接口

• 核心组成
  • Factory：工厂类，简单工厂模式的核心，它负责实现创建所有实例的内部逻辑
  • IProduct：抽象产品类，简单工厂模式所创建的所有对象的父类，描述所有实例所共有的公共接口
  • Product：具体产品类，是简单工厂模式的创建目标

2.2 工厂方法模式：将产品和工厂都抽象为接口（一个工厂只生产一个产品）

• 核心组成
  • IProduct：抽象产品类，描述所有实例所共有的公共接口
  • Product：具体产品类，实现抽象产品类的接口，工厂类创建对象，如果有多个需要定义多个
  • IFactory：抽象工厂类，描述具体工厂的公共接口
  • Factory：具体工场类，实现创建产品类对象，实现抽象工厂类的接口，如果有多个需要定义多个

2.3 抽象工厂模式：将产品和工厂都抽象为接口（一个工厂生产多种产品）

• 核心组成
  • IProduct：抽象产品类，描述所有实例所共有的公共接口
  • Product：具体产品类，实现抽象产品类的接口，工厂类创建对象，如果有多个需要定义多个
  • IFactory：抽象工厂类，描述具体工厂的公共接口
  • Factory：具体工场类，实现创建产品类对象，实现抽象工厂类的接口，如果有多个需要定义多个

3.prototype原型设计模式：是一种对象创建型模式，使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，主要用于创建重复的对象，同时又能保证性能

• 浅拷贝：如果原型对象的成员变量是基本数据类型（int、double、byte、boolean、char等），将复制一份给克隆对象；
  如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址
  通过覆盖Object类的clone()方法可以实现浅克隆
• 深拷贝：无论原型对象的成员变量是基本数据类型还是引用类型，都将复制一份给克隆对象，如果需要实现深克隆，可以通过序列化(Serializable)等方式来实现
• 代码实现

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
* @className Person
* @Description TODO
* @Author DuGu 1181755282@qq.com
* @Date 2024-04-07 17:21
* @Version 1.0
*/
public class Person implements Cloneable, Serializable {

   private String name;

   private int age;

   private List<String> list=new ArrayList<>();

   /**
    * 浅拷贝：引用类型的数据只拷贝地址
    * @return
    * @throws CloneNotSupportedException
    */
   @Override
   protected Person clone() throws CloneNotSupportedException {
       return (Person) super.clone();
   }

   /**
    * 深拷贝
    * @return
    */
   public Object deepClone() {
       try {
           //输出 序列化
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           ObjectOutputStream oos = new ObjectOutputStream(baos);
           oos.writeObject(this);

           //输入 反序列化
           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
           ObjectInputStream ois = new ObjectInputStream(bais);
           Person copyObj = (Person) ois.readObject();

           return copyObj;
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       }
   }


   public Person() {
   }

   public Person(String name, int age, List<String> list) {
       this.name = name;
       this.age = age;
       this.list = list;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public List<String> getList() {
       return list;
   }

   public void setList(List<String> list) {
       this.list = list;
   }
}