简单工厂模式 Simple Factory Pattern
又称静态工厂方法模式，使用静态的方法创建对象。
组成：
-
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
-
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
-
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
//抽象产品角色
public abstract class Pizza {
abstract void what();
}
//具体产品角色
public class CheesePizza implements Pizza {
@Override
public void what() {
System.out.println("CheesePizza");
}
}
public class PepperoniPizza implements Pizza {
@Override
public void what() {
System.out.println("PepperoniPizza");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// 工厂类角色，它只做一件事情：帮它的客户创建披萨
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
}
return pizza;
}
}
|
工厂方法模式 Factory Method Pattern
组成
-
抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
-
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
-
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
-
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
//抽象产品角色
public interface Moveable {
void run();
}
//具体产品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
//抽象工厂
public abstract class VehicleFactory {
abstract Moveable create();
}
//具体工厂
public class PlaneFactory extends VehicleFactory{
public Moveable create() {
return new Plane();
}
}
public class BroomFactory extends VehicleFactory{
public Moveable create() {
return new Broom();
}
}
|
测试
1
2
3
4
5
6
7
8
|
//测试类
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BroomFactory();
Moveable m = factory.create();
m.run();
}
}
|
抽象工厂模式 Abstract Factory Pattern
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
抽象产品
1
2
3
4
5
6
|
public abstract class Food {
public abstract void what();
}
public abstract class Weapon {
public abstract void power();
}
|
具体产品
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Apple extends Food{
@Override
public void what() {
System.println("Apple");
}
}
public class AK47 extends Weapon{
@Override
public void power() {
System.println("power 90");
}
}
|
抽象工厂
1
2
3
4
|
public abstract class AbstractFactory {
public abstract Weapon createWeapon();
public abstract Food createFood();
}
|
具体工厂
1
2
3
4
5
6
7
8
9
10
|
public class FirstFactory extends AbstractFactory{
@Override
public Food createFood() {
return new Apple();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
|
总结
- 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
- 工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
- 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。