UML类图与七大原则

已于 2024-02-02 15:08:46 修改
阅读量2k 收藏 44
点赞数 14
分类专栏： # DesignPattern Java全栈 文章标签： uml 设计模式
于 2024-02-02 15:08:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44781071/article/details/135994180
版权
Java全栈

UML类图

统一建模语言（Unified Modeling Language，UML）是用来设计软件的可视化建模语言。它的特点是简单、统一、图形化、能表达软件设计中的动态与静态信息。

UML 从目标系统的不同角度出发，定义了用例图、类图、对象图、状态图、活动图、时序图、协作图、构件图、部署图等 9 种图。

一、类图概述

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

二、类图的作用

  • 在软件工程中，类图是一种静态的结构图，描述了系统的类的集合，类的属性和类之间的关系，可以简化了人们对系统的理解；
  • 类图是系统分析和设计阶段的重要产物，是系统编码和测试的重要模型。

三、类图表示法

1、类的表示方式

在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的圆矩形来表示，比如下图表示一个Employee类，它包含name,age和address这3个属性，以及work()方法。

属性/方法名称前加的加号和减号表示了这个属性/方法的可见性，UML类图中表示可见性的符号有三种：

  • +：表示 public
  • -：表示 private
  • #：表示 protected

属性的完整表示方式是： 可见性 名称 ：类型 [ = 缺省值]

方法的完整表示方式是： 可见性 名称(参数列表) [ ： 返回类型]

注意：

  • 中括号中的内容表示是可选的
  • 也有将类型放在变量名前面，返回值类型放在方法名前面

举个栗子：

上图Demo类定义了三个方法：

  • method()方法：修饰符为public，没有参数，没有返回值。
  • method1()方法：修饰符为private，没有参数，返回值类型为String。
  • method2()方法：修饰符为protected，接收两个参数，第一个参数类型为int，第二个参数类型为String，返回值类型是int。

2、类与类之间关系的表示方式

1）关联关系

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

关联又可以分为单向关联，双向关联，自关联。

1、单向关联

在UML类图中单向关联用一个带箭头的实线表示。上图表示每个顾客都有一个地址，这通过让Customer类持有一个类型为Address的成员变量类实现。

public class Customer {
    private Address address;
}

2、双向关联

public class Customer {
    private List<Product> products;
}
public class Product {
    private Customer customer;
}

从上图中我们很容易看出，所谓的双向关联就是双方各自持有对方类型的成员变量。

在UML类图中，双向关联用一个不带箭头的直线表示。上图中在Customer类中维护一个List<Product>，表示一个顾客可以购买多个商品；在Product类中维护一个Customer类型的成员变量表示这个产品被哪个顾客所购买。

3、自关联

自关联在UML类图中用一个带有箭头且指向自身的线表示。上图的意思就是Node类包含类型为Node的成员变量，也就是“自己包含自己”。

public class Node {
    private Node subNode;
}
2）聚合关系

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

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

在 UML 类图中，聚合关系可以用带空心菱形的实线来表示，菱形指向整体。下图所示是大学和教师的关系图：

public class University {
    private List<Teacher> teas;

    public University(List<Teacher> teas) {
        for(Teacher teacher : teas) {
            teacher.teach();
        }
    }
}
3）组合关系

组合表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系。

在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在，部分对象不能脱离整体对象而存在。例如，头和嘴的关系，没有了头，嘴也就不存在了。

在 UML 类图中，组合关系用带实心菱形的实线来表示，菱形指向整体。下图所示是头和嘴的关系图：

public class Head {
    private Mouth mouth;

    public Head() {
        mouth = new Mouth();
    }
}
4）依赖关系

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

在 UML 类图中，依赖关系使用带箭头的虚线来表示，箭头从使用类指向被依赖的类。下图所示是司机和汽车的关系图，司机驾驶汽车：

public class Driver {
    private String name;

    public void drive(Car car) {
        car.move();
    }
}
5）继承/泛化关系

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

