策略模式&简单工厂模式&抽象工厂模式

无论工厂还是策略模式，每个具体工具类（工厂模式）/具体策略类（策略模式）中执行方法名都是一样的，都和抽象工具（工厂模式）/抽象策略（策略模式）中方法名一样的

1、简单工厂类

　　思想：将创建何种工具交由工厂。将原本逻辑if...else...中“变”的部分抽离为具体工具类，调用方通过在工厂中传入标志符来确定创建何种工具　　

　　结构图： 

          

　　

　　代码实现：

　　抽象工具类：　

public abstract class FAbsStep {
    public abstract void run();
}

 

 

　　具体工具类：　

public class FBanmaStep extends FAbsStep{
    public void run() {
        System.out.println("斑马编译步骤开始执行");
        System.out.println("斑马编译步骤...");
        System.out.println("斑马编译步骤执行结束");
    }
}


public class FshangqiStep extends FAbsStep{
    public void run() {
        System.out.println("上汽编译步骤开始执行");
        System.out.println("上汽编译步骤...");
        System.out.println("上汽编译步骤执行结束");
    }
}

 

　　工厂类：用于创建具体工具（通过传入string类型标志位来判断创建何种工具）

public class Ffactory {
    public FAbsStep getStep(String name) {  //①通过name来判断创建何种具体工具  ②返回抽象产品结果
        if(name.equals("banma")) {
            return new FBanmaStep();
        }else {
            return new FshangqiStep();
        }
    }
}

 

　　main方法

public class Fmain {
    public static void main(String[] args) {
        Ffactory tfactory=new Ffactory();
        FAbsStep step=tfactory.getStep("shangqi"); //创建出具体工具实例
        step.run();  //执行具体实例方法
    }
}

 

　　

2、策略模式

　　思想：根据传入何种策略具体执行对应行为

　　结构图：

　　

　　

　　代码实现：

　　抽象策略：

public abstract class TAbsStep {
    public abstract void run();
}

 

　　具体策略：　

public class TBanmaStep extends FAbsStep{
    public void run() {
        System.out.println("斑马编译步骤开始执行");
        System.out.println("斑马编译步骤...");
        System.out.println("斑马编译步骤执行结束");
    }
}

public class TshangqiStep extends FAbsStep{
    public void run() {
        System.out.println("上汽编译步骤开始执行");
        System.out.println("上汽编译步骤...");
        System.out.println("上汽编译步骤执行结束");
    }
}

 

　　环境类：抽象策略类作为成员变量，接收具体策略 

//TEnvironment环境类，用户传入具体策略类名进而执行具体策略
public class TEnvironment {  
    private FAbsStep fAbsStep;  //抽象策略   策略类作为环境类的成员变量
    public TEnvironment(FAbsStep fAbsStep) { //环境类构造方法，抽象策略作为形参
        this.fAbsStep=fAbsStep;
    }
    public void exec() {
        fAbsStep.run();
    }
}

 

　　main类：

public class Tmain {
    public static void main(String[] args) {
        TEnvironment tEnvironment = new TEnvironment(new TshangqiStep()); //环境类传入具体策略方法，用来执行对应策略方法
        tEnvironment.exec();
    }
}

 

 

 

简单工厂VS策略

1.首先看一下接收的参数：简单工厂类中的Ffactory.getStep() 方法接收的是字符串，返回的是一个 FAbsStep(抽象工厂类)对象；而 策略模式Environment 类初始化时需要接收一个 new TshangqiStep()(具体策略类)对象。 

2.简单工厂类中是根据接收的条件创建一个相应的对象，而 Context 类接收的是一个对象，可以调用方法去执行此对象的方法

 

总结简单工厂模式和策略模式
1.从类型上说：简单工厂模式属于创建型模式，而策略模式属于行为型模式。
2.接下来，看一个小例子：

 斧子有很多种，有一个工厂专门负责生产各种需求的斧子。

