类图总结

1，关联关系

在使用Java、C#和C++等编程语言实现关联关系时，通常将一个类的对象作为另一个类的成员变量

1. public class LoginForm {  
2. private JButton loginButton; //定义为成员变量  
3. ……  
4. }  
5.   
6. public class JButton {  
7.     ……  
8. }

1.1自关联

1. public class Node {  
2. private Node subNode;  
3. ……  
4. }  

1.2双向关联

1. public class Customer {  
2. private Product[] products;  
3. ……  
4. }  
5.   
6. public class Product {  
7. private Customer customer;  
8. ……  
9. } 

2，聚合关系

 聚合(Aggregation)关系表示整体与部分的关系。在聚合关系中，成员对象是整体对象的一部分，但是成员对象可以脱离整体对象独立存在
通常成员对象通常作为构造方法、Setter方法或业务方法的参数注入到整体对象中

1. public class Car {  
2.     private Engine engine;  
3.   
4.     //构造注入  
5.     public Car(Engine engine) {  
6.         this.engine = engine;  
7.     }  
8.       
9.     //设值注入  
10. public void setEngine(Engine engine) {  
11.     this.engine = engine;  
12. }  
13. ……  
14. }  
15.   
16. public class Engine {  
17.     ……  
18. }  

3，组合关系

组合(Composition)关系也表示类之间整体和部分的关系，但是在组合关系中整体对象可以控制成员对象的生命周期，一旦整体对象不存在，成员对象也将不存在，成员对象与整体对象之间具有同生共死的关系

通常在整体类的构造方法中直接实例化成员类

1. public class Head {  
2.     private Mouth mouth;  
3.   
4.     public Head() {  
5.         mouth = new Mouth(); //实例化成员类  
6.     }  
7. ……  
8. }  
9.   
10. public class Mouth {  
11.     ……  
12. }  

4，依赖关系

大多数情况下，依赖关系体现在某个类的方法使用另一个类的对象作为参数。

依赖关系通常通过三种方式来实现，第一种也是最常用的一种方式：将一个类的对象作为另一个类中方法的参数，第二种方式是在一个类的方法中将另一个类的对象作为其局部变量，第三种方式是在一个类的方法中调用另一个类的静态方法。

1. public class Driver {  
2.     public void drive(Car car) {  
3.         car.move();  
4.     }  
5.     ……  
6. }  
7.   
8. public class Car {  
9.     public void move() {  
10.         ......  
11.     }  
12.     ……  
13. } 

5，泛化关系

泛化(Generalization)关系也就是继承关系，用于描述父类与子类之间的关系

1. //父类  
2. public class Person {  
3. protected String name;  
4. protected int age;  
5.   
6. public void move() {  
7.         ……  
8. }  
9.   
10.     public void say() {  
11.     ……  
12.     }  
13. }  
14.   
15. //子类  
16. public class Student extends Person {  
17. private String studentNo;  
18.   
19. public void study() {  
20.     ……  
21.     }  
22. }  
23.   
24. //子类  
25. public class Teacher extends Person {  
26. private String teacherNo;  
27.   
28. public void teach() {  
29.     ……  
30.     }  
31. }  

6，实现关系

在UML中，类与接口之间的实现关系用带空心三角形的虚线来表示

1. public interface Vehicle {  
2. public void move();  
3. }  
4.   
5. public class Ship implements Vehicle {  
6. public void move() {  
7.     ……  
8.     }  
9. }  
10.   
11. public class Car implements Vehicle {  
12. public void move() {  
13.     ……  
14.     }  
15. }  

总结：

（1）各种关系的强弱顺序： 泛化 = 实现  >  组合  >  聚合  >  关联   >   依赖

（2）组合，聚合，关联都是   类的成员变量级别的，被引用的类是引用方的成员变量。       而依赖仅仅是在类的某个方法中持有对另一个对象的引用

（3）组合中 成员对象和整体对象具有同生共死的关系，   聚合中成员对象可以脱离整体对象独立存在，组合和聚合都是强的关联关系