设计模式--工厂方法模式

1
整体类图：

接口：

public interface Output {
    public void print();
}

两个实现类：

public class OutputImpl implements Output{
    @Override
    public void print() {
        System.out.println("OutputImpl->print");
    }
}
public class BetterOutputImpl implements Output {
    @Override
    public void print() {
        System.out.println("BetterOutputImpl-->Output");
    }
}

工厂接口:

public interface OutputFactory {
    public Output getOutput();
}   

工厂实现类：

public class OutputImplFactory implements OutputFactory{
    @Override
    public Output getOutput() {
        // TODO Auto-generated method stub
        return new OutputImpl();
    }
}
public class BetterOutputImplFactory implements OutputFactory{
    @Override
    public Output getOutput() {
        // TODO Auto-generated method stub
        return new BetterOutputImpl();
    }
}

超级工厂方法：

public class OutFactoryFactory {
    public static OutputFactory getOutputFactory(String type){
        if("BetterOutputImpl".equals(type)){
            return new BetterOutputImplFactory();
        }else{
            return new OutputImplFactory();
        }
    }
}

测试：

public class TextMain {

    private Output output;
    public TextMain(Output output) {
        this.output = output;
    }
    public void print(){
        output.print();
    }

    public static void main(String[] args) {
        OutputFactory outputFactory=OutFactoryFactory.getOutputFactory("BetterOutputImpl");
        TextMain textMain=new TextMain(outputFactory.getOutput());
        textMain.print();
    }
}

简单方法模式与工厂模式类似，不同的是简单工厂模式使用一个方法为不同接口实现类返回不同的对象，工厂方法模式为每一个接口实现类都分别创建一个工厂来返回对应的对象。

2
对于工厂方法模式的第二种理解，将选择哪种类交给外部去判断，为每一个实现类分别创建一个工厂。继承结构图：

操作接口：

public interface Operation {
    public Integer getResult();
}

定义一个抽象类，添加操作数：

public abstract class OperationAbstract implements Operation{

    public Integer numberA;

    public Integer numberB;

    public Integer getNumberA() {
        return numberA;
    }

    public void setNumberA(Integer numberA) {
        this.numberA = numberA;
    }

    public Integer getNumberB() {
        return numberB;
    }

    public void setNumberB(Integer numberB) {
        this.numberB = numberB;
    }
}

两个实现类：

public class OperationAdd extends OperationAbstract{
    @Override
    public Integer getResult() {
        // TODO Auto-generated method stub
        return numberA+numberB;
    }
}
public class OperationSub extends OperationAbstract{
    @Override
    public Integer getResult() {
        // TODO Auto-generated method stub
        return numberA-numberB;
    }
}

工厂接口：

public interface Factory {
    public OperationAbstract createOperation();
}

工厂实现类：

public class FactoryAdd implements Factory{
    @Override
    public OperationAbstract createOperation() {
        // TODO Auto-generated method stub
        return new OperationAdd();
    }
}
public class FactorySub implements Factory {
    @Override
    public OperationAbstract createOperation() {
        // TODO Auto-generated method stub
        return new OperationSub();
    }
}

测试：

Factory factory=new FactorySub();
        OperationAbstract operationAbstract=factory.createOperation();
        operationAbstract.setNumberA(1);
        operationAbstract.setNumberB(1);
        System.out.println(operationAbstract.getResult());

相比简单工厂模式，工厂方法模式可扩展性更高，更灵活。
参考《大话设计模式》