时序图：

是什么

它通过描述对象之间发送消息的时间顺序显示多个对象之间的动态协作。
时序图是一个二维图，横轴表示对象，纵轴表示时间，消息在各对象之间横向传递，依照时间顺序纵向排列。

作用是什么

1、展示对象之间交互的顺序。将交互行为建模为消息传递，通过描述消息是如何在对象间发送和接收的来动态展示对象之间的交互；

2、相对于其他UML图，时序图更强调交互的时间顺序；

3、可以直观的描述并发进程。

组成有哪些

角色（Actors）
对象（Object）
生命线（Lifetime）
消息（Message）
激活（Focus of Control）
组合片段

角色：

通常指“人”，也可以是组织、机器、系统等等“抽象的人”，和用例图一样，用小人图表示

对象：

就是与上述“人”对应的“物”了，包括所有产品、服务、设备等等抽象的物体

3f8460b934e547c899290cab3aff54e3

生命线：

在时序图中表示为从对象图标向下延伸的一条虚线，表示对象存在的时间。
f55c8844d8944bb0a026ae417ceafaab

消息：

消息一般分为

同步消息（Synchronous Message）
异步消息（Asynchronous Message）
返回消息（Return Message）
自关联消息：表示方法的自身调用或者一个对象内的一个方法调用另外一个方法。

消息的发送者把控制传递给消息的接收者，然后停止活动，等待消息的接收者放弃或者返回控制。用来表示同步的意义；

消息发送者通过消息把信号传递给消息的接收者，然后继续自己的活动，不等待接受者返回消息或者控制。异步消息的接收者和发送者是并发工作的；

返回消息表示从过程调用返回。

激活：

激活用一个细长的矩阵框（在生命线上）表示。 8f4c388f9ba4466ea69886a4b444ca4f

组合片段：

组合片段用来解决交互执行的条件和方式，它允许在序列图中直接表示逻辑组件，用于通过指定条件或子进程的应用区域，为任何生命线的任何部分定义特殊条件和子进程。组合片段共有13种，名称及含义如下： 06090867c298444fa34cfad1434d5650
举例：
（1）抉择(Alt）
ebe34737aef740208f6bd1df219d6a7d

（2）循环（Loop）

片段重复一定次数，可以在临界中指示片段重复的条件。

fc1234a4010644ceb88e30f7a6fae98c

（3）并行（Par）

aa1ab5cd8406452995c7d5d0b10063e9

类图

类图属于UML中的静态视图，主要用来分析业务概念，描述静态场景；动态视图描述业务行为，分析动态场景。
25e473b28a154b118a22057f7e9ba2eb

是什么

类图（Class Diagrame）是描述类、接口、协作以及它们之间关系的图，用来显示系统中各个类的静态结构。

类图包含7个元素：类、接口、协作、依赖关系、泛化关系、实现关系以及关联关系。

作用是什么

对系统的词汇建模（建立抽象系统词汇，如班级、学生）；
对简单协作建模（将系统词汇中是事物协同工作的方式可视化和详述，如班级和学生的关系表示）；
对逻辑数据库模式建模

组成有哪些

在类图中，类用矩形来表示，分为3个部分：名称部分（Name）、属性部分（Attribute）和方法部分（Operation）。
8e764ef7f0644bcf91845c36b7d05617
例如定义一个Student类：

class student //定义学生类
    {
        public string name;
        private int englishScore;
        private int mathScore;
        private int computerScore;
        public int sumScore;

       public student(string x, int y, int  z, int k)
        {
            name = x;
            englishScore = y;
            mathScore = z;
            computerScore =k;
        }

        public void sum()
        {
            sumScore = englishScore + mathScore + computerScore;
        }
    }

对应的类图：
23a52e2728fb46af844c1396b5854056
关系

依赖（Dependency）关系
泛化（Generalization）关系
关联（Association）关系
聚合（Aggregation）关系
实现（Realization）关系

（1）依赖（Dependency）关系

依赖表示一个类以某种形式依赖于其他类。当两个类处于依赖关系中时，其中一个类的改变可能会影响另一个类。
符号：虚线箭头
ce3b4045579d4849987e48be039b3c21
依赖关系在代码中的表现
在程序代码中，依赖关系意味着一个类的对象出现在另一个类的操作中。常见的有两种情况：一个类将另一个类的对象作为自己某个操作的参数（形参），或者是操作的局部变量。

程序演示：
train类：

1  class train
 2     {
 3         public string number;
 4 
 5         public train(string num)
 6         {
 7             number = num;
 8         }
 9 
10         public void run()
11         {
12             Console.WriteLine("列车启动……列车到站");
13         }
14     }

person类：

1  class person
 2     {
 3         public string name;
 4         public person(string name)
 5         {
 6             this.name=name;
 7         }
 8         public void GoToBeijing(train mytrain)  //从河南到北京
 9         {
10             Console.Write(name+"去北京乘坐{0}列车：",mytrain.number);
11             mytrain.run();
12         }
13         public void GoToHenan()   //从北京到河南
14         {
15             train mytrain = new train("1488"); 
16             Console.Write(name + “去河南乘坐{0}列车：", mytrain.number);
17             mytrain.run();
18         }
19     }

主程序：

1  class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             person person1 = new person("张三");
 6             person person2 = new person("李四");
 7 
 8             train train1 = new train("1487次"); //河南到北京
 9         train train2 = new train(“1488次”); //河南到北京
10         person1.GoToBeijing(train1);
11             person2.GoToBeijing(train2);
12             person1.GoToHenan();
13             person2.GoToHenan();
14         }
15     }

