设计模式-简单工厂、工厂方法、抽象工厂方法模式

最新推荐文章于 2024-05-18 00:10:54 发布

victor_wk

最新推荐文章于 2024-05-18 00:10:54 发布

阅读量200

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/victor_wk/article/details/88197871

版权

设计模式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

工厂模式分析

简介
工厂方法模式分为：

简单工厂模式
工厂方法模式
抽象工厂方法模式

简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实

UML图示例

在这里插入图片描述

代码示例

public class EasyFactory {

    interface IProduct{
        String getCar();
    }

    static class JeepProduct implements IProduct{

        @Override
        public String getCar() {
            return "JeepCar";
        }
    }

    static class SportProduct implements IProduct{

        @Override
        public String getCar() {
            return "SportCar";
        }
    }

    static class BydProduct implements IProduct{

        @Override
        public String getCar() {
            return "BydCar";
        }
    }

    public static void main(String[] args){
        IProduct iProduct = new JeepProduct();
        IProduct iProduct1 = new SportProduct();
        IProduct iProduct2 = new BydProduct();
        System.out.println(iProduct.getCar());
        System.out.println(iProduct1.getCar());
        System.out.println(iProduct2.getCar());
    }

优点：
简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：
很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

工厂方法模式

工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

首先看一下下UML类图结构示例
　　在这里插入图片描述
　　
代码示例

public class MethodFactory {
    interface IProduct{
        String getCar();
    }

    static class JeepProduct implements IProduct{

        @Override
        public String getCar() {
            return "JeepCar";
        }
    }

    static class SportProduct implements IProduct{

        @Override
        public String getCar() {
            return "SportCar";
        }
    }

    static class BydProduct implements IProduct{

        @Override
        public String getCar() {
            return "BydCar";
        }
    }

    interface IFactory{
        IProduct createCar();
    }

    static class JeepFactory implements IFactory{

        @Override
        public IProduct createCar() {
            return new JeepProduct();
        }
    }

    static class SportFactory implements IFactory{

        @Override
        public IProduct createCar() {
            return new SportProduct();
        }
    }

    static class BydFactory implements IFactory{

        @Override
        public IProduct createCar() {
            return new BydProduct();
        }
    }

    public static void main(String[] args){
        IFactory iFactory = new JeepFactory();
        IFactory iFactory2 = new SportFactory();
        IFactory iFactory3 = new BydFactory();
        System.out.println(iFactory.createCar().getCar());
        System.out.println(iFactory2.createCar().getCar());
        System.out.println(iFactory3.createCar().getCar());
    }

优点：

子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性
屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
多态性：客户代码可以做到与特定应用无关，适用于任何实体类。

缺点：
需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次。

抽象工厂方法模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

看一下下UML类图结构示例
在这里插入图片描述
代码示例

public class AbstractMethodFactory {

    static abstract class IProductA{
        abstract String getCar();
    }

    static class JeepProduct extends IProductA{

        @Override
        public String getCar() {
            return "JeepCar";
        }
    }

    static class SportProduct extends IProductA{

        @Override
        public String getCar() {
            return "SportCar";
        }
    }

    static abstract class IProductB{
        abstract String getPacket();
    }

    static class BaaProduct extends IProductB{

        @Override
        String getPacket() {
            return "BaaProduct";
        }
    }

    static class BbbProduct extends IProductB{

        @Override
        String getPacket() {
            return "BbbProduct";
        }
    }

    static abstract class IFactory{
        abstract IProductA createCar();
        abstract IProductB createPacket();
    }

    static class JeepFactory extends IFactory{

        @Override
        public IProductA createCar() {
            return new JeepProduct();
        }

        @Override
        IProductB createPacket() {
            return new BaaProduct();
        }
    }

    static class SportFactory extends IFactory{

        @Override
        public IProductA createCar() {
            return new SportProduct();
        }

        @Override
        IProductB createPacket() {
            return new BbbProduct();
        }
    }

    public static void main(String[] args){
        IFactory iFactory = new JeepFactory();
        IFactory iFactory2 = new SportFactory();
        System.out.println(iFactory.createCar().getCar()+"          "+iFactory.createPacket().getPacket());
        System.out.println(iFactory2.createCar().getCar()+"          "+iFactory2.createPacket().getPacket());
    }

优点：