设计模式-Strategy Strategy将算法封装到类中,通过组合的方式 将具体算法的实现在组合对象中实现

以下代码来源: 设计模式精解-GoF 23种设计模式解析附C++实现源码

//strategy.h

#pragma once
class Strategy
{
public:
    Strategy();
    virtual ~Strategy();
    virtual void AlgrithmInference() = 0;
protected:
private:
};

class ConcreateStrategyA :public Strategy
{
public:
    ConcreateStrategyA();
    virtual ~ConcreateStrategyA();
    void AlgrithmInference();
protected:
private:
};

class ConcreateStrategyB :public Strategy
{
public:
    ConcreateStrategyB();
    virtual ~ConcreateStrategyB();
    void AlgrithmInference();
protected:
private:
};

//strategy.cpp

#include"strategy.h"
#include<iostream>

Strategy::Strategy(){}
Strategy::~Strategy()
{
    std::cout << "~Strategy....." << std::endl;
}
void Strategy::AlgrithmInference()
{

}

ConcreateStrategyA::ConcreateStrategyA(){}
ConcreateStrategyA::~ConcreateStrategyA()
{
    std::cout << "~ConcreateStrategyA" << std::endl;
}

void ConcreateStrategyA::AlgrithmInference()
{
    std::cout << "test ConcreateStrategyA" << std::endl;
}

ConcreateStrategyB::ConcreateStrategyB(){}
ConcreateStrategyB::~ConcreateStrategyB()
{
    std::cout << "~ConcreateStrategyB" << std::endl;
}
void ConcreateStrategyB::AlgrithmInference()
{
    std::cout << "test ConcreateStrategyB...." << std::endl;
}

//Context.h

#pragma once

class Strategy;
//Strategy模式与Template模式的根本区别是 Strategy通过 组合(委托)方式实现算法异构,Template使用继承的方式
class Context
{
public:
    Context(Strategy* stg);
    virtual ~Context();
    void DoAction();
protected:
private:
    Strategy* _stg;
};

//Context.cpp

#include"Context.h"
#include"strategy.h"
#include<iostream>

Context::Context(Strategy* stg)
{
    _stg = stg;
}
Context::~Context()
{
    if (!_stg)
        delete _stg;
}
void Context::DoAction()
{
    _stg->AlgrithmInference();
}

//main.cpp

#include"Context.h"
#include"strategy.h"
#include<iostream>
#include<string>

int main(int args, char* argv)
{
    Strategy* ps = new ConcreateStrategyA();
    Context* pc = new Context(ps);
    pc->DoAction();
    if (NULL != pc)
        delete pc;
    getchar();
    return 0;
}

原文地址:https://www.cnblogs.com/fourmi/p/12079671.html

时间: 2024-10-14 09:18:51

设计模式-Strategy Strategy将算法封装到类中,通过组合的方式 将具体算法的实现在组合对象中实现的相关文章

设计模式之Strategy Pattern

Declaration 首先声明, 本篇blog的内容是参考Design pattern FAQ Part 3 ( Design pattern training series)这篇博文写的, 图片也是来自这篇博客. 部分是翻译, 加上自己的理解形成这篇博文. 希望和大家一起学习设计模式, 共同进步. Scene for Strategy Pattern Strategy Pattern,这个翻译成策略模式应该是没有问题的.策略模式希望做到的是在运行的情况下,根据对象的类型选择使用的算法.简单来

java中封装类Feild和使用setter和getter方法访问封装的类Feild

class Person { private String name; private int age; public void setName(String name) //定义访问name的方法 { if (name.length() > 6 || name.length() < 2) { System.out.println("您设置的人名长度不合要求!"); } else { this.name = name; } } public String getName()

JAVA之旅(五)——this,static,关键字,main函数,封装工具类,生成javadoc说明书,静态代码块

JAVA之旅(五)--this,static,关键字,main函数,封装工具类,生成javadoc说明书,静态代码块 周末收获颇多,继续学习 一.this关键字 用于区分局部变量和成员变量同名的情况 this的特点 this就代表本类对象 这在我们的set方法里面是有的 public void setName(String name) { this.name = name; } this代表他所在的函数对属对象的引用 现在我们这里有这么一个需求 //公共的 类 类名 public class H

Java 设计模式(九) Strategy(策略)模式及Spring引申

Strategy 基本概念 策略模式(Strategy Pattern): 定义一组算法,将每个算法都封装起来,并且他们之间可以互换. 使用面向对象的继承和多态机制实现 Strategy中的角色: Context封装角色: 它叫做上下文角色,起承上启下的封装作用,屏蔽高层模块对策略.算法的直接访问,封装可能存在的变化. Strategy抽象策略角色: 策略,算法家族的抽象,通常为接口,定义每个策略或算法的必须具有的算法和属性. Concrete Strategy具体策略角色: 实现抽象策略中的操

JAVA设计模式十--strategy(策略者模式)

概念策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化.(原文:The Strategy Pattern defines a family of algorithms,encapsulates each one,and makesthem interchangeable. Strategy lets the algorithm vary independently from clients that use it.)Conte

Design Pattern 设计模式1 - Strategy 1

实现 : Defferent Heros attack Defferently. - 不同的英雄使用不用的招数 Strategy设计的思路: 基类A,更加小的基类B,新的继承类C: 1 从基类A中抽出一个更加小的基类B 2 利用这个更加小的基类B实现不同的效果 3 把这个更加小的基类B包含进基类A中去 4 新的继承类C只需要和基类A打交道,设计不同行为,不需要理会更加小的基类B #pragma once #ifndef _STRATEGY_HEROS_H #define _STRATEGY_HE

封装各种生成唯一性ID算法的工具类

/** * Copyright (c) 2005-2012 springside.org.cn * * Licensed under the Apache License, Version 2.0 (the "License"); */ package com.minxinloan.common.utils; import java.security.SecureRandom; import java.util.UUID; /** * 封装各种生成唯一性ID算法的工具类. * @aut

第四章:定义封装的类类型

就.NET平台而言,最基本的编程结构就是类类型. 类是由字段数据(通常叫做成员变量)以及操作这个数据的成员(构造函数,熟悉,方法,事件等)所构成的自定义类型. 注:类中的字段很少定义为公共(public)的,为了保护状态数据的完整性,最好将数据定义为私有(private)的或是受保护(protected)的. public class CDome { public int id; private int code; protected int pCode; public CDome(){} pu

20150113--PDO增删改查+封装PDO类

回顾 方法重写:是因为对象的访问会先去子类的类空间找,从而形成了对父类的覆盖. 继承链:类只能单继承,但是可以通过继承链来实现多继承 特殊类:final类和抽象类 接口:interface PHP重载:当访问一个权限不够或者不存在的属性或者方法的时候,会自动触发的魔术方法. 属性重载和方法重载 对象的保存和还原:serialize和unserialize(对应的类已经在内存:如果有资源属性必须进行重新加载资源),魔术方法(__sleep和__wakeup) 对象遍历:默认只能遍历public属性