策略模式: 定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。
策略模式:
定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。

Strategy_Pattern
1
using System;
2
using System.Collections.Generic;
3
using System.Text;
4
5
namespace Strategy_Pattern
6

{
7
class Program
8
{
9
static void Main(string[] args)
10
{
11
Duck duck = new RedheadDuck();
12
13
duck.display();
14
15
duck.performFly();
16
duck.performQuack();
17
IFlyBehavior fly;
18
IQuackBehavior quack;
19
fly = new FlyNoWay();
20
quack = new Squack();
21
duck.setFlyBehavior(fly);
22
duck.setQuackBehavior(quack);
23
duck.performFly();
24
duck.performQuack();
25
26
fly = new FlyRocketPowered();
27
quack = new MuteQuack();
28
duck.setFlyBehavior(fly);
29
duck.setQuackBehavior(quack);
30
duck.performFly();
31
duck.performQuack();
32
33
}
34
}
35
36
public interface IFlyBehavior //飞行接口
37
{
38
void Fly();
39
40
}
41
42
public class FlyWithWings : IFlyBehavior //用翅膀飞行
43
{
44
public void Fly()
45
{
46
Console.WriteLine("I'm fly with wings!!");
47
}
48
}
49
50
public class FlyNoWay : IFlyBehavior //不能飞行
51
{
52
public void Fly()
53
{
54
Console.WriteLine("I can't flying!!");
55
}
56
}
57
58
public class FlyRocketPowered : IFlyBehavior //用火箭飞行
59
{
60
public void Fly()
61
{
62
Console.WriteLine("I'm flying with a rocket!!");
63
}
64
}
65
66
public interface IQuackBehavior //叫的接口
67
{
68
void quack();
69
70
}
71
72
public class Quack : IQuackBehavior //呱呱叫
73
{
74
public void quack()
75
{
76
Console.WriteLine("Quack!!!");
77
}
78
}
79
80
public class Squack : IQuackBehavior //吱吱叫
81
{
82
public void quack()
83
{
84
Console.WriteLine("Squack!!!");
85
}
86
}
87
88
public class MuteQuack : IQuackBehavior //不能叫
89
{
90
public void quack()
91
{
92
Console.WriteLine("Mute!!!");
93
}
94
}
95
96
public abstract class Duck //鸭子抽象类
97
{
98
IFlyBehavior flyBehavior;
99
IQuackBehavior quackBehavior;
100
101
public Duck()
102
{
103
flyBehavior = new FlyWithWings() ;
104
quackBehavior = new Quack();
105
}
106
107
public void swim()
108
{
109
Console.WriteLine("I'm swimming!!");
110
}
111
112
public abstract void display();
113
114
public void performFly()
115
{
116
flyBehavior.Fly();
117
}
118
119
public void performQuack()
120
{
121
quackBehavior.quack();
122
}
123
124
public void setFlyBehavior(IFlyBehavior fly)
125
{
126
flyBehavior = fly;
127
}
128
129
public void setQuackBehavior(IQuackBehavior quack)
130
{
131
quackBehavior = quack;
132
}
133
134
}
135
136
public class RedheadDuck : Duck //红头鸭
137
{
138
public override void display()
139
{
140
Console.WriteLine("I'm a redhead duck!!");
141
}
142
}
143
144
}
145
定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。


1

2

3

4

5

6



7

8



9

10



11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37



38

39

40

41

42

43



44

45



46

47

48

49

50

51



52

53



54

55

56

57

58

59



60

61



62

63

64

65

66

67



68

69

70

71

72

73



74

75



76

77

78

79

80

81



82

83



84

85

86

87

88

89



90

91



92

93

94

95

96

97



98

99

100

101

102



103

104

105

106

107

108



109

110

111

112

113

114

115



116

117

118

119

120



121

122

123

124

125



126

127

128

129

130



131

132

133

134

135

136

137



138

139



140

141

142

143

144

145
