java设计模式--创建型分类

/**
 * @author: xbl
 * @Date: 2022/9/14/16/14
 * @说明：
 * @类中文名：单例模式 ：饿汉模式
 */
public class Singleton {
    private static final Singleton singleton = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {

        return singleton;
    }
    public static void doSomething() {
        
    }


}

/**
 * @author: xbl
 * @Date: 2022/9/14/16/14
 * @说明：
 * @类中文名：单例模式 :懒汉
 */
 class Singleton {
    private static final Singleton singleton = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            return new Singleton();
        }
        return singleton;
    }

    public static void doSomething() {

    }

}

1.2单例的优缺点：

1.2.1优点：

由于单例模式在内存中只有一个实例，减少了内存开支.（特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显）
由于单例模式只生成一个实例，所以减少了系统的性能开销。
单例模式可以避免对资源的多重占用
单例模式可以在系统设置全局的访问点，优化和共享资源访问

1.2.2缺点：

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途

径可以实现。
单例对测试不可，单例模式与单一职责原则有冲突

1.3单例的使用场景

要求生成唯一序列号的环境；
在整个项目中需要一个共享访问点或共享数据
创建一个对象需要消耗的资源过多
需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式

1.4线程安全

//懒汉模式加Synchronized
 final class ThreadSafeSingleton
{
    private static ThreadSafeSingleton singObj = null;

    private ThreadSafeSingleton(){
    }

    public static synchronized   ThreadSafeSingleton getSingleInstance(){
    if(null == singObj ){
        singObj = new ThreadSafeSingleton();
    }
    return singObj;
}

//双重检查锁
 final class DoubleCheckedSingleton
{
    private static DoubleCheckedSingleton singObj = null;

    private DoubleCheckedSingleton(){
    }

    public static DoubleCheckedSingleton getSingleInstance(){
        if(null == singObj ) {
            synchronized(DoubleCheckedSingleton.class){
                if(null == singObj){
                    singObj = new DoubleCheckedSingleton();  
                }
                   
            }
        }
        return singObj;
    }
}

2.工厂模式

2.1工厂方法

2.2代码

2.2.1 产品抽象类


/**
 * @author: xbl
 * @Date: 2022/9/14/16/42
 * @说明：
 * @类中文名：
 */
public abstract class Product {
    /**
     * 产品类的公共方法
     */
    public void method1(){
        //业务逻辑处理
    }
    /**抽象方法**/
    public abstract void method2();
}

2.2.2具体产品类

public class ConcreteProduct1 extends Product{

    @Override
    public void method2() {
        
    }
}

public class ConcreteProduct2 extends Product{

    @Override
    public void method2() {

    }
}

2.2.3抽象工厂类

/**
 * @author: xbl
 * @Date: 2022/9/14/16/49
 * @说明：
 * @类中文名：
 */
public abstract  class Creator {

    /**
     * 创建一个产品对象，其输入参数类可以自行设置
     * 通常为String Enum Class 等
     * @param c 参数
     * @param <T> 类型
     * @return
     */
    public abstract <T extends  Product>T createProduct(Class<T>c);
}

2.2.4具体工厂类

public class  ConcreteCreator extends Creator{

    @Override
    public <T extends Product> T createProduct(Class<T> c) {
       Product p = null;
       try{
           p=(Product)Class.forName(c.getName()).newInstance();
       }catch (Exception e){
           
       }
       return (T)p;
    }
}

2.25场景类

/**
 * @author: xbl
 * @Date: 2022/9/14/16/58
 * @说明：
 * @类中文名：
 */
public class Client { 
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class); 
        /** 继续业务处理 */ 
    }
}

2.3 简单工厂模式


/**
 * @author: xbl
 * @Date: 2022/9/14/17/13
 * @说明：
 * @类中文名：
 */
public class ProduceFactory {
    public static <T extends  Produce> T createProduce(Class<T> c){
        //定义一个生产出来的产品
        Produce produce=null;
        try{
            produce=(Produce)Class.forName(c.getName()).newInstance();
        }catch (Exception e){
          e.printStackTrace();
        }
        return (T) produce;
    }
}

public abstract class Produce {
    /**
     * 产品类的公共方法
     */
    public void method1(){
        //业务逻辑处理
    }
    /**抽象方法**/
    public abstract void method2();
}

public class SonProduce extends Produce{

    @Override
    public void method2() {

    }
}

public class SonProduce2 extends Produce{

    @Override
    public void method2() {

    }
}

2.4抽象工厂

2.4.1抽象工厂


/**
 * @author: xbl
 * @Date: 2022/9/14/17/21
 * @说明：
 * @类中文名：
 */
public abstract class AbstractProduceFactory {
    /**
     * 创建产品类
     * @return
     */
    public abstract  <T extends Produce>T createProduce(Class<T> c);

    }

2.4.2具体工厂

/**
 * @author: xbl
 * @Date: 2022/9/14/17/13
 * @说明：
 * @类中文名：可以多个
 */
