策略模式:
定义算法族,分别封装起来,让他们可以互相替换,从而使算法的变化独立与算法的使用者。
类图:
比如说有一个类,需要用到排序,而排序方式自然是多种多样的,显然在这个类中直接用一个方法进行排序是不太好的做法,因为它不能做到在不同情况下使用不同的算法排序。我们怎样应对这中不同的需求呢。我们可以把不同的排序方法封装到不同的类(排序类)中,这些类实现一个共同的接口(排序接口)。 "使用排序的类"拥有"排序接口"类型的引用。在我们需要更换排序方法是我们可以是用一个Set方法把具体的排序对象与这个引用关联。
示例:
下面来做一个可以随意更换算法的Strategy,并且通过泛型可以支持所有数据类型的排序。
class Strategy<T> where T : IComparable
{
ISort<T> isort;
T[] data;
public void Sort()
{
isort.Sort(data);
}
public Strategy(ISort<T> isort, T[] data)
{
this.isort = isort;
this.data = data;
}
public void DoSomething()
{
Console.WriteLine("I working now ..");
}
public void Print()
{
foreach (T st in data)
{
Console.Write(st + "\t");
}
Console.WriteLine();
}
public void SetSorter(ISort<T> isorter)
{
this.isort = isorter;
}
}
如果我通过Strategy 类本身来排序。那么我们必须定义多个不同名称的方法,不利于客户调用。并且一旦要使用新的算法都必须修改Strategy,也不能动态的改变算法。
interface ISort<T> where T:IComparable
{
void Sort(T[] t);
}
class SortC<T>:ISort<T> where T:IComparable
{
// 选择排序
public void Sort(T[] data)
{
for (int i = 0; i < data.Length; i++)
{
int lowIndex = i;
for (int j = data.Length - 1; j > i; j--)
{
if (data[j] .CompareTo(data[lowIndex])==1)
{
lowIndex = j;
}
}
Swaper<T>.Swap(ref data[i], ref data[lowIndex]);
}
}
}
class Swaper<T> where T:IComparable
{
static T temp = default(T);
public static void Swap(ref T left ,ref T right)
{
temp = left;
left = right;
right = temp;
}
}
下面两个是其他算法:
Code
<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />--> public class SortB<T> : ISort<T> where T : IComparable
{
public void Sort(T[] data)
{
quickSort(data, 0, data.Length - 1);
}
private void quickSort(T[] data, int i, int j)
{
int pivotIndex = (i + j) / 2;
Swaper<T>.Swap( ref data[pivotIndex], ref data[j]);
int k = partition(data, i - 1, j, data[j]);
Swaper<T>.Swap(ref data[k], ref data[j]);
if ((k - i) > 1) quickSort(data, i, k - 1);
if ((j - k) > 1) quickSort(data, k + 1, j);
}
private int partition(T[] data, int l, int r, T pivot)
{
do
{
while (data[++l].CompareTo(pivot)==1) ;
while ((r != 0) && data[--r].CompareTo( pivot)==-1) ;
Swaper<T>.Swap(ref data[l], ref data[r]);
}
while (l < r);
Swaper<T>.Swap(ref data[l], ref data[r]);
return l;
}
}
Code
<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />--> class SortA<T>:ISort<T> where T:IComparable
{
public void Sort(T[] t)
{
for (int i = 0; i < t.Length-1; i++)
{
for (int j = i; j < t.Length; j++)
{
if (t[i].CompareTo(t[j]) == 1)
{
Swaper<T>.Swap(ref t[i], ref t[j]);
}
}
}
}
}
static void Main(string[] args)
{
int[] t = new int[] { 12,34,3543,5,454,4};
Strategy<int> strateg = new Strategy<int>(new SortA<int>(),t);
Console.WriteLine("支持int排序的Strategy");
strateg.Sort();
strateg.Print();
strateg.DoSomething();
strateg.SetSorter(new SortB<int>());
strateg.Sort();
strateg.Print();
//Console.WriteLine("支持double排序Strategy");
//double[] dt = new double[]{12.2,12.3,23.3,34,-1};
//Strategy<double> ds = new Strategy<double>(new SortA<double>(),dt);
//ds.Sort();
//ds.Print();
//strateg.DoSomething();
//ds.SetSorter(new SortB<double>());
//ds.Sort();
//ds.Print();
Console.ReadLine();
}
这样支持各种算法支持各种数据类型的排序做好了。
分享到:
相关推荐
### 策略模式 Strategy Pattern #### 概述 策略模式是一种行为设计模式,它使得算法可以在运行时被更改。这种模式允许一个类的行为或其算法在运行时根据需要进行改变,通过这种方式,我们可以轻松地扩展不同的算法...
策略模式(Strategy)是软件设计模式中的一种行为模式,它使你能在运行时改变对象的行为。在Java中,策略模式通常涉及定义一系列算法,并将每个算法封装起来,使得它们可以相互替换,同时使得算法的变化独立于使用它...
2009-03-9 策略模式Strategy:当解决一个问题的途径(策略)有很多种的时候,每一种处理方式都可以做为一种处理策略,通过管理类来切换调用不同的策略。
C#面向对象设计模式 (行为型模式) Strategy 策略模式 视频讲座下载
策略模式的主要组件包括上下文(Context)、策略(Strategy)接口以及具体的策略类。上下文是使用策略的对象,它通过策略接口与策略进行交互。策略接口定义了一组操作,这些操作将在不同的策略实现中有所不同。具体策略...
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在策略模式中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为模式。 在策略模式中,我们创建表示各种策略的对象和一个行为根据...
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件设计中,有时我们需要根据不同的场景或条件选择不同的算法或行为。策略模式允许我们将这些算法封装成独立的类,每个类代表一种策略,然后在运行...
在`Demo1_Strategy`这个示例中,可能包含了多个C++源文件,分别实现了策略模式的不同方面,例如定义了策略接口、具体策略类以及上下文类的实现。通过分析这些源代码,我们可以更深入地理解策略模式的用法和优势。 ...
本文实例讲述了PHP设计模式之 策略模式Strategy。分享给大家供大家参考,具体如下: 1.概述 在软件开发中也常常遇到类似的情况,实现某一个功能有多种算法或者策略,我们可以根据环境或者条件的不同选择不同的算法...
在策略模式中,有三个主要角色:策略接口(Strategy Interface)、具体策略类(Concrete Strategy Classes)和上下文(Context)。策略接口定义了所有支持的算法的公共接口,这样上下文就可以通过这个接口来调用这些...
策略模式的核心组成部分包括策略(Strategy)、上下文(Context)和具体策略(Concrete Strategies)。策略定义了算法家族,而上下文则使用这些策略,但并不知道具体的实现细节。具体策略是实现了策略接口的具体算法...
策略模式的主要组成部分包括上下文(Context)、策略接口(Strategy Interface)和具体策略类(Concrete Strategy Classes)。上下文维护一个对策略对象的引用,并使用这个引用来调用策略对象的算法。策略接口定义了...
首先,策略模式由三个主要组成部分构成:上下文(Context)、策略(Strategy)接口和具体策略(Concrete Strategy)。上下文是使用策略的对象,它维护一个对策略的引用,并调用策略的接口来执行算法。策略接口定义了一组...
策略模式的核心组成部分包括上下文(Context)、策略(Strategy)和具体策略(Concrete Strategy)。上下文是使用策略的对象,它定义了客户所期望的接口,并负责调用具体策略对象的算法。策略是所有具体策略的抽象接口,它...
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。这种模式允许你使用算法族,而无需在代码中硬编码这些算法。通过将算法封装到具有共同接口的独立对象中,策略模式使得你可以根据需要灵活地切换算法,...
在提供的`strategy.h`文件中,可能包含了策略模式的C++实现。文件中可能定义了策略接口和几个具体策略类的声明,以及上下文类的接口。为了进一步了解其内容,我们需要查看源代码。由于实际的代码没有提供,这里只能...
SpringBoot结合策略模式实战套路 策略模式是一种常用的设计模式,它可以使我们的代码更加灵活、可维护和可扩展。在SpringBoot项目中,策略模式可以与依赖注入机制相结合,实现更加灵活的业务逻辑处理。在本文中,...
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。...在提供的压缩包文件"strategy"中,可能包含了关于策略模式的示例代码或者详细解释,你可以解压后查看,进一步理解和学习策略模式的实现和应用。
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件设计中,我们经常遇到需要根据不同的条件或策略来执行不同操作的情况。策略模式提供了一种将算法族封装到各自独立的对象中,使得它们可以在运行...