设计模式-1.概述/UML类图/软件设计原则

目录

一、概述

二、UML类图

2.1 类的表示方式

2.2 类之间的关系

2.2.1 关联关系

2.2.2 聚合关系

2.2.3 组合关系

2.2.4 依赖关系

2.2.5 继承关系

2.2.6 实现关系

三、软件设计原则

3.1 开闭原则

3.2 里氏代换原则

3.3 依赖倒转原则

3.4 接口隔离原则

3.5 迪米特法则

3.6 合成复用原则

---

一、概述

        设计模式是一套被反复使用、多数人知晓 的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题， 以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路

        优点：

        1.正确使用设计模式具有以下优点。

        2.可以提高程序员的思维能力、编程能力和设计能力

        3. 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周 期。 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

        分类：

        创建型模式-用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF（四人组）书中提 供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。

        结构型模式-用于描述如何将类或对象按某种布局组成更大的结构，GoF（四人组）书中提供了代理、适配器、 桥接、装饰、外观、享元、组合等 7 种结构型模式。

        行为型模式-用于描述类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，以及怎样分配职责。 GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访 问者、备忘录、解释器等 11 种行为型模式。

二、UML类图

        类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与 其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。

2.1 类的表示方式

        在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示

+：表示public

- ：表示private

#：表示protected

属性的完整表示方式是：

        可见性 名称 ：类型 [ = 缺省值]

方法的完整表示方式是：

        可见性 名称(参数列表) [ ： 返回类型]

2.2 类之间的关系

2.2.1 关联关系

        关联关系是对象之间的一种引用关系，用于表示一类对象与另一类对象之间的联系，如老师和学生、师傅和徒弟、丈夫和妻子等。关联关系是类与类之间最常用的一种关系，分为一般关联关系、聚合关系和组合关系。我们先介绍一般关联。 关联又可以分为单向关联，双向关联，自关联。

        单向关联：顾客与地址

        双向关联：双方各自持有对方类型的成员变量

         自关联：“自己包含自己“

2.2.2 聚合关系

        聚合关系是关联关系的一种，是强关联关系，是整体和部分之间的关系。

        成员对象是整体对象的一部分，但是成员对象可以脱离整体对象而独立存在。例如，学校与老师的关系，学校包含老师，但如果学校停办了，老师依然存在。

2.2.3 组合关系

        组合表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系。 在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在， 部分对象不能脱离整体对象而存在。

2.2.4 依赖关系

        依赖关系是一种使用关系，它是对象之间耦合度最弱的一种关联方式，是临时性的关联。在代码中，某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类（被依赖类）中的某些方法来完成一些职责。

2.2.5 继承关系

        继承关系是对象之间耦合度最大的一种关系，表示一般与特殊的关系，是父类与子类之间的关系，是一 种继承关系。

2.2.6 实现关系

        实现关系是接口与实现类之间的关系。在这种关系中，类实现了接口，类中的操作实现了接口中所声明 的所有的抽象操作。

三、软件设计原则

3.1 开闭原则

        对扩展开放，对修改关闭。想要达到这样的效果，我们需要使用接口和抽象类。

        因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节 可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

        举例：以 搜狗输入法 的皮肤为例介绍开闭原则的应用 。

        用户可以根据自己的喜 爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个 抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和 HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

//抽象皮肤类
public abstract class AbstractSkin {
    public abstract void display();
}
 
//搜狗输入法
public class SouGouInput {
    private AbstractSkin skin;
 
    public void setSkin(AbstractSkin skin){
        this.skin=skin;
    }
    public void display(){
        skin.display();
    }
}
 
//默认皮肤
public class DefaultSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("默认皮肤");
    }
}
 
//黑马皮肤
public class HeiMaSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("黑马皮肤");
    }
}
 
//测试
public class Client {
    public static void main(String[] args) {
        SouGouInput input=new SouGouInput();
        //DefaultSkin skin=new DefaultSkin();
        HeiMaSkin skin=new HeiMaSkin();
        input.setSkin(skin);
        input.display();
    }
}

3.2 里氏代换原则

        任何基类可以出现的地方，子类一定可以出现。

        通俗理解：子类可以扩展父类的功能， 但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

        举例：在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何 图形相关的软件系统，就可以顺理成章的让正方形继承自长方形。

//长方形
public class Rectangle {
    private double length;
    private double width;
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
}
 
//正方形（重写了父类中的方法）
public class Square extends Rectangle{
    public void setWidth(double width) {
        super.setLength(width);
        super.setWidth(width);
    }
    public void setLength(double length) {
        super.setLength(length);
        super.setWidth(length);
    }
}
 