public class ProduceFactory extends AbstractProduceFactory{
    @Override
    public <T extends Produce> T createProduce(Class<T> c){
        //定义一个生产出来的产品
        Produce produce=null;
        try{
            produce=(Produce)Class.forName(c.getName()).newInstance();
        }catch (Exception e){
          e.printStackTrace();
        }
        return (T) produce;
    }
}

2.4.3抽象实体

/**
 * @author: xbl
 * @Date: 2022/9/14/17/16
 * @说明：
 * @类中文名：
 */
public abstract class Produce {
    /**
     * 产品类的公共方法
     */
    public void method1(){
        //业务逻辑处理
    }
    /**抽象方法**/
    public abstract void method2();
}

2.4.4具体实体

public class SonProduce extends Produce {

    @Override
    public void method2() {

    }
}

public class SonProduce2 extends Produce {

    @Override
    public void method2() {

    }
}

2.5 单例与工厂结合


/**
 * @author: xbl
 * @Date: 2022/9/14/17/43
 * @说明：
 * @类中文名：
 */
public class Singleton{
    //不允许通过new 产生一个对象
    private Singleton(){}
    public void doSomething(){
        //业务处理
    }
}

import java.lang.reflect.Constructor;

/**
 * @author: xbl
 * @Date: 2022/9/14/17/43
 * @说明：
 * @类中文名：
 */
