大话设计模式-----(一)简单工厂模式策略模式二者比较

た入场券 2022-09-29 14:50 125阅读 0赞

写一个计算器把，之前写法都是放在一起。界面显示和逻辑代码放在一起很不好，  
不灵活，耦合度高，要解耦。那么就分开代码两个类。  
这样写就算如此还是有问题。没有扩展性。如果要增加运算符那就要更改逻辑代码  
很麻烦。  
可以把所有可能变化的东西比较提取出他们都有的东西，作为一个类，让其每个运算符  
进行继承，每个在重写其父类。就是进行不同的操作运算。  
返回创建一个相当于工厂，在一个工厂里判断，有什么需求，对应的创建对应的运算符  
子类。而且利于多态，实例化的每个子类都可以用父类来定义。并且因为是重写父类定义的  
方法。直接就是定义的父类调用父类的方法。而不是每个不同的运算符的实例化子类去调用自己的额  
方法。很美。这么写代码  
提取出来的父类

//所有运算符的父类
    class jishuan {
        private double numberA;
        private double numberB;
    
    
        public double getNumberA() {
            return numberA;
        }
    
    
        public void setNumberA(double numberA) {
            this.numberA = numberA;
        }
    
    
        public double getNumberB() {
            return numberB;
        }
    
    
        public void setNumberB(double numberB) {
            this.numberB = numberB;
        }
    
    
        public  double result(){
            double result=0;
            return result;
        }
    
    }

各个运算符继承父类

//加法
    class add extends jishuan{ 
        public double result(){
            double result=0;
            result = getNumberA()+getNumberB();
            return result;
    
        }
    
    
    }
    //减法
    class sub extends jishuan{ 
        public double result(){
            double result=0;
            result = getNumberA()-getNumberB();
            return result;
    
        }
    
    }
    
    //乘法mult
    class mult extends jishuan{ 
        public double result(){
            double result=0;
            result = getNumberA()*getNumberB();
            return result;
    
        }
    
    }

工厂

//工厂类factory
    
    class factory{
        //创建一个静态方法来判断创建实例化运算符
    
        public static jishuan Createjishuan(String yunsuan){
            jishuan js=null;
    
            switch(yunsuan){
    
            case "+":
                js = new add();
                break;
            case "-":
                js = new sub();
                break;
            case "*":
                js= new mult();
                break;
            }
    
            return js;
        }
    
    }

使用这个工厂

public class client {
    
        public static void main(String[] args) {
            jishuan jsclient = factory.Createjishuan("+");
            jsclient.setNumberA(1);
            jsclient.setNumberB(2);
            System.out.println(jsclient.result());
            }
        }

遇到了一些问题。。。。  
jdk 1.6不支持switch 的传入String。  
在eclipse中更改 eclipse和项目的jdk为1.7即可。  
[http://blog.csdn.net/jiuyueguang/article/details/9350753][http_blog.csdn.net_jiuyueguang_article_details_9350753]  
[http://blog.csdn.net/emoven/article/details/43233917][http_blog.csdn.net_emoven_article_details_43233917]

最最重要的是  
子类继承父类后父类的私有属性子类也是继承了的！，但是不能直接使用，可以直接get属性来获取！！！

策略模式就是用来封装算法的，选择所用具体实现的职责由客户端对象承担，并转交给策略模式的Context对象

策略模式的有点事简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试

饺子父类

abstract class jiaozi{
        private String xianString;
        public String getXianString() {
            return xianString;
        }
        public void setXianString(String xianString) {
            this.xianString = xianString;
        }
        public abstract void zuojiaozi();
    }

各种馅的饺子

//牛肉馅
    class niurou extends jiaozi{ 
    
        @Override
        public void zuojiaozi() {
            System.out.println(niurou.this.getXianString());
    
        }
    
    }
    //韭菜馅
    class jiucai extends jiaozi{ 
    
        @Override
        public void zuojiaozi() {
            System.out.println(jiucai.this.getXianString());
    
        }
    
    }
    //酸菜馅
    class suancai extends jiaozi{ 
    
        @Override
        public void zuojiaozi() {
            System.out.println(suancai.this.getXianString());
    
        }
    
    }

策略类

//配置策略类
    
    class Context{
        jiaozi jz;
        public Context(jiaozi jz){
            this.jz = jz;
        }
        public void ContextInterface() {
            jz.zuojiaozi();
        }
    
    }

客户类

public class client {
        public static void main(String[] args){
        jiaozi jz = null;
        String typeString = "牛肉";
    
        switch(typeString){
        case "牛肉":
            jz = new niurou();
            jz.setXianString("牛肉");
            break;
        case "韭菜":
            jz = new jiucai();
            jz.setXianString("韭菜");
            break;
        case "酸菜":
            jz = new suancai();
            jz.setXianString("酸菜");
            break;
        }
    
        //客户选择什么馅后将这个馅传递给策略类
        Context context ;
    
        context = new Context(jz);
        context.ContextInterface();
    }
    }

恩，策略模式就是 有一个策略对象，进行配置。里面封装的是算法。  
策略模式把原来工厂模式的工厂类传入的条件参数换成了子类。然后在其策略方法中调用这些子类继承父类重写父类的方法，来实现算法。在客户端中判断是什么打折条件。  
**策略模式**  
客户自己想吃什么饺子就买什么馅。然后给策略类。策略类根据饺子的规定做法做饺子。再给客户饺子  
应用场景：优惠系统、工资计算系统等

**工厂模式**  
客户想吃饺子。我想吃韭菜馅的饺子。然后告诉工厂。工厂给你做好给你。  
应用场景：多数据库选择，类库文件加载等。  
可以二者结合使用。写成一个策略类。在策略类传入条件，策略类判断使用什么馅的饺子。这使用工厂模式。然后调用做出饺子方法。恩，就是把客户判断条件放在了策略类中。减轻客户的负担。

新手学习设计模式可能理解的不对，若有错误望指出。谢谢。

参考  
[http://blog.csdn.net/fwj380891124/article/details/7552305][http_blog.csdn.net_fwj380891124_article_details_7552305]  
[https://zhidao.baidu.com/question/1606721221938966387.html][https_zhidao.baidu.com_question_1606721221938966387.html]  
[http://www.cnblogs.com/langtianya/archive/2013/03/08/2950934.html][http_www.cnblogs.com_langtianya_archive_2013_03_08_2950934.html]  
[http://blog.csdn.net/tengzhaorong/article/details/6827093][http_blog.csdn.net_tengzhaorong_article_details_6827093]

[http_blog.csdn.net_jiuyueguang_article_details_9350753]: http://blog.csdn.net/jiuyueguang/article/details/9350753
[http_blog.csdn.net_emoven_article_details_43233917]: http://blog.csdn.net/emoven/article/details/43233917
[http_blog.csdn.net_fwj380891124_article_details_7552305]: http://blog.csdn.net/fwj380891124/article/details/7552305
[https_zhidao.baidu.com_question_1606721221938966387.html]: https://zhidao.baidu.com/question/1606721221938966387.html
[http_www.cnblogs.com_langtianya_archive_2013_03_08_2950934.html]: http://www.cnblogs.com/langtianya/archive/2013/03/08/2950934.html
[http_blog.csdn.net_tengzhaorong_article_details_6827093]: http://blog.csdn.net/tengzhaorong/article/details/6827093