模式意图
提供对象的使用接口，隐藏对象的创建过程。
模式结构
AbstractFactory 提供创建对象的接口。 ConcreteFactory 提供真正创建对象的实现类，用于组合并创建不同的对象，实现一个产品族。 AbstractProduct 提供对象的使用接口。 ConcreteProduct 提供真正的适用对象，隐藏该对象的创建过程，是工厂创建的对象。 Client 使用者，通过抽象工厂接口，使用不同的具体工厂方法创建对象组合，从而直接使用对象，无需关注对象的创建过程。
适合场景
1 系统独立于它的产品创建、组合和表示。即无需关心内部对象时如何创建的，怎么创建的，什么含义。
2 系统需要多个产品组合中的一个配置。由于对象很多，能够组合出的组合非常多，而系统只是使用某一个组合。
3 强调的对象的组合结果，而不是他们具体的接口和实现。
代码结构
AbstractFactory.java
interface AbstractFactory {
public AbstractProductA CreateProductA();
public AbstractProductB CreateProductB();
}
ConcreteFactory.java
class ConcreteFactory1 implements AbstractFactory{
@Override
public AbstractProductA CreateProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB CreateProductB() {
return new ConcreteProductB1();
}
}
AbstractProduct.java
interface AbstractProductA {
public void use();
}
interface AbstractProductB {
public void use();
}
ConcreteProduct.java
class ConcreteProductA1 implements AbstractProductA{
@Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use A1 product!");
}
}
class ConcreteProductB1 implements AbstractProductB{
@Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use B1 product!");
}
}
使用方式
public static void main(String[] args){
AbstractProductA pa;
AbstractProductB pb;
AbstractFactory fa1 = new ConcreteFactory1();
pa = fa1.CreateProductA();
pb = fa1.CreateProductB();
pa.use();
pb.use();
AbstractFactory fa2 = new ConcreteFactory2();
pa = fa2.CreateProductA();
pb = fa2.CreateProductB();
pa.use();
pb.use();
}
全部代码
package com.designer;
interface AbstractFactory {
public AbstractProductA CreateProductA();
public AbstractProductB CreateProductB();
}
interface AbstractProductA {
public void use();
}
interface AbstractProductB {
public void use();
}
class ConcreteFactory1 implements AbstractFactory{ @Override
public AbstractProductA CreateProductA() {
return new ConcreteProductA1();
} @Override
public AbstractProductB CreateProductB() {
return new ConcreteProductB1();
} }
class ConcreteFactory2 implements AbstractFactory{ @Override
public AbstractProductA CreateProductA() {
return new ConcreteProductA2();
} @Override
public AbstractProductB CreateProductB() {
return new ConcreteProductB2();
} }
class ConcreteProductA1 implements AbstractProductA{ @Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use A1 product!");
} }
class ConcreteProductA2 implements AbstractProductA{ @Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use A2 product!");
} }
class ConcreteProductB1 implements AbstractProductB{ @Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use B1 product!");
} }
class ConcreteProductB2 implements AbstractProductB{ @Override
public void use() {
// TODO Auto-generated method stub
System.out.println("use B2 product!");
} }
public class Client {
public static void main(String[] args){
AbstractProductA pa;
AbstractProductB pb; AbstractFactory fa1 = new ConcreteFactory1();
pa = fa1.CreateProductA();
pb = fa1.CreateProductB();
pa.use();
pb.use(); AbstractFactory fa2 = new ConcreteFactory2();
pa = fa2.CreateProductA();
pb = fa2.CreateProductB();
pa.use();
pb.use(); }
}
生活中的设计模式
在生活中，我们经常会碰到使用一系列东西的时候。比如，我们愿意吃炸鸡配啤酒，喜欢吃爆米花配可乐。我们不关心炸鸡怎么炸的，啤酒怎么酿的，爆米花怎么爆的，而只关心我们吃什么，喝什么，这就是典型的抽象工厂。
例如，大部分程序猿们都有吃早餐的习惯，当然很多人喜欢睡懒觉也来不及吃，但是为了身体健康，还是要按时吃饭才行！扯远了...
有人喜欢吃中式的，有人喜欢吃西式的。那么去食堂我们不会去问，包子怎么做的，面包怎么烤的，仅仅是付费吃饭而已。而中式一般是豆浆油条，西式面包牛奶。这种搭配已经形成了一种习惯，也就是默认的产品组合。
因此，我们在买单时，只要指定早餐的样式，就可以了。下面就是我们吃早餐，使用早餐工厂的流程...
interface BreakfastFactory{
public StapleFood MakeStapleFood();
public Drinks MakeDrinks();
}
interface StapleFood{
public void eating();
}
interface Drinks{
public void drinking();
}
class BreakfastCStyle implements BreakfastFactory{
@Override
public StapleFood MakeStapleFood() {
return new DeepFriedDoughSticks();
}
@Override
public Drinks MakeDrinks() {
return new SoybeanMilk();
}
}
class BreakfastWStyle implements BreakfastFactory {
@Override
public StapleFood MakeStapleFood() {
return new Bread();
}
@Override
public Drinks MakeDrinks() {
return new Milk();
}
}
class DeepFriedDoughSticks implements StapleFood{
@Override
public void eating() {
System.out.println("我在吃油条！...");
}
}
class SoybeanMilk implements Drinks{
@Override
public void drinking() {
System.out.println("我在喝豆浆！...");
}
}
class Bread implements StapleFood{
@Override
public void eating() {
System.out.println("我在吃面包！...");
}
}
class Milk implements Drinks{
@Override
public void drinking() {
System.out.println("我在喝牛奶！...");
}
}
public class Breakfast{
public static void main(String[] args){
StapleFood sf;
Drinks dk;
System.out.println("——————————————————第一天——————————————————————————");
System.out.println("我要吃中式早餐");
BreakfastFactory bf1 = new BreakfastCStyle();
sf = bf1.MakeStapleFood();
dk = bf1.MakeDrinks();
sf.eating();
dk.drinking();
System.out.println("——————————————————第二天——————————————————————————");
System.out.println("我要吃西式早餐");
BreakfastFactory bf2 = new BreakfastWStyle();
sf = bf2.MakeStapleFood();
dk = bf2.MakeDrinks();
sf.eating();
dk.drinking();
}
}
可以看到，非常方便的就迟到了中式和西式的早餐，而省掉了大量炸油条，烤面包的时间。
——————————————————第一天——————————————————————————
我要吃中式早餐
我在吃油条！...
我在喝豆浆！...
——————————————————第二天——————————————————————————
我要吃西式早餐
我在吃面包！...
我在喝牛奶！...
这就是一个简单的抽象工厂的使用。