public class SingletonFactory {
    private static Singleton  singleton;
    static {
        try{
            Class cl=Class.forName(Singleton.class.getName());
            //获取无参构造
            Constructor constructor=cl.getDeclaredConstructor();
            //设置无参构造是可访问的
            constructor.setAccessible(true);
            //产生一个实例对象
            singleton=(Singleton)constructor.newInstance();
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public  static  Singleton getSingleton(){
        return singleton;
    }
}

2.6延迟初始化

/**
 * @author: xbl
 * @Date: 2022/9/14/17/51
 * @说明：
 * @类中文名：
 */
public class ProductFactory {
    private static final Map<String , Product> pMap=new HashMap();
    public static synchronized  Product createProduct(String type){
        Product product=null;
        //如果Map中已经有这个对象
        if(pMap.containsKey(type)){
            product=pMap.get(type);
        }else{
            if(type.equals("Product1")){
                product=new ConcreteProduct1();
            }
            else{
                product=new ConcreteProduct2();
            }
            pMap.put(type,product);
        }
        return product;
    }
}

/**
 * @author: xbl
 * @Date: 2022/9/14/16/42
 * @说明：
 * @类中文名：
 */
public abstract class Product {
    /**
     * 产品类的公共方法
     */
    public void method1(){
        //业务逻辑处理
    }
    /**抽象方法**/
    public abstract void method2();
}



import createmodel.factory.Product;

class ConcreteProduct1 extends Product {

   @Override
   public void method2() {

   }
}


import createmodel.factory.Product;

public class ConcreteProduct2 extends Product {

    @Override
    public void method2() {

    }
}

3.抽象工厂

3.1工厂类：


/**
 * @author: xbl
 * @Date: 2022/9/15/09/38
 * @说明：
 * @类中文名： 抽象工厂类
 */
public abstract  class AbstractCreator {
    /**
     * 创建A产品家族
     */
    public abstract AbstractProductA createProductA();
    /**
     * 创建B产品家族
     */
    public abstract AbstractProductB createProductB();

}

/**
 * 具体实现工厂
 */
class Creator1 extends AbstractCreator{

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}


/**
 * 具体实现工厂
 */
class Creator2 extends AbstractCreator{

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

3.2具体实体类

/**
 * @author: xbl
 * @Date: 2022/9/15/09/34
 * @说明：
 * @类中文名： 具体产品类 A
 */
public abstract class AbstractProductA {
    /**
     * 每个产品共有的方法
     */
     public void shareMethod(){ }
    /**
     * 每个产品相同方法，不同实现
     */
     public abstract void doSomething();
}

/**
 * 产品实现类
 */
class ProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

/**
 * 产品实现类
 */
class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

/**
 * @author: xbl
 * @Date: 2022/9/15/09/34
 * @说明：
 * @类中文名： 具体产品类 B
 */
public abstract class AbstractProductB {
    /**
     * 每个产品共有的方法
     */
     public void shareMethod(){ }
    /**
     * 每个产品相同方法，不同实现
     */
     public abstract void doSomething();
}

/**
 * 产品实现类
 */
class ProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

/**
 * 产品实现类
 */
class ProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

3.3场景类


/**
 * @author: xbl
 * @Date: 2022/9/15/09/42
 * @说明：
 * @类中文名：
 */
public class Client {
    public static void main(String[] args) {
        //定义出两个工厂
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        //产生A1对象
        AbstractProductA a1 = creator1.createProductA();
        //产生A2对象
        AbstractProductA a2 = creator2.createProductA();
        //产生B1对象
        AbstractProductB b1 = creator1.createProductB();
        //产生B2对象
        AbstractProductB b2 = creator2.createProductB();
        /** 然后在这里就可以为所欲为了... */
    }
}

3.4优点：

封装性，每个产品的实现类不是高层模块要关心的，它要关心的是接口，是抽象
产品族内的约束为非公开状态

3.5缺点：

产品族扩展非常困难

3.6使用场景：

一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式

4.原型模式

4.1解释与UML图

原型模式：通过拷贝原有的原型对象来创建新的对象。

UML：

/**
 * @author: xbl
 * @Date: 2022/9/15/10/01
 * @说明：
 * @类中文名：
 */
public class ProtopeClass implements  Cloneable{
    @Override
    public ProtopeClass clone() {
        ProtopeClass protopeClass=null;
        try{
            protopeClass= (ProtopeClass) super.clone();
            
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return protopeClass;
    }
}

4.2优点：

1. 原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多

2.逃避构造函数的约束

4.3缺点：

1. 不会执行构造函数，减少了约束

4.4使用场景

1. 资源优化场景：类初始化需要消耗非常多资源

2.性能和安全要求，对一个类的new需要非常繁琐的数据准备或访问权限就可以使用原型模式

3.一个对象多个修改者的场景

4.5浅拷贝和深拷贝

浅拷贝：Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝。

/**
 * @author: xbl
 * @Date: 2022/9/15/10/10
 * @说明：
 * @类中文名：
 */
public class ThingProtope implements Cloneable {
    /**
     * 步骤1：定义一个私有变量
     */
    private ArrayList<String> arrayList=new ArrayList<String>();
    /**
     * 步骤2：重写一个clone
     */
    @Override
    public ThingProtope clone(){
        ThingProtope thingProtope=null;
        try{
            thingProtope= (ThingProtope) super.clone();
        }catch (Exception e){
            e.printStackTrace();
        }
        return thingProtope;
    }
    /**
     * 步骤3：设置HashMap值
     */
    public void setValue(String value){
        this.arrayList.add(value);
    }
    /**
     * 获取arrayList的值
     */
    public ArrayList<String> getValue(){
        return this.arrayList;
    }
}

public class Client {
     public static void main(String[] args) {
     //产生一个对象 
    ThingProtope thing = new Thing();
    //设置一个值 
    thing.setValue("张三"); 
    //拷贝一个对象 
    ThingProtope cloneThing = thing.clone(); 
    cloneThing.setValue("李四"); 
    System.out.println(thing.getValue());
    }
}

深拷贝：

import java.util.ArrayList;

/**
 * @author: xbl
 * @Date: 2022/9/15/10/18
 * @说明：
 * @类中文名：
 */
public class Thing2Protope implements Cloneable{
    /**
     *  定义一个私有变量 
     */
    private ArrayList<String> arrayList = new ArrayList<String>();
    @Override 
    public Thing2Protope clone(){
        Thing2Protope thing=null; try { 
            thing = (Thing2Protope)super.clone(); 
            thing.arrayList = (ArrayList<String>)this.arrayList.clone();
        } catch (CloneNotSupportedException e) { 
            e.printStackTrace();
        }
        return thing;
    } 
}

要使用 clone 方法，类的成员变量上不要增加 final 关键字。

5.建造者模式

5.1解释与UML

解释：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

UML:

名称	解释
Product	已经实现模板方法的产品类
Builder	抽象建造者，规范产品组建。
ConcreteBuilder	具体建造者，实现抽象类定义的所有方法，并返回一个组建好的对象
Director	导演类，负责安排已有模块顺序，然后告诉Builder开始建造

5.2代码

/**
 * @author: xbl
 * @Date: 2022/9/15/10/32
 * @说明： 产品类
 */
public class Product implements Cloneable{
    public void doSomething(){
            //独立业务处理
    }

    @Override
    public Product clone() {
        Product productClass=null;
        try{
            productClass= (Product) super.clone();

        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return productClass;
    }
}


/**
 * @author: xbl
 * @Date: 2022/9/15/10/34
 * @说明：
 * @类中文名： 抽象建造者
 */
public  abstract class Builder {
    /**
     * 设置产品的不同部分，以获得不同的产品
     */
    public abstract void setPart();
    /**
     * 建造产品
     */
    public abstract  Product buildProduct();

}

/**
 * @author: xbl
 * @Date: 2022/9/15/10/34
 * @说明：
 * @类中文名： 具体建造者
 */

public class ConcreatedProduct extends Builder{
    private Product product=new Product();
    @Override
    public void setPart() {
        /**
         * 产品类内的逻辑处理
         */
    }

    /**
     * 组建一个产品
     * @return
     */
    @Override
    public Product buildProduct() {
        return product;
    }
}

/**
 * @author: xbl
 * @Date: 2022/9/15/10/38
 * @说明：
 * @类中文名： 导演类
 */
public class Director {
    private Builder builder=new ConcreatedProduct();
    /**
     * 构建不同的产品
     */
    public Product getAProduct(){
        builder.setPart();
        /**
         * 设置不同的零件，产生不同的产品
         */
        return builder.buildProduct();
    }

}