简单工厂
简单工厂也叫静态工厂
- 简单工厂是属于创建型模式。简单工厂是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂是工厂模式家族中最简单的实用模式
- 简单工厂：定义了一个创建对象的类，由这个类来封装实例化对象的行为
在开发中，当我们会用到大量的创建某种、某类、或者某批对象时，就会使用到工厂模式。
简单的例子
生鲜
public abstract class Fresh {
protected String name;
public abstract void prepare();
public void washing() {
System.out.println(name + "正在清洗");
}
public void cut() {
System.out.println(name + "正在分切");
}
public void box() {
System.out.println(name + "正在打包");
}
}
黄瓜
public class Cucumber extends Fresh {
public Cucumber() {
super.name = "黄瓜";
}
@Override
public void prepare() {
System.out.println(super.name + "正在准备");
}
}
西蓝花
public class Broccoli extends Fresh {
public Broccoli() {
super.name = "西蓝花";
}
@Override
public void prepare() {
System.out.println(super.name + "正在准备");
}
}
生鲜厂
public class Factory {
public static Fresh create(String type) {
if (type.equals("broccoli")) {
return new Broccoli();
} else if (type.equals("cucumber")) {
return new Cucumber();
} else {
return null;
}
}
}
河马生鲜
public class Boxhorse {
public Boxhorse() {
Fresh fresh = null;
String orderType; // 订购生鲜产品
do {
fresh = Factory.create(getType());
if (null != fresh) {
fresh.prepare();
fresh.washing();
fresh.cut();
fresh.box();
} else {
System.out.println("不卖了");
break;
}
} while (true);
}
private String getType() {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input type: ");
try {
return bufferedReader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
}
Main
public class Main {
public static void main(String[] args) {
new Boxhorse();
}
}
在这里解释一下每个类的作用
Fresh.java，生鲜食品
Cucumber.java, 黄瓜
Broccoli.java 西蓝花
Factory.java 生鲜加工厂。 这个类就是我们这个简单工厂的核心代码了，它存在的意义是统一加工生产生鲜产品。你只需要告诉他一个种类，便可以得到一个你想要的食品。当后面需要新增产品时，无需修改其他地方，只需要在工厂里新增几行代码即可。改动代价小
Boxhorse.java 河马生鲜。 或许你可能会认为这个有点多余，但是实际开发过程中，生鲜商店会有很多。就好比同城的盒马有很多。如果不统一加工，那每次加工都得新开一个工厂。无法集中管理
Main.java 入口
工厂方法模式
同城的生鲜可以在一个工厂加工，但是跨省市，就无法保证新鲜了。但是为了让工序变得固定，食品安全可靠。我们需要扩大规模
public abstract class Fresh {
protected String name;
public abstract void prepare();
public void washing() {
System.out.println(name + "正在清洗");
}
public void cut() {
System.out.println(name + "正在分切");
}
public void box() {
System.out.println(name + "正在打包");
}
}
public class Panda extends Fresh {
public Panda() {
super.name = "鲜活大熊猫";
}
@Override
public void prepare() {
System.out.println(super.name + "正在清洗");
}
}
public class Octopus extends Fresh {
public Octopus() {
super.name = "鲜活八爪鱼";
}
@Override
public void prepare() {
System.out.println(super.name + "正在清洗");
}
}
public class Fungi extends Fresh {
public Fungi() {
super.name = "新鲜菌类";
}
@Override
public void prepare() {
System.out.println(super.name + "正在清洗");
}
}
public class Crab extends Fresh {
public Crab() {
super.name = "鲜活梭子蟹";
}
@Override
public void prepare() {
System.out.println(super.name + "正在清洗");
}
}
主要的四个类
public abstract class BaseFactory {
public BaseFactory(String factoryName) {
System.out.println(factoryName);
}
/**
* 订购
*/
public void shopping() {
do {
Fresh fresh = createFresh(getType());
if (null != fresh) {
fresh.prepare();
fresh.cut();
fresh.box();
} else {
System.out.println("没有，不卖了");
break;
}
} while (true);
}
/**
* 子类实现生鲜的制作，总部只负责调度，派发
*
* @param type 产品
* @return 生鲜类
*/
abstract Fresh createFresh(String type);
private String getType() {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input fresh type: ");
try {
return bufferedReader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
}
public class CDFactory extends BaseFactory {
public CDFactory() {
super("成都工厂");
}
@Override
Fresh createFresh(String type) {
if ("fungi".equals(type)) {
return new Fungi();
} else if ("panda".equals(type)) {
return new Panda();
}
return null;
}
}
public class GZFactory extends BaseFactory {
public GZFactory() {
super("广州工厂");
}
@Override
Fresh createFresh(String type) {
if ("octopus".equals(type)) {
return new Octopus();
} else if ("crab".equals(type)) {
return new Crab();
}
return null;
}
}
public class Boxhorse {
private BaseFactory factory;
public Boxhorse() {
// 需要初始化一个工厂
this.factory = new CDFactory();
}
public void shopping() {
if (null != this.factory) {
this.factory.shopping();
} else {
System.out.println("没有选择工厂");
}
}
}
生鲜类就不解释了，这里主要变化的有四个类
BaseFactory.java 工厂总部。用户下单到总部，由总部下单到子工厂。
CDFactory.java 成都工厂。成都工厂负责成都市的生鲜制作与派发，主要产品有大熊猫、菌子
GZFactory.java 广州工厂。广州工厂负责广州市的生鲜制作与派发，主要产品有梭子蟹、八爪鱼
Boxhorse.java 生鲜超市。一个生鲜超市配有一个工厂
public class Main {
public static void main(String[] args) {
new Boxhorse().shopping();
new Boxhorse2().shopping();
}
}
console
成都工厂
input fresh type:
panda
鲜活大熊猫正在清洗
鲜活大熊猫正在分切
鲜活大熊猫正在打包
input fresh type:
crab
没有，不卖了
广州工厂
input fresh type:
crab
鲜活梭子蟹正在清洗
鲜活梭子蟹正在分切
鲜活梭子蟹正在打包
input fresh type:
exit
没有，不卖了Process finished with exit code 0
下面是拓展，加入了单例模式
所有工厂必须取得证书才可以生产出产品，证书有限，只有两个。但是却有三个厂
由基类（工厂总部）进行证书的派发与校验。实际上这里才能感受到工厂方法模式最大的省事之处。
enum Authorization {
INSTANCE;
List<String> authorized = new ArrayList<>();
List<String> certificate = new ArrayList<>(Arrays.asList("A1", "A2"));
/**
* 取得证书
* @return 证书
*/
String getAuth() {
String auth = null;
if (certificate.size() > 0) {
auth = certificate.get(0);
authorized.add(auth);
certificate.remove(0);
}
return auth;
}
/**
* 检查证书
* @param auth 证书
* @return 是否存在
*/
boolean check(String auth) {
return authorized.contains(auth);
}
}
public abstract class BaseFactory{
private boolean admit = false;
private String factoryName;
public BaseFactory(String auth, String factoryName) {
this.factoryName = factoryName;
this.admit = Authorization.INSTANCE.check(auth);
}
public void shopping() {
if (admit) {
System.out.println(factoryName + "取得认证");
do {
Fresh fresh = createFresh(getType());
if (null != fresh) {
fresh.prepare();
fresh.cut();
fresh.box();
} else {
System.out.println("没有，不卖了");
break;
}
} while (true);
} else {
System.out.println(factoryName + "没有取得认证，结束");
}
}
/**
* 子类实现生鲜
* @param type 产品
* @return 生鲜类
*/
abstract Fresh createFresh(String type);
/**
* 各个工厂都需要获得证书才可以生产生鲜
* @return String
*/
protected static String authorization() {
return Authorization.INSTANCE.getAuth();
}
private String getType() {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input fresh type: ");
try {
return bufferedReader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
}
public class CDFactory extends BaseFactory {
public CDFactory() {
// 调用父类的构造器，并从父类取得证书。传递给父类
super(authorization(), "成都工厂");
}
@Override
Fresh createFresh(String type) {
if ("fungi".equals(type)) {
return new Fungi();
} else if ("panda".equals(type)) {
return new Panda();
}
return null;
}
}
public class GZFactory extends BaseFactory {
public GZFactory() {
// 调用父类的构造器，并从父类取得证书。传递给父类
super(authorization(), "广州工厂");
}
@Override
Fresh createFresh(String type) {
if ("octopus".equals(type)) {
return new Octopus();
} else if ("crab".equals(type)) {
return new Crab();
}
return null;
}
}
public class ZLFactory extends BaseFactory {
public ZLFactory() {
super(authorization(), "脏乱工厂");
}
@Override
Fresh createFresh(String type) {
if ("octopus".equals(type)) {
return new Octopus();
} else if ("crab".equals(type)) {
return new Crab();
}
return null;
}
}
public class Main {
public static void main(String[] args) {
new Boxhorse().shopping();
new Boxhorse2().shopping();
new Boxhorse3().shopping();
}
}
console
成都工厂取得认证
input fresh type:
crab
没有，不卖了
广州工厂取得认证
input fresh type:
crab
鲜活梭子蟹正在清洗
鲜活梭子蟹正在分切
鲜活梭子蟹正在打包
input fresh type:
ex
没有，不卖了
脏乱工厂没有取得认证，结束Process finished with exit code 0
