23种设计模式详解代码例举和易混淆模式对比

构造类型:

　单例模式、工厂模式、抽象工厂模式、原型模式、建造者模式。

单例：

　　单例写法有很多种，非线程安全的不推荐，部分依赖语言的也不推荐，建议使用饿汉式或者双if 检查写法

　　饿汉式写法：

package com.lomi.designModel.singleton;
 
 
/**
 * 饿汉式
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class HungryTypeSingleton {
 
 
    public static void main(String[] args) {
        System.out.println("程序执行............");
 
        //只要外部类被使用，内部静态字段和静态代码块就被调用了
        HungryTypeService.t1();
 
        HungryTypeService hungryTypeService = HungryTypeService.getInstance();
        hungryTypeService.doSomeThing();
    }
 
 
}
 
class HungryTypeService{
    //饿汉式的初始化可以放到静态代码块中
    private static HungryTypeService hungryTypeService = new HungryTypeService();
 
    public HungryTypeService(){
        System.out.println("HungryTypeSingleton............");
    }
 
 
    //饿汉式的写法2，可以在静态代码块中初始化
   /* static{
        hungryTypeService = new HungryTypeService();
        System.out.println("静态代码块初始化......");
    }*/
 
 
    public static HungryTypeService getInstance(){
        return hungryTypeService;
    }
 
    public static void t1(){
        System.out.println("t1-------------");
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　懒汉式写法(非线程安全)：

package com.lomi.designModel.singleton;
 
/**
 * 懒汉式写法(非线程安全)
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class LazyTypeSingleton {
 
 
    public static void main(String[] args) {
        LazyTypeService lazyTypeService = LazyTypeService.getInstance();
 
 
        lazyTypeService.doSomeThing();
    }
 
}
 
class LazyTypeService{
    private static LazyTypeService lazyTypeService;
 
 
    public static LazyTypeService getInstance(){
        if(  lazyTypeService == null  ){
            lazyTypeService = new LazyTypeService();
        }
        return lazyTypeService;
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　懒汉式写法(线程安全)：

package com.lomi.designModel.singleton;
 
/**
 * 懒汉式写法sysnc写法，效率低(线程安全)
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class LazyTypeSingleton2 {
 
 
    public static void main(String[] args) {
        LazyTypeService2 lazyTypeService = LazyTypeService2.getInstance();
 
 
        lazyTypeService.doSomeThing();
    }
 
}
 
class LazyTypeService2{
    private static LazyTypeService2 lazyTypeService;
 
 
    public synchronized static  LazyTypeService2 getInstance(){
        if(  lazyTypeService == null  ){
            lazyTypeService = new LazyTypeService2();
        }
        return lazyTypeService;
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　懒汉式写法(双if检查写法）：

package com.lomi.designModel.singleton;
 
/**
 * 懒汉式 双if-check写法，效率高，但是又指令冲排序的问题,拿到的对象是内有初始化的对象(线程安全)
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class LazyTypeSingleton3 {
 
 
    public static void main(String[] args) {
        LazyTypeService3 lazyTypeService = LazyTypeService3.getInstance();
 
 
        lazyTypeService.doSomeThing();
    }
 
}
 
class LazyTypeService3{
    private static LazyTypeService3 lazyTypeService;
 
 
    public  static  LazyTypeService3 getInstance(){
        if(  lazyTypeService == null  ){
            synchronized ( LazyTypeService3.class ){
                if(  lazyTypeService == null ){
                    lazyTypeService = new LazyTypeService3();
                }
            }
        }
        return lazyTypeService;
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　懒汉式（双if检查+volatile）：

package com.lomi.designModel.singleton;
 
/**
 * 懒汉式,双if-check 最终写法(线程安全),相比懒汉式写法不管用不用都会一直占用着内存
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class LazyTypeSingleton4 {
 
 
    public static void main(String[] args) {
        LazyTypeService4 lazyTypeService = LazyTypeService4.getInstance();
 
 
        lazyTypeService.doSomeThing();
    }
 
}
 
class LazyTypeService4{
    private static volatile LazyTypeService4 lazyTypeService;
 
 
    public  static  LazyTypeService4 getInstance(){
        if(  lazyTypeService == null  ){
            synchronized ( LazyTypeService4.class ){
                if(  lazyTypeService == null ){
                    lazyTypeService = new LazyTypeService4();
                }
            }
        }
        return lazyTypeService;
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　内部类写法：

package com.lomi.designModel.singleton;
 
/**
 * 静态内部类单例写法
 *
 * 内部类的2个特点，
 *          第一是用到才加载，
 *          第二是保证加载的线程安全
 *
 * 和饿汉的写法区别在于，外部类可以使用只要不用到单例的方法，就不会初始化内部内，外部类静态成员变量只要外部被使用就会初始化
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class InnerClassSingleton {
 
 
    public static void main(String[] args) {
 
        System.out.println("程序执行。。。。。。。。。。");
        InnerClassService innerClassService = InnerClassService.getInstance();
        innerClassService.doSomeThing();
    }
 
}
 
class InnerClassService{
    InnerClassService(){
        System.out.println("InnerClassService初始化............");
    }
 
 
    //使用内部类持有外部的单例对象的引用，实现懒加载
    private static class InnerClassServiceInstance{
        private static final  InnerClassService innerClassService = new InnerClassService();
    }
 
 
    public  static  InnerClassService getInstance(){
        return InnerClassServiceInstance.innerClassService;
    }
 
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

　　枚举写法：

package com.lomi.designModel.singleton;
 
/**
 *
 * 基于枚举的单例，枚举本来就是单例的，天然就是一个单例，如果不用到也不会加载，只是这样语义有点混
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class EnumSingleton {
 
 
    public static void main(String[] args) {
 
        System.out.println("程序执行。。。。。。。。。。");
        EnumService enumService = EnumService.INSTANCE;
        enumService.doSomeThing();
    }
 
}
 
enum EnumService{
    INSTANCE;
 
    public void doSomeThing(){
        String msg = Thread.currentThread().getStackTrace()[1].getMethodName()+"调用了";
        System.out.println(msg);
    }
}

 单例我们需考虑三个因素

 1 单实例对象（枚举，静态常量天然就是单实例）
 2 线程安全(类加载过程天然就是线程安全，也可通过sync 等锁来控制)
 3 尽量懒加载(类枚举天然就是用到才加载，或者通过代码控制)

工厂模式：

　　简单工厂：

package com.lomi.designModel.factory;
 
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.lomi.utils.CodeUtil;
 
/**
 * 简单工厂(简单工厂一般只有一个工厂类，并既然是只有一个，那么就应该是静态的 )
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public class SimpleUserFactory {
 
    public static void main(String[] args) {
 
        User user = SimpleUserFactory.newInstance();
        System.out.println(JSONObject.toJSONString( user ));
 
    }
 
 
    //生成一个唯一ID，有随机默认名字的用户
    public static User newInstance(){
        User user = new User();
        user.setName(  CodeUtil.randomCode(3) );
        user.setId( IdUtil.getSnowflakeNextId() );
        return user;
    }
 
}
 
class User{
    private Long id;
    private String name;
 
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

　　抽象工厂(多工厂)：我们可以，单工厂生产的是一个维度不同产品，多工厂是两个维度的变化的产品。

package com.lomi.designModel.factory;
 
import com.alibaba.fastjson.JSONObject;
import com.lomi.utils.CodeUtil;
 
import cn.hutool.core.util.IdUtil;
 
/**
 *  多工厂（有多个工厂类，可以切换工厂实现类方法）,工厂模式+模板方法
 *
 *  使用情景 有部分生产逻辑类似，但是又有一部分生产逻辑不同，下面的例子在Name字段是2个工厂有自己的特色
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/18
 */
public  class MultipartUserFactory {
 
   private  AbstractUserFactory abstractUserFactory;
 
    public AbstractUserFactory getAbstractUserFactory() {
        return abstractUserFactory;
    }
 
    public void setAbstractUserFactory(AbstractUserFactory abstractUserFactory) {
        this.abstractUserFactory = abstractUserFactory;
    }
 
    public static void main(String[] args) {
 
        MultipartUserFactory multipartUserFactory = new MultipartUserFactory();
        multipartUserFactory.setAbstractUserFactory( new UserFactory1() );
 
        System.out.println( multipartUserFactory.getAbstractUserFactory().newInstance().getName() );
    }
 
}
 
 
abstract class  AbstractUserFactory{
 
    //抽象工厂的模板方法
    abstract User customFeature();
 
 
    //公共部分，特色部分有自定义特色的模板方法产生
    public User newInstance() {
            User user = customFeature();
            user.setId( IdUtil.getSnowflakeNextId() );
            return user;
    }
 
}
 
class UserFactory1 extends  AbstractUserFactory{
 
    @Override
    public User customFeature() {
        User user = new User();
        user.setName( "UserFactory1:" + CodeUtil.randomCode(3) );
        return user;
    }
}
 
 
class UserFactory2 extends  AbstractUserFactory{
 
    @Override
    public User customFeature() {
        User user = new User();
        user.setName( "UserFactory2:" + CodeUtil.randomCode(3) );
        return user;
    }
}

原型模式：

　　Java Object 对象的clone就是用法原型模式,使用的浅拷贝，

　　如果需要深拷贝可以考虑重写clone方法，然后通过 Java对象序列化接口输出到ObjectOutputStream然后再反序列化回来，或者是通过json工具序列化成JSON在反序列回来，也可以在指定需要深拷贝的字段上调用clone 方法。

原型模式类图：

package com.lomi.designModel.prototype;
 
/**
 *  原型复制的元素
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/20
 */
public class ProtoTypeItem implements  Cloneable{
 
    private String name;
    private Long age;
    private Integer state;
 
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Long getAge() {
        return age;
    }
 
    public void setAge(Long age) {
        this.age = age;
    }
 
    public Integer getState() {
        return state;
    }
 
    public void setState(Integer state) {
        this.state = state;
    }
 
    @Override
    public String toString() {
        return "ProtoTypeItem{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", state=" + state +
                '}';
    }
 
    @Override
    protected ProtoTypeItem clone() throws CloneNotSupportedException {
        ProtoTypeItem protoTypeItem = (ProtoTypeItem)super.clone();
        return protoTypeItem;
    }
 
 
    public static void main(String[] args) throws CloneNotSupportedException {
        ProtoTypeItem protoTypeItem = new ProtoTypeItem();
        protoTypeItem.setAge(1L);
        protoTypeItem.setName(new String("张三"));
        protoTypeItem.setState( 2 );
 
 
        ProtoTypeItem protoTypeItem5 = new ProtoTypeItem();
        protoTypeItem5.setAge(1L);
        protoTypeItem5.setName(new String("张三"));
        protoTypeItem5.setState( 2 );
 
 
        ProtoTypeItem protoTypeItem2 = protoTypeItem.clone();;
        ProtoTypeItem protoTypeItem3 = protoTypeItem.clone();;
        ProtoTypeItem protoTypeItem4 = protoTypeItem.clone();;
 
 
        System.out.println(protoTypeItem);
        System.out.println(protoTypeItem2);
        System.out.println(protoTypeItem3);
        System.out.println(protoTypeItem4);
 
 
        System.out.println(protoTypeItem.hashCode());
        System.out.println(protoTypeItem2.hashCode());
        System.out.println(protoTypeItem3.hashCode());
        System.out.println(protoTypeItem4.hashCode());
 
 
        System.out.println(protoTypeItem.getName()  ==  protoTypeItem2.getName() );
        System.out.println(protoTypeItem.getAge()  ==  protoTypeItem2.getAge() );
        System.out.println(protoTypeItem.getState()  ==  protoTypeItem2.getState() );
 
 
 
        System.out.println(protoTypeItem.getName()  ==  protoTypeItem5.getName() );
        System.out.println(protoTypeItem.getAge()  ==  protoTypeItem5.getAge() );
        System.out.println(protoTypeItem.getState()  ==  protoTypeItem5.getState() );
 
    }
}

建造器模式：

　　　　用处在于处理配置属性的一些检查，依赖，顺序等问题，直接new 然后设置容易遗漏，然后遗漏的问题只会在后面的使用中被发现，不同实现的构造器可以按照不同的方式构造对象，把构造过程和产品解耦了

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

package com.lomi.designModel.build;
 
import io.swagger.models.auth.In;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 *  具体的一个构造器
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/20
 */
public class SimpleUserBuilder extends  IUserBuilder {
    private Map<String,Object> configs = new HashMap<>();
 
 
 
    @Override
    public IUserBuilder setName(String name) {
        configs.put("name",name);
        return this;
    }
 
    @Override
    public IUserBuilder setAge(Long age) {
        configs.put("age",age);
        return this;
    }
 
    @Override
    public IUserBuilder setState(Integer state) {
        configs.put("state",state);
        return this;
    }
 
    //我们可以在建造的过程中检查配置是否完整
    @Override
    public User build(){
        User user = new User();
        user.setAge( (Long) configs.get("age") );
        user.setName( (String) configs.get("name") );
        user.setState( (Integer)configs.get("state") );
 
        if(  configs.get("name") == null && configs.get("age") == null ) {
            throw new RuntimeException("name和age 不能同时为空");
        }
        return user;
    }
 
 
    public static void main(String[] args) {
 
        User user = new SimpleUserBuilder().setAge(1L).setName("zs").setState(1).build();
 
        System.out.println( user );
 
 
 
    }
 
}
 
 
 
abstract class  IUserBuilder{
 
    public abstract IUserBuilder setName(String name);
    public abstract IUserBuilder setAge(Long age);
    public abstract IUserBuilder setState(Integer state);
 
    public User build(){
        return new User();
    };
}
 
class User{
 
    private String name;
    private Long age;
    private Integer state;
 
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Long getAge() {
        return age;
    }
 
    public void setAge(Long age) {
        this.age = age;
    }
 
    public Integer getState() {
        return state;
    }
 
    public void setState(Integer state) {
        this.state = state;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", state=" + state +
                '}';
    }
}

结构类型:

　　适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

适配器模式：

　　就是装换接口方法名字和理论实现类方法名字不一样的

　类的适配器：可以继承类的时候使用

package com.lomi.designModel.adapter;
 
/**
 * 类的适配器
 *
 * 1 规范是使用 AdminUserService 接口的 save方法
 * 2 但是我们别的类似系统有里面有个UserService#add方法是同样逻辑的实现只是方法名字不一样
 * 3 我们通过 UserServiceAdapter 来实现装换
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/24
 */
public class ClassAdapter {
 
    public static void main(String[] args) {
 
        UserServiceAdapter userServiceAdapter = new UserServiceAdapter();
        userServiceAdapter.save();
 
    }
 
 
}
 
 
 
class UserServiceAdapter extends  UserService implements AdminUserService {
 
    @Override
    public void save() {
        this.add();
    }
}
 
 
/**
 * 实现
 */
class UserService{
 
 
    public void add(){
        System.out.println("add 一个用户");
    }
 
 
}
 
/**
 * 接口
 */
interface  AdminUserService{
 
    void save();
 
}

　对象适配器：不能继承对象，并且已经有对象实例的情况使用

package com.lomi.designModel.adapter;
 
/**
 * 对象的适配器
 *
 * 1 已有对象  UserService2 userService2
 * 2 需要适配成 AdminUserService2@add
 * 3 使用组合或者聚合对象内部调用
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/24
 */
public class ObjectAdapter {
 
    public static void main(String[] args) {
 
        UserService2 userService2 = new UserService2();
 
        UserServiceAdapter2 userServiceAdapter2 = new UserServiceAdapter2(userService2);
        userServiceAdapter2.save();
 
 
    }
}
 
 
 
class UserServiceAdapter2 implements AdminUserService2 {
    private UserService2 userService2;
 
    public UserServiceAdapter2(UserService2 userService2){
        this.userService2 = userService2;
    }
 
    @Override
    public void save() {
       userService2.add();
    }
 
}
 
 
 
/**
 * 实现
 */
class UserService2{
 
    public void add(){
        System.out.println("add 一个用户");
    }
}
 
/**
 * 接口
 */
interface  AdminUserService2{
 
    void save();
 
}

接口的适配器:

接口有一堆方法，继承都需要重写，但是很多接口我们用不着，这时候需要接口适配器

package com.lomi.designModel.adapter;
 
/**
 * 接口适配器
 *
 * 接口有一堆方法，继承都需要重写，但是很多接口我们用不着，这时候需要接口适配器
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/24
 */
public class InterfaceAdapter {
 
    public static void main(String[] args) {
        MyUserService myUserService  = new MyUserService();
        myUserService.add();
 
 
 
    }
 
 
}
 
 
class MyUserService extends  UserService3Adapter{
    @Override
    public void add() {
        System.out.println("我重写了这个方法");
    }
}
 
 
class UserService3Adapter implements UserService3{
 
 
    @Override
    public void add() {
        System.out.println("未定义的方法");
    }
 
    @Override
    public void delete() {
        System.out.println("未定义的方法");
    }
 
    @Override
    public void update() {
        System.out.println("未定义的方法");
    }
 
    @Override
    public void query() {
        System.out.println("未定义的方法");
    }
}
 
 
interface UserService3{
 
    void add();
    void delete();
    void update();
    void query();
 
}

桥接模式:

1	`桥接模式，让有多重变化属性维度水平拓展，而不是垂直拓展,解决一个维度添加新类型，关联维度所有类型都需要写新的实现的类爆炸问题<br><br>问题jdbc 桥分别有那两种变化条件？数据库实现和数据库操作？或者jdbc不是桥接模，而是策略模式？毕竟数据库操作是几乎不会变得，能变得只有数据库实现。`

package com.lomi.designModel.bridge;
 
/**
 *  桥接模式，让有多重变化属性维度水平拓展，而不是垂直拓展
 *  比如让颜色和形状能够自由独立拓展，而不是每家一个颜色，对应的图形都要有新的实现
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/25
 */
public class BridgeDesignType {
 
    public static void main(String[] args) {
 
 
        ThreePolygon threePolygon = new ThreePolygon(new Green());
        threePolygon.draw();
 
 
    }
 
}
 
/**
 * 颜色
 */
interface Color{
 
    String getColor();
 
}
 
class  Red implements Color{
 
    @Override
    public String getColor() {
        return "红";
    }
}
 
class  Green implements Color{
 
    @Override
    public String getColor() {
        return "绿";
    }
}
 
 
/**
 *多边形
 */
abstract class Polygon{
    Color color;
 
    public Polygon( Color color){
        this.color = color;
    }
 
    abstract String getPolygon();
 
    public void  draw(){
        System.out.println("画出"+color.getColor()+"色的"+getPolygon());
    }
 
}
 
class TwoPolygon extends  Polygon{
 
    public TwoPolygon(Color color) {
        super(color);
    }
 
    @Override
    String getPolygon() {
        return "2边型";
    }
}
 
class ThreePolygon extends  Polygon{
 
    public ThreePolygon(Color color) {
        super(color);
    }
 
    @Override
    String getPolygon() {
        return "3边型";
    }
}

装饰器模式：

1	`对原来对象做了增强，但是元对象依旧有存在的价值，可以独立存在（和代理及其类似，元对象独立存在也是和代理的唯一区别）`

package com.lomi.designModel.decorator;
 
/**
 *  装饰器模式(套娃模式)
 *  对原来对象做了增强，但是元对象依旧有存在的价值，可以独立存在（和代理及其类似，元对象独立存在也是和代理的唯一区别）
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/25
 */
public class DecoratorDesignModel {
 
    public static void main(String[] args) {
        User user = new User();
 
        MZUserDecorator mzUserDecorator = new MZUserDecorator(new STUserDecorator(user));
        mzUserDecorator.show();
 
    }
 
}
 
 
interface   IUser{
 
    void show();
 
}
 
class User implements IUser{
 
 
    @Override
    public void show() {
        System.out.println("一个脑袋2只手的人");
    }
}
 
 
class MZUserDecorator implements  IUser{
    private IUser user;
    public MZUserDecorator(IUser user){
        this.user = user;
    }
    @Override
    public void show() {
        user.show();
        System.out.println("并且这个人带了帽子");
    }
}
 
 
class STUserDecorator implements  IUser{
    private IUser user;
    public STUserDecorator(IUser user){
        this.user = user;
    }
    @Override
    public void show() {
        user.show();
        System.out.println("并且这个人带了手套");
    }
}

组合模式：

　　树形结构嵌套模式，Java的 Map就是这种结构

100

101

102

103

104

105

106

107

108

109

110

111

package com.lomi.designModel.composition;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 组合模式一种树形结构模型
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/25
 */
public class CompositionDesignModel {
 
 
    public static void main(String[] args) {
        Item root = new Item("root");
 
        Item item11 = new Item("item11");
        Item item12 = new Item("item12");
        Item item13 = new Item("item13");
 
        Item item111 = new Item("item111");
        Item item112 = new Item("item112");
 
        Leaf leaf1111 = new Leaf("leaf1111");
 
 
        root.add(item11);
        root.add(item12);
        root.add(item13);
 
        item11.add(item111);
        item11.add(item112);
 
        item111.add(leaf1111);
 
 
        root.p();
 
    }
 
}
 
 
abstract class Node{
 
    abstract  String getName();
 
    abstract  List<Node> getChilds();
 
    public void p(){
        if( getChilds() == null ){
            System.out.println( getName());
        }else{
            for( Node node :getChilds()){
                node.p();
            }
            System.out.println( getName());
        }
    }
 
}
 
class Item extends Node{
 
    private List<Node> childs = new ArrayList<>();
    private String name;
 
    public Item(String name ){
        this.name = name;
    }
 
    void add(Node child){
        childs.add(child);
    }
 
    void  remove(Node node){
        childs.remove(node);
    }
 
 
    @Override
    String getName() {
        return name;
    }
 
    @Override
    List<Node> getChilds() {
        return childs;
    }
}
 
 
class Leaf extends Node{
 
    private String name;
 
    public Leaf(String name ){
        this.name = name;
    }
 
    @Override
    String getName() {
        return name;
    }
 
    @Override
    List<Node> getChilds() {
        return null;
    }
}

外观模式：

解决 部分逻辑依赖的方法或者接口多而且繁杂，这时候需要一个统筹来简化调用过程的类，核心是定义一个高层接口，来统筹复杂的过程

package com.lomi.designModel.facade;
 
/**
 *  外观模式
 *
 * 解决 部分逻辑依赖的方法或者接口多而且繁杂，这时候需要一个统筹来简化调用过程的类
 *
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/25
 */
public class FacadeDesignModel {
 
    public static void main(String[] args) {
 
        Computer computer = new Computer();
        computer.start();
 
    }
}
 
 
class Computer{
 
    private ICPU cpu = new CPU();
    private IMainBoard mainBoard = new MainBoard();
    private IMemory memory = new Memory();
 
    public void start(){
        mainBoard.electrify();
        memory.load();
        cpu.calculate();
 
    }
}
 
 
interface ICPU{
    void calculate();
}
 
 
class CPU implements  ICPU{
 
    public void calculate(){
        System.out.println("CPU开始计算");
    }
}
 
interface IMainBoard{
    void electrify();
}
 
class MainBoard implements IMainBoard{
 
    public void electrify(){
        System.out.println("主板通电");
    }
}
 
 
interface IMemory{
    void load();
}
 
class Memory implements  IMemory{
 
    public void load(){
        System.out.println("内存加载数据");
    }
}

　蝇量模式：

　　用于池，缓存，减少反复创建同样对象的消耗

package com.lomi.designModel.proxy;
 
/**
 *  代理模式
 *
 *  对服务或者对象增强，但是不需要原对象依旧存在，装饰器强调目标对象能独立存在，并且装饰器有多层装饰的隐预
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/26
 */
public class PorxyPattern {
 
    public static void main(String[] args) {
        UserServicePorxy userServicePorxy = new UserServicePorxy(new UserService());
        userServicePorxy.add();
 
    }
}
 
 
interface IUserService{
 
    void add();
}
 
class UserService implements IUserService{
 
   public void add(){
        System.out.println("添加用户");
   };
 
}
 
class UserServicePorxy implements IUserService{
 
    private UserService userService;
 
    public UserServicePorxy(UserService userService){
        this.userService = userService;
    }
 
    public void add(){
        System.out.println("先做日志");
        userService.add();
    };
 
}

代理模式：

package com.lomi.designModel.proxy;
 
/**
 *  代理模式
 *
 *  对服务或者对象增强，但是不需要原对象依旧存在，装饰器强调目标对象能独立存在，并且装饰器有多层装饰的隐预
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/26
 */
public class PorxyPattern {
 
    public static void main(String[] args) {
        UserServicePorxy userServicePorxy = new UserServicePorxy(new UserService());
        userServicePorxy.add();
 
    }
}
 
 
interface IUserService{
 
    void add();
}
 
class UserService implements IUserService{
 
   public void add(){
        System.out.println("添加用户");
   };
 
}
 
class UserServicePorxy implements IUserService{
 
    private UserService userService;
 
    public UserServicePorxy(UserService userService){
        this.userService = userService;
    }
 
    public void add(){
        System.out.println("先做日志");
        userService.add();
    };
 
}

行为类型:

　　模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

模板方法

1	`模板方法(抽象类里面的实现方法调用抽象方法，实体方法确定执行过程，抽象方法拓展实现<br><br>`

package com.lomi.designModel.templetMethod;
 
import org.apache.commons.math3.analysis.function.Abs;
 
/**
 * 模板方法(抽象类里面的实现方法调用抽象方法，实体方法确定执行过程，抽象方法拓展实现)
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/26
 */
public class TempletMethedPattern {
 
    public static void main(String[] args) {
        DiskMessageService diskMessageService = new DiskMessageService();
        diskMessageService.send();
 
 
    }
 
}
 
 
 
abstract class  AbstractMessageService{
 
 
    abstract  String getMsg();
 
   public  void  send(){
        String msg = getMsg();
        System.out.println( "我发送了：" + getMsg() );
    }
}
 
class DiskMessageService extends AbstractMessageService{
 
 
    @Override
    String getMsg() {
        return "从磁盘里面读出来的消息";
    }
}

命令模式:

　　把调用者和命令分开，调用者不需要知道命令是怎么实施的，（命令接受者是不是必须的呢？我感觉没什么必要）

package com.lomi.designModel.command;
 
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 * 命令模式，把命令和命令调用者分开，命令不知道会被谁调用（命令接受者是不是必须的呢？我感觉没什么必要）
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/26
 */
public class CommandPattern {
 
    public static void main(String[] args) throws InterruptedException {
        Invoker invoker = new Invoker();
 
        invoker.add( new RocketMQMessageSendCommand()  );
        invoker.add( new FishCommand()  );
 
 
        invoker.executeOne();
        invoker.executeOne();
 
    }
 
}
 
/**
 * 命令
 */
interface Command{
    void excute();
}
 
 
/**
 * 发送消息命令
 */
class RocketMQMessageSendCommand implements Command {
 
    @Override
    public void excute() {
        System.out.println("发送消息到mq");
    }
}
 
/**
 * 钓鱼命令
 */
class FishCommand implements Command{
 
    @Override
    public void excute() {
        System.out.println("我吊了一条大鱼");
    }
}
 
/**
 * 调用者
 */
class Invoker{
    private BlockingQueue<Command> queue = new LinkedBlockingQueue();
 
    void add(Command command) throws InterruptedException {
        queue.put(command);
    }
 
    void executeOne() throws InterruptedException {
        queue.take().excute();
    }
 
}

访问者模式：

　　让资源和针对资源的行为分开，是行为的变化拓展变得简单，但是资源类型的变化变得十分困难

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

package com.lomi.designModel.visitor;
 
import java.util.LinkedList;
import java.util.List;
 
/**
 * 访问者模式（让资源和针对资源的行为分开，是行为的变化拓展变得简单，但是资源类型的变化变得十分困难）
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/27
 */
public class VisitorPattern {
 
    public static void main(String[] args) {
 
        List<IResource> resList = new LinkedList<>();
        resList.add( new Res1() );
        resList.add( new Res2() );
        resList.add( new Res3() );
        resList.add( new Res2() );
 
        IVisitor countVisitor = new CountVisitor();
        IVisitor countRes1Visitor = new CountRes1Visitor();
        resList.forEach( item->{
            item.accept( countVisitor  );
        }  );
 
        resList.forEach( item->{
            item.accept( countRes1Visitor  );
        }  );
 
        System.out.println( countVisitor.getCount()  );
        System.out.println( countRes1Visitor.getCount()  );
 
 
    }
}
 
 
/**
 * 定义了三种资源
 */
interface  IResource{
 
    String getName();
 
    void accept(IVisitor iVisitor);
}
 
class Res1 implements  IResource{
 
    @Override
    public String getName() {
        return "1";
    }
 
    @Override
    public void accept(IVisitor iVisitor){
        iVisitor.visit(this);
    }
}
 
class Res2 implements  IResource{
 
    @Override
    public String getName() {
        return "2";
    }
 
    @Override
    public void accept(IVisitor iVisitor){
        iVisitor.visit(this);
    }
}
 
class Res3 implements  IResource{
 
    @Override
    public String getName() {
        return "3";
    }
 
    @Override
    public void accept(IVisitor iVisitor){
        iVisitor.visit(this);
    }
}
 
 
 
 
 
 
interface IVisitor{
 
    void visit(Res1 res);
    void visit(Res2 res);
    void visit(Res3 res);
 
    int getCount();
}
 
 
/**
 * 统计总个数的访问者
 */
class CountVisitor implements IVisitor{
 
    int count = 0;
 
    @Override
    public void visit(Res1 res) {
        count+=1;
    }
 
    @Override
    public void visit(Res2 res) {
        count+=1;
    }
 
    @Override
    public void visit(Res3 res) {
        count+=1;
    }
 
    @Override
    public int getCount() {
        return count;
    }
 
}
 
 
/**
 * 统计总个数的访问者
 */
class CountRes1Visitor implements IVisitor{
 
    int count = 0;
 
    @Override
    public void visit(Res1 res) {
        count+=1;
    }
 
    @Override
    public void visit(Res2 res) {
 
    }
 
    @Override
    public void visit(Res3 res) {
 
    }
 
    @Override
    public int getCount() {
        return count;
    }
 
}

迭代器模式：

1	`迭代器模式，为集合提供统一的遍历方式（Java的迭代器提供了删除和快速失败等功能更加完善）`

package com.lomi.designModel.iterator;
 
/**
 * 迭代器模式，为集合提供统一的遍历方式
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/27
 */
public class IteratorPattern {
 
    public static void main(String[] args) {
 
        MyCollection myCollection = new MyCollection();
 
 
        Iterat iterator = myCollection.iterator();
        while( iterator.hasNext() ){
            Object next = iterator.next();
            System.out.println(next);
        }
 
    }
}
 
 
 
interface Iterat<T>{
 
    T next();
    boolean hasNext();
 
}
 
interface IteratAble<T>{
 
    Iterat iterator();
}
 
 
 
 
class MyCollection implements IteratAble{
    String[] datas = new String[1024];
 
    {
        datas[0] = "1";
        datas[1] = "2";
        datas[2] = "3";
        datas[3] = "4";
        datas[4] = "5";
        datas[5] = "6";
    }
 
 
    public String[] getDatas(){
        return datas;
    }
 
     @Override
     public Iterat iterator(){
        return new MyIterat(this);
     };
 
 
     class MyIterat implements  Iterat<String>{
         private MyCollection myCollection;
         private int index;
 
         public MyIterat( MyCollection myCollection){
             this.myCollection = myCollection;
             this.index = 0;
         }
 
         @Override
         public String next() {
             String  data = myCollection.getDatas()[index];
             index++;
             return data;
         }
 
         @Override
         public boolean hasNext() {
             return (myCollection.getDatas()[index] != null);
         }
     }
 
 
}

观察者模式:

　　让感兴趣的事件监听者，可以容易的感知事件的变化

package com.lomi.designModel.observer;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 观察者模式(感知事件的变动)
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/27
 */
public class ObserverPattern {
 
    public static void main(String[] args) {
        Event event = new Event();
        Observer observer1 = new Observer1();
        Observer observer2 = new Observer2();
 
        event.regiter(observer1);
        event.regiter(observer2);
 
        event.setState(0);
        event.setState(1);
        event.setState(3);
 
 
    }
 
}
 
interface  Observer{
 
    void eventSateChange(Event event);
 
}
 
 
 
class Observer1 implements Observer{
 
    @Override
    public void eventSateChange(Event event) {
        System.out.println("观察者1看到状态变化成了："  + event.getState());
    }
}
 
class Observer2 implements Observer{
 
    @Override
    public void eventSateChange(Event event) {
        System.out.println("观察者2看到状态变化成了："  + event.getState());
    }
}
 
 
class Event{
    private Integer state;
 
    private List<Observer> observers = new ArrayList<>();
 
    public void setState(Integer state) {
        this.state = state;
        notifAll();
    }
 
    public Integer getState() {
        return state;
    }
 
 
    public List<Observer> getObservers() {
        return observers;
    }
 
    public void setObservers(List<Observer> observers) {
        this.observers = observers;
    }
 
 
    public  void regiter(Observer observer){
        observers.add(observer);
    }
 
 
    public void notifAll(){
        observers.forEach(  item->item.eventSateChange(this) );
    }
 
}

策略模式:

　　通过改变策略对象，改变真实执行的逻辑

package com.lomi.designModel.strategy;
 
/**
 * 策略模式
 * 是一和模板方法一样简单的设计模式，一句话换实现
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/27
 */
public class StategyPattern {
 
 
    public static void main(String[] args) {
        Order order = new Order();
 
        Counter counter = new Person();
        Counter counter2 = new Computer();
 
        order.setCounter( counter );
        order.getResult();
 
 
        order.setCounter( counter2 );
        order.getResult();
 
 
    }
 
 
}
 
 
interface  Counter{
    void calculate();
}
 
class Person implements Counter{
    @Override
    public void calculate() {
        System.out.println("数手指");
    }
}
 
 
class Computer implements Counter{
    @Override
    public void calculate() {
        System.out.println("用二进制算");
    }
}
 
 
 
class Order{
 
    private  Counter counter;
 
    public Counter getCounter() {
        return counter;
    }
 
    public void setCounter(Counter counter) {
        this.counter = counter;
    }
 
 
    public void getResult(){
        counter.calculate();
    }
}

责任链模式：

　　　　用户数据需要被多次处理的情况

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

package com.lomi.designModel.chain;
 
/**
 * 责任链模式
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/28
 */
public class ChainPatten {
 
    public static void main(String[] args) {
        ChainNode chainNode1 = new ChainNode1();
        ChainNode chainNode2 = new ChainNode2();
        ChainNode chainNode3 = new ChainNode3();
 
        chainNode1.addTaill(chainNode2).addTaill(chainNode3);
 
        chainNode1.in("datadata" );
 
    }
 
}
 
 
 
abstract class ChainNode{
    private ChainNode next;
    private ChainNode pre;
 
 
    public ChainNode addTaill(ChainNode newNode) {
        newNode.pre = this;
        this.next = newNode;
        return newNode;
    }
 
 
    public ChainNode getNext() {
        return next;
    }
 
    public void setNext(ChainNode next) {
        this.next = next;
    }
 
    public ChainNode getPre() {
        return pre;
    }
 
    public void setPre(ChainNode pre) {
        this.pre = pre;
    }
 
 
    abstract void in(Object data);
    abstract  void out(Object data);
 
 
     void doNextIn(Object data){
        if( getNext() == null ){
            out(data);
        }else{
            getNext().in(data);
        }
     };
 
     void doPreOut(Object data){
        if( getPre() == null ){
            return;
        }
        getPre().out(data);
     };
 
}
 
 
class ChainNode1 extends  ChainNode{
    @Override
    void in(Object data) {
        System.out.println("ChainNode1:in");
        doNextIn(data);
    }
 
    @Override
    void out(Object data) {
        System.out.println("ChainNode1:out");
        doPreOut(data);
    }
}
 
 
class ChainNode2 extends  ChainNode{
    @Override
    void in(Object data) {
        System.out.println("ChainNode2:in");
        doNextIn(data);
    }
 
    @Override
    void out(Object data) {
        System.out.println("ChainNode2:out");
        doPreOut(data);
    }
}
 
 
class ChainNode3 extends  ChainNode{
    @Override
    void in(Object data) {
        System.out.println("ChainNode3:in");
        doNextIn(data);
    }
 
    @Override
    void out(Object data) {
        System.out.println("ChainNode3:out");
        doPreOut(data);
    }
}

备忘录模式：

1	`用于建立保存点，被保存的数据允许有多个备份，并且不应该保存在自身`

100

101

102

103

104

105

106

107

108

109

110

111

112

113

package com.lomi.designModel.memo;
 
import java.util.HashMap;
 
/**
 *  备忘录模式
 *  
 *  被保存的数据允许有多个备份，并且不应该保存在自身
 *
 *
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/28
 */
public class MemoPattern {
 
 
    public static void main(String[] args) {
        User user = new User();
        user.setState(  100 );
 
 
        MemoCaretaker memoCaretaker = new MemoCaretaker();
        memoCaretaker.setMemo( "savePoint1", user.toMemo() );
 
        user.setState(200);
        memoCaretaker.setMemo( "savePoint2",user.toMemo() );
 
        user.setState(300);
        System.out.println( user );
 
        user.fromMemo( memoCaretaker.getMemo("savePoint1") );
        System.out.println( user );
 
 
        user.fromMemo( memoCaretaker.getMemo("savePoint2") );
        System.out.println( user );
 
 
 
    }
}
 
 
 
class User {
    private Integer state;
 
    public Integer getState() {
        return state;
    }
 
    public void setState(Integer state) {
        this.state = state;
    }
 
 
    /**
     *  保存点可以有多个，并且不应保存在自己哪里
     * @return
     */
    public Memo<Integer> toMemo(){
        return new Memo<>(this.state);
    }
 
    public void fromMemo(Memo<Integer>  memo){
        this.state = memo.getState();
    }
 
    @Override
    public String toString() {
        return "User{" +
                "state=" + state +
                '}';
    }
}
 
/**
 * 用来保存状态
 * @param <T>
 */
class Memo<T>{
    private T state;
 
    public Memo( T state ){
        this.state = state;
    }
 
    public T getState() {
        return state;
    }
 
    public void setState(T state) {
        this.state = state;
    }
}
 
 
/**
 * 用来统一的管理保存点
 */
class MemoCaretaker{
 
    private HashMap<String,Memo> memos = new HashMap<>();
 
    public Memo getMemo(String savePointName) {
        return memos.get(savePointName);
    }
 
    public void setMemo(String savePointName,Memo memo) {
        memos.put(savePointName,memo);
    }
}

状态模式：

　　和策略模式类似，强调状态改变以后做的事情不一样，并且状态伴随流程变化而变化，状态内部改变，策略模式是外部介入改变策略

package com.lomi.designModel.state;
 
import org.w3c.dom.ls.LSOutput;
 
/**
 * 状态模式（和策略模式类似）
 *
 * 强调状态改变以后做的事情不一样，并且状态伴随流程变化而变化，状态内部改变，策略模式是外部介入改变策略
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/29
 */
public class StatePattern {
 
    public static void main(String[] args) {
        Context context = new Context();
 
        context.doSomeThing();
        context.doSomeThing();
        context.doSomeThing();
        context.doSomeThing();
 
    }
 
}
 
 
 
class Context{
    public static State state1 = new State1();
    public static State state2 = new State2();
    public static State state3 = new State3();
 
    private State state;
 
    public  Context(){
        this.state = state1;
    }
 
    public State getState() {
        return state;
    }
 
    /**
     * 如果是策略模式一边通过对外接口改变策略，状态模式是内部流程改变状态
     * @param state
     */
    public void setState(State state) {
        this.state = state;
    }
 
    public void doSomeThing(){
        state.doSomeThing(this);
    }
}
 
interface State{
 
    void doSomeThing(Context context);
 
}
 
 
class State1 implements State{
 
 
    @Override
    public void doSomeThing(Context context) {
        System.out.println("做状态改变1的事情");
        context.setState( Context.state2 );
    }
}
 
class State2 implements State{
 
 
    @Override
    public void doSomeThing(Context context) {
        System.out.println("做状态改变2的事情");
        context.setState( Context.state3 );
    }
}
 
 
class State3 implements State{
 
 
    @Override
    public void doSomeThing(Context context) {
        System.out.println("做状态改变3的事情");
    }
}

中介者模式：

1	`中介者的作用是解耦类对象之间的关系，一切耦合都由中介来承担，尤其是多方关系的时候`

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

package com.lomi.designModel.mediator;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * 中介者模式（中介者的作用是解耦类对象之间的关系，一切耦合都由中介来承担，尤其是多方关系的时候）
 *
 * @Author ZHANGYUKUN
 * @Date 2022/10/30
 */
public class MediatorPattern {
    public static void main(String[] args) {
        Mediator mediator = new HouseMediator();
        User customer = new Customer("Customer",mediator);
        User owner = new Owner("Owner",mediator);
 
 
        owner.sendMessage("query");
        customer.sendMessage("query");
        customer.sendMessage("ok");
 
 
    }
}
 
interface  Mediator{
 
    void register(String userName,User user);
 
    void receiveMessage(String userName,String message);
 
}
 
 
class HouseMediator implements Mediator{
    private Map<String,User> users = new HashMap<>();
 
 
    @Override
    public void register(String userName, User user) {
        users.put(userName,user);
    }
 
    @Override
    public void receiveMessage(String userName, String message) {
 
        if( "Customer".equals(userName) ){
            if(  "query".equals(message) ){
                System.out.println("客人询问租房价格");
                //可以在Owner中定义询价接口，强制转换然后调用
            }else if( "ok".equals(message)){
                System.out.println("客人确定要这个房子");
            }
 
 
        }else if("Owner".equals(userName) ){
            if(  "query".equals(message) ){
                System.out.println("房主登记房屋");
            }
        }
 
    }
}
 
 
 
 
interface User{
 
    void sendMessage(String message);
 
    Mediator getMediator();
 
}
 
 
class Owner implements User{
    private String userName;
    private Mediator mediator;
 
    public Owner(String userName,Mediator mediator){
        this.mediator = mediator;
        this.userName = userName;
    }
 
    @Override
    public void sendMessage( String message) {
        mediator.receiveMessage( userName,message );
    }
 
    @Override
    public Mediator getMediator() {
        return mediator;
    }
}
 
class Customer implements User{
    private String userName;
    private Mediator mediator;
 
    public Customer(String userName,Mediator mediator){
        this.mediator = mediator;
        this.userName = userName;
    }
 
    @Override
    public void sendMessage( String message) {
        mediator.receiveMessage( userName,message );
    }
 
    @Override
    public Mediator getMediator() {
        return mediator;
    }
}

解释器模式：

　　为解释表达式之类的业务提供的设计模式，使解释表达式变得容易拓展

posted on 2022-10-18 20:06 zhangyukun 阅读(84) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 架构杂记(2)

· reactor的三种模式

· 设计模式复习笔记-菜鸟教程

· 12月19每日打卡

· 23种设计模式总结（大白话，适合小白）

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球运作规律

构造类型:

单例：

饿汉式写法：

懒汉式写法(非线程安全)：

懒汉式写法(线程安全)：

懒汉式写法(双if检查写法）：

懒汉式（双if检查+volatile）：

内部类写法：

枚举写法：

工厂模式：

简单工厂：

抽象工厂(多工厂)：我们可以，单工厂生产的是一个维度不同产品，多工厂是两个维度的变化的产品。

原型模式：

建造器模式：

结构类型:

适配器模式：

类的适配器：可以继承类的时候使用

对象适配器：不能继承对象，并且已经有对象实例的情况使用

接口的适配器:

桥接模式:

装饰器模式：

组合模式：

外观模式：

蝇量模式：

代理模式：

行为类型:

模板方法

访问者模式：

迭代器模式：

观察者模式:

策略模式:

责任链模式：

备忘录模式：

状态模式：

中介者模式：

解释器模式：

导航

公告

搜索

常用链接

随笔档案

　　饿汉式写法：

　　懒汉式写法(非线程安全)：

　　懒汉式写法(线程安全)：

　　懒汉式写法(双if检查写法）：

　　懒汉式（双if检查+volatile）：

　　内部类写法：

　　枚举写法：

　　简单工厂：

　　抽象工厂(多工厂)：我们可以，单工厂生产的是一个维度不同产品，多工厂是两个维度的变化的产品。

　类的适配器：可以继承类的时候使用

　对象适配器：不能继承对象，并且已经有对象实例的情况使用

　蝇量模式：