威尼斯人线上娱乐

概括工厂形式,设计方式

29 3月 , 2019  

逐渐的做笔录,做最精锐的融洽

大二甘休了java和java
web的基本功课程,大三方始进修各个框架,在看书和观察录制进程中发现本身设计方式知识的供不应求,使得本身读书的时候云里雾里,知其然不知其所以然,在某一篇博文中来看“框架是软件,而设计方式是软件的学识”,所以决定自个儿再扎实的学2回设计情势,并且写下自身计算的小说,各样繁杂的定义就不写了,网上和书上一大堆,希望团结能够写的偏实际一点。(由于第①回写小说,水平有限,若有不当希望大家指正)

  简单工厂形式(Factory
Pattern)是一种创设型的设计格局,像工厂一样依据供给生产目的实例。

  不难工厂方式(Factory
Pattern)是一种创立型的设计方式,像工厂一样基于须要生育指标实例。

看了牛皮设计格局之后感触很深,发现自身还有很多上学的东西,设计软件并不是一两句代码把效果写完了就行,须要考虑的始末有过多

实际上那也是初学设计形式时平日会想到的难题,网上给的例证一般都太简单,固然能够注明达成形式和原理,可总给人一种为了利用而使用的痛感,绕来绕去笔者还比不上本人new2个目的

  特点:根据不一样的规格,工厂实例化出确切的靶子。

  特点:依据差别的基准,工厂实例化出确切的对象。

代码来源参考大话设计形式那本书,那里在博客里记录一下,不容许每一趟都去翻书,不过在博客里面是相当好找的。

首先,工厂形式是为着解耦,“高内聚、低耦合”是装有软件设计者所追求的,很多设计格局也都以为着那么些目的而留存。接下来笔者会用相当的大篇幅的代码一步一步的引出为何要求不难工厂情势

  《大话设计形式》中实例:四则运算总括器

  《大话设计形式》中实例:四则运算总计器

范例为一个简易工厂格局的总结器,首先先创制3个总计器运算所须要选择的数据模型,在java里面也叫bean,就是2个抽象的类,那里大家先成立叁个Operation类

在《大话设计格局》有一个写简单计算器的例证如下

  代码:

  代码:

public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        public virtual double GetResult()
        {
            double results = 0;
            return results;
        }



    }
public class Calculator { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println; Double numberA = scanner.nextDouble(); System.out.println("请输入运算符号"); scanner.nextLine();//吃一个换行符 String operator = scanner.nextLine(); System.out.println; Double numberB = scanner.nextDouble(); Double result; switch  { case "+": result = numberA + numberB; break; case "-": result = numberA - numberB; break; case "*": result = numberA * numberB; break; case "/": try { result = numberA / numberB; } catch (ArithmeticException e) { System.out.println; return; } break; default: System.out.println("没有该运算规则"); return; } System.out.println("结果是:"+result); }}
 1 #!/usr/bin/env python
 2 #-*- coding: utf-8 -*-
 3 
 4 class Operation:
 5     def getResult(self):
 6         pass
 7 
 8 class OperationAdd(Operation):
 9     def getResult(self):
10         return self.op1+self.op2
11 
12 class OperationSub(Operation):
13     def getResult(self):
14         return self.op1-self.op2
15     
16 class OperationMul(Operation):
17     def getResult(slef):
18         return self.op1*self.op2
19 
20 class OperationDiv(Operation):
21     def getResult(self):
22         try:
23             return self.op1/float(self.op2)
24         except:
25             print("Error:除数为0!")
26             return 0
27 
28 class OperationOther(Operation):
29     def getResult(self):
30         print("Error:没有定义的运算符!")
31         return 0
32     
33 
34 class OperationFactory:
35     
36     operation = {}
37     operation["+"] = OperationAdd()
38     operation["-"] = OperationSub()
39     operation["*"] = OperationMul()
40     operation["/"] = OperationDiv()
41     
42     def createOperation(self,choice):
43         if choice in self.operation.keys():
44             op = self.operation[choice]
45         else:
46             op = OperationOther()
47         return op
48 
49 
50 
51 if __name__ == "__main__":
52     op = raw_input("请输入运算符:")
53     num_a = input("a:")
54     num_b = input("b:")
55 
56     factory = OperationFactory()
57     cal = factory.createOperation(op)
58 
59     cal.op1 = num_a
60     cal.op2 = num_b
61     
62     print(u"运算结果为:" + str(cal.getResult()))
63 
 1 #!/usr/bin/env python
 2 #-*- coding: utf-8 -*-
 3 
 4 class Operation:
 5     def getResult(self):
 6         pass
 7 
 8 class OperationAdd(Operation):
 9     def getResult(self):
10         return self.op1+self.op2
11 
12 class OperationSub(Operation):
13     def getResult(self):
14         return self.op1-self.op2
15     
16 class OperationMul(Operation):
17     def getResult(slef):
18         return self.op1*self.op2
19 
20 class OperationDiv(Operation):
21     def getResult(self):
22         try:
23             return self.op1/float(self.op2)
24         except:
25             print("Error:除数为0!")
26             return 0
27 
28 class OperationOther(Operation):
29     def getResult(self):
30         print("Error:没有定义的运算符!")
31         return 0
32     
33 
34 class OperationFactory:
35     
36     operation = {}
37     operation["+"] = OperationAdd()
38     operation["-"] = OperationSub()
39     operation["*"] = OperationMul()
40     operation["/"] = OperationDiv()
41     
42     def createOperation(self,choice):
43         if choice in self.operation.keys():
44             op = self.operation[choice]
45         else:
46             op = OperationOther()
47         return op
48 
49 
50 
51 if __name__ == "__main__":
52     op = raw_input("请输入运算符:")
53     num_a = input("a:")
54     num_b = input("b:")
55 
56     factory = OperationFactory()
57     cal = factory.createOperation(op)
58 
59     cal.op1 = num_a
60     cal.op2 = num_b
61     
62     print(u"运算结果为:" + str(cal.getResult()))
63 

接下来再次创下设加减乘除类,以便工厂开始展览调用

这是初学者在读书java时最不难写出的代码,尤其是刚刚学习C语言过后,大家来看一看上边的代码在设计上存在怎么样难点

  

  

class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA / NumberB;
            return result;
        }
    }
