精华内容
下载资源
问答
  • 简单工厂+策略模式-上

    千次阅读 2014-06-12 10:56:08
    简单工厂加策略模式的应用


                这次写了一个简单工厂加策略模式、写的糊里糊涂的、主要实现了这么个功能、输入相应的字符串、输入相应的几个数、自动选择算法。以后到上下机、是想输入时间和相应的数据、自动算出相应的钱数。


                故事:富兰克林去黑煤窑干苦力哭、嘿咻、嘿咻、累了一天又一天、节假日也不休息、富兰克林跟老板说、老板你每天让我干活23小时惊恐、才给那么点、而且节假日也不给个加班费啥的、龟YEYE不干了= =发火


                老板怕小龟龟走、没人给他拉煤、就给小龟龟出了道难题疑问、如果你能用简单工厂和策略模式写出一个能根据每小时钱数、和小时数算工资的软件、对了、节假日还要有特殊的加成、一点按钮就能算出来、我就按你说的给工钱得意


                富兰克林:你妹啊、搞IT的就好好搞IT、挖煤作甚发火、好在龟YEYE学过Design pattern、等着Give Money吧!得意


                经过三天三夜的奋战、富兰克林终于画出了UML图、他找到了搞IT的肉白卡、肉白卡肉白卡、快来看看、这图咋样!生气




    ————————羡慕哇塞!!!


    ————————看不懂= =害羞


    富兰克林说:@¥#%……#¥@……


    (要想知道富兰克林说的是什么、请重新阅读图片前面的内容——)


    肉白卡:

                哦哦哦!你们那黑心的老板、快给我讲讲、最近我们学校正让做机房收费系统、上下机有好几种算法、搞得GU-NAI-NAI头晕目眩的、看你这个好像能用的上、说说吧!


    富兰克林:

                看UML图、首先 你要知道有、工厂类、侧略类、算法的抽象类、和算法类


                抽象算法类:有一个计算金额的抽象方法、而继承他的子类、也就是实际的算法类重写他的功能、这里我还加入了构造方法、构造方法就是接受要计算的数值、算法1的类是接受2个、算法2的类是接受3个。


                策略类:这个类主要有2个方法、一个是传入具体算法类、这里声明了抽象算法类、可以传入他的所有子类、传入之后用策略类声明的一个抽象算法接受、第二个方法使用这个算法类的计算方法、返回算数结果。


                工厂类:这个其实就是根据传入的字符串、判断到底实例化哪个计算类、省去了客户端手动NEW类、客户端不用知道实现方式、只要知道想要什么、就跟工厂类说就可以了、工厂类有2个构造方法、一个能接受2个int型的数字、另一个能接受3个int型的数字、分别满足2个算法类计算需要的数字。

    富兰克林:小肉肉你懂了没大笑


    肉白卡:没懂………………


    富兰克林:尴尬你不是搞IT的吗?


    肉白卡:            

                哎…………还高IT的呢、马上就要挨踢了、正所谓一瓶子不满半瓶子晃荡、机房收费系统上下机弄不出来、我还当什么程序员、还是回去弹GT吧- -


    富兰克林:

                小白就是小白、这样吧我把源码给你、你回去研究下、下次去你对象那吃饭、记得打1折!

    肉白卡:1折?!那直接请你好了!发火


    富兰克林:好的大笑马上给你代码



    ''' <summary>
    ''' 算法抽象列(CashAlgorithm现金算法)
    ''' </summary>
    ''' <remarks></remarks>
    Public MustInherit Class CashAlgorithm
    
        ''' <summary>
        ''' 算现金的抽象方法
        ''' </summary>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Overridable Function countMoney() As Integer
    
        End Function
        '必须被重写
        'Public Overrides Sub Move(ByVal NewX As Integer, ByVal NewY As Integer)
        '    '...
        'End Sub
        'Public Property XPos() As Integer
        '    '...
        'End Property
    
    End Class
    
    
    ''' <summary>
    ''' 算法1 正常工资
    ''' </summary>
    ''' <remarks></remarks>
    Public Class CashOne
        '继承抽象类
        Inherits CashAlgorithm
        Dim _workTime As New Integer
        Dim _hourMoney As New Integer
        ''' <summary>
        ''' 构造函数(因为每个算法有可能传入值不一样)
        ''' </summary>
        ''' <param name="workTime"></param>
        ''' <param name="hourMoney"></param>
        ''' <remarks></remarks>
        Sub New(workTime As Integer, hourMoney As Integer)
            ' TODO: Complete member initialization 
            _workTime = workTime
            _hourMoney = hourMoney
        End Sub
    
        ''' <summary>
        ''' 正常工资的算法
        ''' </summary>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Overrides Function countMoney() As Integer
            Dim money As Integer '定义存放钱的变量
            money = _workTime * _HourMoney * 1 '正常工资
            Return money '返回计算结果
        End Function
    End Class
    
    
    ''' <summary>
    ''' 算法2 节假日工资算法
    ''' </summary>
    ''' <remarks></remarks>
    Public Class CashTwo
        '继承抽象类
        Inherits CashAlgorithm
        Dim _workTime As New Integer
        Dim _hourMoney As New Integer
        Dim _addMoney As New Integer
        ''' <summary>
        ''' 构造函数(因为每个算法有可能传入值不一样)
        ''' </summary>
        ''' <param name="workTime"></param>
        ''' <param name="hourMoney"></param>
        ''' <remarks></remarks>
        Sub New(workTime As Integer, hourMoney As Integer, addMoney As Integer)
            ' TODO: Complete member initialization 
            _workTime = workTime
            _hourMoney = hourMoney
            _addMoney = addMoney
        End Sub
        ''' <summary>
        ''' 节假日工资的算法
        ''' </summary>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Overrides Function countMoney() As Integer
            Dim money As Integer '定义存放钱的变量
            money = _workTime * _hourMoney + _addMoney '这里是正常工资的2倍
            Return money '返回计算结果
        End Function
    End Class
    
    
    ''' <summary>
    ''' 策略模式类
    ''' </summary>
    ''' <remarks></remarks>
    Public Class CashContext
    
        Private insideCashAlgorithm As CashAlgorithm '声明一个算法抽象类
    
        ''' <summary>
        ''' 构造方法、接受外部传入的算法类(这里声明抽象算法类、使用他的子类、也就是策略)
        ''' </summary>
        ''' <param name="outSideCashAlgorithm"></param>
        ''' <remarks></remarks>
        Public Sub CashContext(outSideCashAlgorithm As CashAlgorithm)
            insideCashAlgorithm = outSideCashAlgorithm
        End Sub
        ''' <summary>
        ''' 使用接受算法的方法、计算出money返值
        ''' </summary>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Function countMoney() As Integer
            Return insideCashAlgorithm.countMoney()
        End Function
    
    End Class
    
    ''' <summary>
    ''' 简单工厂类
    ''' </summary>
    ''' <remarks></remarks>
    Public Class CashFactory
    
        Dim fCashContext As New CashContext '定义策略
    
        Dim _workTime As New Integer
        Dim _hourMoney As New Integer
        Dim _addMoney As New Integer
        Dim _str As String
        '《构造函数****************************************************
        '让工厂类可以传入葛总不同的值
        ''' <summary>
        ''' 正常上班传入值构造方法
        ''' </summary>
        ''' <param name="str">选择要素string类型  正常上班or假日上班</param>
        ''' <param name="workTime">工作时间 int型</param>
        ''' <param name="hourMoney">小时/钱  int型</param>
        ''' <remarks></remarks>
        Sub New(str As String, workTime As Integer, hourMoney As Integer)
            ' TODO: Complete member initialization 
            _workTime = workTime
            _hourMoney = hourMoney
            _str = str
        End Sub
    
    
        ''' <summary>
        ''' 假日上班传入值构造方法
        ''' </summary>
        ''' <param name="str">选择要素string类型  正常上班or假日上班</param>
        ''' <param name="workTime">工作时间 int型</param>
        ''' <param name="hourMoney">小时/钱  int型</param>
        ''' <param name="addMoney">加班费 int型</param>
        ''' <remarks></remarks>
        Sub New(str As String, workTime As Integer, hourMoney As Integer, addMoney As Integer)
            ' TODO: Complete member initialization 
            _workTime = workTime
            _hourMoney = hourMoney
            _addMoney = addMoney
            _str = str
        End Sub
    
        '构造函数****************************************************》
        ''' <summary>
        ''' 计算钱、选择算法、运算并返回结果
        ''' </summary>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Function CountMoney() As Integer
            Select Case (_str)
                Case "正常上班"
                    fCashContext.CashContext(New CashOne(_workTime, _hourMoney))
                Case "假日上班"
                    fCashContext.CashContext(New CashTwo(_workTime, _hourMoney, _addMoney))
                Case Else
                    MsgBox("未找到相应算法策略")
            End Select
            Return fCashContext.countMoney() '计算法返回结果
        End Function
    
    End Class
    
    
     ' 客户端
     ''' <summary>
        ''' 正常上班
        ''' </summary>
        ''' <param name="sender"></param>
        ''' <param name="e"></param>
        ''' <remarks></remarks>
        Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    
            Dim cashFactory As New CashFactory(Button1.Text, txtTime1.Text, txtMoney2.Text)
    
            MsgBox(cashFactory.CountMoney())
    
        End Sub
        ''' <summary>
        ''' 假日上班
        ''' </summary>
        ''' <param name="sender"></param>
        ''' <param name="e"></param>
        ''' <remarks></remarks>
        Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
            Dim cashFactory As New CashFactory(Button2.Text, txtTime1.Text, txtMoney2.Text, txtAddMoney.Text)
    
            MsgBox(cashFactory.CountMoney())
        End Sub






    肉白卡:好的大笑、搞好了请你吃龙虾!


    富兰克林:羡慕好啊!!!说定了


    第二天………………………………


                老板、我做好了、你看            


                正常上班输入工作时间和每小时工资点击正常上班就可核算工资、二假日上班在输入工作时间和每小时工资的基础上、输入假日补贴、点击假日上班就可以啦!疑问



                恩!很好、老板摸了富兰克林的龟头说道、小伙子、前途无量嘛!以后咱们黑煤窑、啊不是、咱们光明煤窑就用你这个软件算工资了!



                只见公司老板输入了1 23 1这几个数字………点了2下出现了23 和24两个数字………………恩恩!!!卜错卜错O(∩_∩)O~



                富兰克林:疑问惊讶惊恐大哭发火敲打再见



    —————————————————这次博客信息量有点多—————————————————


    ——————————chenchen——————————














    展开全文
  • 策略模式:以相同的方式调用所有算法,工厂让仕途藏认识到了两个类:工厂类和对象类,而策略模式只有一个Context类来维护。 策略模式: 简单工厂+策略模式 源码地址:http://pan.baidu.com/s/1c1Sl2co

    策略模式:以相同的方式调用所有算法,工厂让仕途藏认识到了两个类:工厂类和对象类,而策略模式只有一个Context类来维护。


    策略模式:

    简单工厂+策略模式



    源码地址:http://pan.baidu.com/s/1jIrHJmu

    展开全文
  • 简单工厂策略模式

    热门讨论 2016-01-24 16:44:14
    简单工厂模式、策略模式、简单工厂和策略的比较与结合、

         时间过得好快,不知不觉又到了写博客的time了;这次简单介绍一些简单工厂、策略模式,还有他们的区别和联系,恩,进入正题:

    抽象理论借助具体实例更有助于理解,这次借助我们熟知的“商场促销”,效果图:      

    两个模式相同的代码部分: 

     //客户端
            double total=0.0d;
            private void Form1_Load(object sender, EventArgs e)
            {
                cmdCount.Items.AddRange(new object[] { "正常收费", "打八折", "打七折", "打五折" });
    
                cmdCount.SelectedIndex = 0;
            }
            //现金收费抽象类
            abstract class CashSuper
            {
                //现金收取父类的抽象方法,收取现金,参数为原价,返回为当前价
                public abstract double acceptCash(double money);
            }
            //正常收费类
            class CashNormal:CashSuper
            {
                public override double acceptCash(double money)
                {
                    //正常收取,原价返回
                    return money;
                }
            }
            //打折收费子类
            class CashRebate:CashSuper
            {
                private double moneyRebate = 1d;
                public CashRebate (string moneyRebate)
                {
                    //打折收费,初始化时输入折扣率:如0.8
                    this.moneyRebate = double.Parse(moneyRebate);
                }
                //重写方法
                public override double acceptCash(double money)
                {
                    //现金*折扣率
                    return money * moneyRebate;
                }
            }
            //返利收费
            class CashReturn:CashSuper
            {
                private double moneyCondition = 0.0d;
                private double moneyReturn = 0.0d;
                //返利收费,初始化输入返利条件,返利值
                public CashReturn (string moneyCondition,string moneyReturn)
                {
                    //条件、返利值
                    this.moneyCondition = double.Parse(moneyCondition);
                    this.moneyReturn = double.Parse(moneyReturn);
                }
                public override double acceptCash(double money)
                {
                    double result = money;
                    if (money >= moneyCondition)
                        result = money - Math.Floor(money / moneyCondition) * moneyReturn;
                    return result;
                }
            }

       CashSuper、CashNormal、CashRebate、CahReturn是具体的子类,他们里面的acceptCash方法是对CashSuper.acceptCash这一虚方法的重写,使其变成带有各自Signet的方法 。               

    简单工厂模式

          创建型模式 ,它关注对象创建,提供创建对象的接口. 
      一个工厂类,负责根据不同的打折优惠方法来使用不同的子类,调用相应的方法计算结果、显示信息。

       class CashFactory
            {
                //现金收取工厂
                //不同的情况,可增加分支
                public static CashSuper createCashAccept(string type)
                {
                    CashSuper cs = null;
                    switch (type)
                    {
                        case"正常收费":
                            cs = new CashNormal();
                            break;
                        case "满300返100":
                            CashReturn cr1=new CashReturn ("300","100");
                            cs=cr1 ;
                            break ;
                        case"打八折":
                            CashRebate cr2 = new CashRebate("0.8");
                            cs = cr2;
                            break;
                    }
                    return cs;
                }
            }
            private void btnSure_Click(object sender, EventArgs e)
            {
                //简单工厂模式,根据下拉列表框生成相应的对象
                CashSuper csuper = CashFactory.createCashAccept(cmdCount.SelectedItem.ToString());
                double totalPrices = 0d;
                //csuper自带对象,用相应的acceptCash方法计算
                totalPrices = csuper.acceptCash(Convert.ToDouble(txtprice.Text)
                    * Convert.ToDouble(txtNum.Text));
    
                total = total + totalPrices;
                //显示在listbox中
                lstSum.Items.Add("单价:" + txtprice.Text + "数量" + txtNum.Text + ""
                    + cmdCount.SelectedItem + "合计" + totalPrices.ToString());
               //显示总计
                lblSum.Text = total.ToString();
            }

         违反了“开闭原则”:由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则(GRASP职责分配原则),将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类,很难避免模块功能的蔓延,对系统的维护和扩展非常不利。

    策略模式

         对象行为型模式 ,它关注行为和算法的封装 ,通常把一个系列的算法封装到一系列的策略类里面
       它定义一系列的算法,并对算法进行封装,算法间可以相互替换。把算法的责任和算法本身分割开委派给不同的对象管理。算法可独立于使用它的客户而变化。 改模式中应当由客户端自己决定在什么情况下使用什么具体策略角色。
    <span style="font-family:KaiTi_GB2312;font-size:18px;">  private void btnSure_Click(object sender, EventArgs e)</span><span style="font-family: Arial; font-size: 14px;">
            {
                CashContext cc = null;
                //下拉列表,相应策略、传人
                switch (cmdCount .SelectedItem.ToString ())
                {
                    case"正常收费":
                        //相应的方法
                        cc = new CashContext(new CashNormal());
                        break;
                    case "满300返100":
                        cc = new CashContext(new CashReturn("300", "100"));
                        break;
                    case "打8折":
                        cc = new CashContext(new CashRebate("0.8"));
                        break;
                }
                double totalPrices = 0d;
                totalPrices = cc.GetResult(Convert.ToDouble(txtNum.Text) * Convert.ToDouble(txtprice.Text));
    
                total = total + totalPrices;
                lstSum.Items.Add("单价" + txtprice.Text + "数量" + txtNum.Text
                    + " " + cmdCount.SelectedItem + "合计:" + total.ToString());
                lblSum.Text = total.ToString();
            }
            class CashContext
            {
                //声明一个cashsuper对象
                private CashSuper cs;
                //传入具体收费策略
                public CashContext (CashSuper csuper)
                {
                    this.cs = csuper;
                }
                //根据策略、运用方法、计算结果
                public double GetResult(double money)
                {
                    return cs.acceptCash(money);
                }
            }
    </span>
            策略模式并不决定在何时使用何种算法,算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性,但是客户端需要理解所有具体策略类之间的区别,以便选择合适的算法,这也是策略模式的缺点之一,在一定程度上增加了客户端的使用难度。并且 Strategy和Context之间的通信开销、策略模式将造成产生很多策略类等等不足之处使得策略模式在某些方面存在缺陷。 
        简单工厂模式和策略模式各有优缺,取长补短是人类的智慧。

    简单工厂和策略模式的结合

          private void btnSure_Click(object sender, EventArgs e)
            {
                //将相应的算法字符串传人cashcontext对象中
                CashContext csuper = new CashContext(cmdCount.SelectedItem.ToString());
                double totalPrices = 0d;
                //计算总价
                totalPrices = csuper.GetResult(Convert.ToDouble(txtNum.Text) * Convert.ToDouble(txtprice.Text));
                total = total + totalPrices;
                //显示
                lstSum.Items.Add("单价" + txtprice.Text + "数量" + txtNum.Text
                    + " " + cmdCount.SelectedItem + "合计:" + total.ToString());
                lblSum.Text = total.ToString();
            }
    
            class CashContext
            {
                //声明一个cashsuper对象
                 CashSuper cs=null;
                //传入具体收费策略
                public CashContext (string type)
                {
                    switch (type)
                    {
                        case"正常收费":
                          CashNormal   cs0 = new CashNormal();
                            cs=cs0;
                            break;
                        case "满300返100":
                            CashReturn cr1=new CashReturn ("300","100");
                            cs=cr1 ;
                            break ;
                        case"打八折":
                            CashRebate cr2 = new CashRebate("0.8");
                            cs = cr2;
                            break;
                    }
                }
                //根据策略、运用方法、计算结果
                public double GetResult(double money)
                {
                    return cs.acceptCash(money);
                }
            }
    很不错的一个链接:介绍策略模式的
    http://blog.csdn.net/hguisu/article/details/7558249  最后的例子亮了闭嘴
        吃饭,策略模式的做法:有几种方案供你选择,选择去餐厅好呢还是自己做,完全由人自行决定去构建吃饭方案(你自己需要去买餐厅,或者做饭)。而工厂模式是你决定哪种吃饭方案后,不用关注这吃饭方案怎么给你创建,也就是说你告诉我方案的名称就可以了,然后由工厂代替你去构建具体方案(工厂代替你去做饭)。
    thanks for your time微笑
    展开全文
  • ** 本文介绍工厂加策略模式的设计模式 因为对设备操作解析报文的全量数据太多需要判断 所以以下对数据解析的 if-else采用了设计模式对代码简洁开发 耦合度更高 更加可观方便的新增代码** 前提例子对比 上图给个例子...

    前提概要

    ** 本文介绍工厂加策略模式的设计模式 因为对设备操作解析报文的全量数据太多需要判断 所以以下对数据解析的 if-else采用了设计模式对代码简洁开发 耦合度更高 更加可观方便的新增代码**

    前提例子对比

    在这里插入图片描述
    上图给个例子:一般我们对数据进行判断需要用到switch或者if-else进行判断 数据量大的话要写很多的判断 这样后续需要加新的判断就会变得很麻烦 而且代码的结构性会很大一段 看起来非常吃力后续维护也是非常麻烦,所以来看看运用了设计模式在项目的运用

    项目结构

    在这里插入图片描述

    第一步定义一个枚举类

    我这边采用枚举类来判断值,就是定义需要你在if里面需要等于的那个值 放在枚举类里面

    package com.qykfa.enumtype;
    
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    
    /**
     * @author Administrator
     * @auther KeShuai
     * @Date: 2020/08/20/9:50
     * @Description:
     */
    @Getter
    @NoArgsConstructor
    public enum AlarmType {
        /**
         * 终止流程
         */
        ChangeAlarmJud("02008001"),
        /**
         * 故障
         */
        failure("01002001"),
        /**
         * 告警
         */
        GiveAnAlarm("01003001"),
        /**
         * 烟雾
         */
        SmokeAlarm("02017001"),
        /**
         * 浸水
         */
        SoakingAlarm("02018001"),
        /**
         * 温度告警
         */
        TemperatureAlarm("02007001")
        ;
        private String value;
        AlarmType(String value) {
            this.value = value;
        }
        public String getValue() {
            return value;
        }
        public void setDesc(String value) {
            this.value = value;
        }
    }
    
    

    定义注解

    采用注解方式 方便工厂注入

    /**
     * @author Administrator
     * @auther KeShuai
     * @Date: 2020/08/20/10:14
     * @Description:
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AlarmAnnotation {
        /**
         * 相关类型名称
         */
        AlarmType value();
    }
    

    定义需要解析的数据对象

    根据自己需要解析的数据 if判断完要设置的对象 自己定义

    import lombok.Data;
    
    /**
     * @author Administrator
     * @Auther: KeShuai
     * @Date: 2020/08/12/17:10
     * @Description:列表对象
     */
    @Data
    public class AttrListAlarmDto {
    
        private String id;
    
        private String value;
    
        private String doorId;
    
        private String devId;
    
        private String  alarmDesc;
    
        private String  batteryId;
    
        private String alarmFlag;
    
        private String alarmTime;
    
        private Integer statusFlag;
    
    }
    
    

    定义策略角色接口

    /**
     * @author Administrator
     * @auther KeShuai
     * @Date: 2020/08/13/16:51
     * @Description: 信号量策略模式接口
     */
    public interface AlarmRelated {
        /**
         * 判断接口
         * @param dto
         * @return
         */
        void batIf(AttrListAlarmDto dto);
    }
    

    定义工厂工具类和工厂

    定义工厂的工具类

    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    /**
     * @author Administrator
     * @auther KeShuai
     * @Date: 2020/08/13/17:23
     * @Description: 工厂工具类
     */
    
    @Component
    public class SpringContextUtil implements ApplicationContextAware {
    
        private ApplicationContext context;
    
        public ApplicationContext getContext() {
            return context;
        }
    
        @Override
        public void setApplicationContext(ApplicationContext context)throws BeansException {
            this.context = context;
        }
    }
    
    

    工厂对注解类进行判断生成策略接口对应的实现类

    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import java.util.Map;
    
    /**
     * @author KeShuai
     * @auther KeShuai
     * @Date: 2020/08/13/17:24
     * @Description: 存取信号量对象的工厂
     */
    
    @Component
    public class AlarmRelatedFactory {
        @Autowired
        SpringContextUtil springContextUtil;
    
        private static Map<AlarmType, AlarmRelated> RelatedMap = Maps.newConcurrentMap();
    
        /**
         * 工厂将 Spring 装配的相关的 Bean 用 Map 保存起来
         */
        @PostConstruct
        public void init(){
            Map<String, Object> beanMap = springContextUtil.getContext().getBeansWithAnnotation(AlarmAnnotation.class);
    
            for(Object doorRelated : beanMap.values()) {
                AlarmAnnotation annotation = doorRelated.getClass().getAnnotation(AlarmAnnotation.class);
                RelatedMap.put(annotation.value(), (AlarmRelated)doorRelated);
            }
        }
    
        public static AlarmRelated createRelated(AlarmType relatedType) {
            return RelatedMap.get( relatedType );
        }
    }
    
    

    定义策略模式的实现类

    此实现类就是相当于 if-else判断完 实现的需要的功能 if-else{ 每个实现类相当于括号这里面的功能}
    以下列出一个例子 后续根据这个创建即可

    /**
     * @author Administrator
     * @auther KeShuai
     * @Date: 2020/08/20/17:10
     * @Description: 机柜告警
     */
    //本类的类名 这里不能重复不然工厂创建会查出俩条报错
    @Component("AlarmTemperatureRelatedImpl")
    //这里对应枚举类里面的判断数据
    @AlarmAnnotation( value = AlarmType.TemperatureAlarm) 
    public class AlarmTemperatureRelatedImpl implements AlarmRelated {
    	//插入数据库的服务类引入
        @Autowired
        private AlarmService alarmService;
        @Override
        public void batIf(AttrListAlarmDto dto) {
            AlarmDTO batDto=new AlarmDTO();
            //判断枚举类里面值和传进来的值是否对应
            if (AlarmType.TemperatureAlarm.getDesc().equals(dto.getId())){
            	//存取操作
                batDto.setCabId(dto.getDevId());
                batDto.setAlarmDesc("温度过高告警");
                alarmService.save(batDto);
    
            }
        }
    }
    

    最后

    最后的写在 服务上面的if 变成下图代码这样,如要加条件 则创建对应的策略实现类即可 在实现类里面写if判断完的服务就行了

    //通过 枚举的值 反射获取枚举类 传入(枚举类,枚举值,枚举类的getVulue方法)
    //data.getId() 传入对应刚才定义枚举类的值  如 ChangeAlarmJud("02008001")
    //data.getId() = 02008001
    AlarmType batName = EnumUtils.valueOf(AlarmType.class, data.getId(), AlarmType.class.getMethod("getValue"));
       if (batName != null) {
          //传入枚举对象获取
         AlarmRelated related = AlarmRelatedFactory.createRelated(batName);
                    //如果等于空说明没有改判断对象
                  if (related != null) {
                    //传入对应的实现类判断
                    related.batIf(data);
               }
    }
    

    写的代码比较粗糙 现在也是在学习进阶阶段 整合起来方便记录学习,还望各位大佬提出意见或者相互学习。谢谢!!

    展开全文
  • java设计模式之策略模式(Strategy),简单工厂+策略模式 1.简要 策略模式(Strategy): 定义了算法家族,分别封装起来,让他们直接可以相互替换,从而使得算法的改变不会影响到使用算法的一方。 ...
  • 简单工厂如果有新的产品需要添加,则需要对原来的代码进行修改,不符合设计模式中的开闭原则 工厂方法:引入了面向接口编程的思想,当添加新的产品时,不需要对原有的代码进行修改,符合了设计模式的开闭原则 抽象...
  • 工厂模式之策略模式

    2019-03-17 21:02:03
    工厂模式之策略模式
  • 目录23种设计模式之——简单工厂模式/工厂方法模式/抽象工厂模式+策略模式汇总对比简单工厂模式工厂方法模式抽象工厂模式策略模式异同 简单工厂模式 UML 代码 #include <iostream> using namespace std; ...
  • 工厂模式和策略模式

    2013-10-28 21:36:33
    详细解释工厂模式和策略模式,是一个完整的项目(源码)
  • 简单工厂工厂方法、抽象工厂策略模式、策略与工厂的区别 结合简单示例和UML图,讲解工厂模式简单原理。   一、引子 话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰)、Bmw(宝马)、Audi...
  • 使用简单工厂模式+策略模式结合的方法有如下优点: 1. 降低耦合,客户端只需要调用Context即可(策略模式的优点); 2. 封装了变化,简化客户端职责,减轻了客户端的压力(简单工厂模式的优点); 3. 简化单元测试,...
  • 策略模式针对的是行为即方法 可以提供某种功能 同时可以加入额外功能 如日志打印 对象的创建 简单工厂 是自己创建 策略模式是由使用者创建 调用的方法 简单工厂针对的是对象 需要使用者调用对象的目标方法 策略...
  • 简单工厂模式和策略模式 这里讨论一下简单工厂模式和策略模式的区别。 简单工厂模式是把通过类创建实例的过程封装起来,如上图所示,封装在Factory类中,一般情况下Factory类返回的是基类类型,这里用到了多态。 ...
  • 策略模式工厂方法模式,观察者模式 例子学习资料,初学者适用
  • 静态工厂模式与策略模式的比较静态工厂模式:一般采用if…else语句或switch语句通过条件判断,并返回结果。这样写起来是比较方便的,适用于不复杂的类,但是该模式耦合程度比较高。策略模式:通过由实现类实现行为...
  • 什么是策略模式 策略(Strategy)模式的定义:该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响使用算法的客户。...在下面的代码中,分别用策略模式和策略工厂模式实
  • 本篇博客转载于策略模式工厂模式比较 2.区别 这段时间看了一些设计模式,看到策略模式工厂模式的时候,总是感觉他们很相似,不要区分,到具体的场景了你可能还在徘徊到底用工厂还是策略呢?这几天就想写一篇...
  • 简单工厂模式和策略模式的区别与结合 简单工厂模式和策略模式是大部分程序员,在学习设计模式时接触得最早,或在工作实践中也是用得相对比较多的两个设计模式。 一个是创建型,另一个是行为型,然而两种不同类型的...
  • 一个策略模式结合spring-boot的starter (设计模式:策略模式 工厂模式 单例模式) 代码连接 代码连接
  • 简单工厂模式与策略模式

    千次阅读 2018-07-26 08:45:56
    工厂模式 工厂模式属于创建型模式,这个模式中不会暴露给你具体的创建过程,只会返给你 抽象的对相,就跟你去饭馆吃饭点了一个红烧鱼一样,你不需要知道这个红烧鱼是怎么做的,你要做的是吃就行。工厂模式侧重的是...
  • 策略模式工厂模式

    2015-10-08 18:06:13
    看了Head-First工厂模式那一章,完全蒙了,发现工厂模式和策略模式好像,傻傻地分不出来什么他们的区别,上网找各种资料,然后反复看了一下Head First设计模式这本书,现在我来做一些我个人的总结吧,引用一些在网上...
  • 设计模式之禅之 工厂方法模式+策略模式 设计模式之禅之 工厂方法模式+策略模式
  • 设计模式一(单子、工厂策略模式)练习 1. 假设现在要设计一个贩卖各类书籍的电子商务网站的购物车系统。对所有的教材类图书 实行每本一元的折扣;对连环画类图书提供每本 7%的促销折扣;而对非教材类的计算 机...
  • 深入浅出设计模式之抽象工厂模式+工厂方法模式+策略模式实现手机加工厂
  • 简单工厂模式:的最大优点是在工厂类中包含了必要的逻辑判断,根据客户端的选择动态实例化相关类,去得到客户想要的产品。但个人觉得简单工厂模式的最大优点正是产生它最大缺点之处。因为它的工厂类违反了开放-封闭...
  • 简单工厂模式和策略模式的区别

    千次阅读 2018-07-17 12:10:21
    简单工厂模式和策略模式在结构模式上两者很相似,所以我们经常会混淆它们。这里就先说一说我对它们的理解。  简单工厂模式::客户端传一个条件进工厂类,工厂类根据条件生成相应的对象并返回给客户端。  策略...
  • 简单工厂+策略模式-下

    千次阅读 热门讨论 2014-06-16 15:48:28
    深夜食堂、简单工厂策略模式的应用
  • 一、策略模式 策略模式定义了一组算法,将每个算法都封装起来,并且使它们之间可以互换 1、策略模式主要角色 主要角色如下: 封装角色(Context):也叫做上下文角色,起承上启下封装作用,屏蔽高层模块对策略、...
  • 简单工厂策略模式

    2015-04-04 08:38:29
    今天,首先看了简单工厂,后看了策略模式,看完后,有没有人和我有一样的感觉,这两个设计模式很像啊。 我个人的理解:两个模式,对于调用者的目的不同,工厂方法,客户端要的是对象实例,策略方法要的是结果。 ...
  • 工厂模式和策略模式的区别在使用上,两者都有一个抽象类或接口,供不同的“产品”或者“策略”去继承或者实现,不同点在于,工厂模式中,具体产品的实例化发生在工厂内部,然后通过工厂的某个方法传递给外部使用,而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,732
精华内容 39,092
关键字:

工厂加策略模式