《Head First设计模式》 - 抽象工厂模式

2020-04-10 16:26:31 浏览数 (3)
前言： 前沿技术一直在迭代，有一种东西是不会更新的，那就是设计模式的思想。 可以来学习学习设计模式的思维，巧妙设计！ 抽象工厂模式是工厂方法的进一步抽象，但对于OCP最为体现！

1.官方话语概述六大原则个人解读概述六大原则今日主题场景概述代码实现抽象工厂全部代码读者须知进度

1.官方话语

概述

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

六大原则
  1. 单一职责原则 （Single ResponsiBility Principle） 概括：应该有且仅有一个原因引起类的变更
  2. 里氏替换原则（liskov Substitution Principle ） 概括：基类出现的地方，子类一定可以出现
  3. 依赖倒转原则（Depndece Inversion Principle） 概括：针对接口编程，依赖于抽象而不是具体
  4. 接口隔离原则（Interface Segregation Principle） 概括：使用多个隔离的接口，比使用单个接口好 （细分接口，降低耦合）
  5. 迪米特法则 (Demeter Principle) 概括：实体应当尽量少的与其他类发生互相作用，使得系统功能模块相对独立
  6. 开闭原则（Open Close Principle） 概括： 对扩展开放，对修改关闭

个人解读

概述

设计模式在代码层级中，是让你在某种业务场景刚开始设计时，能让未来的相关需求扩展极为方便的一个思想。 简单的说，在一开始设计好，扩展是很方便的，设计模式就是这个功劳者。 对于我们本来就懒的开发人员来说，这是求之不得的。

六大原则

而对于六大原则，简单过一下就行，不用刻意理解，如果你会了面向对象和设计模式的使用，自然就遵循了。

今日主题

工厂方法模式： 概述：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

场景

火锅店，任何一个火锅订单，都包含着不同火锅类型，而不同火锅类型的套餐又不是一样的，每个火锅套餐里的东西创建采用工厂创建。

概述

一个事务（火锅）下，创建该事务下不同组件的时候可以采用（肉，菜，底料）

代码实现

抽象工厂全部代码
代码语言：javascript复制
package top.huey.designpattern.factorypattern.abstractfactory.beans;

/**
 * @author huey
 * @Description : 火锅抽象对象组件
 * @Date Created in 2018/7/29 15:18
 */
public abstract class HotPot {

    /**
     * 肉
     */
    protected String meat;

    /**
     * 菜
     */
    protected String greens;

    /**
     * 底料
     */
    protected String material;

    /**
     * @author huey
     * @Description : 每类火锅需要哪些肉，菜，底料等。
     * @Date Created in 2018/7/29 15:20
     */
    public abstract String prepare();

