我们为什么要使用策略模式？

Question

我刚刚从互联网上了解了战略模式的真正含义。 但是我想知道它如何改善我的代码。 例如，我在Internet上这样找到以下代码。 这是名为Animal的超类：

abstract public class Animal {
    private String name;
    private int weight;
    private String sound;

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setWeight(int weight){
        if(weight > 0){
            this.weight = weight;
        }else {
            System.out.println("Weight must be bigger than 0");
        }
    }

    public int getWeight(){
        return weight;
    }

    public void setSound(String sound){
        this.sound = sound;
    }
    public String getSound(){
        return sound;
    }

    public void specialMethod(){
        System.out.println("Ok");
    }
}

这是名为Dog的子类：

public class Dog extends Animal {
    public void digHole(){
        System.out.println("Dig a hole");
    }

    public Dog(){
        super();
        setSound("bark");
    }

    public void testSuper(Animal obj){
        System.out.println(obj.getName());
    }
}

在教程中，它说是否要增加飞行能力，以便我可以检查狗是否可以飞行。 如下面的代码所示，像这样直接添加代码是不好的。

具有超强飞行能力方法的超一流动物

abstract public class Animal {
    private String name;
    private int weight;
    private String sound;

    // Add fly method to the superclass which is a bad idea 
    public String fly(){
        return " I am flying ";
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setWeight(int weight){
        if(weight > 0){
            this.weight = weight;
        }else {
            System.out.println("Weight must be bigger than 0");
        }
    }

    public int getWeight(){
        return weight;
    }

    public void setSound(String sound){
        this.sound = sound;
    }

    public String getSound(){
        return sound;
    }

    public void specialMethod(){
        System.out.println("Ok");
    }
}

使用策略模式，我们可以使用fly方法创建名为Flys的接口，允许任何子类实现该方法，因此，如本教程所示，我创建了名为Flys的接口，其中有两个实现该接口的子类：

public interface Flys {
    String fly();
}

class ItFlys implements Flys{
    public String fly(){
        return "Flying high";
    }
}

class CantFly implements Flys{
    public String fly(){
        return "I can't fly";
    }
}

建立介面后，就可以重构Animal类，

abstract public class Animal {
    private String name;
    private int weight;
    private String sound;
    Flys flyingType; // Add an object of the interface to the superclass 

    public String tryToFly(){ // add a new method tryToFly
        return flyingType.fly();
    }

    // Adding another method named setFlyingAbility 
    public void setFlyingAbility(Flys newFlyType){
        flyingType = newFlyType;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setWeight(int weight){
        if(weight > 0){
            this.weight = weight;
        }else {
            System.out.println("Weight must be bigger than 0");
        }
    }

    public int getWeight(){
        return weight;
    }

    public void setSound(String sound){
        this.sound = sound;
    }

    public String getSound(){
        return sound;
    }

    public void specialMethod(){
        System.out.println("Ok");
    }
}

现在，在我的Dog子类中，我只需添加另一个代码

public class Dog extends Animal {
    public Dog(){
        super();
        setSound("bark");
        flyingType = new CantFly(); // I set flyingType object 
    }

    public void digHole(){
        System.out.println("Dig a hole");
    }

    public void testSuper(Animal obj){
        System.out.println(obj.getName());
    }
}

在最后一堂课，我可以执行所有代码，并检查我的Dog课是否可以飞行。

public class AnimalPlay {
    public static void main(String args[]){
        Animal sparky = new Dog();
        Animal tweety = new Bird();
        System.out.println("Dog " + sparky.tryToFly()); // the result is I can't fly 
        System.out.println("Bird " + tweety.tryToFly()); // the result is I am flying 
        sparky.setFlyingAbility(new ItFlys());
        System.out.println("Dog " + sparky.tryToFly()); // the result is I am flying 
    }
}

我的问题是，如果仍然以传统方式添加fly（）方法，它会得到相同的结果吗？

在超类中添加fly（）方法，以便可以在Dog类中覆盖fly（）方法，但这不是一个好主意。

abstract public class Animal {
    private String name;
    private int weight;
    private String sound;

    // Add fly method to the superclass which is a bad idea 
    public String fly(){
        return " I am flying ";
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setWeight(int weight){
        if(weight > 0){
            this.weight = weight;
        }else {
            System.out.println("Weight must be bigger than 0");
        }
    }

    public int getWeight(){
        return weight;
    }

    public void setSound(String sound){
        this.sound = sound;
    }
    public String getSound(){
        return sound;
    }

    public void specialMethod(){
        System.out.println("Ok");
    }
}

Answer 1

我的问题是，如果仍然以传统方式添加fly（）方法，它会得到相同的结果吗？

答案是不'。

1. 策略模式允许您将行为转移到单独的类中，这对SOLID原则“ S”（单一职责）有利。 您需要学习机器人或人类以“吠叫”的图像-无需使它们继承动物基类。 而且您也不需要在每个类中实现吠叫。
2. 在基类中具有所有属性也是不好的，因为它反对SOLID'L'-Liskou替代。 如果猴子不需要吠叫该怎么办呢？
3. 策略模式可让您根据SOLID'I'设计代码-接口隔离-仅使IAnimalAction接口实现吠叫的许多实现并将IAnimalAction属性分配给所需的动物类（作为属性或作为另一个实现的接口）
4. 策略也可以帮助解决SOLID'D'的问题-您可以注入所需的动物策略（吠叫，飞行），而无需让每个动物都知道

我们可以继续寻找其他奖金。 但是你可以看到一张照片

祝好运！

Answer 2

我不确定哪个先出现，但是像其他任何行为模式一样，策略模式是打开关闭原则的特定实例。 通常，您想要更改对象的行为而不必更改其代码。 这在可扩展性，可维护性和一致性方面具有深远的影响。