尚无动用到面向对象的讨论

设若后天大家的身边有一个总计器,大家想一想它会是怎么的,首先我们会看到荧屏和各类按键,当正确的按下一名目繁多按键后,大家会在显示屏上阅览结果,可前边的有血有肉运算进度大家是看不到的。接下来看上边的代码,输出打字与印刷语句类比为显示器,输入语句是按键,剩下的case
switch
定义变量等语句都以计量进度,而那么些总结进程都以足以隐蔽起来的,那样界面和事情逻辑完全分离,下落耦合性,便于程序维护。

概括工厂形式,设计方式。修改之后代码如下

public class View { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println; Double numberA = scanner.nextDouble(); System.out.println("请输入运算符号"); scanner.nextLine();//吃一个换行符 String operator = scanner.nextLine(); System.out.println; Double numberB = scanner.nextDouble(); Double result = null; try { result = Calculator.calculator(numberA,operator,numberB); System.out.println("结果是:"+result); } catch (Exception e) { e.printStackTrace(); } }}

public class Calculator { public static Double calculator(Double numberA,String operator,Double numberB) throws ArithmeticException{ double result; switch  { case "+": result = numberA + numberB; break; case "-": result = numberA - numberB; break; case "*": result = numberA * numberB; break; case "/": try { result = numberA / numberB; } catch (ArithmeticException e) { throw new ArithmeticException("被除数不能为0"); } break; default: throw new ArithmeticException("没有这个运算规则"); } return result; }}

如此那般就分别了事情逻辑和界面,但我们再看看那样的代码还有如何难点

  当供给动用到单个实体的多少个变体时,能够选取工厂情势。例如地点的事例中,供给做运算(单个实体),不过常用的演算包罗加、减、乘、除(变体),差别的规范下须求创制不一致的变体,这时就足以因此工厂来创立差异的运算。

