一个例子讲解策略设计模式

假设我们项目中已经有了一个类

public abstract class Car {
    public abstract void setFeature();
}

而且这个类有四个实现类:
public class AudiCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("奥迪四个环");
    }
}

public class BMWCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("宝马别摸我");
    }
}

public class Benz extends Car {
    @Override
    public void setFeature() {
        System.out.println("奔驰三个尖");
    }
}

public class TrucksCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("大货车个头很大");
    }
}

突然有一天,我们的需求变了,我们需要给这个Car增加自动泊车功能,怎么办?
思路一:我们可以在Car这个类里面增加一个抽象方法,比如:

public abstract class Car {
    public abstract void setFeature();
    //新增自动泊车功能
    public abstract void autoPark();
}

这样的话,它的四个实现类都要实现这个自动泊车的方法:

public class AudiCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("奥迪四个环");
    }

    @Override
    public void autoPark() {
        System.out.println("全自动泊车");
    }
}

public class Benz extends Car {
    @Override
    public void setFeature() {
        System.out.println("奔驰三个尖");
    }
    @Override
    public void autoPark() {
        System.out.println("全自动泊车");
    }
}

public class BMWCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("宝马别摸我");
    }
    @Override
    public void autoPark() {
        System.out.println("全自动泊车");
    }
}

public class TrucksCar extends Car {
    @Override
    public void setFeature() {
        System.out.println("大货车个头很大");
    }
    @Override
    public void autoPark() {
        System.out.println("半自动泊车,请注意倒车");
    }
}

这样的话,我们实现了需求,但是这样的话,稍微麻烦,因为AudiCar, Benz, BMWCar这三个类实现自动泊车的功能是一样的,我们完全没有必要这三个类都去重写.
这个时候,策略模式出来了!
思路二:我们把新增的功能抽象出接口:

public interface IAutoPark {
     void autoPark();
}

因为目前需求这个功能有两种具体的实现,一个"全自动泊车",一个"半自动泊车,请注意倒车",所以我们定义两个实现类:

public class AutoParkImp implements IAutoPark {
    @Override
    public void autoPark() {
        System.out.println("全自动泊车");
    }
}

public class HalfAutoParkImp implements IAutoPark {
    @Override
    public void autoPark() {
        System.out.println("半自动泊车,请注意倒车");
    }
}

然后修改Car:

public abstract class Car {
    protected IAutoPark autoPark;
    //它的子类在初始化的时候要传入自己自动泊车功能的具体实现
    public Car(IAutoPark autoPark){
        this.autoPark = autoPark;
    }
    public abstract void setFeature();
    //新增自动泊车功能
    public  void autoPark(){
        autoPark.autoPark();
    }
}

四个子类的实现:

public class AudiCar extends Car {
    public AudiCar(IAutoPark autoPark) {
        super(autoPark);
    }

    @Override
    public void setFeature() {
        System.out.println("奥迪四个环");
    }

}

public class Benz extends Car {
    public Benz(IAutoPark autoPark) {
        super(autoPark);
    }

    @Override
    public void setFeature() {
        System.out.println("奔驰三个尖");
    }
}

public class BMWCar extends Car {
    public BMWCar(IAutoPark autoPark) {
        super(autoPark);
    }

    @Override
    public void setFeature() {
        System.out.println("宝马别摸我");
    }

}

public class TrucksCar extends Car {
    public TrucksCar(IAutoPark autoPark) {
        super(autoPark);
    }

    @Override
    public void setFeature() {
        System.out.println("大货车个头很大");
    }

}

我们在使用的时候:

Car audi = new AudiCar(new AutoParkImp());
audi.setFeature();
audi.autoPark();
Car trucks = new TrucksCar(new HalfAutoParkImp());
trucks.setFeature();
trucks.autoPark();

日志打印:

 System.out: 奥迪四个环
System.out: 全自动泊车
System.out: 大货车个头很大
System.out: 半自动泊车,请注意倒车

所谓的设计模式就是大家总结出来的套路,使用的时候还是要根据自己项目中的需求来选择,不要为了使用而使用