【设计模式】——抽象工厂模式

抽象工厂模式描述：

提供对象的使用接口，隐藏对象的创建过程。比如涉及到系列和家族。

场景：

1.系统独立于她的产品创建、组合和表示。无需关注内部是如何创建的，怎么创建的。

2.系统需要多个产品组合中的一种组合。

3.强调对象的组合结果，而不是他们具体的接口和实现。

                                                             

AbstractFactory 提供创建对象的接口。

ConcreteFactory 提供真正创建对象的实现类，用于组合并创建不同的对象，实现一个产品族。

AbstractProduct 提供对象的使用接口。

ConcreteProduct 提供真正的适用对象，隐藏该对象的创建过程，是工厂创建的对象。

Client 使用者，通过抽象工厂接口，使用不同的具体工厂方法创建对象组合，从而直接使用对象，无需关注对象的创建过程。

代码结构：

例如：画一个头像，这个头像可能是男孩的也可能是女孩的；可以是元旦主题的，也可以是圣诞主题的。

AbstactFactory.java

interface AbstractFactory {
    public AbstractProductA CreateProductA();
    public AbstractProductB CreateProductB();
}

相同如下   PersonFactory.java

public interface PersonFactory {
    public Boy createBoy();
    public Girl createGirl();
}

ConcreteFactory.java

class ConcreteFactory1 implements AbstractFactory{

    @Override
    public AbstractProductA CreateProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ConcreteProductB1();
    }

}

如同

public class NYFactory implements PersonFactory {

    @Override
    public Boy createBoy() {
        return new NYBoy();
    }

    @Override
    public Girl createGirl() {
        return new NYGirl();
    }

}

以及

public class MCFactory implements PersonFactory {

    @Override
    public Boy createBoy() {
        return new MCBoy();
    }

    @Override
    public Girl createGirl() {
        return new MCGirl();
    }

}

AbstractProduct.java

interface AbstractProductA {
    public void use();
}
interface AbstractProductB {
    public void use();
}

如同

public interface Boy {
    public void drawBoy();
}


public interface Girl {
    public void drawGirl();
}

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 class MCBoy implements Boy {

    @Override
    public void drawMan() {
        System.out.println("一个圣诞系列的男孩");
    }

}
public class MCGirl implements Girl {

@Override
public void drawGirl() {
System.out.println("这是一个圣诞系列的女孩");
}

}

public class NYBoy implements Boy {

@Override
public void drawMan() {
System.out.println("一个新年系列的男孩");
}

}

public class NYGirl implements Girl {

@Override
public void drawGirl() {
System.out.println("这是一个元旦系列的女孩");
}

}

使用方式

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();
        
    }

如同下方：

public class Client {

    public static void main(String[] args) {
        NYFactory factory = new NYFactory();
        Boy boy = factory.createBoy();
        boy.drawMan();
        Girl girl = factory.createGirl();
        girl.drawGirl();
    }

}

如此可以实现一个圣诞或者元旦的男孩或者女孩的任意一种组合。