//测试
public class test {
    //调整长和宽
    public static void resize(Rectangle rectangle) {
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }
    //打印长方形的长和宽
    public static void printLengthAndWidth(Rectangle rectangle) {
        System.out.println(rectangle.getLength());
        System.out.println(rectangle.getWidth());
    }
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        resize(rectangle);
        printLengthAndWidth(rectangle);//用长方形对象代码正常执行
        System.out.println("============");
        Rectangle rectangle1 = new Square();
        rectangle1.setLength(10);
        resize(rectangle1);
        printLengthAndWidth(rectangle1);//换成正方形对象就卡住了
    }
}

3.3 依赖倒转原则

        高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

        简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。        

        举例：现要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选 择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船 等。

         我们看computer的代码：

public class Computer {
    private XiJieHardDisk hardDisk;
    private IntelCpu cpu;
    private KingstonMemory memory;
    public IntelCpu getCpu() {
        return cpu;
    }
    public void setCpu(IntelCpu cpu) {
        this.cpu = cpu;
    }
    public KingstonMemory getMemory() {
        return memory;
    }
    public void setMemory(KingstonMemory memory) {
        this.memory = memory;
    }
    public void run() {
        System.out.println("运行计算机");
        String data = hardDisk.get();
        System.out.println("从硬盘上获取的数据是：" + data);
        cpu.run();
        memory.save();
    }
}
 
上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金
士顿的，硬盘只能是希捷的（固定死的），这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择
自己喜欢的配件。
 
根据依赖倒转原则进行改进：
代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个
组件具体的实现类。

         改进后的Computer类：

public class Computer {
 
    private HardDisk hardDisk;
    private Cpu cpu;
    private Memory memory;
 
    public HardDisk getHardDisk() {
        return hardDisk;
    }
 
    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }
 
    public Cpu getCpu() {
        return cpu;
    }
 
    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }
 
    public Memory getMemory() {
        return memory;
    }
 
    public void setMemory(Memory memory) {
        this.memory = memory;
    }
 
    //运行计算机
    public void run() {
        System.out.println("运行计算机");
        String data = hardDisk.get();
        System.out.println("从硬盘上获取的数据是：" + data);
        cpu.run();
        memory.save();
    }
}

        一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

3.4 接口隔离原则

        客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上。

        举例：安全门案例

        我们需要创建一个 黑马 品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防 盗功能提取成一个接口，形成一套规范。类图如下：

        但现在如果我们还需要再创建一个传智品牌的安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现 SafetyDoor接口就违背了接口隔离原则，那么我们如何进行修改呢？看如下类图：

         其实就是把接口进一步细化了。

3.5 迪米特法则

        又叫最少知识原则。只和你的直接朋友交谈，不跟“陌生人”说话。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

        举例：明星-经纪人-粉丝

        明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业 务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。

         agent类代码如下：

public class Agent {
 
    private Star star;
    private Fans fans;
    private Company company;
 
    public void setStar(Star star) {
        this.star = star;
    }
 
    public void setFans(Fans fans) {
        this.fans = fans;
    }
 
    public void setCompany(Company company) {
        this.company = company;
    }
 
    //和粉丝见面的方法
    public void meeting() {
        System.out.println(star.getName() + "和粉丝" + fans.getName() + "见面");
    }
 
    //和媒体公司洽谈的方法
    public void business() {
        System.out.println(star.getName() + "和" + company.getName() + "洽谈");
    }
}

        测试方法：

public class Client {
    public static void main(String[] args) {
        //创建经纪人类
        Agent agent = new Agent();
        //创建明星对象
        Star star = new Star("林青霞");
        agent.setStar(star);
        //创建粉丝对象
        Fans fans = new Fans("李四");
        agent.setFans(fans);
        //创建媒体公司对象
        Company company = new Company("黑马媒体公司");
        agent.setCompany(company);
 
        agent.meeting();//和粉丝见面
        agent.business();//和媒体公司洽谈业务
    }
}

        明星与粉丝、媒体公司通过经纪人间接接触。

3.6 合成复用原则

        通常类的复用分为继承复用和合成复用两种.

        尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

        继承复用的缺点：

        1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所 以这种复用又称为“白箱”复用。

        2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。

        3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可 能发生变化。

        合成复用的优点：

        1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱” 复用。

        2. 对象间的耦合度低。可以在类的成员位置声明抽象。

        3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。 

         举例：汽车分类管理程序

        汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色 汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：

        从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话， 就需要再定义新的类。我们试着将继承复用改为聚合复用看一下：