设计模式——抽象工厂

工厂角色：

package designpattern.creation.abstractfactory;

public interface IFactory {

    IProductA getProductA();

    IProductB getProductB();
}

package designpattern.creation.abstractfactory;

public class FactoryAB1 implements IFactory{

    public IProductA getProductA() {
        return new ProductA1();
    }
    

    public IProductB getProductB() {
        return new ProductB1();
    }
}

package designpattern.creation.abstractfactory;

public class FactoryAB2 implements IFactory{

    public IProductA getProductA() {
        return new ProductA2();
    }

    public IProductB getProductB() {
        return new ProductB2();
    }

}

产品角色：

package designpattern.creation.abstractfactory;

public interface IProductA {

    void useA();
}

package designpattern.creation.abstractfactory;

public interface IProductB {

    void useB();
}

package designpattern.creation.abstractfactory;

public class ProductA1 implements IProductA {

    public void useA() {
        // TODO Auto-generated method stub
        System.out.println("ProductA1.use()");
    }

}

package designpattern.creation.abstractfactory;

public class ProductA2 implements IProductA {

    public void useA() {
        // TODO Auto-generated method stub
        System.out.println("ProductA2.use()");
    }

}

package designpattern.creation.abstractfactory;

public class ProductB1 implements IProductB {

    public void useB() {
        // TODO Auto-generated method stub
        System.out.println("ProductB1.use()");
    }

}

package designpattern.creation.abstractfactory;

public class ProductB2 implements IProductB {

    public void useB() {
        // TODO Auto-generated method stub
        System.out.println("ProductB2.use()");
    }

}

客户端：

package designpattern.creation.abstractfactory;

/**
 * @param args
 * 
 * 产品继续复杂，出现了不兼容的产品， ———— 即
 * 但是，我们将复杂度交给了客户端，即由客户来选择应该调用的api
 * 
 * 抽象工厂要素：
 * 1 多类的不兼容的产品A、B。 
 * 2 抽象工厂里面有获取不同类别的产品的方法，由有不同类别的具体工厂来实现
 * 3 每个具体工厂为每个类别产品提供一个具体方法，分别来获取具体的产品
 * 4 为每个增加一个细类别产品，则需要增加一个具体工厂，N个具体细类别产品
 * 
 * 使用场景？
 * 对应一些比较复杂的情况，有多类别产品，并且他们不兼容；每类别产品下有多个具体产品
 * 产品类别的格式应该是固定的， 否则可能导致抽象工厂类的修改 ！！
 */

public class Client {

    public static void main(String[] args) {
        IProductA producta1 = new FactoryAB1().getProductA();
        producta1.useA();

        IProductB productb1 = new FactoryAB1().getProductB();
        productb1.useB();
        
        IProductA producta2 = new FactoryAB2().getProductA();
        producta2.useA();

        IProductB productb2 = new FactoryAB2().getProductB();
        productb2.useB();
    }

}