Program

对应的类图：
e73d0bbd6ea7401593f8e880780db1f6
依赖关系与关联关系的区别
1、符号和在代码中的区别加粗样式
2、语义上的区别

  当一个类的实例与另一个类的一些特定实例存在固定的对应关系时，这两个类之间为关联关系。

  只要一个类用到另一个类，但是和另一个类的关系不是太明显的时候（可以说是用到了那个类），就可以把这种关系看成是依赖，依赖也可以说是一种偶然的关系。

  比如上面的人和火车的关系：在某个方法中偶然用到了它，但在现实中我和它并没多大关系。

总结
依赖关系还是比较好理解的，注意和关联关系的区别及符号的表示方式不同，一个用虚箭头，一个用实箭头。

（2）泛化（Generalization）关系（相当于继承）

表示一种存在于一般元素和特殊元素之间的分级关系，描述了“is a kind of”（是……的一种）的关系，如汽车是交通工具的一种。在类中一般元素称为超类或父类，特殊元素称为子类。
举例:

9c0bb454a81d418cb248516078143a03

fd28dda99d6e46b5af9db3239870640f
箭头要指向父类
泛化关系的应用——多态
多态性：在泛化关系中，父类所定义的操作被子类继承之后，可以表现出不同的行为。

   多态性允许在（有继承关系的）多个类中定义同名的操作，并在每一个类中有不同的实现。

c#中的多态机制：

   父类中：可见性 virual返回值类型 方法名（参数）

   子类中：可见性 override 返回值类型 方法吗（参数）

多态的实现机制

子类覆盖父类同名的方法。

当一个类被继承时，他的方法也就被其子类继承。这种继承可以是无条件的继承全部旧方法，也可以重新编写新方法来覆盖旧方法。

多态就是指不同对象收到相同消息时，会产生不同行为，同一个类在不同的场合下表现出不同的行为特征

多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

（3）关联（Association）关系

关联用来表示两个或多个类的对象之间的结构关系，它在代码中表现为一个类以属性的形式包含对另一个类的一个或多个对象的应用。

person类：

1 class person
 2     {
 3         public string name;
 4         public person(string eName)
 5         {
 6             name = eName;
 7         }
 8         public void startWork()
 9         {
10             Console.WriteLine("员工{0}开始工作",name);
11         }
12     }

company类：

1 class company
 2     {
 3         public string name;     //公司名称
 4       public person[ ] employee = new person[3]; 
 5      
 6         public company(string cName)  //构造函数
 7         {
 8             name = cName;
 9         }
10 
11         public void run()
12         {
13             Console.WriteLine("公司“{0}”开始运作",name);
14             employee[0].startWork();
15             employee[1].startWork();
16             employee[2].startWork();
17         }
18 
19         public void stop()
20         {
21             Console.WriteLine("公司“{0}”停止运作", name);
22         }    
23  }

Program类：

1  class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             company c = new company("北京能力有限公司");
 6             c.employee[0] = new person("张三");
 7             c.employee[1] = new person("李四");
 8             c.employee[2] = new person("王二");
 9             c.run();
10             c.stop();
11             Console.Read();
12         }
13     }

对应的类图：
68e4b0808e084755aeeb0fdec8ebc386
双向关联：简而言之就是你中有我，我中有你
d7434d0cf273461d9cba986688b6dd9f
双向关联关系对应的代码：

public class A
{
      private B b;
}

public class B
{
      private A a;
}

关联的多重性
多重性是指有多少个对象参与了关联。具体的说，是指类A的一个对象对应类B的对象的个数。
举例：
69678679c39045f19b790f8131ab43dc

public class 狗
{
  private 腿[] X = new 腿[4];
}

public class 腿
{
  ……
}

多重性有哪些表示？

1: 表示1个
0..：表示任意多个（ ≥0）（可以换成n）

*：表示任意多个（ ≥0）