    /**
     * @author huey
     * @Description : 区分不同对象
     * @Date Created in 2018/7/29 15:29
     */
    public void display() {
        System.out.println(this.meat   this.greens   this.material);
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.beans;

import top.huey.designpattern.factorypattern.abstractfactory.factory.HotPotFactory;

/**
 * @author huey
 * @Description : 1类 火锅
 * @Date Created in 2018/7/29 15:18
 */
public class OneHotPot extends HotPot {

    private HotPotFactory hotPotFactory;

    /**
     * @author huey
     * @Description : 抽象工厂赋值
     * @Date Created in 2018/7/29 17:47
     */
    public OneHotPot(HotPotFactory hotPotFactory) {
        this.hotPotFactory = hotPotFactory;
    }


    /**
     * @author huey
     * @Description : 每类火锅需要哪些肉，菜，底料等。
     * 抽象工厂生产需要的肉，菜，底料
     * @Date Created in 2018/7/29 15:20
     */
    @Override
    public String prepare() {
        String meat = hotPotFactory.createMeat();
        String greens = hotPotFactory.createGreens();
        String material = hotPotFactory.createMaterial();
        this.meat = meat;
        this.greens = greens;
        this.material = material;
        return this.getClass()   "prepare----------";
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.beans;

import top.huey.designpattern.factorypattern.abstractfactory.factory.HotPotFactory;

/**
 * @author huey
 * @Description : 1类 火锅
 * @Date Created in 2018/7/29 15:18
 */
public class TwoHotPot extends HotPot {

    private HotPotFactory hotPotFactory;

    /**
     * @author huey
     * @Description : 抽象工厂赋值
     * @Date Created in 2018/7/29 17:47
     */
    public TwoHotPot(HotPotFactory hotPotFactory) {
        this.hotPotFactory = hotPotFactory;
    }


    /**
     * @author huey
     * @Description : 每类火锅需要哪些肉，菜，底料等。
     * 抽象工厂生产需要的肉，菜，底料
     * @Date Created in 2018/7/29 15:20
     */
    @Override
    public String prepare() {
        String meat = hotPotFactory.createMeat();
        String greens = hotPotFactory.createGreens();
        String material = hotPotFactory.createMaterial();
        this.meat = meat;
        this.greens = greens;
        this.material = material;
        return this.getClass()   "prepare----------";
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.creater;


import top.huey.designpattern.factorypattern.abstractfactory.beans.HotPot;

/**
 * @author huey
 * @Description : 商店
 * @Date Created in 2018/7/29 15:40
 */
public abstract class HotPotStore {

    /**
     * 暴露
     */
    public void orderHotPot() {
        /**
         *调用具体创建者
         */
        HotPot hotPot = this.createHotPot();
        hotPot.prepare();
        hotPot.display();
    }

    /**
     * @author huey
     * @Description : 抽象创建火锅对象
     * @Date Created in 2018/7/29 16:02
     */
    public abstract HotPot createHotPot();

}

package top.huey.designpattern.factorypattern.abstractfactory.creater;

import top.huey.designpattern.factorypattern.abstractfactory.beans.HotPot;
import top.huey.designpattern.factorypattern.abstractfactory.beans.OneHotPot;
import top.huey.designpattern.factorypattern.abstractfactory.factory.OneHotPotFactory;

/**
 * @author huey
 * @Description : 具体创建者
 * @Date Created in 2018/7/29 16:04
 */
public class OneHotPotStore extends HotPotStore {
    /**
     * @author huey
     * @Description : 抽象创建火锅对象
     * @Date Created in 2018/7/29 16:02
     */
    @Override
    public HotPot createHotPot() {
        return new OneHotPot(new OneHotPotFactory());
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.creater;

import top.huey.designpattern.factorypattern.abstractfactory.beans.HotPot;
import top.huey.designpattern.factorypattern.abstractfactory.beans.TwoHotPot;
import top.huey.designpattern.factorypattern.abstractfactory.factory.TwoHotPotFactory;

/**
 * @author huey
 * @Description : 具体创建者
 * @Date Created in 2018/7/29 16:04
 */
public class TwoHotPotStore extends HotPotStore {
    /**
     * @author huey
     * @Description : 抽象创建火锅对象
     * @Date Created in 2018/7/29 16:02
     */
    @Override
    public HotPot createHotPot() {
        return new TwoHotPot(new TwoHotPotFactory());
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.factory;

/**
 * @author huey
 * @Description : 建造对象
 * @Date Created in 2018/7/29 15:33
 */
public abstract class HotPotFactory {

    public abstract String createMeat();

    public abstract String createGreens();

    public abstract String createMaterial();
}

package top.huey.designpattern.factorypattern.abstractfactory.factory;

/**
 * @author huey
 * @Description : 1类火锅需要的工厂
 * @Date Created in 2018/7/29 17:48
 */
public class OneHotPotFactory extends HotPotFactory {

    private String prefix = "one";

    /**
     * @author huey
     * @Description : 具体生产组件 模拟
     * @Date Created in 2018/7/29 17:49
     */
    @Override
    public String createMeat() {
        return prefix   "createMeat";
    }

    @Override
    public String createGreens() {
        return prefix   "createGreens";
    }

    @Override
    public String createMaterial() {
        return prefix   "createMaterial";
    }
}

package top.huey.designpattern.factorypattern.abstractfactory.factory;

/**
 * @author huey
 * @Description : 2类火锅需要的工厂
 * @Date Created in 2018/7/29 17:48
 */
public class TwoHotPotFactory extends HotPotFactory {

    private String prefix = "two";

    /**
     * @author huey
     * @Description : 具体生产组件 模拟
     * @Date Created in 2018/7/29 17:49
     */
    @Override
    public String createMeat() {
        return prefix   "createMeat";
    }

    @Override
    public String createGreens() {
        return prefix   "createGreens";
    }

    @Override
    public String createMaterial() {
        return prefix   "createMaterial";
    }
}

package top.huey.designpattern.factorypattern.abstractfactory;

import org.junit.Test;
import top.huey.designpattern.factorypattern.abstractfactory.creater.HotPotStore;
import top.huey.designpattern.factorypattern.abstractfactory.creater.OneHotPotStore;
import top.huey.designpattern.factorypattern.abstractfactory.creater.TwoHotPotStore;

/**
 * @author huey
 * @Description : 抽象工厂测试
 * @Date Created in 2018/7/29 17:48
 */
public class AbstractFactoryTest {

    @Test
    public void test1() {
        HotPotStore hotPotStore1 = new OneHotPotStore();
        hotPotStore1.orderHotPot();
        HotPotStore hotPotStore2 = new TwoHotPotStore();
        hotPotStore2.orderHotPot();
    }
}
读者须知

1.本系列文章内容会比较简陋，望有兴趣读者还是fork源码，调试一下。（如果你看过该书，一定可以加深印象） 2.联想下实际运用的哪些业务场景用到该模式，哪些中间件用到该模式，是否自己能在业务中使用。 3.即使你现在用不到某些设计模式，但是还是应该理解其原理的。 4.当时理解并不意味着自己已会，可以自己尝试练习，并幻想一种业务场景，画画类图，设计一下。

coding 时，做到了如何落实; writing时，做到了如何表达; sharing时，做到了如何传授; thinking时，做到了如何提升;

代码请参考码云:https://gitee.com/tjhuey/CodingGroup 设计模式相关概念请参考:http://naotu.baidu.com/file/5811bf42020e6a2d877b992cfca90d26

进度

√策略模式，已完成

√观察者模式，已完成;

√装饰者模式，已完成;

√工厂方法模式，已完成;

√抽象工厂模式，已完成;

x..，未完成;

coding fork interface sharing 设计模式

0 人点赞