设计模式-引言及个人认识(1)

设计模式(Design Patterns)


                                  ——可复用面向对象软件的基础

本系列的主要知识来源是Head First设计模式以及各大博主的知识总结,相关引用位置会予以说明,疏漏之处还望指正,如侵删。

设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因。

按照HeadFirst书中的定义为:在某种情况下,针对某问题的解决方案。个人理解为,是前人在大量的编程实践过程中逐渐总结出来的最优解决方案,在目前的圈内充斥着左倾与右倾的言论,一些人认为设计模式至高无上,任何程序设计过程都应遵循或严格遵守设计模式,而另一些人则认为设计模式只不过是一些教条般的总结,并不登大雅之堂,程序设计应该遵循自由的原则,不该被这些条条框框所约束。而在我看来,设计模式的知识,更像是一本史书,“读史可以使人明智 鉴以往可以知未来”,以前的程序员们走过的弯路,总结出来捷径给后人以警醒,我觉得设计模式是每个程序员必备的基本功,但是我们又不能神化,固化它,设计模式更像是一种准则或者说一种建议,我们在其基础上,通过理解其设计的内涵与思想,应用到我们实际的程序设计中去,这才是对待设计模式最适合的态度。没有万能的公式,只有最优化的程序员自己。

设计模式因其广泛传播性,逐渐成为圈内交流的一种方式,就像HF(HeadFirst)书中所说的一样,学习设计模式有什么用,最直观的一点就是能让你显得更加专业,交谈更加简洁,并且能让团队合作更加高效且便捷。通俗点来讲,就是大家都不会就你会,那显得你就很厉害;大家都会就你不会,那根本融入不了团队中去,因此你必须要学。同时,设计模式典型的应用就是Java框架,我们如果想要在这个行业领域更加深入,那框架源码绝对是你绕不开的大山,如果对设计模式不太熟悉,那你攻读源码绝对举步维艰。

通过浏览许多的面经,我们也可以发现,有的面试官偏爱设计模式的考量,如果你在基础扎实的基础上,会主流的几种设计模式,并且读过主流框架的核心源码,能将框架功能的实现与设计模式相对应,那绝对让面试官眼前一亮。

总而言之,设计模式,绝对是你不可错过的一块知识点。个人建议,设计模式的学习安排在主流框架学习之后,学习完SSM或者SSH的使用之后,就可以开始设计模式的学习,推荐教材是HeadFirst设计模式,以及各大博客的内容,你也可以跟着我这篇系列走下去,参照着HF,动手操作,相信你会很快的入门并且掌握其重点。

-------------------------------------------------------------------------------------------------------------

设计模式分为三大类:
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类:并发型模式和线程池模式。

设计模式的六大原则:

总原则-开闭原则

对扩展开放,对修改封闭。在程序需要进行拓展的时候,不能去修改原有的代码,而是要扩展原有代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。
想要达到这样的效果,我们需要使用接口和抽象类等,后面的具体设计中我们会提到这点。

1、单一职责原则

不要存在多于一个导致类变更的原因,也就是说每个类应该实现单一的职责,否则就应该把类拆分。

2、里氏替换原则(Liskov Substitution Principle)

任何基类可以出现的地方,子类一定可以出现。里氏替换原则是继承复用的基石,只有当衍生类可以替换基类,软件单位的功能不受到影响时,基类才能真正被 复用,而衍生类也能够在基类的基础上增加新的行为。
里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中,子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构,通过这个规范的接口与外界交互,子类不应该随便破坏它。

3、依赖倒转原则(Dependence Inversion Principle)

面向接口编程,依赖于抽象而不依赖于具体。写代码时用到具体类时,不与具体类交互,而与具体类的上层接口交互。


4、接口隔离原则(Interface Segregation Principle)

每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分。使用多个隔离的接口,比使用单个接口(多个接口方法集合到一个的接口)要好。


5、迪米特法则(最少知道原则)(Demeter Principle)

