23种设计模式—— 工厂设计模式

定义:

定义了一个创建产品对象的工厂接口，将实际创建工作推迟到子类工厂当中。

场景模拟：

一个面条项目的方案设计
面条项目：要方便面条品种的扩展，要便于维护，要能运行时扩展

面条类设计：

面条工厂设计：if....else if....else

一、普通oop设计方式

/*
* 面条父类
*/
public abstract class Noodles {
// 面条名称
String name;
// 每种面条制作方式不同，声明为抽象方法
public abstract void make();
// 模拟定义为每种面条打包方式一致
public void box() {
System.out.println(name + " 打包;");
}
}

/*
* 麻辣面
*/
public class MLNoodles extends Noodles {
@Override
public void make() {
this.name = "麻辣面";
System.out.println(name + "制作;");
}
}

/*
* 牛肉面
*/
public class BeefNoodles extends Noodles {
@Override
public void make() {
this.name = "牛肉面";
System.out.println(name + "制作;");
}
}

/*
* 兰州拉面
*/
public class LZNoodles extends Noodles {
@Override
public void make() {
this.name = "兰州拉面";
System.out.println(name + "制作;");
}
}

/*
* 面条订单
*/
public class OrderNoodles {
public OrderNoodles() {
Noodles noodles = null;
String ordertype;
do {
ordertype = gettype();

if (ordertype.equals("ml")) {
// 选择了麻辣面
noodles = new MLNoodles();
} else if (ordertype.equals("beef")) {
// 选择了牛肉面
noodles = new BeefNoodles();
} else if (ordertype.equals("lz")) {
// 选择了兰州拉面
noodles = new LZNoodles();
} else {
break;
}
noodles.box();
} while (true);
}

private String gettype() {
//接收用户选择
Scanner scan = new Scanner(System.in);
System.out.println("请选择您要点的面");
String str = scan.next();
return str;
}
}

/*
* 主方法测试
*/
public class NoodlesStroe {
public static void main(String[] args) {
OrderNoodles orderNoodles;
orderNoodles = new OrderNoodles();

}

}

总结：

目前的需求解决了，但是一旦新增面条种类，需要修改订单部分的代码，违反了java开闭原则（Open Close Principle），不合理。

二、简单工厂模式：定义一个实例化面条的类，封装创建对象的代码

/*
* 面条父类同上
*/

/*
* 简单工厂
*/
public class SimpleNoodlesFactory {

//实例化面条对象
public Noodles CreateNoodles(String ordertype) {
Noodles noodles = null;

if (ordertype.equals("ml")) {
// 选择了麻辣面
noodles = new MLNoodles();
} else if (ordertype.equals("beef")) {
// 选择了牛肉面
noodles = new BeefNoodles();
} else if (ordertype.equals("lz")) {
// 选择了兰州拉面
noodles = new LZNoodles();
}
return noodles;

}

}

/*
* 面条订单
*/
public class OrderNoodles {
SimpleNoodlesFactory simpleNoodlesFactory;

public OrderNoodles(SimpleNoodlesFactory simpleNoodlesFactory) {

setFactory(simpleNoodlesFactory);
}

public void setFactory(SimpleNoodlesFactory simpleNoodlesFactory) {
Noodles noodles = null;
String ordertype;

this.simpleNoodlesFactory = simpleNoodlesFactory;

do {
ordertype = gettype();
noodles = simpleNoodlesFactory.CreateNoodles(ordertype);
if (noodles != null) {
noodles.make();
noodles.box();
}
} while (true);

}

private String gettype() {
//接收用户选择
Scanner scan = new Scanner(System.in);
System.out.println("请选择您要点的面：");
String str = scan.next();
return str;
}

}

/*
* 主方法测试
*/
public class NoodlesStroe {
public static void main(String[] args) {
//实例化工厂
SimpleNoodlesFactory simpleNoodlesFactory=new SimpleNoodlesFactory();
//创建订单
OrderNoodles orderNoodles;
orderNoodles = new OrderNoodles(simpleNoodlesFactory);
}
}

总结：

解决了上个方案遗留的问题，再次新加对象种类时，无需修改订单部分代码。但项目进一步扩展，在不同地区开展加盟店，然而每个地区制作出的口味不同，进而利用工厂方法模式进行设计。

三、工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类（针对每一种产品提供一个工厂类 。通过不同的工厂实例来创建不同的产品实例）

/*
* 北京牛肉面
*/
public class BJBeefNoodles extends Noodles {
@Override
public void make() {
this.name = "北京牛肉面";
System.out.println(name+"制作;");
}
}

