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

栏目: 后端 · 发布时间: 5年前

内容简介:抽象产品类具体产品抽象工厂类
  1. 一个抽象产品类
  2. 多个具体产品类
  3. 一个抽象工厂
  4. 多个具体工厂 - 每一个具体产品对应一个具体工厂
  5. 符合 -OCP开放封闭原则
设计模式-简单工厂、工厂方法模式、抽象工厂模式

优点

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

缺点

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

代码角度进一步解读

抽象产品类

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

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

复制代码

具体产品

/**
 * @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");
    }
}
复制代码

抽象工厂类

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

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

复制代码

具体工厂

/**
 * @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();

    }
}
复制代码

打印结果

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

Process finished with exit code 0
复制代码

抽象工厂模式

概要

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

优点

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

缺点

1.扩展产品族相当麻烦 而且扩展产品族会违反OCP,因为要修改所有的工厂,例如我们有电脑和鼠标组成的一个产品族,我们写完代码再去添加一个键盘就会很麻烦,看完下面代码就会理解了

2.由于抽象工厂模式是工厂方法模式的扩展 总体的来说 很笨重

代码角度进一步解读

抽象产品

/**
 * 计算机-抽象产品类
 * @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();
}
复制代码

具体产品

电脑的具体产品

/**
 * 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原则(对扩展开放,对修改关闭),而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品,而是生成一组产品,抽象工厂也是声明一组产品,对应扩展更加灵活,但是要是扩展族系就会很笨重。


以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

锋利的jQuery

锋利的jQuery

单东林、张晓菲、魏然 / 人民邮电出版社 / 2012-7-1 / 49.00元

《锋利的jQuery(第2版)》循序渐进地对jQuery的各种函数和方法调用进行了介绍,读者可以系统地掌握jQuery的选择器、DOM操作、事件和动画、AJAX应用、插件、jQuery Mobile、jQuery各个版本变化、jQuery性能优化和技巧等知识点,并结合每个章节后面的案例演示进行练习,达到掌握核心知识点的目的。 为使读者更好地进行开发实践,《锋利的jQuery(第2版)》的第8......一起来看看 《锋利的jQuery》 这本书的介绍吧!

JS 压缩/解压工具
JS 压缩/解压工具

在线压缩/解压 JS 代码

XML、JSON 在线转换
XML、JSON 在线转换

在线XML、JSON转换工具

Markdown 在线编辑器
Markdown 在线编辑器

Markdown 在线编辑器