实例探索Java模式之路——简单工厂模式

简单工厂模式

简单工厂模式是所有设计模式中最简单的一种模式，我们通过了解相关概念以及一个相关的例子熟悉此模式。

1、简单工厂模式是类的创建模式，又叫静态工厂方法模式。
简单工厂模式是由一个工厂对象决定创建哪一种产品类的实例。


2、工厂模式几种形态：
工厂模式专门负责将大量的有共同接口的类实例化，工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪个类。


简单工厂模式：又叫静态工厂方法模式。
工厂方法模式：又称多态性工厂模式、虚拟构造子模式。
抽象工厂模式：工具箱模式。


3、简单工厂模式的结构：

简单工厂模式就是由工厂类根据传入的参量决定创建哪一种产品的实例。


工厂类角色：这个角色是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。
工厂类在客户端的直接调用下创建产品对象，往往由一个具体的Java类实现。
抽象产品角色:这个角色是工厂方法模式所创建的对象的父类，或者是他们共同拥有的接口。
抽象产品角色可以由Java接口或Java抽象类事项。
具体产品角色：工厂模式所创建的任何对象都是这个角色的实例，由具体的Java类实现。


4、简单工厂模式的优缺点；


优点：工厂类可以决定什么时候创建哪一个产品类的实例。客户端可以直接免除直接创建产品对象的责任，而仅仅负责消费产品。
这种做法实现了对责任的分割。

缺点：当产品类有复杂的多层次的等级结构时，工厂类只有它自己。
以不变应万变。是模式的缺点。工厂类是一个全能类，对所有的产品负责，如果什么时候不能工作了，整个系统就会受到影响。
这么多的逻辑集中放到一个类中的另一个缺点是，使得系统在将来进行功能扩展时较为困难。这样缺点在工厂方法中得到克服。


5、简单工厂模式相图


简单工厂模式中，只有一个产品等级结构，一个工厂类负责对所有产品负责。后面还有多个产品等级结构以及多个工厂的，对于产品等级结构以及产品簇的知识我们后续再了解，这里先有个认识，用处不大。真正有用的地方是在抽象工厂模式中，那里我们在详谈。


6、简单工厂角色只在有限的程度上支持开闭原则。


7、通过一个简单工厂模式例子深入理解：


有一个系统，负责向市场销售各种水果，这里我们就用简单工厂模式实现。


首先有个水果接口，以区分其他植物：


/**
 * 农村水果必须实现的接口
 */
public interface Fruit {
// 生长
void grow();


// 收获
void harvest();


// 种植
void plant();
}


苹果类：


public class Apple implements Fruit {


private int treeAge;


@Override
public void grow() {
System.out.print("Apple is growing!");
}


@Override
public void harvest() {
System.out.print("Apple is harvested!");
}


@Override
public void plant() {
System.out.print("Apple is planted!");
}


// 辅助方法
public static void log(String msg) {
System.out.print("Apple is msg!");
}


// apple的年龄
public int getTreeAge() {
return treeAge;
}


public void setTreeAge(int treeAge) {
this.treeAge = treeAge;
}


}
葡萄类：


public class Grape implements Fruit {


private boolean seedless;


@Override
public void grow() {
System.out.print("Grape is growing!");
}


@Override
public void harvest() {
System.out.print("Grape is harvested!");
}


@Override
public void plant() {
System.out.print("Grape is planted!");
}


// 辅助方法
public static void log(String msg) {
System.out.print("Grape is msg!");
}


// Grape的种子类型
public boolean isSeedless() {
return seedless;
}


public void setSeedless(boolean seedless) {
this.seedless = seedless;
}


}
草莓类：


public class Strawberry implements Fruit {


@Override
public void grow() {
System.out.print("Strawberry is growing!");
}


@Override
public void harvest() {
System.out.print("Strawberry is harvested!");
}


@Override
public void plant() {
System.out.print("Strawberry is planted!");
}


// 辅助方法
public static void log(String msg) {
System.out.print("Strawberry is msg!");
}


}


下面创建园丁工厂类,他会根据客户端的要求创建出来水果对象，如果请求的水果不合法，则抛出异常：


import IFruit.Fruit;
import IFruit.Fruitimpl.Apple;
import IFruit.Fruitimpl.Grape;
import IFruit.Fruitimpl.Strawberry;


public class FruitGardener {


// 静态工厂方法
public static Fruit factory(String which) throws BadFruitException {
if (which.equalsIgnoreCase("apple")) {
return new Apple();
} else if (which.equalsIgnoreCase("grape")) {
return new Grape();
} else if (which.equalsIgnoreCase("strawberry")) {
return new Strawberry();
} else {
throw new BadFruitException("Bad fruit request!");
}


}
}


自定义的异常类；


public class BadFruitException extends Exception {


public BadFruitException(String msg) {
super(msg);
}
}


在使用时候，客户端只需要调用FruitGardener的factory方法即可：


import FruitGardener.BadFruitException;
import FruitGardener.FruitGardener;


public class client {


public static void main(String[] args) {
try {
FruitGardener.factory("apple").grow();
FruitGardener.factory("apple").harvest();
FruitGardener.factory("apple").plant();
FruitGardener.factory("grape").grow();
FruitGardener.factory("grape").harvest();
FruitGardener.factory("grape").plant();
FruitGardener.factory("strawberry").grow();
FruitGardener.factory("strawberry").harvest();
FruitGardener.factory("strawberry").plant();
} catch (BadFruitException e) {


}
}
}

通过此实例，相信对该模式有了进一步的认识。

每天努力一点，每天都在进步。