/*
* 北京麻辣面
*/
public class BJMLNoodles extends Noodles {
@Override
public void make() {
this.name = "北京麻辣面";
System.out.println(name+"制作;");
}
}

/*
* 上海牛肉面
*/
public class SHBeefNoodles extends Noodles {
@Override
public void make() {
this.name = "上海牛肉面";
System.out.println(name+"制作;");
}
}

/*
* 上海麻辣面
*/
public class SHMLNoodles extends Noodles {
@Override
public void make() {
this.name = "上海麻辣面";
System.out.println(name+"制作;");
}
}

/*
* 工厂方法模式——抽象订单类
*/
public abstract class OrderNoodles {
public OrderNoodles() {
Noodles noodles = null;
String ordertype;
do {
ordertype = gettype();
noodles = createNoodles(ordertype);
noodles.make();
noodles.box();
} while (true);
}

//实例化对象由加盟店具体实例化
abstract Noodles createNoodles(String ordertype);

private String gettype() {
//接收用户选择
Scanner scan = new Scanner(System.in);
System.out.println("请选择您要点的面：");
String str = scan.next();
return str;
}
}

/*
* 北京订单类
*/
public class BJOrderNoodles extends OrderNoodles {
@Override
Noodles createNoodles(String ordertype) {
Noodles noodles = null;
if (ordertype.equals("ml")) {
noodles = new BJMLNoodles();
} else if (ordertype.equals("beef")) {
noodles = new BJBeefNoodles();
}
return noodles;
}
}

/*
* 上海订单类
*/
public class SHOrderNoodles extends OrderNoodles {
@Override
Noodles createNoodles(String ordertype) {
Noodles noodles = null;

if (ordertype.equals("ml")) {
noodles = new SHMLNoodles();
} else if (ordertype.equals("beef")) {
noodles = new SHBeefNoodles();
}
return noodles;
}
}

/*
* 主方法测试
*/
public class NoodlesStroe {
public static void main(String[] args) {
OrderNoodles orderNoodles;
orderNoodles = new SHOrderNoodles();
}
}

总结：

此次改进后，只需在主方法中实例化不同的OrderNoodles对象，就可以体验不同地区的Noodles。

四、抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类（抽象工厂往往有多种方法，可以生产多种产品，即产品簇，比如工厂还可以生产饼，汤等等）。

/*
* 抽象工厂
*/
public interface AbsFactory {
public Noodles CreateNoodles(String ordertype) ;
}

/*
* 北京工厂
*/
public class BJFactory implements AbsFactory {
@Override
public Noodles CreateNoodles(String ordertype) {
Noodles noodles = null;
if (ordertype.equals("ml")) {
noodles = new BJMLNoodles();
} else if (ordertype.equals("beef")) {
noodles = new BJBeefNoodles();
}
return noodles;
}
}

/*
* 上海工厂
*/
public class SHFactory implements AbsFactory {
@Override
public Noodles CreateNoodles(String ordertype) {
Noodles noodles = null;
if (ordertype.equals("ml")) {
noodles = new SHMLNoodles();
} else if (ordertype.equals("beef")) {
noodles = new SHBeefNoodles();
}
return noodles;
}
}

/*
* 抽象工厂模式——订单类
*/
public class OrderNoodles {
AbsFactory mFactory;

public OrderNoodles(AbsFactory mFactory) {
setFactory(mFactory);
}

public void setFactory(AbsFactory mFactory) {
Noodles noodles = null;
String ordertype;
this.mFactory = mFactory;
do {
ordertype = gettype();
noodles = mFactory.CreateNoodles(ordertype);
if (noodles != null) {
noodles.make();
noodles.box();
}
} while (true);
}

private String gettype() {
//接收用户选择
Scanner scan = new Scanner(System.in);
System.out.println("请选择您要点的面：");
String str = scan.next();
return str;
}
}

/*
* 主方法测试
*/
public class NoodlesStroe {
public static void main(String[] args) {
OrderNoodles orderNoodles;
orderNoodles = new OrderNoodles(new BJFactory());
}
}

抽象工厂模式与工厂方法模式的区别：

　　抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

适用场景：

　　无论是简单工厂模式，工厂方法模式还是抽象工厂模式，它们都具有类似的特性，适用场景也十分类似。他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

　　所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。使用工厂方法后，调用端的耦合度大大降低了。并且对于工厂来说，是可以扩展的，以后如果想组装其他的产品，只需要再增加一个工厂类的实现就可以。无论是灵活性还是稳定性都得到了极大的提高。

9a06