设计模式初识（二）创建型模式

最新推荐文章于 2022-09-26 21:02:52 发布

三笠·阿卡曼

最新推荐文章于 2022-09-26 21:02:52 发布

阅读量326

点赞数 1

分类专栏：设计模式文章标签：设计模式 java spring 面试

本文链接：https://blog.csdn.net/cjl_xupt/article/details/117405989

版权

设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文深入探讨了Java中的创建型设计模式，包括单例模式、工厂模式和建造者模式。通过示例代码展示了如何实现这些模式，如双重检查锁单例、静态内部类单例、简单工厂、工厂方法以及抽象工厂。此外，还提及了原型模式在性能优化中的作用。

摘要由CSDN通过智能技术生成

为什么使用创建型模式

创建型模式关注点"怎样创建出对象"
将创建的与使用分离开（Java中就是不使用传统的new对象的方式）
降低系统的耦合度；
使用者无需关注对象的创建细节：
- 各种工厂模式：对象的创建由工厂完成；
- 建造者模式：对象的创建由一个建造者来完成；
- 原型模式：对象的创建由原来对象克隆完成；
- 单例模式：对象时钟在系统中只有一个实例

单例模式

一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建；

双重检测锁模式+volatile

package com.vleus.design.creation.singleton;

/**
 * @author vleus
 * @date 2021年05月30日 21:25
 */
public class Person {

    private String name;

    private String age;

    private Person() {
        System.out.println("创建了Person");
    }

    private volatile static Person instance;

    //基于懒汉式模式的双重检测锁的单例模式
    public static Person guiguBoss() {

        if (instance == null) {
            synchronized (Person.class) {
                if (instance == null) {
                    Person person = new Person();
                    instance = person;
                }
            }
        }
        return instance;
    }

}

这种模式可能有指令重排的问题，加volatile即可；

静态内部类方式

package com.vleus.design.creation.singleton;

/**
 * @author vleus
 * @date 2021年08月31日 23:13
 */
public class StaticSingleton {

    private StaticSingleton() {

    }

    public static StaticSingleton getInstance() {
        return SingletonHolder.instance;
    }

    //定义静态内部类
    private static class SingletonHolder{
        private static final StaticSingleton instance = new StaticSingleton();
    }
}

单例模式的场景

多线程中的线程池；
数据库的连接池；
系统环境信息；
系统上下文（ServerContext）；
…
面试问题：
系统环境信息；
Spring是如何保持组件单例的？
ServletContext是什么？是单例吗？如何保证？
ApplicationContext是什么？是单例？怎么保证？
- ApplcationContext：在Tomcat中，一个应用（部署的一个war包）会有一个应用上下文；
- ApplicationContext：在Spring中表示整个IOC容器（怎么保证单例的），ioc容器中有很多组件；
数据库连接池一般怎么创建出啦的？如何保证单实例？

原型模式（Prototype Pattern）

概念：原型模式是用于创建重复的对象，同时又要能保证性能；
在这里插入图片描述

工厂模式

工厂模式（Factory Pattern）提供了一种创建对象的最佳方式，我们不必关系对象的创建细节，只需要根据不同情况获取不同产品即可；
工厂模式可分为静态工厂、工厂方法、抽象工厂三种；

以造车为例

简单工厂

定义一个产品的抽象类AbstractCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:07
 * @desc 工厂的产品
 */
public abstract class AbstractCar {

    String engine;

    public abstract void run();
}

整两个产品的实现类，具体是什么品牌的车
MiniCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:10
 */
public class MiniCar extends AbstractCar{

    public MiniCar() {
        this.engine = "四缸水平对峙发动机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---->嘟嘟嘟");
    }
}

VanCar

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:09
 */
public class VanCar extends AbstractCar{

    VanCar() {
        this.engine = "单缸柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---> 哒哒哒。。。");
    }
}

简单工厂类，根据传入的类型创建对应的具体的产品

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:11
 * @desc 简单工厂，产品数量少
 */
public class WulinSimpleFactory {

    //工厂的核心方法
    public AbstractCar newCar(String typeName) {
        if ("van".equals(typeName)) {
            return new VanCar();
        } else if ("mini".equals(typeName)) {
            return new MiniCar();
        }
        return null;
    }

}

整一个测试类：

package com.vleus.design.creation.factory.simpleFactory;

/**
 * @author vleus
 * @date 2021年05月31日 22:06
 */
public class MainTest {

    public static void main(String[] args) {

        WulinSimpleFactory wulinSimpleFactory = new WulinSimpleFactory();

        AbstractCar van = wulinSimpleFactory.newCar("van");
        AbstractCar mini = wulinSimpleFactory.newCar("mini");
        AbstractCar zz = wulinSimpleFactory.newCar("zz");

        System.out.println();
        System.out.println(mini);
        System.out.println(zz);


    }
}