1..*：表示1个或多个（≥1）
0..1：表示0个或1个
5..11：表示5-11个
1，3，8：表示个1或3个或8个
0，3..8：表示0个或3-8个

（4）聚合（Aggregation）关系

是一种特殊形式的关联关系。表示整体与部分关系的关联，聚合意味着一个类拥有但共享另一个类的对象。简单来说，就是关联关系中的一组元素组成了一个更大、更复杂的单元。描述了“has a”的关系。如大学和学院，大学是由很多个学院组成的，因此两者之间是聚合关系。
001a96562d29428296f118e6f21111f6
cpu类：

class cpu
    {
        public string name; //品牌
        public string rate; //主频

        public cpu(string cpuName,string cpuRate)
        {
            name = cpuName;
            rate = cpuRate;
        }
    }

computer类

class computer
    {
        public string buyTime;
        public string color;
        public cpu mycpu;

        public computer(string computerBuyTime,string computerColor)
        {
            buyTime = computerBuyTime;
            color = computerColor;
        }
        public void cpuInfo()
        {
            Console.WriteLine("该电脑的CPU品牌为：{0}",mycpu.name);
            Console.WriteLine("该电脑的CPU主频为：{0}", mycpu.rate);
        }
    }

Program类（主类）

class Program
    {
        static void Main(string[ ] args)
        {
            cpu cpuA = new cpu("Intel","2.93");
            cpu cpuB = new cpu("AMD","2.61");

            computer computerC = new computer("2008-9-1","黑色");
            Console.WriteLine("购买时间为：{0}", computerC.buyTime);
            Console.WriteLine("颜色为：{0}\n", computerC.color);

            Console.WriteLine("现在安装第一块CPU");
            computerC.mycpu = cpuA;  //将cpuA装入该电脑中
            computerC.cpuInfo();

            Console.WriteLine("\n现在安装第二块CPU");
            computerC.mycpu = cpuB;  //将cpuA装入该电脑中
            computerC.cpuInfo();
        }
    }

电脑“拥有”cpu
聚合的符号：在整体类端加空心菱形
dda016599d214015a7cc95044ef1a376
当整体类不存在时，不分类仍可能存在。部分类销毁时，整体类也将能够存在。

  关联关系和聚合关系在语法上是没办法区分的，得从语义上才能更好的区分两者的区别。

组合

  组合的概念：组成是一种特殊形式的聚合。

  与聚合相比，它有两个特点：

一个部分类最多只能属于一个整体类
当整体类不存在时，部分类将同时被销毁。
最容易理解的一个例子就是窗体和文本框，当窗体不存在时，文本框也将不存在
7595dd8aec7a40ffbdb03e976e27a93e
组合的符号：

  在整体类端加实心菱形。如图：

9a818636d49e4745a2100b6de4481b58
关联与聚合（包括组合）的区别
关联关系所涉及的两个类是处于同一个层次上的。比如学生和课程就是一种关联关系，而不是聚合关系，因为学生不是有课程组成的。

   聚合关系涉及的两个类处于不平等的层次上，一个代表整体，一个代表部分。比如电脑和显示器、键盘、主板、内存就是聚合关系，因为主板是电脑的组成部分。而键盘等部件不会因为电脑没了，就不存在了。

聚合与组合的区别：

  组合：整体类端的重数必须是1，部分类的重数是任意的。

  聚合：整体类端的重数可以大于1，部分类的重数是任意的。

（5）实现（Realization）关系

接口的概念:
接口是一组没有实现的操作的集合。接口只提供操作的声明，不提供任何相应的功能代码。具体的功能代码由使用该接口的类实现，这叫做实现关系。

   一般意义的操作：

1  public void turnUp()
2   {
3        Console.WriteLine("{0}风扇加速转动",name);
4   }

  没有实现的操作：

1	1 public void turnUp();

c#中定义接口的方法

  [可见性] interface 接口名｛[返回值类型] 方法名([参数]);｝

接口中只能包含方法、属性、索引器和事件的声明，没有字段和构造函数。
接口中的操作都被视为公有的，不需要添加可见性。
接口中只能提供方法的格式声明，而不能包含方法的实现，所以接口方法的声明总是以分号结束。

时序图：

是什么

作用是什么

组成有哪些

角色：

对象：

生命线：

消息：

激活：

组合片段：

类图

是什么

作用是什么

组成有哪些

（1） 依赖（Dependency）关系

（2） 泛化（Generalization）关系（相当于继承）

（3） 关联（Association）关系

（4） 聚合（Aggregation）关系

（5） 实现（Realization）关系

（1）依赖（Dependency）关系

（2）泛化（Generalization）关系（相当于继承）

（3）关联（Association）关系

（4）聚合（Aggregation）关系

（5）实现（Realization）关系