  当供给动用到单个实体的八个变体时,能够选择工厂方式。例如地点的事例中,必要做运算(单个实体),但是常用的演算包含加、减、乘、除(变体),区别的规则下必要创设区别的变体,那时就足以由此工厂来创立差别的运算。

创制工厂类,实例化出确切的靶子

扩展性极差

设若有一天我们必要加上开药方、平方等运算,全部的加减乘除等功效都得参加程序的编译,在追加效果的同时还有误修改源码的风险,违背开放闭合原则。

接轨修改代码

abstract public class Operation { private double a; private double b; abstract public double getResult() throws Exception; //定义一个抽象类 其中有一个运算抽象方法 public double getA() { return a; } public void setA { this.a = a; } public double getB() { return b; } public void setB { this.b = b; }}

public class AddOperation extends Operation{ @Override public double getResult() { double result=super.getA()+super.getB(); return result; }}

public class SubOperation extends Operation{ @Override public double getResult() { double result=super.getA()-super.getB(); return result; }}

public class MulOperation extends Operation { @Override public double getResult() { double result=super.getA()*super.getB(); return result; }}

public class SubOperation extends Operation{ @Override public double getResult() { double result=super.getA()-super.getB(); return result; }}

修改后的代码增加性大大增强,当大家供给充实其它运算时,大家只须要让新类继承Operation类并落到实处getResult方法,不需求去修改其余功能模块的代码。可新题材来了,在运算的时候,大家必要有选拔性的实例化某3个指标,那些时候就用到了总结工厂情势。

就算如此笔者真的越发特别尤其的不爱好那么些臃肿的概念,不过在一些角度看来,为了让知识系统化,精通一些概念依旧挺有必不可少的。可是在上定义在此之前,我们先看看方式的构造

简易工厂方式涵盖如下角色:Factory:工厂角色Product:抽象产品剧中人物ConcreteProduct:具体产品剧中人物

厂子角色是简简单单工厂格局的主干,它承受兑现创制全体具体产品类的实例。工厂类能够被外边间接调用,创设所需的产品对象。(相当于大家在后边的OperationFactory类)

空洞产品剧中人物是兼备具体产品剧中人物的父类,它承担描述全数实例所共有的国有接口。(上边代码的Operation类)

实际产品角色(Concrete
Product)
再而三自抽象产品剧中人物,一般为七个,是简简单单工厂方式的创造指标。工厂类重回的都以该角色的某一现实产品。(Operation的子类)

补齐后边的代码

public class OperationFactory { public static Operation createOperation throws Exception{ switch  { case '+': return new AddOperation(); case '-': return new SubOperation(); case '*': return new MulOperation(); case '/': return new DivOperation(); default: throw new Exception; } }}

public class Main { public static void main(String[] args) { Operation opr = null; double a; char op; double b; Scanner sc = new Scanner(System.in); a = sc.nextDouble(); op = sc.next().charAt; b = sc.nextDouble(); try { opr=OperationFactory.createOperation; opr.setA; opr.setB; System.out.println(opr.getResult; }catch (Exception e) { System.out.println(e.getMessage; } }}

简单工厂方式(Simple Factory Pattern):又称之为静态工厂方法(Static
Factory
Method)形式,它属于类成立型形式。在简要工厂格局中,能够根据参数(也等于上述的种种运算符号)的例外重返差异类的实例(上述的演算方法子类)。简单工厂形式尤其定义2个类(上述的OperationFactory类)来负担创设别的类的实例,被创立的实例平时都富有协同的父类(上述的Operation类)。

不难易行工厂形式无非是对面向对象思想的一种呈现,小编索要什么样,你就给笔者提供什么,通过几次三番和多态又将工作逻辑中的代码解耦,使得各样职能之间耦合度降低,便于程序扩大维护,当然有人会说,在追加新职能未来,大家如故需求去修改工厂类的switch语句,那几个标题就因此之后在写抽象工厂情势的下结论的时候解答吧。

  步骤:

  步骤:

 public static Operation CreateOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;

            }
            return oper;
        }
  • 创办实体类

    class Entity(): #实体

    def Func(self):
        "方法体"
    

         #pass

  • 成立变体类

    class Variant1(Entity):

    def Func(self):
    

         pass

  • 始建实体类

    class Entity(): #实体

    def Func(self):
        "方法体"
    

         #pass

  • 开创变体类

    class Variant1(Entity):

    def Func(self):
    

         pass

 

class Variant2(Entity):
    def Func(self):
     pass
class Variant2(Entity):
    def Func(self):
     pass

经过多态,再次来到父类的措施,然后落成计算结果

 

 

static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.CreateOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine(result);
            Console.ReadLine();
        }
  • 创立工厂类

    class EntityFactory():

    def create_variant(self,choice):
        #根据choice创建不同的variant类
        #函数体
        #return
    
  • 创立工厂类

    class EntityFactory():

    def create_variant(self,choice):
        #根据choice创建不同的variant类
        #函数体
        #return
    

然而不难工厂格局会存在贰个题材,后续借使新增方法的话那么还索要后续创设运算类,然后实例化对象,那么如此会增多代码结构的复杂度,当然如故有方法化解的,然则此地就只做不难工厂格局的牵线了,

威尼斯人线上娱乐 , 

 

三层模型基本上只要不是用了专门的点子那么基本都以根据不难工厂情势来处理办法的

  使用工厂类:

  使用工厂类:

  

  

factory  = EntityFactory()
variant = factory.create_variant(choice)
print(variant.Func())
factory  = EntityFactory()
variant = factory.create_variant(choice)
print(variant.Func())

 

 


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图