简单工厂的特点：简单工厂就是十分简单，工厂其实就是简单的一个类，根据用户传入的类型去创建相应对象，简单但扩展难；

工厂方法

工厂方法是基于简单工厂的上层抽象，将简单工厂创建对象的方式向上提，做成一个抽象类，那么实现这个抽象类就相当于实现一个专门创造某个产品的工厂，那么扩展起来即是扩展这个抽象类即可，满足设计模式的七大原则

产品不变
抽象产品类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:07
 * @desc 工厂的产品
 */
public abstract class AbstractCar {

    String engine;

    public abstract void run();
}

实现抽象产品类的几种产品

package com.vleus.design.creation.factory.factorymethod;


/**
 * @author vleus
 * @date 2021年05月31日 22:09
 */
public class VanCar extends AbstractCar {

    VanCar() {
        this.engine = "单缸柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine + "---> 哒哒哒。。。");
    }
}

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:24
 */
public class RacingCar extends AbstractCar{

    public RacingCar() {
        this.engine = "v9发动机";
    }

    @Override
    public void run() {
        System.out.println(engine + "嗖一下。。。");
    }
}

工厂的抽象类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:27
 */
public abstract class AbstractCarFactory {

    public abstract AbstractCar newCar();
}

工厂的实现类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:28
 */
public class WulingVanCarFactory extends AbstractCarFactory{

    @Override
    public AbstractCar newCar() {
        return new VanCar();
    }
}

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:29
 */
public class WulingRacingFactory extends AbstractCarFactory {

    @Override
    public AbstractCar newCar() {
        return new RacingCar();
    }
}

测试类

package com.vleus.design.creation.factory.factorymethod;

/**
 * @author vleus
 * @date 2021年05月31日 22:33
 */
public class MainTest {

    public static void main(String[] args) {

        AbstractCarFactory carFactory = new WulingRacingFactory();
        AbstractCar abstractCar = carFactory.newCar();
        abstractCar.run();

        carFactory = new WulingVanCarFactory();
        AbstractCar vanCar = carFactory.newCar();
        vanCar.run();

    }
}

抽象工厂

建造者模式

抽象建造者类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:57
 */
public abstract class AbstractBuilder {

    Phone phone;

    abstract AbstractBuilder customCpu(String cpuName);

    abstract AbstractBuilder customMem(String mem);

    abstract AbstractBuilder customDisk(String disk);

    abstract AbstractBuilder customCam(String cam);

    Phone getProduct() {
        return phone;
    }
}

实现一个Builder类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:58
 */
public class XiaomiBuilder extends AbstractBuilder{

    public XiaomiBuilder() {
        phone = new Phone();
    }

    @Override
    AbstractBuilder customCpu(String cpuName) {
        phone.cpu = cpuName;
        return this;
    }

    @Override
    AbstractBuilder customMem(String mem) {
        phone.mem = mem;
        return this;
    }

    @Override
    AbstractBuilder customDisk(String disk) {
        phone.disk = disk;
        return this;
    }

    @Override
    AbstractBuilder customCam(String cam) {
        phone.cam = cam;
        return this;
    }
}

产品类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年05月31日 23:53
 */
public class Phone {

    protected String cpu;

    protected String mem;

    protected String disk;

    protected String cam;

    public String getCpu() {
        return cpu;
    }

    public String getMem() {
        return mem;
    }

    public String getDisk() {
        return disk;
    }

    public String getCam() {
        return cam;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Phone{");
        sb.append("cpu='").append(cpu).append('\'');
        sb.append(", mem='").append(mem).append('\'');
        sb.append(", disk='").append(disk).append('\'');
        sb.append(", cam='").append(cam).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

测试类

package com.vleus.design.creation.factory.builder;

/**
 * @author vleus
 * @date 2021年06月01日 0:00
 */
public class MainTest {

    public static void main(String[] args) {

        AbstractBuilder builder = new XiaomiBuilder();

        builder.customMem("16G");
        builder.customDisk("1T");
        builder.customCam("2亿");
        builder.customCpu("骁龙888");

        //链式建造者
        builder = builder.customCpu("骁龙888").
                customCam("2亿").
                customDisk("2T").
                customMem("16G");

        Phone product = builder.getProduct();

        System.out.println(product);
    }
}

三笠·阿卡曼

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
4
评论
设计模式初识（二）创建型模式

为什么使用创建型模式创建型模式关注点"怎样创建出对象"将创建的与使用分离开（Java中就是不使用传统的new对象的方式）降低系统的耦合度；使用者无需关注对象的创建细节：各种工厂模式：对象的创建由工厂完成；建造者模式：对象的创建由一个建造者来完成；原型模式：对象的创建由原来对象克隆完成；单例模式：对象时钟在系统中只有一个实例单例模式一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建；双重检测锁模式+volatilepackage com.vleus.desig
复制链接

扫一扫

专栏目录