简单工厂模式、工厂模式和抽象工厂模式例子

一、简单工厂模式

算法的封装： 定义一个抽象的算法接口，提供不同算法的公共接口方法。其他具体算法继承这个抽象类，并实现具体的算法。

简单工厂类： 作为一个独立的类，实现了针对不同的算法进行实例化。

题目：输入两个数和运算符，得出结果。

package simpleFacotory;

public class Operation {
  protected int a;
  protected int b;
  public int getA() {
    return a;
  }
  public void setA(int a) {
    this.a = a;
  }
  public int getB() {
    return b;
  }
  public void setB(int b) {
    this.b = b;
  }

 public int getResult(){
   return 0;
 }
}

//算法一
package simpleFacotory;

public class OperationAdd extends Operation {
     @Override
    public int getResult() {
        return a+b;
    }
}

//算法二
package simpleFacotory;

public class OperationSub extends Operation {

  public int getResult(){
    return a-b ;
  }
}

//父工厂
package simpleFacotory;

public class OperationFactory {

  public static Operation createOperation(char operate) {
    Operation oper = null;
    switch (operate) {
      case '+':
        oper = new OperationAdd();
        break;
      case '-':
        oper = new OperationSub();
        break;
    }
    return oper;
  }

}

总结：
优点：客户端不需要修改代码，因为业务逻辑是在工厂类中判断的。
缺点：当需要增加新的运算类的时候，不仅需新加运算类，还要修改工厂类，违反了开闭原则。

二、工厂模式

/*
 * 运算接口
 */
public interface Operation {

    public int getResult(int a,int b);

}

/*
 * 算法一
 */
public class OperationAdd implements Operation{

    @Override
    public int getResult(int a, int b) {
        return a+b;
    }

}

/*
 * 算法二
 */
public class OperationSub implements Operation{

    @Override
    public int getResult(int a, int b) {
        // TODO Auto-generated method stub
        return a-b;
    }

}

/*
 * 工厂接口
 */
public interface OperationFactory {
    public Operation creatOperation();
}

/*
 * 加法工厂
 */
public class AddFactory implements OperationFactory{

    @Override
    public Operation creatOperation() {
        return new OperationAdd();
    }

}

/*
 * 减法工厂
 */
public class SubFactory implements OperationFactory{

    @Override
    public Operation creatOperation() {
        return new OperationSub();
    }

}

/*
 * 客户端
 */
public class App {
    public static void main(String[] args) {
        OperationFactory operationFacoty = new AddFactory();
        OperationAdd add = (OperationAdd) operationFacoty.creatOperation();
        System.out.println("- result ->"+add.getResult(5,10));
    }
}

总结：
这个和简单工厂有区别，简单工厂模式只有一个工厂，工厂方法模式对每一个产品都有相应的工厂

好处：增加一个运算类（例如N次方类），只需要增加运算类和相对应的工厂，两个类，不需要修改工厂类。

缺点：增加运算类，会修改客户端代码，工厂方法只是把简单工厂的内部逻辑判断移到了客户端进行。

三、抽象工厂模式

首先要明白几个概念，以电脑为例：

1.产品族：例如一个电脑由CPU，显卡，显示器，硬盘等组成，组成电脑的这些产品就是产品族

2.产品等级：惠普CPU，inter CPU，就是两个产品等级

3.产品族等级：惠普电脑，联想电脑

如果只涉及产品等级的话，是不需要应用抽象工厂模式，使用工厂方法模式即可；
工厂方法模式解决的范畴是产品等级（AMD处理器，Intel处理器等）；
抽象工厂模式解决的范畴是产品族等级（联想PC、惠普PC等）；

以中国家庭和美国家庭为例，中国家庭和美国家庭就属于两个产品族等级。
组成一个美国家庭的美国父亲和美国母亲就是美国家庭的产品族。
中国母亲和美国母亲就是产品等级。

/*
 * mother接口
 */
public interface IMother {
    public void printName();
}

/*
 * Father接口
 */
public interface IFather {
    public void printName();
}

/*
 * 中国母亲类
 */
public class ChineseMother implements IMother{

    private String name;

    public ChineseMother(String name) {
        this.name = name;
    }


    public String getName() {
        return name;
    }



    public void setName(String name) {
        this.name = name;
    }



    @Override
    public void printName() {
        System.out.println("中国母亲名："+name);
    }

}

/*
 * 中国父亲类
 */
public class ChineseFather implements IFather{

    private String name;

    public ChineseFather(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void printName() {
        System.out.println("中国父亲名："+this.name);
    }

}

/*
 * 美国父亲类
 */
public class AmericanFather implements IFather{

    private String name;

    public AmericanFather(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void printName() {
        System.out.println("美国父亲名："+this.name);
    }

}


/*
 * 美国母亲类
 */
public class AmericanMother implements IMother{

    private String name;

    public AmericanMother(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void printName() {
        System.out.println("美国母亲名："+this.name);
    }

}


/*
 * 家庭工厂
 */
public interface IFamilyFactory {
    public IMother createMother(String name);
    public IFather createFather(String name);
}


/*
 * 中国家庭工厂
 */
public class ChineseFamilyFatory implements IFamilyFactory{

    @Override
    public IMother createMother(String name) {
        return new ChineseMother(name);
    }

    @Override
    public IFather createFather(String name) {
        return new ChineseFather(name);
    }

}

/*
 * 美国家庭工厂
 */
public class AmericanFamilyFatory implements IFamilyFactory{

    @Override
    public IMother createMother(String name) {
        return new AmericanMother(name);
    }

    @Override
    public IFather createFather(String name) {
        return new AmericanFather(name);
    }

}