在 UML 类图中，泛化关系用带空心三角箭头的实线来表示，箭头从子类指向父类。在代码实现时，使用面向对象的继承机制来实现泛化关系。例如，Student 类和 Teacher 类都是 Person 类的子类，其类图如下图所示：

class Person {
    String name;
    int age;
    public void speak() {}
}
class Student extends Person {
    String stidentNo;
    public void study() {}
}
6）实现关系

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

在 UML 类图中，实现关系使用带空心三角箭头的虚线来表示，箭头从实现类指向接口。例如，汽车和船实现了交通工具，其类图如图 9 所示。

interface Vehicle {
    public void move();
}
class Car implement Vehicle {
    public void move() {}
}

七大原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础！(即：设计模式为什么这样设计的依据)

一、单一职责原则（各行其职，互不影响）

1、基本介绍

对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为 A1，A2。

2、应用实例

以交通工具案例讲解

1) 方案1
public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}

/**
 * 交通工具类
 * 违反了单一职责原则
 */
class Vehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
    }
}
2) 方案2
public class SingleResponsibility2 {
    public static void main(String[] args) {
        RoadVehicle vehicle1 = new RoadVehicle();
        vehicle1.run("汽车");
        AirVehicle vehicle2 = new AirVehicle();
        vehicle2.run("飞机");
    }
}

/**
 * 交通工具类
 * 遵循单一职责原则但是花销很大
 */
class RoadVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
    }
}
class AirVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "在天空上运行。。。");
    }
}
3) 方案3
public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.run1("汽车");
        vehicle.run2("飞机");
    }
}

/**
 * 交通工具类
 * 在类级别没有遵循单一职责原则，但在方法级别遵顼了单一职责原则
 */
class Vehicle2 {
    public void run1(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
    }
    public void run2(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
    }
}

3、注意事项和细节

  1. 降低类的复杂度，一个类只负责一项职责
  2. 提高类的可读性，可维护性
  3. 降低变更引起的风险
  4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

二、接口隔离原则（接口拆分）

1、基本介绍

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

2、应用实例

【例】安全门案例

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

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

代码如下：

public interface A {
    void antiTheft();
}
public interface B {
    void fireproof();
}
interface C {
    void waterproof();
}
public class HeiMaSafetyDoor implements A,B,C {
    public void antiTheft() {
        System.out.println("防盗");
    }
    public void fireproof() {
        System.out.println("防火");
    }
    public void waterproof() {
        System.out.println("防水");
    }
}
class ItcastSafetyDoor implements A,B {
    public void antiTheft() {
        System.out.println("防盗");
    }
    public void fireproof() {
        System.out.println("防火");
    }
}

三、依赖倒转(倒置)原则

1、基本介绍

  1. 高层模块不应该依赖低层模块，二者都应该依赖其抽象（可能是接口或者抽象类）
  2. 抽象不应该依赖细节，细节应该依赖抽象（高层既抽象类或者接口，底层既实现类）
  3. 依赖倒转(倒置)的中心思想是面向接口编程
  4. 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类
  5. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给实现类去完成

2、应用实例

【例】组装电脑

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

类图如下：

代码如下：

希捷硬盘类（XiJieHardDisk）:

public class XiJieHardDisk implements HardDisk {
    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据" + data);
    }
    public String get() {
        System.out.println("使用希捷希捷硬盘取数据");
        return "数据";
    }
}

Intel处理器（IntelCpu）：

public class IntelCpu implements Cpu {
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

金士顿内存条（KingstonMemory）：

public class KingstonMemory implements Memory {
    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

电脑（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 XiJieHardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(XiJieHardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void run() {
        System.out.println("计算机工作");
        cpu.run();
        memory.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);
    }
}

测试类（TestComputer）：

测试类用来组装电脑。

public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setHardDisk(new XiJieHardDisk());
        computer.setCpu(new IntelCpu());
        computer.setMemory(new KingstonMemory());
        computer.run();
    }
}

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

类图如下：

