Uml basics (ultimate summary)

ArticleDirectory

• 1.1.1. Things in UML)
• 1.1.2. relationgships)
• 1.1.3. diagrams)
• 1.3.1. Specifications
• 1.3.2. Modifier
• 1.3.3. General Division
• 1.3.4. Extension Mechanism

1.1. Building Blocks)

Things are the abstraction of the most representative components in the model. links are the combination of things. graphs aggregate related things.

1.1.1. Things in UML)

Some basic graphical symbols that constitute the model diagram. They represent some basic object-oriented concepts.

1.1.1.1. Structure

1. Class: class refers to the description of a group of objects with the same attributes, methods, relationships, and semantics. A class implements one or more interfaces.

2. Interface: an interface describes a service operation set of a class or component. An interface only defines a set of Operation Specifications and does not provide the specific implementation of these operations.

3. collaboration: A collaboration defines an interaction, which is a group of roles and other elements that work together to provide a collaboration, these cooperative behaviors are greater than the sum of the actions of all elements. Therefore, all structures, actions, and dimensions of collaboration are collaborated. A given class can participate in several collaboration activities.

4. Use Case: A Use Case describes a set of action sequences. executing these actions by the system produces valuable and observed results for specific actors.

5. activeclass: an active class has at least one process or thread, so it can start control activities.

6. Component: a component is a physical and replaceable component in the system. It follows and provides the implementation of a set of interfaces.

7. node: A node is a physical element that exists during running. It represents a computing resource and usually has at least some memory processing capabilities. A component set can reside in one node or be migrated from one node to another.

1.1.1.2. Action

Action is a dynamic part of the UML model. They are the verbs in the model and describe the actions that span time and space. There are two main types of behavior things

1. Interaction: interaction is an action that consists of a group of objects that complete a specific task in a specific context and exchange messages. The behavior of an object group or the behavior of a single operation can be described by one interaction.

Interaction involves other elements, including messages, action sequences (actions caused by a message), and links (connections between objects)

2. state Machine (statemachine): A state machine describes a sequence of states that an object or an interaction experiences in responding to an event within its lifecycle, the behavior of collaboration between a single class or a group of classes can be described by the state machine. A state machine involves some other elements, including State Transition (from one State to another) events (sending converted things) and activities (responding to a conversion)

1.1.1.3. group things

Grouping is part of the UML model.

1. Package: A package organizes elements into groups.

A package is the only organizational mechanism in UML.

The package can have other elements, such as classes, interfaces, components, nodes, collaboration, use cases, and diagrams, or even other packages.

A package forms a namespace. In a package, the names of the same element must be unique. elements in different packages can have the same name.

1.1.1.4. Comments

Annotation is the interpretation part of the UML model. These annotation things are used to describe, describe, and annotate any element of the model. There is a major annotation thing called annotation.

1. annotation (Note): annotation is a simple symbol that is attached to an element or a group of elements to constrain or explain it.

1.1.2. relationgships)

Represents the relationship between symbols in the basic graph.

1. Association: Describes the structural relationships between two or more classes. Draw an association relationship as a solid line with arrows on the graph.

2. dependency: dependency is the semantic relationship between two things. Changes in one thing (independent things) will affect the semantics of the other thing (dependent things, draw dependency into a dotted line that may have a direction

3. generalization: generalization is a special/general relationship. Objects of special elements (child elements) can replace objects of general elements (parent elements). In this way, the child element shares the structure and behavior of the parent element. In the graph, the generalized relationship is drawn into a solid line with a hollow arrow pointing to the parent element.

4. implementation: Implementation is the semantic relationship between class elements. One Class element specifies the contract that is executed by another class element to use the implementation relationship in two places: one is between interfaces and the classes or components that implement them, and the other is between use cases and collaboration that implement them. Draw an implementation relationship as a dotted line with a hollow arrow on the graph.

1.1.3. diagrams)

Abstract description of the system from a specific perspective

1. use case diagram (Use Case Diagrams): used to describe the user's needs, describe the system's functions from the user's perspective, and point out the executors of each function, emphasizing who is using the system, what functions does the system perform for the performer?

2. Class Diagrams: used to define the class in the system, including describing the internal structure of the class and the relationship between the class. The class diagram is mainly used to describe the static structure of the system.

3. object diagrams: an object graph is an instance of a class graph. It describes the objects contained in the system at specific time points and the relationships between objects.

4. statechart diagrams: used to describe all the states of class objects and transfer conditions of States when an event occurs.

5. Activity Diagrams: used to describe the activities to be performed and the constraints of the activity time to meet the requirements of the use case. Using activity diagrams is conducive to identifying the parallel activities of the system.

6. Sequence Diagram (sequence diagrams): Describes the interaction sequence between objects, focuses on the time sequence of message transmission between objects, and also displays the interaction process between objects.

7. Collaboration diagram (collaboration diagrams): Describes the relationships between objects, and focuses more on the objects with messages transmitted between them.

Sequence Diagrams and cooperative diagrams can be converted to each other

8. Component diagram (Component diagrams): used to describeCodePhysical Structure of components and dependencies between components. A component can be a resource file, a binary file, or an executable file.

9. Deployment diagram (deployment diagrams): defines the physical architecture of the system hardware to describe the actual physical devices and their connection relationships.

Static diagram: class diagram, object diagram; behavior diagram: status diagram, activity diagram, InterAction diagram (sequence diagram, collaboration diagram); Implementation diagram: component diagram, deployment Diagram

1.2. UML rules

1. Name: Name a thing, link, and graph.

2. Scope: give a name a specific context

3. Visibility: How to make others use or see the name

4. Integrity: how do things interact correctly and consistently

5. Execution: what is the meaning of running or simulating a dynamic model?

1.3. Common mechanism 1.3.1 in UML. Specification Description

The Specification Description provides a text description of the syntax and semantics of the constructed block,

The system is visualized to describe the details of the system.

A semantic bottom plane is provided, which contains all the parts of various models of a system, and each part is connected and consistent. Therefore, a UML diagram is just a simple visual projection of the bottom plane, each figure shows a specific aspect of the system.

1.3.2. Modifier

Each element in UML notation has a basic symbol. You can add various modifier details to this symbol.

1.3.3. General Division

Class/object dichotomy: A class is an abstraction; an object is a concrete form of this abstraction. Almost every construction block at the top of the UML has a division like class/object, such as use cases and use case instances (scenarios), component and component instances, nodes and node instances.

Interface/implementation bipartite: an interface declares a contract, and the implementation represents the specific implementation of the contract, which is responsible for implementing the complete semantics of the interface truthfully. Almost every UML constructor has a division like interface/implementation.

1.3.4. Extension Mechanism

Extends the UML graphical symbols, including the construction type stereotype, taggedvalue, and constraints constraint.