The relationship and representation between classes in UML class diagram (Class Diagram)

There are five types of relationships between classes:

 

1. Dependency

One-way , which means that a class depends on the definition of another class, and changes in one class will affect the other class, which is a " use a " relationship

If A depends on B, then B behaves as A's local variables, method parameters, static method calls, etc.

[java]  view plain copy  

 

1. publicclass Person {   
2.     publicvoid doSomething(){   
3.         Card card =  new  Card(); //local variable  
4.         ....  
5.     }  
6. }  

[java]  view plain copy  

 

1. publicclass Person {   
2.     public void  doSomething(Card card){ //Method parameters   
3.         ....  
4.     }  
5. }  

[java]  view plain copy  

 

1. publicclass Person {   
2.     publicvoid doSomething(){   
3.         int  id = Card.getId(); // static method call  
4.         ...  
5.     }  
6. }  

 

2. Association

One-way or two-way (usually we need to avoid using two-way association relationship), is a " has a " relationship, if A is unidirectionally related to B, then it can be said that A has a B, usually expressed as a global variable

[java]  view plain copy  

 

1. publicclass Person {   
2.     public Phone phone;  
3.       
4.     publicvoid setPhone(Phone phone){         
5.         this.phone = phone;  
6.     }  
7.       
8.     public Phone getPhone(){          
9.         return phone;  
10.     }  
11. }  

 

3. Aggregation

One-way, a type of association relationship, the difference between the association relationship is semantic, the two objects associated are usually equal, and the aggregation is generally unequal, there is a sense of the whole and the part, and there is little difference in implementation

Class is composed of Student, its life cycle is different, the whole does not exist, part still exists , the current Team is disbanded, the people are still there, you can also join other groups

[java]  view plain copy  

 

1. publicclass Team {   
2.     public Person person;  
3.       
4.     public Team(Person person){  
5.         this.person = person;  
6.     }  
7. }  

 

4. Composition

One-way, is a special aggregation relationship with strong dependencies

Head, Body, Arm and Leg are combined into People, and their life cycle is the same. If the whole does not exist, the parts will also die.

[java]  view plain copy  

 

1. publicclass Person {   
2.     public Head head;  
3.     public Body body;  
4.     public Arm arm;  
5.     public Leg leg;  
6.       
7.     public Person(){  
8.         head = new Head();  
9.         body = new Body();  
10.         arm = new Arm();  
11.         leg = new Leg();  
12.     }  
13. }  

 

5. Inheritance

A class implements an interface, a class inherits an abstract class, and a class inherits from a parent class belongs to this relationship

It can be divided into finer points:

Realization: A class implementing an interface belongs to this relationship

Generalization: the " is a " relationship, the class inherits the abstract class, and the class inherits the parent class belongs to this relationship