【设计模式】- 工厂模式

工厂方法模式

定义一个创建对象的接口，但让实现这个接口的类来决定实例化那个类，工厂方法让类的实例化推迟带子类中进行。
缺点：创建的类过多

/**
 * 工厂接口
 */
public interface IFactory {
    IObj create();
}

/**
 * 对象接口
 */
public interface IObj { 
    void doSomeing();
}

/**
 * A对象实现类
 */
public class AObj implements IObj {
    public void doSomeing() {
        System.out.println("A Obj Method");
    }
}

/**
 * B对象实现类
 */
public class BObj implements IObj {
    public void doSomeing() {
        System.out.println("B Obj Method");
    }
}

/**
 * 只负责创建具体A对象的工厂类
 */
public class AObjFactory implements IFactory {
    @Override
    public IObj create() {
        return new AObj();
    }
}

/**
 * 只负责创建具体B对象的工厂类
 */
public class BObjFactory implements IFactory {
    @Override
    public IObj create() {
        return new BObj();
    }
}

抽象工厂

抽象工厂是提供创建一系列相关的或相互依赖对象接口，无须指定具体实现类。与工厂方法不同的是抽象工厂用于创建多种对象，强调的是产品族的概念。
缺点：需要确定产品族中可能的产品，对拓展产品时需要修改抽象工厂的接口，增加系统抽象程度和可理解性。

/**
 * 工厂抽象类，也可用接口
 */
public abstract AbsFactory {
    // 共同逻辑
    public void preJob(){
        System.out.println("init  something");
    }
    public abstract IObjA createA();
    public abstract IObjB createB();
}

/**
 * 对象A接口
 */
public interface IObjA { 
    void doSomeing();
}
/**
 * 对象B接口
 */
public interface IObjB { 
    void doSomeing();
}

/**
 * A对象实现类
 */
public class AObj1 implements IObjA {
    public void doSomeing() {
        System.out.println("A Obj Method");
    }
}
/**
 * A对象实现类
 */
public class AObj2 implements IObjA {
    public void doSomeing() {
        System.out.println("A Obj Method");
    }
}

/**
 * B对象实现类
 */
public class BObj1 implements IObjB {
    public void doSomeing() {
        System.out.println("B Obj Method");
    }
}
/**
 * B对象实现类
 */
public class BObj2 implements IObjB {
    public void doSomeing() {
        System.out.println("B Obj Method");
    }
}

/**
 * 工厂类1
 */
public class ObjFactory1 extends AbsFactory {
    public IObjA createA() {
        return new AObj1();
    }
    public IObjB createB() {
        return new BObj1();
    }
}

/**
 * 工厂类2
 */
public class ObjFactory2 implements AbsFactory {
    public IObjA createA() {
        return new AObj2();
    }
    public IObjB createB() {
        return new BObj2();
    }
}

工厂类常常结合单例模式使用，使用时基于接口调用，而不是具体的实现类。