技術標籤：Java設計模式java

我們先來看一下在未使用策略模式之前採用面向物件的方式來做以下案例。用一個最簡單的案例，來了解策略模式的思維方式。

直接上程式碼：

Dog超類：

/**
 * Dog超類
 */
public abstract class Dog {
    //狗狗的毛色各不相同,由子類去實現
    public abstract void color();

    //狗狗的叫聲是共性行為，直接由父類實現
    public void bark() {
        System.out.println("汪汪汪......");
    }
}

 

Dog實現類BlackDog：

//黑色的狗狗
public class BlackDog extends Dog{
    @Override
    public void color() {
        System.out.println("我的毛色是黑色的！");
    }
}

Dog實現類WhiteDog：

//白色的狗狗
public class WhiteDog extends Dog{
    @Override
    public void color() {
        System.out.println("我的毛色是白色的！"
 
);
    }
}

來一個測試類看一下執行結果

public class Test {

    public static void main(String[] args) {
        BlackDog blackDog = new BlackDog();
        WhiteDog whiteDog = new WhiteDog();

        blackDog.color();
        blackDog.bark();

        whiteDog.color();
        whiteDog.bark();
    }
}

執行結果如下：

此時若是來一個新的需求，我們來看一下當前專案的擴充套件性如何
如果這個時候需要新增游泳的功能（假設有的狗狗可以游泳，有的狗狗不會）
若是直接在父類中新增swim()方法，那麼所有的子類都會游泳了，這樣是不符合我們的需求的。即便是子類重寫這個方法，隨之而來的工作量也會增多。當然，你也可以把這個swim()方法定義為抽象函式，具體實現讓子類去實現，但是這樣做的話，程式碼的複用性就會降低。

這個時候我們就需要去使用策略模式的思維方式去解決出現的問題：

抽象成介面加實現（將會發生變化的部分與不變的部分分離，變化的地方交給介面去定義，不變的地方直接在父類中定義）

以下是使用策略模式思想修改後的程式碼：

定義一個游泳行為的介面：

public interface SwimCapacity {
    void swim();
}

定義兩個類實現該介面：

public class CanSwim implements SwimCapacity{
    @Override
    public void swim() {
        System.out.println("我會游泳");
    }
}

public class CannotSwim implements SwimCapacity{
    @Override
    public void swim() {
        System.out.println("我不會游泳");
    }
}

Dog超類：

/**
 * Dog超類
 */
public abstract class Dog {
    //新增一個行為物件
    SwimCapacity swimCapacity;

    //狗狗的毛色各不相同,由子類去實現
    public abstract void color();

    //狗狗的叫聲是共性行為，直接由父類實現
    public void bark() {
        System.out.println("汪汪汪......");
    }

    //游泳的行為方式函式中不再具體實現，直接呼叫行為物件
    public void swim() {
        swimCapacity.swim();
    }
}

Dog實現類BlackDog：

//黑色的狗狗
public class BlackDog extends Dog {
    public BlackDog() {
        //傳送具體的行為能力
        swimCapacity = new CanSwim();
    }
    @Override
    public void color() {
        System.out.println("我的毛色是黑色的！");
    }
}

Dog實現類WhiteDog：

//白色的狗狗
public class WhiteDog extends Dog {
    public WhiteDog() {
        swimCapacity = new CannotSwim();
    }
    @Override
    public void color() {
        System.out.println("我的毛色是白色的！");
    }
}

測試類看一下執行結果

public class Test {

    public static void main(String[] args) {
        BlackDog blackDog = new BlackDog();
        WhiteDog whiteDog = new WhiteDog();

        blackDog.color();
        blackDog.bark();
        blackDog.swim();

        whiteDog.color();
        whiteDog.bark();
        whiteDog.swim();
    }
}

執行結果如下：

總結：

以上就是策略模式的運用，從中我們可以看出策略模式將行為封裝到了介面中，父類裡面放的是介面的物件，然後在子類的建構函式中設定具體的行為物件。