精华内容
下载资源
问答
  • 常见设计模式类图

    千次阅读 2018-10-30 20:49:45
    概要 最近看了设计模式相关的书籍...常见设计模式类图 策略模式 代理模式 动态代理模式 命令模式 外观模式 装饰器模式 适配器模式 工厂模式 迭代器模式 组合模式 观察者模式 模版方法模式 状态模式 ...

    概要

    最近看了设计模式相关的书籍,在此通过类图的形式总结下常用的设计模式;
    

    常见设计模式类图

    • 策略模式
    • 代理模式
    • 动态代理模式
    • 命令模式
    • 外观模式
    • 装饰器模式
    • 适配器模式
    • 工厂模式
    • 迭代器模式
    • 组合模式
    • 观察者模式
    • 模版方法模式
    • 状态模式
    展开全文
  • 测试用例的几种常见设计方法

    千次阅读 2018-04-11 12:30:50
    测试用例的几种常见设计方法 测试用例常见的设计方法有:等价类划分法、边界值分析法、错误推测法、判定表法、正交实验法。 一.等价类划分法 顾名思义,等价类划分,就是将测试的范围划分成几个互不相交的子集,...

    测试用例的几种常见设计方法



      测试用例常见的设计方法有:等价类划分法、边界值分析法、错误推测法、判定表法、正交实验法。
      一.等价类划分法
      顾名思义,等价类划分,就是将测试的范围划分成几个互不相交的子集,他们的并集是全集,从每个子集选出若干个有代表性的值作为测试用例。
      例如,我们要测试一个用户名是否合法,用户名的定义为:8位数字组成的字符。
      我们可以先划分子集:空用户名,1-7位数字,8位数字,9位或以上数字,非数字。
      然后从每个子集选出若干个有代表性的值:
      空用户名:“”      (无效等价类实例,指对于软件规格说明而言,没有意义的、不合理的输入)
      1-7位数字:"234"       (无效等价类实例)
      8位数字:"00000000"    (有效等价类实例,能检验程序是否实现了规格说明中所规定的功能和性能)
      9位或以上数字:"1234567890"    (无效等价类实例)
      非数字:"abc&!!!"                (无效等价类实例)
      他们5个,就是用等价类划分选出的测试用例。实际上,对于1-7位数字的子集来说,选“234”和“11111”没有本质的区别。
      等价类的划分,最关键的是子集的划分。实际上,非数字还可以继续划分子集:字母,特殊字符。
      究竟要划分到何种程度才合适呢?我请教过做测试的朋友,他的意见是,看你有多少资源和时间,还有,看是否值得。
      对此,我表示赞同,毕竟无论你怎么测试,总会有未发现的缺陷存在,所以,先解决容易被发现的问题再说。
      二.边界值分析法
      长期的测试工作经验告诉我们,大量的错误是发生在输入或输出范围的边界上,而不是发生在输入输出范围的内部。因此针对各种边界情况设计测试用例,可以查出更多的错误。选出的测试用例,应选取正好等于、刚刚大于、刚刚小于边界的值,例如,对于在区间min,max的值,测试用例可以记为min,min+,max,max-。
      例如,假定 X 为整数,10≤X≤100,那么 X 在测试中应该取的边界值为:10,11,99,100。
      注:上面只是说边界值,如果是完整的测试,除了边界值外,还需要一个正常值,即12-98之间的任意值。
      三.错误推测法
      错误推测法是指:在测试程序时,人们可以根据经验或直觉推测程序中可能存在的各种错误,从而有针对性地编写检查这些错误的测试用例的方法。
      这种方法没有固定的形式,依靠的是经验和直觉,很多时候,我们都会不知不觉的使用到。
      四.判定表法
      又称为策略表,基于策略表的测试,是功能测试中最严密的测试方法。该方法适合于逻辑判断复杂的场景,通过穷举条件获得结果,对结果再进行优化合并,会得到一个判断清晰的策略表。
      例如,某公司的对客户分类标准如下:
      顾客每次订货额在 1000元以上(含1000元),信誉好的,订单设“优先”标志;
      信誉不好,但是老客户的,订单设“优先”标志;
      信誉不好,但是新客户的,订单设“正常”标志;
      每次订货额在 1000元以下,订单设“正常”标志。
      绘制的决策表如下:
      此表分两大行,两大列,分别用不同的颜色区别。
      浅蓝:列出所有条件(或称为输入)
      浅灰:列出所有结果(或称为输出,行动或决策)
      浅黄:穷举所有条件的组合
      浅绿:根据每一列的条件,判断出结果
      因为穷举了所有条件,所以可以说这个判断是100%正确的。下一步是对这个表进行合并优化。
       例如,从编号为1,2的列可以看出,顾客订单>=1000,信誉好,不管是新顾客还是老顾客,都设为优先,于是上面的表合并整理后,得到下表
      这样,我们就可以得到更清晰的逻辑判断,也可以更好的协助我们编写测试用例。而决策表,对于开发人员来说一样有用。
      从上面的表格,我们就可以写出更简洁的判断语句。
      五.正交实验法
      用语言描述正交实验法会很抽象难懂,简单说,就是在各因素互相独立的情况下,设计出一种特殊的表格,找出能以少数替代全面的测试用例。
      其中,上面所说的特殊表格就是正交表,是按照一定规则生成的表。
      虽然说是特殊的表格,实际表现形式跟一般的表格没有什么区别,正交表的主要特征是,“均匀分布,整齐划一”,正是因为“均匀”的,所以才能以少数代替全部。
      例如:
      某所大学通信系共2个班级,刚考完某一门课程,想通过“性别”、“班级”和“成绩”这三个查询条件对通信系这门课程的成绩分布,男女比例或班级比例进行人员查询。
      按照传统的方式,我们将会穷举所有的组合,来编写测试用例,组合个数是2*2*2=8。
      排列组合参见下表
      当组合条件不多的时候,穷举暂时没问题,但是,一旦条件多了,组合个数就会以指数形式增长。
      这个时候,就要用到正交表了,通过选出有代表性的测试实例,达到以少数代替全面的效果。
      正交表如何设计呢,这个问题实际很复杂,涉及到组合统计的数学知识,有的正交表甚至到目前为止,还未得出算法。
      我们只能通过已知的模型套上去。
      例如,Dr. Genichi Taguchi 设计的正交表
      https://www.york.ac.uk/depts/maths/tables/orthogonal.htm
      Technical Support ( support.sas.com ) com 提供的
      http://support.sas.com/techsup/technote/ts723_Designs.txt
      首先,我们来看看基本的概念。
      因素:被测的元素称为因素,例如上面的性别,班级,成绩,均为因素,因素的个数我们记为k,此处k=3
      水平:因素的可能值,称为水平。例如班级的可能值为1或2。水平的个数我们记为m,此处正好每个因素的水平都是2,此处m=2。
      那么正交表的行数n的计算公式为,n=k*(m-1)+1,此处为n=3*(2-1)+1=4。即共有4行。
      我们通常用L表示这个正交表,完整的表示为Ln(mk)
      如果每个因素的水平数相等,我们称之为单一水平正交表,例如本例子就是,L4(23)
      各列水平数不完全相同的正交表称为混合水平正交表。如L8(4124),表示有一个因素的水平为4,有4个因素的水平为2。
      按照这个表达式,我们可以去套用已知的正交表。例如本例子是L4(23),从上面提供的两个链接均可以查到例子,虽然表达方式略有不同,但实际是一样的,我们从http://support.sas.com/techsup/technote/ts723_Designs.txt 查到,其正交表的格式为:
      23     n=4
      000
      011
      101
      110
      此处0,1是对可能值的编号,例如,我们可以将(0,1)分别映射为(女,男)(1班,2班)(及格,不及格)
      按照上面的格式,
      000:女  1班  及格
      011:女  2班  不及格
      101:男  1班  不及格
      110:男  2班  及格
      这就是我们所得到的正交表。
      六.总结
      功能测试方法还有很多,例如因果图法,状态转换测试法等,他们都略为复杂,像正交实验法一样,有各自的一套东西,不过本质都是通过画图,让我们更好的思考,最后转化成判定表。
      实际上常用的是前面五种方法,包括:等价类划分法、边界值分析法、错误推测法、判定表法、正交实验法。

    转自:http://www.51testing.com/html/30/n-3719130.html

    展开全文
  • 对几种常见设计模式的理解

    千次阅读 2015-08-31 10:58:49
    对几种常见设计模式的理解 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 最早提出“设计模式”概念的...

    对几种常见设计模式的理解

      设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

      最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投计模式的发现,因为它已经存在了千百年之久,而现代才被通过大量的研究而被发现。在《建筑的永恒之道》里这样描述:模式是一条由三个部分组成的通用规则:它表示了一个特定环境、一类问题和一个解决方案之间的关系。每一个模式描述了一个不断重复发生的问题,以及该问题解决方案的核心设计。

    一、23种经典的设计模式

      
    这里写图片描述

    二、设计模式的六大原则

    1、开闭原则
    开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类。
    2、里氏代换原则
    里氏代换原则面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。
    3、依赖倒转原则
    这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。
    4、接口隔离原则
    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。
    5、迪米特法则(最少知道原则)
    为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
    6、合成复用原则
    原则是尽量使用合成/聚合的方式,而不是使用继承。

    三、为什么要把很简单的东西搞得那么复杂

      我们所理解的“简单”就是一把钥匙开一把锁的模式,目的仅仅是着眼于解决现在的问题,而设计模式的“复杂”就在于它是要构造一个“万能钥匙”,目的是提出一种对所有锁的开锁方案。在真正理解设计模式之前我一直在编写“简单”的代码。这个“简单”不是功能的简单,而是设计的简单。简单的设计意味着缺少灵活性,代码很钢硬,只在这个项目里有用,拿到其它的项目中就是垃圾,我将其称之为“一次性代码”。

    下面的一个例子说明了“为什么要把很简单的东西搞得那么复杂”:(策略模式)

    说明:
    模拟鸭子游戏的应用程序,要求:游戏中会出现各种颜色外形的鸭子,一边游泳戏水,一边呱呱叫。

    第一种方法:(一次性代码)
    直接编写出各种鸭子的类:MallardDuck//野鸭,RedheadDuck//红头鸭,各类有三个方法:

    quack():叫的方法
    swim():游水的方法
    display():外形的方法

    第二种方法:运用继承的特性,将其中共同的部分提升出来,避免重复编程。
    即:设计一个鸭子的超类(Superclass),并让各种鸭子继承这个超类。

    public class Duck{
         public void quack(){  //呱呱叫
                  System.out.println("呱呱叫");
          }
         public void swim(){   //游泳
                System.out.println(" 游泳");
          }    
         public  abstratact void display(); /*因为外观不一样,让子类自己去决定了。*/
    }

    对于它的子类只需简单的继承就可以了,并实现自己的display()方法。

    //野鸭
     public class MallardDuck extends Duck{
         public void display(){
              System.out.println("野鸭的颜色...");
       }
     }
    //红头鸭
     public class RedheadDuck extends Duck{
         public void display(){
              System.out.println("红头鸭的颜色...");
       }
    }

    不幸的是,现在客户又提出了新的需求,想让鸭子飞起来。这个对于程序员,在简单不过了,在超类中在加一个方法就可以了。

    public class Duck{
         public void quack(){  //呱呱叫
                  System.out.println("呱呱叫");
          }
         public void swim(){   //游泳
                System.out.println(" 游泳");
        }    
        public  abstract void display(); /*因为外观不一样,让子类自己去决定了。*/
       public void fly(){
            System.out.println("飞吧!鸭子"); 
      }
    }

    这样所有的继承这个超类的鸭子都会fly了。但是问题又出来了,客户又提出有的鸭子会飞,有的不能飞对于不能飞的鸭子,在子类中只需简单的覆盖。

    //残废鸭
     public class DisabledDuck extends Duck{
         public void display(){
              System.out.println("残废鸭的颜色...");
       }
       public void fly(){
        //覆盖,变成什么事都不做。 
      }
    } 

    其它会飞的鸭子不用覆盖。

    点评:
    对于上面的设计,你可能发现一些弊端,如果超类有新的特性,子类都必须变动,这是我们开发最不喜欢看到的,一个类变让另一个类也跟着变,这有点不符合OO设计了。这样很显然的耦合了一起。利用继承–>耦合度太高了.

    第三种方法:用接口改进.
    我们把容易引起变化的部分提取出来并封装之,来应付以后的变法。虽然代码量加大了,但可用性提高了,耦合度也降低了。
    我们把Duck中的fly方法和quack提取出来。

        public interface Flyable{
          public void fly(); 
      }
       public interface Quackable{
         public void quack();
      }

    最后Duck的设计成为:

    public class Duck{
         public void swim(){   //游泳
                System.out.println(" 游泳");
        }    
        public  abstract void display(); /*因为外观不一样,让子类自 己去决定了。*/
    }

    而MallardDuck,RedheadDuck,DisabledDuck 就可以写成为:

    //野鸭
     public class MallardDuck extends Duck  implements Flyable,Quackable{
         public void display(){
              System.out.println("野鸭的颜色...");
       }
       public void fly(){
        //实现该方法
      }
       public void quack(){
        //实现该方法
      }
     }
    //红头鸭
     public class RedheadDuck extends Duck implements Flyable,Quackable{
         public void display(){
              System.out.println("红头鸭的颜色...");
       }
       public void fly(){
        //实现该方法
      }
       public void quack(){
        //实现该方法
      }
    } 
    //残废鸭 只实现Quackable(能叫不能飞)
     public class DisabledDuck extends Duck implements Quackable{
         public void display(){
              System.out.println("残废鸭的颜色...");
       }
       public void quack(){
        //实现该方法
      }
    }

    点评:
    好处:
    这样已设计,我们的程序就降低了它们之间的耦合。
    不足:
    Flyable和 Quackable接口一开始似乎还挺不错的,解决了问题(只有会飞到鸭子才实现 Flyable),但是Java接口不具有实现代码,所以实现接口无法达到代码的复用。

    第四种方法:可用以下的策略模式来解决.

    ————————- strategy(策略模式) ————————-

    我们有一个设计原则:
    找出应用中相同之处,且不容易发生变化的东西,把它们抽取到抽象类中,让子类去继承它们;找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
    –>important.现在,为了要分开“变化和不变化的部分”,我们准备建立两组类(完全远离Duck类),一个是”fly”相关的,另一个是“quack”相关的,每一组类将实现各自的动作。比方说,我们可能有一个类实现“呱呱叫”,另一个类实现“吱吱叫”,还有一个类实现“安静”。

    首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior(叫的行为).

     public interface FlyBehavior{
         public void fly();     
     }
     public interface QuackBehavior{
         public void quack();
     }

    我们在定义一些针对FlyBehavior的具体实现。

    public class FlyWithWings implements FlyBehavior{
        public void  fly(){
         //实现了所有有翅膀的鸭子飞行行为。
       }
     }
    public class FlyNoWay implements FlyBehavior{
    
        public void  fly(){
          //什么都不做,不会飞
        }
     }   

    针对QuackBehavior的几种具体实现。

    public class Quack implements QuackBehavior{
        public void quack(){
          //实现呱呱叫的鸭子
      }
    }
    
    public class Squeak implements QuackBehavior{
        public void quack(){
          //实现吱吱叫的鸭子 
      }
    }
    
    public class MuteQuack implements QuackBehavior{
        public void quack(){
          //什么都不做,不会叫
      }
    }

    点评一:
    这样的设计,可以让飞行和呱呱叫的动作被其他的对象复用,因为这些行为已经与鸭子类无关了。而我们增加一些新的行为,不会影响到既有的行为类,也不会影响“使用”到飞行行为的鸭子类。

    最后我们看看Duck 如何设计。

       public class Duck{        --------->在抽象类中,声明各接口,定义各接口对应的方法.
          FlyBehavior flyBehavior;//接口
          QuackBehavior quackBehavior;//接口
           public Duck(){}
           public abstract void display();
           public void swim(){
            //实现游泳的行为
            }
           public void performFly(){
                flyBehavior.fly();  -->由于是接口,会根据继承类实现的方式,而调用相应的方法.
             }
         public void performQuack(){
              quackBehavior.quack();
            }
     }

    看看MallardDuck如何实现。
    —–>通过构造方法,生成’飞’,’叫’具体实现类的实例,从而指定’飞’,’叫’的具体属性

    public class MallardDuck extends Duck{
           public MallardDuck {       
            flyBehavior = new FlyWithWings ();
            quackBehavior = new Quack(); 
          //因为MallardDuck 继承了Duck,所有具有flyBehavior 与quackBehavior 实例变量
          }
        public void display(){
         //实现
       }
     }

    这样就满足了即可以飞,又可以叫,同时展现自己的颜色了。
    这样的设计我们可以看到是把flyBehavior ,quackBehavior 的实例化写在子类了。我们还可以动态的来决定。
    我们只需在Duck中加上两个方法。

    在构造方法中对属性进行赋值与用属性的setter的区别:
    构造方法中对属性进行赋值:固定,不可变;
    用属性的setter,可以在实例化对象后,动态的变化,比较灵活。

      public class Duck{
          FlyBehavior flyBehavior;//接口
          QuackBehavior quackBehavior;//接口
          public void setFlyBehavior(FlyBehavior flyBehavior){
                this.flyBehavior = flyBehavior;
         }
        public void setQuackBehavior(QuackBehavior quackBehavior  {
                this.quackBehavior= quackBehavior;
         }
     }

    四、几种常见的设计模式

    1、单例模式(singelton)

    基本概念:
    Singleton 是一种创建性模型,它用来确保只产生一个实例,并提供一个访问它的全局访问点.对一些类来说,保证只有一个实例是很重要的,比如有的时候,数据库连接或 Socket 连接要受到一定的限制,必须保持同一时间只能有一个连接的存在.
    运用:
    在于使用static变量;
    创建类对象,一般是在构造方法中,或用一个方法来创建类对象。在这里方法中,加对相应的判断即可。

    public class Singleton {  
      private static Singleton s; 
      public static Singleton getInstance() {
        if (s == null)
          s = new Singleton();
        return s;
      }
    }
    // 测试类
    class singletonTest {
      public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        if (s1==s2)
          System.out.println("s1 is the same instance with s2");
        else
          System.out.println("s1 is not the same instance with s2");
      }
    }
    singletonTest运行结果是:
    s1 is the same instance with s2

    2、简单工厂(StaticFactory Method)

      简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。
      举例如下:(我们举一个发送邮件和短信的例子)
    首先,创建二者的共同接口:

    [java] view plaincopy
    public interface Sender {  
        public void Send();  
    }  

    其次,创建实现类:

    [java] view plaincopy
    public class MailSender implements Sender {  
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    [java] view plaincopy
    public class SmsSender implements Sender {  
    
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }  

    最后,建工厂类:

    [java] view plaincopy
    public class SendFactory {  
    
        public Sender produce(String type) {  
            if ("mail".equals(type)) {  
                return new MailSender();  
            } else if ("sms".equals(type)) {  
                return new SmsSender();  
            } else {  
                System.out.println("请输入正确的类型!");  
                return null;  
            }  
        }  
    }  

    我们来测试下:

    [java] view plaincopy
    public class FactoryTest {  
    
        public static void main(String[] args) {  
            SendFactory factory = new SendFactory();  
            Sender sender = factory.produce("sms");  
            sender.Send();  
        }  
    }  

    输出:this is sms sender!

    3、观察者模式(Observer)

    基本概念:
      观察者模式属于行为型模式,其意图是定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。这一个模式的关键对象是目标(Subject)和观察者(Observer)。一个目标可以有任意数目的依赖它的观察者,一旦目标的状态发生改变,所有的观察者都得到通知,作为对这个通知的响应,每个观察者都将查询目标以使其状态与目标的状态同步。
    适用场景:
      观察者模式,用于存在一对多依赖关系的对象间,当被依赖者变化时,通知依赖者全部进行更新。因此,被依赖者,应该有添加/删除依赖者的方法,且可以将添加的依赖者放到一个容器中;且有一个方法去通知依赖者进行更新。

    4、迭代器模式(Iterator)

    基本概念:
    迭代器模式属于行为型模式,其意图是提供一种方法顺序访问一个聚合对象中得各个元素,而又不需要暴露该对象的内部表示。至少可以历遍first,next,previous,last,isOver,或是历遍选择符合某种条件的子元素.

    5、外观模式(Facade)

      外观模式属于结构型模式,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。外观模式的主要用途就是为子系统的复杂处理过程提供方便的调用方法,使得子系统更加容易被使用。–>将复杂的过程包含在里面,提供一个简单的应用接口即可.

    例如在一个泡茶的过程中,需要作如下的工作:烧开水,准备茶叶,把茶叶放在被子里,把烧开的水放到茶杯中,只有经过这些过程之后才能泡出好的茶叶来。这是一个常用的步骤,80%的泡茶步骤都是这个样子的,可以把这些动作串联起来,形成一个整体的步骤.如下例的MakeACuppa(),使用了facade的模式,这样在调用步方法时就比较方便。这便是外观模式,里面的细节被屏蔽掉了。

    public class TeaCup{.....}
    public class TeaBag{.....}
    public class Water{.....}
    public class FacadeCuppaMaker{
        private boolean TeaBagIsSteeped;
        public FacadeCuppaMaker(){
           System.out.println("FacadeCuppaMaker 准备好冲茶了");
        }
        public TeaCup makeACuppa(){
           TeaCup cup = new TeaCup();
           TeaBag teaBag= new TeaBag();
           Water water = new Water();
           cup.addFacadeTeaBag(teaBag);
           water.boilFacadeWater();
           cup.addFacadeWater(water);
           cup.steepTeaBag();
           return cup;
        }
    }

    6、适配器模式(adapter)

    适配器模式的意图是将一个已存在的类/接口进行复用,将其转换/具体化成客户希望的另外的一个类/接口。
    如何实例复用:
    将要进行复用的类,放到目标类的构造方法中,进行实例化,然后在目标类的相应方法中,进行调用,修改原来方法中的参数,或添加相应的逻辑。即复用了已有类的原来方法。
    要被复用的类:

    public class Adaptee{
        public long getPower(long base,long exp){
           long result=1;
           for(int i=0;i<exp;i++)
               result*=base;
           return result;
        }
    }
    目标类:--也可直接实现,不用接口。
    public interface Target{
        public long get2Power(long exp);
    }
    public class Adapter implements Target{
        private Adaptee pt;
        public Adapter(){
           pt = new Adaptee();
        }
        public long get2Power(long exp){
           return pt.getPower(2,exp);   ---修改原来方法中的参数,
        }
    }

    7、建造模式(Builder)

      建造模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到。
    将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

    8、合成模式(Composite)

      合成模式:将对象以树形结构组织起来,以达成“部分-整体” 的层次结构,使得客户端对单个对象和组合对象的使用具有一致性. 合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
    windows的目录树(文件系统)

    9、状态模式(State)

      状态模式:状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里,每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候,其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时,系统便改变所选的子类。

    另外,MVC模式

      MVC模式:它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件:模型、视图、控制器。它们各自处理自己的任务。相互通信。MVC还使用了的设计模式,如:用来指定视图缺省控制器的Factory Method和用来增加视图滚动的Decorator。但是MVC的主要关系还是由Observer、Composite和Strategy三个设计模式给出的。

    展开全文
  • 在拿到 UI 设计稿时,可以经常看设计稿中常见的字体有 PingFangSC-Regular、PingFangSC-Medium、PingFangSC-Bold,并不会直接给我们 font-weight 的值。在这我们就需要知道常见字体和 font-weight 的对应关系 详细...

    在拿到 UI 设计稿时,可以经常看设计稿中常见的字体有 PingFangSC-RegularPingFangSC-MediumPingFangSC-Bold,并不会直接给我们 font-weight 的值。在这我们就需要知道常见字体和 font-weight 的对应关系

    Pingfang SC 有六个字重,设计师经常会用 Pingfang SC Medium 字体,大概很多人会忽略它,直接设 font-weight: bold,但是对于 Pingfang SC 字体,设成 bold 其实变成了 Pingfang SC SemiboldPingfang SC Medium 的字重是 500。

    详细可以看 font-weight 的介绍 传送门

    font-weight 属性执行字体中字形的重量,这取决于黑度等级或笔划粗细,其值的意义如下:

    这些有序排列中的每个值,表示至少与其起身拥有相同黑度的重量。其大致符合下列通用重量名称:

    • 100 - Thin
    • 200 - Extra Light (Ultra Light)
    • 300 - Light
    • 400 - Regular (Normal、Book、Roman)
    • 500 - Medium
    • 600 - Semi Bold (Demi Bold)
    • 700 - Bold
    • 800 - Extra Bold (Ultra Bold)
    • 900 - Black (Heavy)
    展开全文
  • 常见设计模式—单例模式(Singleton)

    千次阅读 多人点赞 2020-03-15 20:14:59
    对于常用的23种设计模式,这里笔者会根据自己学习和出现频率、重要程度进行学习记录吧。 单例模式 单例模式(Singleton Pattern)是设计模式中最简单的模式之一,属于创建型模式。这种设计模式主要是类的对象只有一...
  • 常见设计模式笔试面试题

    万次阅读 多人点赞 2018-08-10 15:45:46
    设计模式一套被反复使用,多数人知晓的代码设计经验的总结,实现可重用代码,使代码更容易被理解,保证代码可靠性。 总体来说,设计模式分为三大类: 创建型模式(五种):工厂方法模式、抽象工厂模式、单例模式、...
  • 1.1 设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接...
  • 五种常见设计模式

    万次阅读 2017-01-22 22:37:03
    设计模式 一书将设计模式引入软件社区,该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design(俗称 “四人帮”)。所介绍的设计模式背后的核心概念非常简单。经过多年的软件开发实践...
  • Java常见设计模式面试题

    万次阅读 2016-10-15 17:05:27
    常见面试题 设计模式 工厂模式(Factory pattern) 观察者模式(Observer pattern) 重载 线程安全的单例模式
  • 常见设计模式面试题

    万次阅读 2012-09-08 10:42:33
    1、写出常用的设计模式,如单例、工厂、装饰者、观察者等模式,分别介绍他们运用的场景 2、关于标准的JDK库中使用的一些设计模式 Decorator设计模式常被用于各种Java IO类中 Singleton模式常被用在运行环节中,...
  • 分页查询接口常见设计思路

    万次阅读 2017-08-05 17:13:32
    我们在web开发中,在页面展示时经常会遇到分页技术,常见的分页实现的思路有: 客户端分页:直接将全部或多页结果数据一次性返回给客户端,客户端通过展现组件进行数据分页的控制。 数据库分页:进行数据查询时,...
  • 黑盒测试的测试用例常见设计方法都有哪些?请分别以具体的例子来说明这些方法在测试用例设计工作中的应用。 1)等价类划分 等价类是指某个输入域的子集合.在该子集合中,各个输入数据对于揭露程序中的错误都是等效...
  • 设计模式的几个重要原则 单一职责原则 开闭原则 依赖倒转原则 里氏代换原则 合成聚合复用原则:尽量使用组合/聚合代替继承 迪米特原则:降低耦合性 设计模式 类图 优点 缺点 ...
  • /* * 问题: * 接口(方法比较多) -- 实现类(仅仅使用一个,也得把其他的实现给提供了,哪怕是空实现) * 太麻烦了。 * 解决方案: * 接口(方法比较多) -- 适配器类(实现接口,仅仅空实现) -- 实现类(用哪个重写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 897,540
精华内容 359,016
关键字:

常见的设计