Java设计模式1:策略模式

浅浅的花香味﹌ 2022-06-06 09:35 161阅读 0赞

**一.策略模式**  
1.介绍:  
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的多个实现类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。  
![这里写图片描述][SouthEast]  
2.角色划分:  
**环境(Context)**：持有一个Strategy的引用。  
**抽象策略(Strategy)**：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。  
**具体策略(ConcreteStrategy)**：实现了抽象策略角色，包装了相关的算法或行为，实现了单独的不同功能。

**二.案例**  
◆造鸭子  
使用场景:(造鸭子)  
1.所有的鸭子必须要有且相同的功能:游泳  
2.所有鸭子必须要有且功能不同:颜色  
3.有些需要有，有些不需要有，且功能不同:飞行速度  
4.有些需要有，有些不需要有，且功能不同：叫声  
![这里写图片描述][SouthEast 1]  
代码:  
1.abstract class Duck.java（环境角色的父类,可以不要，根据个人设计）

package tiglle.patterns.strategy;
    //抽象鸭子父类
    public abstract class Duck { 
    /**************************************************************/
        //3的功能(飞行速度)
        private FlySpeed fly;
    
        //4的功能(叫声)
        private Voice voice;
    
        //构造方法,初始化fly和voice
        public Duck(FlySpeed fly,Voice voice){
            this.fly = fly;
            this.voice = voice;
        }
    
        //具体 飞行速度 调用委托给父类
        public void fly(){
            fly.fly();
        }
    
        //具体 叫声 调用委托给父类
        public void cry(){
            voice.cry();
        }
    
    /**************************************************************/
        //1.游泳:所有的鸭子必须要有且相同的功能,直接写成能被所有子鸭子继承的方法
        public void swing(){
            System.out.println("我遨游在大海...");
        }
    
        //2.颜色:所有鸭子必须要有且功能不同,写成抽象方法,由子鸭子自己决定颜色
        public abstract void color();
    
    /**************************************************************/    
        //fly和voice的setter方法，以便运行时改变功能
        public void setFly(FlySpeed fly) {
            this.fly = fly;
        }
    
        public void setVoice(Voice voice) {
            this.voice = voice;
        }
    
    }

2.class RedDuck.java(红色子鸭子(环境角色))

package tiglle.patterns.strategy;
    //红色子鸭子(环境角色)
    public class RedDuck extends Duck{ 
    
        //给父类fly和voice赋值
        public RedDuck(FlySpeed fly, Voice voice) {
            super(fly, voice);
        }
    
        //重写抽象方法:2.颜色:所有鸭子必须要有且功能不同,写成抽象方法,由子鸭子自己决定颜色
        @Override
        public void color() {
            System.out.println("我是红色子鸭子");
        }
    
    }

3.class GreenDuck.java(绿色子鸭子(环境角色))

package tiglle.patterns.strategy;
    //绿色子鸭子(环境角色)
    public class GreenDuck extends Duck{ 
    
        //给父类fly和voice赋值
        public GreenDuck(FlySpeed fly, Voice voice) {
            super(fly, voice);
        }
    
        //重写抽象方法:2.颜色:所有鸭子必须要有且功能不同,写成抽象方法,由子鸭子自己决定颜色
        @Override
        public void color() {
            System.out.println("我是绿色子鸭子");
        }
    
    }

4.interface FlySpeed.java（飞行速度接口(抽象策略)）

package tiglle.patterns.strategy;
    //飞行速度接口(抽象策略)
    public interface FlySpeed {
    
        public void fly();
    
    }

5.class FastFly.java(非得很快 实现类(具体策略))

package tiglle.patterns.strategy;
    //非得很快 实现类(具体策略)
    public class FastFly implements FlySpeed{ 
    
        @Override
        public void fly() {
            System.out.println("我飞的很快");
        }
    
    }

6． class FlySpeed.java(飞的很慢 实现类(具体策略))

package tiglle.patterns.strategy;
    //飞的很慢 实现类(具体策略)
    public class SlowFly implements FlySpeed{ 
    
        @Override
        public void fly() {
            System.out.println("我飞的很慢");
        }
    
    }

7.interface Voice.java(叫声接口(抽象策略))

package tiglle.patterns.strategy;
    //叫声接口(抽象策略)
    public interface Voice {
    
        public void cry();
    
    }

8.class GuaGua.java(呱呱叫实现类(具体策略))

package tiglle.patterns.strategy;
    //呱呱叫实现类(具体策略)
    public class GuaGua implements Voice{ 
    
        @Override
        public void cry() {
            System.out.println("呱呱叫");
        }
    
    }

9.class ZhiZhi.java(吱吱叫 实现类(具体策略))

package tiglle.patterns.strategy;
    //吱吱叫 实现类(具体策略)
    public class ZhiZhi implements Voice{ 
    
        @Override
        public void cry() {
            System.out.println("吱吱叫");
        }
    
    }

10.class DoNothing.java(什么都不做(叫)实现类(具体策略))

package tiglle.patterns.strategy;
    //什么都不做(叫)实现类(具体策略)
    public class DoNothing implements Voice{ 
    
        @Override
        public void cry() {
            //do nothing
        }
    
    }

11.class MainExec.java(测试main方法)

package tiglle.patterns.strategy;
    
    public class MainExec { 
    
        /* 策略模式 1.简介: 策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的多个实现类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 2.角色: 环境(Context)：持有一个Strategy的引用。 抽象策略(Strategy)：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。 具体策略(ConcreteStrategy)：实现了抽象策略角色，包装了相关的算法或行为，实现了单独的不同功能。 3.使用场景:(造鸭子) 1.所有的鸭子必须要有且相同的功能:游泳 2.所有鸭子必须要有且功能不同:颜色 3.有些需要有，有些不需要有，且功能不同:飞行速度 4.有些需要有，有些不需要有，且功能不同：叫声 */
        public static void main(String[] args) {
            //红色子鸭子飞的快，呱呱叫
            RedDuck redDuck = new RedDuck(new FastFly()/*飞得快实现类*/, new GuaGua()/*呱呱叫实现类*/);
            redDuck.color();
            redDuck.fly();//飞的快
            redDuck.cry();//呱呱叫
            //绿色子鸭子飞得慢吱吱叫
            GreenDuck greenDuck = new GreenDuck(new SlowFly()/*飞得慢实现类*/, new ZhiZhi()/*吱吱叫实现类*/);
            redDuck.color();
            greenDuck.fly();
            greenDuck.cry();
    
            /*********************运行时改变功能*****************************************/
            //红色子鸭子想飞得慢
            redDuck.setFly(new SlowFly()/*飞得慢实现类*/);
            redDuck.fly();
            //绿色子鸭子想成为哑巴
            greenDuck.setVoice(new DoNothing()/*什么声音都没有实现类*/);
            greenDuck.cry();
        }
    
    
    }
    
    运行结果:
    我是红色子鸭子
    我飞的很快
    呱呱叫
    我是红色子鸭子
    我飞的很慢
    吱吱叫
    我飞的很慢

◆根据会员等级优惠图书  
[http://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html][http_www.cnblogs.com_java-my-life_archive_2012_05_10_2491891.html]

[SouthEast]: /images/20220606/5528183a04a945b78dd8198e5cb2390c.png
[SouthEast 1]: /images/20220606/f9fe0e6efb704e7d89351b87e0d83d9f.png
[http_www.cnblogs.com_java-my-life_archive_2012_05_10_2491891.html]: http://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html