电脑（Computer）：

@Data
public class Computer {
    private HardDisk hardDisk;
    private Cpu cpu;
    private Memory memory;

    public void run() {
        System.out.println("计算机工作");
    }
}

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

四、里氏替换原则

1、基本介绍

里氏代换原则是面向对象设计的基本原则之一。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现。

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

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

2、应用实例

【例】正方形不是长方形。

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

代码如下：

长方形类（Rectangle）：

@Data
public class Rectangle {
    private double length;
    private double width;
}

正方形（Square）：

由于正方形的长和宽相同，所以在方法setLength和setWidth中，对长度和宽度都需要赋相同值。

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);
    }
}

类RectangleDemo是我们的软件系统中的一个组件，它有一个resize方法依赖基类Rectangle，resize方法是RectandleDemo类中的一个方法，用来实现宽度逐渐增长的效果。

public class RectangleDemo {

    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);
    }
}

我们运行一下这段代码就会发现，假如我们把一个普通长方形作为参数传入resize方法，就会看到长方形宽度逐渐增长的效果，当宽度大于长度，代码就会停止，这种行为的结果符合我们的预期；

假如我们再把一个正方形作为参数传入resize方法后，就会看到正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。

我们得出结论：在resize方法中，Rectangle类型的参数是不能被Square类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square类和Rectangle类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

如何改进呢？此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口(Quadrilateral)，让Rectangle类和Square类实现Quadrilateral接口

五、开闭原则

1、基本介绍

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类。

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

2、应用实例

【例】搜狗输入法 的皮肤设计。

分析：搜狗输入法 的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

public abstract class AbstractSkin {
    public abstract void display();
}

public class DefaultSkin extends AbstractSkin{
    public void display() {
        System.out.println("默认皮肤");
    }
}
public class HeiMaSkin extends AbstractSkin{
    public void display() {
        System.out.println("黑马皮肤");
    }
}
public class SouGouInput {
    private AbstractSkin skin;

    public void setSkin(AbstractSkin skin) {
        this.skin = skin;
    }

    public void display() {
        skin.display();
    }
}

class Test {
    public static void main(String[] args) {
        SouGouInput souGouInput = new SouGouInput();
//        DefaultSkin skin = new DefaultSkin();
        HeiMaSkin skin = new HeiMaSkin();
        souGouInput.setSkin(skin);
        souGouInput.display();
    }
}

六、迪米特法则

1、基本介绍

迪米特法则又叫最少知识原则。

只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

2、应用实例

【例】明星与经纪人的关系实例

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

类图如下：

代码如下：

明星类（Star）

@Data
public class Star {
    private String name;
}

粉丝类（Fans）

@Data
public class Fans {
    private String name;
}

媒体公司类（Company）

@Data
public class Company {
    private String name;
}

经纪人类（Agent）

@Data
public class Agent {
    private Star star;
    private Fans fans;
    private Company company;

    public void meeting() {
        System.out.println(fans.getName() + "与明星" + star.getName() + "见面了。");
    }

    public void business() {
        System.out.println(company.getName() + "与明星" + star.getName() + "洽淡业务。");
    }
}

七、合成复用原则

1、基本介绍

合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

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

继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

  1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
  2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
  3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

  1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
  2. 对象间的耦合度低。可以在类的成员位置声明抽象。
  3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

2、应用实例

【例】汽车分类管理程序

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

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

