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

时间  2019-11-17
标签 设计 模式 简单 工厂 方法 抽象 繁體版
原文   原文链接

工厂方法模式

概要

  1. 一个抽象产品类
  2. 多个具体产品类
  3. 一个抽象工厂
  4. 多个具体工厂 - 每个具体产品对应一个具体工厂
  5. 符合 - OCP开放封闭原则

image

优势

  1. 下降了代码耦合度，对象的生成交给子类去完成
  2. 实现了开放封闭原则 - 每次添加子产品 不须要修改原有代码

缺点

  1. 增长了代码量，每一个具体产品都须要一个具体工厂
  2. 当增长抽象产品 也就是添加一个其余产品族 须要修改工厂 违背OCP

代码角度进一步解读

抽象产品类java

/** * @author cuishifeng * @create 2018-08-02 **/
public interface Computer {

    /** * 生产电脑 */
    void createComputer();
}

复制代码

具体产品git

/** * @author cuishifeng * @create 2018-08-02 **/
public class Cpu implements Computer {

    @Override
    public void createComputer() {
        System.out.println("生产cpu");
    }
}

复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class Disk implements Computer {

    @Override
    public void createComputer() {
        System.out.println("生产磁盘disk");
    }
}

复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class Displayer implements Computer {
    @Override
    public void createComputer() {
        System.out.println("生产显卡displayer");
    }
}
复制代码

抽象工厂类github

/** * @author cuishifeng * @create 2018-08-02 **/
public interface ComputerFactory {

    /** * 工厂方法模式的抽象工厂 * @return */
     Computer getProduct();
}

复制代码

具体工厂ide

/** * @author cuishifeng * @create 2018-08-02 **/
public class CpuFactory implements ComputerFactory {

    @Override
    public Computer getProduct() {
        return new Cpu();
    }
}
复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class DiskFactory implements ComputerFactory{
    @Override
    public Computer getProduct() {
        return new Disk();
    }
}
复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class DisplayerFactory implements ComputerFactory {
    @Override
    public Computer getProduct() {
        return new Displayer();
    }
}
复制代码
/** * 客户端 * @author cuishifeng * @create 2018-08-02 **/
public class AppClient {

    public static void main(String[] args) {
        ComputerFactory computerFactory = new CpuFactory();
        computerFactory.getProduct().createComputer();

        System.out.println("---------------------------- ");

        computerFactory = new DiskFactory();
        computerFactory.getProduct().createComputer();

        System.out.println("---------------------------- ");

        computerFactory = new DisplayerFactory();
        computerFactory.getProduct().createComputer();

    }
}
复制代码

打印结果ui

生产cpu
---------------------------- 
生产磁盘disk
---------------------------- 
生产显卡displayer

Process finished with exit code 0
复制代码

抽象工厂模式

概要

  1. 多个抽象产品类
  2. 具体产品类
  3. 抽象工厂类 - 声明(一组)返回抽象产品的方法
  4. 具体工厂类 - 生成(一组)具体产品

image

优势

  1. 代码解耦
  2. 实现多个产品族(相关联产品组成的家族)，而工厂方法模式的单个产品,能够知足更多的生产需求
  3. 很好的知足OCP开放封闭原则
  4. 抽象工厂模式中咱们能够定义实现不止一个接口，一个工厂也能够生成不止一个产品类 对于复杂对象的生产至关灵活易扩展

缺点

1.扩展产品族至关麻烦 并且扩展产品族会违反OCP,由于要修改全部的工厂，例如咱们有电脑和鼠标组成的一个产品族，咱们写完代码再去添加一个键盘就会很麻烦，看完下面代码就会理解了spa

2.因为抽象工厂模式是工厂方法模式的扩展 整体的来讲 很笨重.net

代码角度进一步解读

抽象产品code

/** * 计算机-抽象产品类 * @author cuishifeng * @create 2018-08-02 **/
public abstract class Computer {

