设计模式之简单工厂、工厂方法模式、抽象工厂模式

设计模式之简单工厂、工厂方法模式、抽象工厂模式

这里讲三种模式放在一起说明，是因为三种模式关联性很强——抽象工厂模式简单化以后就是工厂方法模式，工厂方法模式再简单化就是简单工厂模式（简单工厂模式并没有被列入到GOF的设计模式中）。

1.定义：

简单工厂：提供一个创建对象实例的功能，而无需关心其具体的实现。被创建的实例的类型可以是接口、抽象类，也可以是具体的类。

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

2.uml类图

简单工厂



工厂方法模式



抽象工厂方法模式

3.代码

简单工厂

public class SimpleFactory {

public static void main(String[] args) {
//通过简单工厂来获取具体的产品实例
Productor p = Factory.createrProductor(0);
p.show();
}

}
//简单工厂类，实现创建产品对象
class Factory{

/**
* 创建产品对象的方法
* @param code  传入需要创建的产品对应的信息
* @return 需要创建的产品实例
*/
public static Productor createrProductor(int code){
Productor productor = null;
switch (code) {
case 0:
productor = new ProductorA();
break;
case 1:
productor = new ProductorB();
break;
default:
new Throwable("productor is undefined");
break;
}
return productor;
}
}
//产品接口
interface Productor{
public void show();
}
//具体产品的对象
class ProductorA implements Productor{

@Override
public void show() {
System.out.println("this is ProductorA");
}

}
//具体产品的对象
class ProductorB implements Productor{

@Override
public void show() {
System.out.println("this is ProductorB");
}

}

工厂方法模式：就是将简单工厂方法中，实现产品对象的方法不在工厂类中完成，而是在工厂类的子类中完成，让子类决定怎么完成产品对象的创建。

public class FactoryMethod {

public static void main(String[] args) {
// TODO Auto-generated method stub
Factory f = new FactoryA();
f.operator();
}

}

//工厂类，实现产品的展示
abstract class Factory{
public void operator(){
Productor productor = createProductor();
productor.show();
}
//抽象工厂方法，子类决定实例化那个产品
protected abstract Productor createProductor();
}
//A产品的工厂
class FactoryA extends Factory{

//实现A产品的实例的工厂方法
@Override
protected Productor createProductor() {
return new ProductorA();
}

}
//B产品的工厂
class FactoryB extends Factory{
//实现B产品的实例的工厂方法
@Override
protected Productor createProductor() {
return new ProductorB();
}

}
//产品接口
interface Productor{
public void show();
}
//具体产品的对象
class ProductorA implements Productor{

@Override
public void show() {
System.out.prin
4000
tln("this is ProductorA");
}

}
//具体产品的对象
class ProductorB implements Productor{

@Override
public void show() {
System.out.println("this is ProductorB");
}

}

抽象工厂模式：抽象工厂模式是在工厂方法模式的基础上增加了系列产品的概念。比如现在有产品A、B，然后每个产品都有一个A1、A2和B1、B2。现在有个需求，产品x1是一个系列、产品x2是一个系列，而且不能混合，这样的话就需要将工厂方法拓展下，拓展成生产产品系列1的工厂和生产产品系列2的工厂，各个工厂负责各自系列的产品生产。

public class AbstractFactory {
public static void main(String[] args) {
Factory f = new Serial_1Factory();
AssembleSerial as = new AssembleSerial();
as.showSerial(f);
}
}
//抽象工厂接口
interface Factory{
public ProductorA createA();
public ProductorB createB();
}
//组合产品系列的类
class AssembleSerial{
public void showSerial(Factory f){
ProductorA pa = f.createA();
ProductorB pb = f.createB();
pa.show();
pb.show();
}
}
//产品系列1的抽象工厂
class Serial_1Factory implements Factory{

//创建产品系列1的产品A
@Override
public ProductorA createA() {
return new ProductorA1();
}
//创建产品系列1的产品B
@Override
public ProductorB createB() {
return new ProductorB1();
}

}
//产品系列2的抽象工厂
class Serial_2Factory implements Factory{
//创建产品系列2的产品A
@Override
public ProductorA createA() {
return new ProductorA2();
}
//创建产品系列2的产品B
@Override
public ProductorB createB() {
return new ProductorB2();
}

}
//产品A的接口
interface ProductorA{
public void show();
}
//产品B的接口
interface ProductorB{
public void show();
}
//产品系列1中的产品A类
class ProductorA1 implements ProductorA{

@Override
public void show() {
System.out.println("this is ProductorA of serial_1");
}

}
//产品系列2中的产品A类
class ProductorA2 implements ProductorA{

@Override
public void show() {
System.out.println("this is ProductorA of serial_2");
}

}
//产品系列1中的产品B类
class ProductorB1 implements ProductorB{

@Override
public void show() {
System.out.println("this is ProductorB of serial_1");
}

}
//产品系列2中的产品B类
class ProductorB2 implements ProductorB{

@Override
public void show() {
System.out.println("this is ProductorB of serial_2");
}

}