-
设计模式概述
-
定义
设计模式是一套被反复使用,多数人知晓的,经过分类的,代码设计经验总结简单来说:经验复用!
-
使用语言:
并不要求一定用某种语言,理论上适合于任何oo语言(面向对象编程语言)(Java,C#等)
-
意义&目的:
代码复用,增加可维护性。每种模式在现时中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因。
-
-
策略模式概述
- 预备知识:本文以java举例,请先了解 类、复用、继承、多态、接口,抽象类等
- 策略模式( Strategy Pattern):定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
- (划重点!!!)最主要用法:许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法
正文!
用例子理解:
有一个Duck()类
鸭子会叫
所以有一个Quack()方法
因为红头鸭和绿头鸭会飞,现在,要新加入一种 fly()方法。
方法一:继承
继承是指一个对象直接使用另一对象的属性和方法。
即直接在Duck类里面加入fly()方法,再由子类继承。
但是!!!
不是所有的鸭子都会飞
那么,对于每一个Duck子类的实例对象,都必须覆盖fly()方法(会飞的不会飞的,乃至用不同姿态飞的鸭子)
然而,如果还有一个诱饵鸭:
不会飞也不会叫。。。。。。
那么,又得覆盖Quack()方法。
代码:
public class StrategyModel1 {
public static void main(String[] args) {
Duck1 duck=new Duck1();
System.out.println("Duck1:");
duck.fly1();
duck.Quack1();
duck.Swim1();
Duck1 rubberduck=new rubberDuck1();
System.out.println("RubberDuck1:");
rubberduck.fly1();
rubberduck.Quack1();
rubberduck.Swim1();
Duck1 Decoyduck=new DecoyDuck1();
System.out.println("DecoyDuck1:");
Decoyduck.fly1();
Decoyduck.Quack1();
Decoyduck.Swim1();
}
}
class Duck1{
public void fly1() {
System.out.println("I'm flying!");
}
public void Quack1() {
System.out.println("呱呱呱");
}
public void Swim1() {
System.out.println("All the Ducks are swimming!");
}
}
class rubberDuck1 extends Duck1{
public void fly1() {
System.out.println("I can't fly!");//point1
}
public void Quack1() {
System.out.println("吱吱吱");
}
}
/*看似可行,但是可能不同的类有相同的方法,直接继承会继承不相同不想要的方法。
比如DecoyDuck1想要用RubberDuck1的fly1方法,要么继承Duck1,再重写fly1方法;
要么不继承Duck1而继承RubberDuck1,再重写Quack1方法。
无论哪种继承,都会导致代码在多个子类中重复。*/
class DecoyDuck1 extends Duck1{
public void fly1() {
System.out.println("I can't fly!");//point2
}
public void Quack1() {
System.out.println("呱呱呱");
}
}
结论:
1.利用继承的方法,改动会牵一发而动全身,造成其他不想要的改变
2.代码在多个子类中重复。
简单来说:有新方法子类就要覆盖父类。覆盖其实没有逻辑问题,问题是同样的方法在不同类里面要重写多次,代码繁琐。
方法二:接口
继承不行。因为鸭子会不断更新,这样每当有新的鸭子类出现,就得检查甚至覆盖fly()和Quack()方法。
那么
我们可以把fly()从父类中取出来,放到Flyalbe接口中,这样,只有会飞的鸭子才能实现此接口。Quackable接口同理。
接口:(interface),是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
【注意与抽象类区分!】(抽象类是对一种事物的抽象,即对类抽象{is-a}(全部方法和属性继承)。而接口是对行为的抽象{has-a}。(指定方法继承))
代码:
public class StrategyModel2 {
public static void main(String[] args) {
Duck2 duck=new Duck2();
duck.fly2();
Duck2 rubberduck=new rubberDuck2();
rubberduck.fly2();
}
}
class rubberDuck2 extends Duck2 implements Flyable2 {
public void fly2() {
System.out.println("I don't wanna to fly!");
}
}
class Duck2 implements Flyable2{
public void fly2() {
System.out.println("I'm flying!");
}
}
interface Flyable2{
public abstract void fly2();
}
//Flyalbe2导致fly2完全不能复用
现在虽然Flyable接口可以解决会飞的橡皮鸭问题,
但是!!!
这是一种更蠢的方法,只有方法声明,没有方法实现!
代码将完全无法复用,无论方法是否一样,每次必须重写。
方法三:策略模式!
继承不能解决问题,因为鸭子的行为在子类里不断改变,而且让所有子类都有这些行为是不恰当的。
接口似乎可行,只有会飞的鸭子继承Flyable接口,但是Java接口不具有实现代码,继承接口无法使代码复用。
有一个设计原则,恰好适用于此:(第一个设计原则!)
找出变化之处,把它独立出来,与无需变化的代码隔离
这个概念很简单,
几乎是每个设计模式背后的精神所在!
哪些可变哪些不可变?
每次新的需求一来,都会使某方面的代码发生变化,那么这部分代码就要被抽出来,区分与其他稳定代码。
Fly()和Quack()会随着鸭子的类不同而改变。
我们把它们从Duck类中取出,新建一组类来代表每个行为
第二个设计原则:针对接口编程!而不是针对实现编程
我们利用接口代表每个行为,比方说,FlyBehavior,而行为的每个实现都将实现其中的一个接口。
这样的做法迥异于以往,以前的做法是:行为来自Duck父类的具体实现,或是继承某个接口并由子类自行实现而来。这两种做法都是依赖于“实现”,我们被实现绑得死死的,没办法更改行为(除非写更多代码)。
在我们的新设计中,鸭子的子类将使用接口FlyBehavior所表示的行为,所以实际的“实现”不会被绑死在鸭子的子类中。
换句话说,特定的具体行为编写在实现了FlyBehavior的类中。
这样设计,甚至可以让fly被其他对象复用,因为这个fly动作已经与鸭子类无关了。
代码:
public class StrategyModel3 {
public static void main(String[] args) {
Duck3 duck=new Duck3();
duck.Swim3();
Duck3 rubberduck=new RubberDuck3();
rubberduck.Swim3();
rubberduck.PerformFly();
Duck3 decoyduck=new DecoyDuck3();
decoyduck.PerformFly();
}
}
class Duck3{
public FlyBehavior flybehavior;
public void Swim3() {
System.out.println("All the ducks are swimming!");
}
public void PerformFly() {
flybehavior.fly3();
}
}
class RubberDuck3 extends Duck3{
public RubberDuck3() {
flybehavior=new FlyWithWings();
}
}
class DecoyDuck3 extends Duck3{
public DecoyDuck3() {
flybehavior=new FlyNoWay();
}
}
interface FlyBehavior{
public void fly3();
}
class FlyWithWings implements FlyBehavior{
public void fly3() {
System.out.println("I'm flying!");
}
}
class FlyNoWay implements FlyBehavior{
public void fly3() {
System.out.println("I can't fly!");
}
}
(Quack同理)
将两个类结合起来使用,如同本例,就是组合。这种做法和“继承”不同的地方在于,鸭子的行为不是继承来的,而是和适当的行为对象组合来的。
第三个设计原则:多用组合,少用继承!
复习:
策略模式:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
概念图示:
结束
------By@YYSir