#探讨简单工厂模式和策略模式的区别#

需求：设计一个能随意切换枪械的装置。

策略界面vs工厂界面

//策略类界面
    class testShot2 {
        public void printFrame(){
            Scanner s = new Scanner(System.in);
            pkgShot2 pks2 = null;//初始化策略类，策略类包装了shot对象！！
            
            System.out.println("请选择抢型:1.cnnonShot 2.gunShot 3.machineGunShot");
            String num = s.nextLine();
            
            pks2 = new pkgShot2(num);//实例化策略类，起到筛选作用
            pks2.execute();//间接发出射击方法
            s.close();
        }
        public static void main(String[] args) {
            testShot2 ts2 = new testShot2();
            ts2.printFrame();
        }
    }
//工厂类界面
    class testShot3{
        public void printFrame(){
            Scanner s = new Scanner(System.in);
            Shot st;//直接初始化shot对象
            
            System.out.println("请选择抢型:1.cnnonShot 2.gunShot 3.machineGunShot");
            String num = s.nextLine();
            
            st = ShotFactory.creatShot(num);//实例化策略对象，生产出符合要求的枪械，起到筛选作用
            st.shotMethod();//直接调用射击方法
            s.close();
        }
        public static void main(String[] args) {
            testShot3 ts3 = new testShot3();
            ts3.printFrame();
        }
    }

策略类vs工厂类

//策略类
class pkgShot2 {
    private Shot shot;//初始化shot
    public pkgShot2(String num){
        switch (num) {
        case "1":
            this.shot = new cannonShot();
            break;

        case "2":
            this.shot = new gunShot();
            break;
        case "3":
            this.shot = new machineGunShot();
        }
    }
    public void execute(){//间接调用
        shot.shotMethod();
    }
}
//工厂
class ShotFactory{
    
    public static Shot creatShot(String num){
        Shot st = null;//初始化shot
        switch (num) {
        case "1":
            st = new cannonShot();
            break;
        case "2":
            st = new gunShot();
            break;
        case "3":
            st = new machineGunShot();
            break;
        }
        return st;//返回shot对象
    }
}

其余相同类补充：

父类射击类

package com.strategyDemo;
//射击类抽象
public abstract class Shot {
    public abstract void shotMethod();
}

子类射击类型

package com.strategyDemo;

public class cannonShot extends Shot {

    @Override
    public void shotMethod() {
        // TODO Auto-generated method stub
        System.out.println("大炮轰击，BOOM！！");
    }
    
}

//手枪射击
public class gunShot extends Shot{

    @Override
    public void shotMethod() {
        System.out.println("发射手枪子弹！！");
    }

}
//机枪射击
public class machineGunShot extends Shot{
    
    @Override
    public void shotMethod() {
        System.out.println("机关枪死亡扫射！！");
    }
    
    

}

同样的结果：

 

分析：两个设计模式的不同，工厂模式是直接对象调用枪械方法，策略模式通过策略类封装shot对象调用枪械方法，个人感觉策略类更加符合面向对象的思想，减轻了客户端的职责。

 

Ending... ...