上一篇：设计模式（一）——工厂模式
下一篇：设计模式（三）——单例模式
一、概述
官方解释：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。）
我的理解：抽象工厂模式，即实现了工厂本身的抽象化。在工厂模式上更进一步，不仅解决工厂产品的向上转型，还体现工厂本身的向上转型。
第一步，有一个抽象工厂，在工厂创建类中根据形参确定运行时类型，新建并返回各个具体工厂；
第二步，由每个工厂负责对应的抽象产品，对于任意一个抽象产品，再由工厂类中的产品创建类根据形参确定运行时类型，新建并返回各个具体产品。
（其中第二步就是上一篇的工厂模式）
| 工厂模式与抽象工厂模式 | |
| 工厂模式 | 抽象产品 |
| 抽象工厂模式 | 抽象工厂+抽象产品 |
参与者：产品类（抽象产品类AbstractProduct、具体产品类ConcreteProduct）、工厂类（抽象工厂类AbstractFactory、具体工厂类ConcreteFactory）
类图：
二、代码
具体类图
代码示意
interface Fruit{
public void display();
}
class Apple implements Fruit{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("This is an Apple");
}
}
class Orange implements Fruit{
@Override
public void display() {
System.out.println("This is an orange");
}
}
class Banana implements Fruit{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("This is a banana");
}
}
interface Vegetable {
public void display();
}
class Potato implements Vegetable{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("This is a Potato");
}
}
class Tomato implements Vegetable{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("This is a Tomato");
}
}
class Cabbage implements Vegetable{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("This is a Cabbage");
}
}
abstract class AbstarctFactory{
abstract Fruit produce_Fruit(String type);
abstract Vegetable produce_Vegetable(String type);
}
class FruitFactory extends AbstarctFactory{
public Fruit produce_Fruit(String type){
//工厂模式的精髓在于 工厂类的工厂方法中根据参数 ，新建不同工厂产品， 其中运用到多态
if (type.equalsIgnoreCase("apple")) {
return new Apple();
}
if (type.equalsIgnoreCase("orange")) {
return new Orange();
}
if (type.equalsIgnoreCase("banana")) {
return new Banana();
}
return null;
}
@Override
Vegetable produce_Vegetable(String type) {
// TODO Auto-generated method stub
return null;
}
}
class VegetableFactory extends AbstarctFactory{
@Override
Fruit produce_Fruit(String type) {
// TODO Auto-generated method stub
return null;
}
@Override
Vegetable produce_Vegetable(String type) {
if (type.equalsIgnoreCase("Potato")) {
return new Potato();
}
if (type.equalsIgnoreCase("Tomato")) {
return new Tomato();
}
if (type.equalsIgnoreCase("Cabbage")) {
return new Cabbage();
}
return null;
}
}
public class TestAbstractFactory {
public static void main(String[] args) {
System.out.println("=====水果工厂=====");
AbstarctFactory _fruit_factory=new FruitFactory();
_fruit_factory.produce_Fruit("apple").display();
_fruit_factory.produce_Fruit("orange").display();
_fruit_factory.produce_Fruit("banana").display();
System.out.println("=====蔬菜工厂=====");
AbstarctFactory _vegetable_factory=new VegetableFactory();
_vegetable_factory.produce_Vegetable("potato").display();
_vegetable_factory.produce_Vegetable("tomato").display();
_vegetable_factory.produce_Vegetable("cabbage").display();
}
}
输出：
=====水果工厂=====
This is an Apple
This is an orange
This is a banana
=====蔬菜工厂=====
This is a Potato
This is a Tomato
This is a Cabbage三、小结
抽象工厂模式不仅完成对产品的抽象化，更新增对工厂的抽象化处理，学习抽象工厂模式可以加强我们面向对象的理解，熟练的使用抽象工厂模式可以让开发事半功倍。
上一篇：设计模式（一）——工厂模式
下一篇：设计模式（三）——单例模式