一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂,都应该将逻辑封装在方法的内部,通过public方法提供给外部。这样当被依赖的类变化时,才能最小的影响该类。
最少知道原则的另一个表达方式是:只与直接的朋友通信。类之间只要有耦合关系,就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

6、合成复用原则(Composite Reuse Principle)

尽量首先使用合成/聚合的方式,而不是使用继承。


-------------------------------------------------------------------------------------------------------------------------------


下面是基础知识的学习,在设计模式过程中,我们会遇到各式各样的类图,他们之间的关系就用类图可以简单地表示出来,下面是最基础的各个类之间的关系。

     在java以及其他的面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们的耦合度依次增强。

1. 依赖(Dependence)

        依赖关系的定义为:对于两个相对独立的对象,当一个对象负责构造另一个对象的实例,或者依赖另一个对象的服务时,这两个对象之间主要体现为依赖关系。定义比较晦涩难懂,但在java中的表现还是比较直观的:类A当中使用了类B,其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。类上面的图例中:People类依赖于Book类和Food类,Book类和Food类是作为类中方法的参数形式出现在People类中的。

代码样例:

public class People{
    //Book作为read方法的形参
     public void read(Book book){
        System.out.println(“读的书是”+book.getName());
    }
}

2.关联(Association)

单向关联:

 

双向关联:

        对于两个相对独立的对象,当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时,这两个对象之间为关联关系。关联关系分为单向关联和双向关联。在java中,单向关联表现为:类A当中使用了类B,其中类B是作为类A的成员变量。双向关联表现为:类A当中使用了类B作为成员变量;同时类B中也使用了类A作为成员变量。

代码样例:

public class Son{
   //关联关系中作为成员变量的类一般会在类中赋值
    Father father = new Father();
    public void getGift(){
        System.out.println(“从”+father.getName()+”获得礼物”);
    }
}

public class Father{
    Son son = new Son();
    public void giveGift(){
        System.out.println(“送给”+son.getName()+“礼物”);
    }
}

3.聚合(Aggregation)

        聚合关系是关联关系的一种,耦合度强于关联,他们的代码表现是相同的,仅仅是在语义上有所区别:关联关系的对象间是相互独立的,而聚合关系的对象之间存在着包容关系,他们之间是“整体-个体”的相互关系。

代码样例:

public class People{
    Car car;
    House house; 
    //聚合关系中作为成员变量的类一般使用set方法赋值
     public void setCar(Car car){
        This.car = car;
    }
    public void setHouse(House house){
        This.house = house;
    }

    public void driver(){
        System.out.println(“车的型号:”+car.getType());
    }
    public void sleep(){
        System.out.println(“我在房子里睡觉:”+house.getAddress());
    }
}

4.组合(Composition)

        相比于聚合,组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系,“整体”负责“部分”的生命周期,他们之间是共生共死的;并且“部分”单独存在时没有任何意义。在下图的例子中,People与Soul、Body之间是组合关系,当人的生命周期开始时,必须同时有灵魂和肉体;当人的生命周期结束时,灵魂肉体随之消亡;无论是灵魂还是肉体,都不能单独存在,他们必须作为人的组成部分存在。

Public class People{
    Soul soul;
    Body body; 
    //组合关系中的成员变量一般会在构造方法中赋值
     Public People(Soul soul, Body body){ 
        This.soul = soul;
        This.body = body;
    }

    Public void study(){
        System.out.println(“学习要用灵魂”+soul.getName());
    }
    Public void eat(){
        System.out.println(“吃饭用身体:”+body.getName());
    }
}

5.继承(Generalization)

        继承表示类与类(或者接口与接口)之间的父子关系。在java中,用关键字extends表示继承关系。UML图例中,继承关系用实线+空心箭头表示,箭头指向父类。

6.实现(Implementation)

         表示一个类实现一个或多个接口的方法。接口定义好操作的集合,由实现类去完成接口的具体操作。在java中使用implements表示。UML图例中,实现关系用虚线+空心箭头表示,箭头指向接口。

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页