策略模式学习案例
转载请注明出处：http://blog.csdn.net/droyon/article/details/8611418
策略模式：顾名思义就是提供一系列策略，在不同的情形下可以选择不同的策略。
官方定义：定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
学习源代码下载
案例：
家庭的动物们要开音乐会，我们分几种不同的方案实现。最后使用策略模式实现。
1、使用继承实现：
Animal.java
public class Animal {
private String mName;
private String mSing;
public Animal(String name){
mName = name;
}
public void display(){
System.out.println(mName +"唱歌"+mSing);
}
public void sing(){
System.out.println("我在唱歌");
}
public String getmName() {
return mName;
}
public void sing(Animal animal){
animal.sing();
}
}
Cat.java
public class Cat extends Animal{
public Cat(String name) {
super(name);
}
@Override
public void sing() {
// super.sing();
System.out.println("喵~ 喵喵~");
}
}
public class Dog extends Animal{
public Dog(String name) {
super(name);
}
@Override
public void sing() {
// super.sing();
System.out.println("汪~ 汪汪~");
}
}
Sheep.java
public class Sheep extends Animal{
public Sheep(String name) {
super(name);
}
@Override
public void sing() {
// super.sing();
System.out.println("咩~ 咩咩~");
}
}
StrategyPatternTest.java
public class StrategyPatternTest {
public static void main(String args[]){
System.out.println("家庭动物音乐会");
Animal cat1 = new Cat("小花猫");
Animal cat2 = new Cat("大花猫");
Animal dog = new Dog("小花狗");
Animal sheep = new Sheep("小绵羊");
System.out.println("预备唱-----");
System.out.print(cat1.getmName()+":");
cat1.sing();
System.out.print(cat2.getmName()+":");
cat2.sing();
System.out.print(dog.getmName()+":");
dog.sing();
System.out.print(sheep.getmName()+":");
sheep.sing();
}
}
测试结果：
家庭动物音乐会
预备唱-----
小花猫:喵~ 喵喵~
大花猫:喵~ 喵喵~
小花狗:汪~ 汪汪~
小绵羊:咩~ 咩咩~
2、接口实现:
SingBehavior.java
public interface SingBehavior {
public void singSong();//在具体实现类中实现歌唱
}
Animal.java
public class Animal {
private String mName;
private String mSing;
public Animal(String name){
mName = name;
}
public void display(){
System.out.println(mName +"唱歌"+mSing);
}
public void sing(){
System.out.println("我在唱歌");
}
public String getmName() {
return mName;
}
}
Bird.java
public class Bird extends Animal implements SingBehavior{
public Bird(String name) {
super(name);
}
@Override
public void singSong() {
System.out.println("伊~ 呀呀~");
}
}
Rabbit.java
public class Rabbit extends Animal implements SingBehavior{
public Rabbit(String name) {
super(name);
}
@Override
public void singSong() {
//只会吃萝卜，不会唱歌
}
}
StrategyPatternTest.java
public class StrategyPatternTest {
public static void main(String args[]){
Bird bird = new Bird("小鸟");
System.out.print(bird.getmName()+":");
bird.singSong();
Rabbit rabbit = new Rabbit("兔子");
System.out.print(rabbit.getmName()+":");
rabbit.singSong();
}
}
测试结果：
小鸟:伊~ 呀呀~
兔子:
3、利用组合实现：（策略模式实现）
SingInterface.java 策略接口
package StrategyPattern;
public interface SingInterface {
public void sing();
}
CatSing.java 歌唱策略
package StrategyPattern;
public class CatSing implements SingInterface{
@Override
public void sing() {
System.out.println("喵喵喵");
}
}
DogSing.java 歌唱接口
package StrategyPattern;
public class DogSing implements SingInterface{
@Override
public void sing() {
System.out.println("汪汪汪");
}
}
Animal.java
package StrategyPattern;
public class Animal {
private String mName;
private String mSing;
private SingInterface mSingBehavior;//接口保证了调用时的统一以及方便策略的切换。
public Animal(String name,SingInterface singInterface){
mName = name;
mSingBehavior = singInterface;
}
public void display(){
System.out.println(mName +"唱歌"+mSing);
}
public void sing(){
mSingBehavior.sing();
}
public SingInterface getmSingBehavior() {
return mSingBehavior;
}
public void setmSingBehavior(SingInterface mSingBehavior) {
this.mSingBehavior = mSingBehavior;
}
public String getmName() {
return mName;
}
}
Cat.java
package StrategyPattern;
public class Cat extends Animal{
public Cat(String name, SingInterface singInterface) {
super(name, singInterface);
}
}
Dog.java
package StrategyPattern;
public class Dog extends Animal{
public Dog(String name, SingInterface singInterface) {
super(name, singInterface);
}
}
Bage.java
package StrategyPattern;
/**
* 八哥学舌，别人唱什么，他学什么
* @author
*
*/
public class Bage extends Animal{
public Bage(String name, SingInterface singInterface) {
super(name, singInterface);
}
}
StrategyPattern.java
package StrategyPattern;
public class StrategyPattern {
public static void main(String args[]){
SingInterface catSing = new CatSing();
SingInterface dogSing = new DogSing();
Animal cat = new Cat("花猫",catSing);
Animal dog = new Dog("小狗",dogSing);
Bage bage = new Bage("八哥",null);
System.out.println("预备唱---");
System.out.print(cat.getmName()+":");
cat.sing();
System.out.print(bage.getmName()+":");
bage.setmSingBehavior(catSing);
bage.sing();
System.out.print(dog.getmName()+":");
dog.sing();
System.out.print(bage.getmName()+":");
bage.setmSingBehavior(dogSing);
bage.sing();
}
}
测试结果：
预备唱---
花猫:喵喵喵
八哥:喵喵喵
小狗:汪汪汪
八哥:汪汪汪
总结：
继承可以保证代码复用，有时只需改动一下父类，那么所有的子类都具有了相应属性。但为了代码复用采用继承，不是个好主意。因为改动代码，会影响所有的子类，包括那些不需要改变的子类。
接口提供了统一的接口，但必须在每个实现类中进行实现，产生了重复代码。
上述代码中：CatSing，DogSing都是SingInterface的策略，在Animal中可以通过setmSingBehavior方法对策略进行切换。
策略模式把会变化的部分抽离出来，进行封装，可以动态的增加和去除，而不影响不需要变化的部分。（找出应用中可能需要变化之处，把他们独立出来，不要和不需要变化的代码混在一起--设计原则），封装变化。
策略模式让我们针对超类型（接口和虚方法）编程。经常需要变化的实现不依赖具体的实现类，从而可以动态的运作变化的部分。（针对接口编程，而不是针对实现编程--设计原则）
在设计中多用组合，少用继承---设计原则。
代码应当具备弹性，应能够应付变化。