方法和简单工厂的对比：
添加新功能时，二者的区别：
添加一个新功能类＋更改工厂类
方法需要完成工作：添加一个新功能类＋添加一个生成对象的工厂＋更改客户端实例化工厂的代码
方法的优点：
方法在添加新功能时，需要更改工厂类，这违背了开放－封闭原则。工厂方法通过将工厂类抽象为：接口抽象工厂＋多个具体生成对象的工厂，保证了在新增功能时，只需要通过添加：一个生成对象的工厂＋一个新功能类，即可。如果一定要说有改写代码的地方，那就是客户端，需要添加实例化工厂的代码。此外，再无其它对方的代码修改操作。
代码来进行。之前你添加功能时，都是修改工厂类，现在是修改客户端代码。
方法的缺点：
方法的缺点也是由其优点带来的：每增加一个功能类时，需要增加一个具体对象生成的工厂类，从而增进了额外的开发量。
方法在选择实例化哪一个功能类时，是在工厂类里面选择的；而工厂方法则是在客户端决定的，由客户端决定实例化哪一个工厂类，从而确定了实例化哪一个功能类。
方法模式的准确定义：
方法使一个类的实例化延迟到子类。
方法的UML图：
/**
- @Author: cxh
- @CreateTime: 18/1/3 23:32
- @ProjectName: JavaBaseTest
*/
public interface Operation {
void setFirst(int first);
void setSecond(int second);
int getResult();
}
/**
-
@Author: cxh
-
@CreateTime: 18/1/3 23:30
-
@ProjectName: JavaBaseTest
*/
public class AddOperation implements Operation {
private int first,second;
@Override
public void setFirst(int first) {
this.first=first;
}
@Override
public void setSecond(int second) {
this.second=second;
}
public int getResult(){
return first+second;
}
}
/**
-
@Author: cxh
-
@CreateTime: 18/1/3 23:43
-
@ProjectName: JavaBaseTest
*/
public class MulOperation implements Operation {
private int first,second;
public void setFirst(int first) {
this.first = first;
}
public void setSecond(int second) {
this.second = second;
}
@Override
public int getResult() {
return first*second;
}
}
/**
-
@Author: cxh
-
@CreateTime: 18/1/3 23:43
-
@ProjectName: JavaBaseTest
*/
public class MulOperation implements Operation {
private int first,second;
public void setFirst(int first) {
this.first = first;
}
public void setSecond(int second) {
this.second = second;
}
@Override
public int getResult() {
return first*second;
}
}
/**
-
@Author: cxh
-
@CreateTime: 18/1/3 23:44
-
@ProjectName: JavaBaseTest
*/
public class DivOperation implements Operation {
private int first,second;
public void setFirst(int first) {
this.first = first;
}
public void setSecond(int second) {
this.second = second;
}
@Override
public int getResult() {
try{
return first/second;
}catch (Exception e){
return 0;
}
}
}
/**
- @Author: cxh
- @CreateTime: 18/1/3 23:33
- @ProjectName: JavaBaseTest
*/
public interface CreateFactory {
Operation getOperation();
}
/**
- @Author: cxh
- @CreateTime: 18/1/3 23:34
- @ProjectName: JavaBaseTest
*/
public class AddFactory implements CreateFactory {
@Override
public Operation getOperation() {
return new AddOperation();
}
}
/**
- @Author: cxh
- @CreateTime: 18/1/3 23:36
- @ProjectName: JavaBaseTest
*/
public class SubFactory implements CreateFactory {
@Override
public Operation getOperation() {
return new SubOperation();
}
}
/**
- @Author: cxh
- @CreateTime: 18/1/6 11:43
- @ProjectName: JavaBaseTest
*/
public class MulFactory implements CreateFactory {
@Override
public Operation getOperation() {
return new MulOperation();
}
}
/**
- @Author: cxh
- @CreateTime: 18/1/6 11:43
- @ProjectName: JavaBaseTest
*/
public class DivFacotry implements CreateFactory {
@Override
public Operation getOperation() {
return new DivOperation();
}
}
/**
-
@Author: cxh
-
@CreateTime: 18/1/6 11:44
-
@ProjectName: JavaBaseTest
*/
public class Client{
public static void main(String[] args) {
CreateFactory factory;
Operation operation;
//加法
factory=new AddFactory();
operation=factory.getOperation();
operation.setFirst(11);
operation.setSecond(22);
System.out.println("11+22="+operation.getResult());
//减法
factory=new SubFactory();
operation=factory.getOperation();
operation.setFirst(11);
operation.setSecond(22);
System.out.println("11-22="+operation.getResult());
//乘法
factory=new MulFactory();
operation=factory.getOperation();
operation.setFirst(11);
operation.setSecond(22);
System.out.println("11*22="+operation.getResult());
//除法
factory=new DivFacotry();
operation=factory.getOperation();
operation.setFirst(22);
operation.setSecond(11);
System.out.println("22/11="+operation.getResult());
}
}
输出：