    /** * 生产计算机 */
    public abstract void productComputer();
}
复制代码
/** * 鼠标 - 抽象产品类 * @author cuishifeng * @create 2018-08-02 **/
public abstract class Mouse {

    /** * 生产鼠标 */
    public abstract void productMouse();
}
复制代码

具体产品orm

电脑的具体产品cdn

/** * PC计算机具体产品类 * @author cuishifeng * @create 2018-08-02 **/
public class PcComputer extends Computer {

    @Override
    public void productComputer() {
        System.out.println("PC端计算机");
    }
}
复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class ServerComputer extends Computer {

    @Override
    public void productComputer() {
        System.out.println("Server端计算机");
    }
}
复制代码

鼠标具体产品

/** * @author cuishifeng * @create 2018-08-02 **/
public class GameMouse extends Mouse {

    @Override
    public void productMouse() {
        System.out.println("游戏鼠标");
    }
}
复制代码
/** * @author cuishifeng * @create 2018-08-02 **/
public class OfficeMouse extends Mouse {

    @Override
    public void productMouse() {
        System.out.println("办公鼠标");
    }
}
复制代码

抽象工厂

/** * @author cuishifeng * @create 2018-08-02 **/
public interface IFactory {

    /** * 获取计算机 * @return */
    Computer getComputer();

    /** * 获取鼠标 * @return */
    Mouse getMouse();

}

复制代码

产品A具体工厂

/** * @author cuishifeng * @create 2018-08-02 **/
public class ProductFactoryA implements IFactory {

    @Override
    public Computer getComputer() {
        return new PcComputer();
    }

    @Override
    public Mouse getMouse() {
        return new OfficeMouse();
    }
}
复制代码

产品B具体工厂

/** * @author cuishifeng * @create 2018-08-02 **/
public class ProductFactoryB implements IFactory {
    @Override
    public Computer getComputer() {
        return new ServerComputer();
    }

    @Override
    public Mouse getMouse() {
        return new GameMouse();
    }
}
复制代码

简单工厂

概要

  1. 一个抽象产品类
  2. 具体产品类
  3. 一个工厂

优势

  1. 简单易于实现
  2. 把类的实例化交给工厂,易于解耦

缺点

1.添加具体产品须要修改工厂 违反OCP开放封闭原则

代码角度进一步解读

抽象产品类

/** * @author cuishifeng * @create 2018-07-09 **/
public interface Car {

    /** * 我有一辆什么车 */
     void myCar();
}

复制代码

具体产品

/** * @author cuishifeng * @create 2018-07-09 **/

public class BenChiCar implements Car {


    @Override
    public void myCar() {
        System.out.println("我有一辆奔驰车！");
    }
}
复制代码
public class FerrariCar implements Car {

    @Override
    public void myCar() {
        System.out.println("我有一辆法拉利！");
    }
}
复制代码
public class LamborghiniCar implements Car {
    @Override
    public void myCar() {
        System.out.println("我有一辆兰博基尼！");
    }
}
复制代码

工厂类

public class CarFactory {

    public static Car createCar(String carName){
        if (carName == null){
            return null;
        }
        switch (carName){
            case "BenChiCar":
                return new BenChiCar();
            case "FerrariCar":
                return new FerrariCar();
            case "LamborghiniCar":
                return new LamborghiniCar();
            default:
                return null;
        }
    }
}
复制代码
Car car = CarFactory.createCar("BenChiCar");
car.myCar();

Car car2 = CarFactory.createCar("FerrariCar");
car2.myCar();

输出

我有一辆奔驰车！
我有一辆法拉利！
复制代码

总结

简单工厂模式最大的有点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当咱们须要什么产品只须要修改客户端的调用而不须要去修改工厂，对于客户端来讲下降了与具体产品的依赖

工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，若是像添加功能只须要修改客户和添加具体的功能，不用去修改以前的类。

抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象工厂模式不单单遵循了OCP原则(对扩展开放，对修改关闭)，并且能够添加更多产品(抽象产品),具体工厂也不单单能够生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，可是要是扩展族系就会很笨重。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程