工厂模式：
1）根据你给出的目的来生产不同用途的斧子，例如要砍人，那么工厂生产砍人斧子，要伐木就生产伐木斧子。
2）即根据你给出一些属性来生产不同行为的一类对象返回给你。
3）关注对象创建
策略模式：
1）用工厂生产的斧子来做对应的事情，例如用砍人的斧子来砍人，用伐木的斧子来伐木。
2）即根据你给出对应的对象来执行对应的方法。
3）关注行为的选择
3.简单工厂模式：根据客户选择的条件，来帮客户创建一个对象。
 策略模式：客户给它一个创建好的对象，它来帮客户做相应的事

 

 

三、抽象工厂模式

结构图：

 

简单工厂模式中工厂类代码中存在很多业务逻辑：

public class Ffactory {
    public FAbsStep getStep(String name) {  //通过name来判断创建何种具体工具
        if(name.equals("banma")) {
            return new FBanmaStep();
        }else {
            return new FshangqiStep();
        }
    }
}

 

抽象工厂将简单工厂中工厂类业务代码抽离实现。具体逻辑如下

业务逻辑：肯德基和麦当劳都有汉堡和可乐产品，现需要针对不同客户要求，生产不同品牌的产品

 

抽象产品类

//抽象汉堡产品
public interface IHumburg {
    public HumburgDto getHumberDes();
}


//抽象可乐产品
public interface ICole {
    public ColeDto getCole();
}

 

 

具体产品类

//肯德基劳可乐
public class KfcCole implements ICole {

    @Override
    public ColeDto getCole() {
        ColeDto coleDto=new ColeDto();
        coleDto.setIsIce(false);
        coleDto.setName("肯德基可乐");
        coleDto.setPrize(12);
        coleDto.setSize('M');
        
        return coleDto;
    }

}

//肯德基汉堡
public class KfcHumburge implements IHumburg {

    @Override
    public HumburgDto getHumberDes() {
        HumburgDto humburgDto=new HumburgDto();
        humburgDto.setName("肯德基汉堡");
        humburgDto.setPrice(26);
        humburgDto.setSize('M');
        return humburgDto;
    }

}

//麦当劳可乐
public class McCole implements ICole {

    @Override
    public ColeDto getCole() {
        ColeDto coleDto=new ColeDto();
        coleDto.setIsIce(true);
        coleDto.setName("麦当劳可乐");
        coleDto.setPrize(10);
        coleDto.setSize('L');
        
        return coleDto;
    }

}

//麦当劳汉堡
public class McHumburge implements IHumburg {

    @Override
    public HumburgDto getHumberDes() {
        HumburgDto humburgDto=new HumburgDto();
        humburgDto.setName("麦当劳汉堡");
        humburgDto.setPrice(22);
        humburgDto.setSize('L');
        return humburgDto;
    }

}

 

 

抽象工厂类  --生产抽象产品

public interface IFactory {
    public IHumburg getHumbuger();
    public ICole getCole();
}

 

 

具体工厂类 --生产具体产品

//肯德基工厂
public class KfcFactory implements IFactory {

    public IHumburg getHumbuger() {
        return new KfcHumburge();
    }

    @Override
    public ICole getCole() {
        // TODO Auto-generated method stub
        return new KfcCole();
    }
    

}

//麦当劳产品
public class McFactory implements IFactory {

    public IHumburg getHumbuger() {
        return new McHumburge();
    }

    @Override
    public ICole getCole() {
        // TODO Auto-generated method stub
        return new McCole();
    }
    

}

 

测试类

public class Test {

    public static void main(String[] args) {
        IFactory kfcFactory=new KfcFactory(); //测试代码中直接创建对应产品工厂，而无需在工厂类中通过业务代码判断
        IHumburg kfcHumbuger=kfcFactory.getHumbuger();
        ICole kfcCole=kfcFactory.getCole();
        System.out.println(JSON.toJSONString(kfcHumbuger)+" "+JSON.toJSONString(kfcCole));
        
        IFactory McFactory=new McFactory();
        IHumburg mcHumbuger=McFactory.getHumbuger();
        ICole mcCole=McFactory.getCole();
        System.out.println(JSON.toJSONString(mcHumbuger)+" "+JSON.toJSONString(mcCole));
    }

}