工厂设计模式(三种)详解

工厂设计模式,顾名思义,就是用来生产对象的,在java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重,假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则,如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦

本篇主要介绍三种工厂设计模式的使用:
1、简单工厂
2、工厂方法
3、抽象工厂

简单工厂设计模式

定义:一个工厂方法,依据传入的参数,生成对应的产品对象;
角色:
1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者
使用说明:先将产品类抽象出来,比如,苹果和梨都属于水果,抽象出来一个水果类Fruit,苹果和梨就是具体的产品类,然后创建一个水果工厂,分别用来创建苹果和梨;代码如下:

水果接口

  1. public interface Fruit {
  2. void whatIm();
  3. }

具体类 苹果

  1. public class Apple implements Fruit {
  2. @Override
  3. public void whatIm() {
  4. //苹果
  5. }
  6. }

具体类 梨

  1. public class Pear implements Fruit {
  2. @Override
  3. public void whatIm() {
  4. //梨
  5. }
  6. }

具体工厂 水果工厂

  1. public class FruitFactory {
  2. public Fruit createFruit(String type) {
  3. if (type.equals("apple")) {//生产苹果
  4. return new Apple();
  5. } else if (type.equals("pear")) {//生产梨
  6. return new Pear();
  7. }
  8. return null;
  9. }
  10. }

产品使用

  1. FruitFactory mFactory = new FruitFactory();
  2. Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果
  3. Pear pear = (Pear) mFactory.createFruit("pear");//获得梨

就这样,一个非常简单的工厂设计模式就完成了,但是有没有发现什么问题呢?
对,那就是如果我想吃香蕉,想吃橘子呢,我万一什么都想吃呢??所以,以上的这种方式,每当我想添加一种水果,就必然要修改工厂类,这显然违反了开闭原则,亦不可取;所以简单工厂只适合于产品对象较少,且产品固定的需求,对于产品变化无常的需求来说显然不合适;所以我们来看下一种方式;

工厂方法设计模式

定义:将工厂提取成一个接口或抽象类,具体生产什么产品由子类决定;
角色:
抽象产品类
具体产品类
抽象工厂类
具体工厂类
使用说明:和上例中一样,产品类抽象出来,这次我们把工厂类也抽象出来,生产什么样的产品由子类来决定;
代码如下:
水果接口 苹果类和梨类 代码和上例一样

工厂接口

  1. public interface FruitFactory {
  2. Fruit createFruit();//生产水果
  3. }

苹果工厂

  1. public class AppleFactory implements FruitFactory {
  2. @Override
  3. public Fruit createFruit() {
  4. return new Apple();
  5. }
  6. }

梨工厂

  1. public class PearFactory implements FruitFactory {
  2. @Override
  3. public Fruit createFruit() {
  4. return new Pear();
  5. }
  6. }

使用

  1. AppleFactory appleFactory = new AppleFactory();
  2. PearFactory pearFactory = new PearFactory();
  3. Apple apple = (Apple) appleFactory.createFruit();//获得苹果
  4. Pear pear = (Pear) pearFactory.createFruit();//获得梨

以上这种方式,虽然解耦了,也遵循了开闭原则,但是问题根本还是没有解决啊,换汤没换药,如果我需要的产品很多的话,需要创建非常多的工厂,所以这种方式的缺点也很明显;

抽象工厂设计模式

定义:为创建一组相关或者是相互依赖的对象提供的一个接口,而不需要指定它们的具体类。
角色:和工厂方法一样
抽象工厂和工厂方法的模式基本一样,区别在于,工厂方法是生产一个具体的产品,而抽象工厂可以用来生产一组相同,有相对关系的产品;重点在于一组,一批,一系列;举个例子,假如生产小米手机,小米手机有很多系列,小米note、红米note等;假如小米note生产需要的配件有825的处理器,6英寸屏幕,而红米只需要650的处理器和5寸的屏幕就可以了;用抽象工厂来实现:

cpu接口和实现类

  1. public interface Cpu {
  2. void run();
  3. class Cpu650 implements Cpu {
  4. @Override
  5. public void run() {
  6. //625 也厉害
  7. }
  8. }
  9. class Cpu825 implements Cpu {
  10. @Override
  11. public void run() {
  12. //825 处理更强劲
  13. }
  14. }
  15. }

屏幕接口和实现类

  1. public interface Screen {
  2. void size();
  3. class Screen5 implements Screen {
  4. @Override
  5. public void size() {
  6. //5寸
  7. }
  8. }
  9. class Screen6 implements Screen {
  10. @Override
  11. public void size() {
  12. //6寸
  13. }
  14. }
  15. }

工厂接口

  1. public interface PhoneFactory {
  2. Cpu getCpu();//使用的cpu
  3. Screen getScreen();//使用的屏幕
  4. }

具体工厂实现类:小米手机工厂

  1. public class XiaoMiFactory implements PhoneFactory {
  2. @Override
  3. public Cpu getCpu() {
  4. return new Cpu.Cpu825();//高性能处理器
  5. }
  6. @Override
  7. public Screen getScreen() {
  8. return new Screen.Screen6();//6寸大屏
  9. }
  10. }

具体工厂实现类:红米手机工厂

  1. public class HongMiFactory implements PhoneFactory {
  2. @Override
  3. public Cpu getCpu() {
  4. return new Cpu.Cpu650();//高效处理器
  5. }
  6. @Override
  7. public Screen getScreen() {
  8. return new Screen.Screen5();//小屏手机
  9. }
  10. }

以上例子可以看出,抽象工厂可以解决一系列的产品生产的需求,对于大批量,多系列的产品,用抽象工厂可以更好的管理和扩展;

三种工厂方式总结:
1、对于简单工厂和工厂方法来说,两者的使用方式实际上是一样的,如果对于产品的分类和名称是确定的,数量是相对固定的,推荐使用简单工厂模式;
2、抽象工厂用来解决相对复杂的问题,适用于一系列、大批量的对象生产;

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值