UML Class Diagram III

2. Dependency relationship

A dependency (Dependency) Relationship is a usage relationship in which a change in a particular thing can affect other things that use the thing, and use dependencies when it is necessary to indicate that one thing is using another. in most cases, a dependency is embodied in a method of a class that uses an object from another class as a parameter. in UML, a dependency relationship is indicated by a dashed line with arrows, and the relying party points to the relying party. For example: The driver drives, the car type Object car is passed as a parameter in the drive () method of the driver class, so that the car's move () method can be called in the drive () method, and the driver () method relies on the car's Move () method, So the class driver dependency class car,1 shows:

Figure 1 Dependency Instance

In the system implementation phase, the dependencies are usually implemented in three ways, the first and most commonly used way is 1, the object of one class as the parameter of the method in another class , the second way is to use the object of another class as its local variable in the method of one class. The third way is to invoke the static method of another class in the method of one class . The corresponding Java code snippet in Figure 1 is as follows:

[Java]View PlainCopy

2. Public class Driver {
4. public void Drive (car car) {
6. Car.move ();
8. }
10. ......
12. }
16. Public class Car {
18. public void Move () {
20. ......
22. }
24. ......
26. }

3. Generalization relationship

a generalization (generalization) relationship is also an inheritance relationship that describes the relationship between a parent class and a subclass, which is also known as a base class or superclass, and a subclass is also known as a derived class. In UML, the generalization relation is represented by a straight line with a hollow triangle. when the code is implemented, we use an object-oriented inheritance mechanism to implement generalization relationships, such as using the extends keyword in the Java language, and using the colon ":" in c++/c#. For example: The student class and the teacher class are subclasses of the person class, and the student class and the teacher class inherit the properties and methods of the person class, the property of the person class contains the name (name), and the Age, Each of the student and teacher also has these two attributes, and the student class adds the attribute number (STUDENTNO), the teacher class adds the attribute teacher number (Teacherno), and the person class method includes the walk Move () and speak Say (), student class and teacher class inherit both methods, and student class is also new method study (), teacher class is also new method teach (). 2 is shown below:

Figure 2 Generalization Relationship Example

The corresponding Java code snippet in Figure 2 is as follows:

[Java]View PlainCopy

2. Parent class
4. Public class Person {
6. protected String name;
8. protected int age;
12. Public void Move () {
14. ......
16. }
20. public Void Say () {
22. ......
24. }
26. }
30. Sub-class
32. Public class Student extends person {
34. Private String Studentno;
38. Public Void Study () {
40. ......
42. }
44. }
48. Sub-class
50. Public class Teacher extends person {
52. Private String Teacherno;
56. Public Void Teach () {
58. ......
60. }
62. }

4. Interface and Implementation relationship

In many object-oriented languages have introduced the concept of interfaces, such as Java, C #, etc., in the interface, usually no attributes, and all operations are abstract, only the operation of the Declaration, there is no implementation of the operation. UML represents an interface in a manner similar to the representation of a class, as shown in 3:

Figure 3 UML diagram of the interface

Interfaces can also have inheritance relationships and dependencies similar to those between classes, but there is also an implementation (realization) relationship between the interface and the class, in which the class implements the interface, and the operations in the class implement the actions declared in the interface. in UML, the implementation relationship between a class and an interface is represented by a dashed line with a hollow triangle. For example: Defines a transport interface vehicle, which contains an abstract operation Move (), which implements the move () operation in both class ship and class car, but the specific implementation details will be different, as shown in 4:

Figure 4 Implementing a relationship instance

When implementing a relationship in a programmatic implementation, different object-oriented languages also provide different syntax, such as using the Implements keyword in the Java language, and using the colon ":" in c++/c#. The corresponding Java code snippet in Figure 4 is as follows:

[Java]View PlainCopy

2. Public interface Vehicle {
4. Public void Move ();
6. }
10. Public class ship implements Vehicle {
12. Public void Move () {
14. ......
16. }
18. }
22. Public class Car implements Vehicle {
24. Public void Move () {
26. ......
28. }
30. }

UML Class Diagram III