UML规范-类图
FF-ZERO
02-20 766
依赖表示一个类依赖于另一个类的情况，通常在一个类中使用了另一个类作为参数、返回类型或局部变量等。组合是聚合关系的一种特殊形式，其中一个类包含另一个类的实例，并且两者的生命周期相互依赖。继承表示类之间的父子关系，其中子类（派生类）继承了父类（基类）的属性和方法。聚合表示类之间的整体部分关系，其中一个类包含另一个类的实例。关联表示类之间的连接关系，用于描述类之间的关联关系。在软件设计的过程中，类和类，类和接口，属性和类之前的关系很重要，接下来重点分析一下关系的表达方式。属性是类的特征或状态，用于描述类的特性。
【设计模式一】七大原则、UML类图、设计模式分类
土味儿
07-25 1666
目录一、七大原则1、单一职责原则2、接口隔离原则3、依赖倒置原则4、里氏替换原则5、开闭原则6、迪米特原则7、合成复用原则8、核心思想二、UML类图1、基本介绍2、UML图3、UML类图4、继承和实现1)继承(Inheritance)2)实现(Realization)3)继承和实现的区别5、依赖、关联、聚合和组合1)依赖(Dependency)2)关联(Association)3)聚合(Aggr...
UML--类图规范
小小张自由—>张有博
05-14 2733
类图规范
UML之序列图的执行规范
最新发布
光头颜说IT
04-26 1040
本文介绍了UML中执行规范（Execution Specification）的概念、用法及其与激活状态的区别。文中通过多个示意图说明执行规范在同步消息、回调及复杂交互中的表现形式，并指出常见误解。最后，提供了实际建模建议，帮助读者准确表达系统行为语义，提升建模质量。
经典的设计模式——UML类图的一些规范
weixin_63967970的博客
06-05 1542
当一个类“知道”另一个类时，可以用关联关系表示，比如企鹅和气候就是这种关系，企鹅需要知道气候，在企鹅类里边可以定义气候。这个用的也还是比较多的。聚合表示弱拥有关系，体现的是A对象可以包含对象B，但B对象不是A对象的一部分。部分和整体的关系，强拥有关系。用实心菱形+实线来表示。这个一般在客户端实现那里使用，其余的地方没见过有用这个表示的。比如动物依赖于氧气和水的关系就是依赖关系。+号表示公有，-表示私有，#表示保护。我感觉这个依赖关系模模糊糊的。这个也用的稍微多一点点吧。这个用的还是比较多的。
UML类图绘制规则
weixin_44780781的博客
10-30 1569
在软件设计中，UML（统一建模语言）类图是一个核心工具，用于描述和展示系统中的类结构及其关系。类图不仅有助于开发者理解系统的组成和交互逻辑，也能够为未来的维护提供清晰的参考。本文将深入讲解UML类图的各项绘制规则，帮助你快速掌握类图绘制方法。了解和掌握UML类图的绘制规则，可以更直观地表达系统的类设计及关系。合理使用UML类图的可见性符号、属性和方法格式、关系连线以及多重性、角色名等细节，不仅有助于项目团队的沟通与协作，还能为系统的维护提供长远支持。
快速读懂UML类图绘制规范
琪琪的博客
04-10 8634
架构师或者项目经理可能经常需要绘制UML类图，但是很多人却绘制的很不规范，其实UML针对Java是有专业规范存在的，下面开始详解 一.类属性描述： 在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示，比如下图表示一个NoticeAction类，它包含notice和noticeService这2个属性，以及saveNotice()等方法。 ...
UML类图与面向对象设计七大原则详解：设计模式复习指南
2. 面向对象设计七大原则： - 开闭原则：强调系统应保持开放，易于扩展，避免修改已有的代码，以便在不影响其他部分的情况下添加新功能。 - 依赖倒转原则：高层模块不应依赖于低层模块，而是依赖于抽象接口，以...
UML类图与设计文档：利用类图创建清晰的设计文档
[UML类图与设计文档：利用类图创建清晰的设计文档](https://img-blog.csdnimg.cn/92c214a0c0c04873a1bdce24dcb6bfc0.png) # 1. UML类图基础** UML类图是一种用于可视化表示软件系统中类的结构和关系的图表。它提供...
面向对象设计原则探索：以UML类图优化为例
"这篇内容主要介绍了面向对象设计的七大原则，并通过具体的代码示例和UML类图进行了讲解。由郑州大学软件学院的赵哲老师主讲，涉及到的原理包括单一职责原则、开-闭原则、里氏代换原则等。在实际案例中，通过对Game...
Java设计模式-UML类图
Fatter$hday的博客
03-08 821
从这一专栏开始将学习设计模式，上课学习和自己总结归纳的笔记将总结出来供大家参考。
UML基础：类图
03-05
这是关于统一建模语言、即UML里采用的基本图的一系列文章的一部分。在我先前关于序列图的文章里，我把重点从UML1.4版，转移到OMG的采用UML2.0版草案规范（又称为UML2）。在这篇文章中，我将会讨论结构图，这是已经在UML2中提出的一种新图种类。由于本系列文章的目的是使人们了解记号元素及它们的含意，该文主要关注类图。你很快就会知道这样做的理由。随后的文章将会覆盖结构范畴中包含的其它图。我也想提醒读者，这一系列文章是关于UML记号元素的，所以这些文章并不意味着为建模的最好方式提供指导方针，或是该如何决定哪些内容应该首先被建模。相反的，该文及本系列文章的目的主要是帮助大家对于记号元素--语法
UML图绘制规则
weixin_41687820的博客
02-22 742
数据成员：visibility name：type= defaultValue 其中：Visibility是+（public）或-（private）或#（protect） Name是数据成员名； type是数据成员的数据类型； defaultValue是数据成员初始值。 **类操作：**visibility name (parameter-list)：return-type(property-st...
UML类图规则
wsb1321的专栏
04-09 7976
UML类之间的关系     UML类图中的关系分为四种：泛化、依赖、关联、实现，其中关联关系又可以细化为聚合和组合。 1. 泛化（Generalization）       泛化是父类和子类之间的关系，子类继承父类的所有结构和行为。在子类中可以增加新的结构和行为，也可以覆写父类的行为。 2. 依赖（Generalization）       依赖关系是一种使用关系，特定事
UML 类图介绍
热门推荐
跬步致远——Ai92
12-02 1万+
UML 类图介绍一、UML简介UML（Unified Modeling Language）即统一建模语言，是OMG（Object Management Group）发表的图标式软件设计语言。UML的功能：可视化：使用图表的形式来表现业务关系或者物理关系，可以促进对问题的理解和解决。说明：UML提供了一种通用的、精通的、没有歧义的通信机制进行。建造：UML通过自己的语法规则使得可以通过使用建模工具软
UML的类图规则
weixin_38441229的博客
08-08 1003
public:+号 private:-号 protected:#号 类图多重关系： 泛化关系： 概念：也就是继承关系。 表示方式：用带空心三角形的直线来表示。 例子：动物和猫，人和老师 关联关系： 概念：用于表示一类对象与另一类对象之间的联系。 子关系： 双向关联： 表示方式：一条直线 例子：客户和产品 单向关联： 表示方式：一条线加上一个箭头 例子：客户和例子 自关联： 表示方式：
UML类图基础与设计模式六大原则
weixin_44584422的博客
09-26 2349
值得收藏的设计模式启蒙文章
UML2的设计原则
shuyaji的专栏
06-01 1533
UML元模型的设计思想遵循以下原则： 模块化－应用强内聚、松耦合的原则来将建模的概念分组到多个包，并将功能特性组织到多个元类中。 分层－UML元模型应用了两种分层。首先，包的结构分离了元语言核心概念与使用它们的高层概念。第二，四层元模型的架构模式分离了跨越很多抽象层的关注点（尤其是有关实例的关注点）。 分区－分区用于组织相同层的概念范围。在Infrastructu
UML图规范
weixin_30608131的博客
05-09 396
1、子类与父类的继承关系用空心三角形+实线表示。 2、类实现接口用空心三角形+虚线表示。（实现关系） 3、类与类之间的关系用实线箭头表示。（关联关系） 关联关系还可细分为三类：单项关联（下图）、双向关联、自我关联。 4、接口的两种表示方式。 ① interface表示法 ②棒棒糖表示法 5、聚合关系 聚合表示一种弱的“拥有”关系，体现的是A对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值