1. Abstract (abstraction) abstraction is a class, use case, signal, other types, or other generic elements that cannot be directly instantiated, which can also be used to describe the operations that are not implemented. Antonym: concrete. See Abstract Operation, Generalizable Element. Semantic abstraction classes are unformetled classes, that is, it can be unable to instance, which may be because it is incomplete (such as lack of one or more ways), may be because even it's description It is complete that it does not want to be instantiated. The abstract class is for later explanation. Abstract classes must have a descending of examples to use, and an abstract leaf is useless (it can appear as the leaves in the frame, but eventually it must be illustrated). The specific class can have no abstract operation (otherwise, it is abstract), but the abstract class can have a specific operation. The specific operation is actions that can be implemented once and in all subclasses. In their implementation, specific operations can only use the features (attributes and operations) that declare their classes. One of the inheritance purposes will be decomposed in an abstract superclass such that they can be shared by all subclasses. A specific operation can be polymorphic, the method in the procedural class is preferred in it, but it can also be a leaf operation. A class that all operations is implemented can be abstract, but this must be explicitly declared. A class with one or more unrealized operations is naturally abstract. The same semantics are also suitable for use in use. Abstract use cases define a piece of behavior, this behavior does not appear, but it can appear in the definition of specific use cases by generalization, including or extending relationships. The model becomes smaller and easy to understand by decomposing the common behavior in abstract use cases. Similar relationships also exist in other types and genremal elements. The name of the expression or abstract operation is represented by a bevel word. Keyword Abstract can be placed in a list of tables below or later, such as Account {Abstract}. See Class Name. Example Figure 13-1 shows an abstract class Account, which has an abstract operation ComputeInterest and a specific operation deposite. Two specific subclasses have been declared. Because subclasses are specific, they must implement COMPUTEINTEREST. Attributes are always specific. Figure 13-1 Abstract and concrete class discussion will be an abstract or concrete, and the difference is not as clear and substantially like it appears for the first time. It is more like the design results of the model rather than inheritance. During the development of the design, the state of the class may change. If the subclass of the possibilities will be added to the specific class, then this specific class can build abstraction. If the difference between the subclass is considered unnecessary and deleted, or these differences are denoted by different subclasses, then this abstraction class can be built into specific. One of the ways to simplify the decision is to adopt the following design guidelines: All non-leafs must be abstract (except for some abstract leaves described later, all leaves must be specific). This is not the rule of UML, which can be used or not used, the reason for designing this "abstract superclass" rule is a hyperclass inherited approach and the specific class method often has different needs, this Demand cannot be greatly implemented by a single method. The method in the superclass is forced to do two things: Define the common examples of observed by all desirations and implementational examples for specific classes. But these two goals often have conflicts. Instead, an non-abstract superclass can be mechanically separated into an abstract superclass and a specific leaf class. Abstract superclars include methods inherited by all subclasses; specific subclasses contain all specific method of instantiated classes. There is also a complete difference between the variables or parameters to maintain a particular particular type of variables or parameters to maintain a super-class variable or parameter in the abstract superclad rules.
Figure 13-2 The specific superclass generated fuzzy in Figure 13-2, considering the declaration of the class Letter, it does not follow abstract superclass rules. This class has a getNextSentence operation, which returns the next text of the sentence that has not been read, and the resetcursor operation, it starts at the beginning of the mouse. Sub-class Encryptedletter represents the letters already encrypted. Operation GetNextSentenceUse Reserved is overloaded because it must be decrypted before it is returned. The implementation of the operation is completely different. Because letter is a specific superclass, it is impossible (non-overload). Ordinary Letter or Encryptedletter subclass. Abstract superclass methods are used to distinguish abstract class Letter (which may be encrypted letters, or unprinted letters) and join class NonenCrypedletter to indicate specific examples, as shown in Figure 13-3. In this example, GetNextSentence is an abstract operation implemented by each subclass, and ResetCursor is the same as the same specific operation in all subclasses. This model is symmetrical. If you follow an abstract class rule, the abstract class declaration can automatically determine from the class level, and it is also redundant in the figure. Declare an abstract leaf usually useless, but there is an exception: as a universal namespace of a set of global scope properties and operations can be declared. This situation is small, most of which is used to process the non-proportional object language programming, it is recommended that users do not use it in most cases. The global value violates the spirit of object-oriented design by reference global dependencies. Single Example Categories can provide the same function in a more expanded manner (see [Gamma-95]). Figure 13-3 Abstract superclass avoids ambiguity 2. Abstract Class abstract class may not be instantiated classes. See Abstract. Semantic abstract classes may have no direct instance, there may be indirect instances (through its specific progeny). See discussion of Abstract. 3. Abstract Operation Abstract operation lacks implementation, that is, it only has an explanation without a method. Implementation must be supplemented by specific descendants. See Abstract, Generalizable, Inheritance, Polymorphic. Semantics If an operation is declared in the class as abstract, then the operation lacks the implementation in the class, and the class itself must be abstract. The implementation of the operation must be satisfied by the specific procedural future generation. If the class inherits an operation, it is abstract, then the abstract declaration is invalid to make the method inherited in the class. If an operation is declared in the class, it is specific, then the class must meet or inherit the implementation obtained from the ancestors, this implementation may be a method or calling an event. If the operation is not declared in the class, the class inherits the operational statement and implementation you get from its ancestors. Operation can be implemented as a method or by the state machine triggered by the calling event. Each class can declare its own method, the operation calling event or inherits the definition of the ancestors. The name of the presentation method is indicated by a bevel word, as shown in Figures 13-4, and the keyword Abstract can be placed in the characteristic table after the operation feature label. Figure 13-4 The maximum use of the inheritance concept is to support abstract operations that can be distinguished from each particular descendent. Abstract Operation allows caller to use operations without knowing which objects of the object (assuming the target object supports this operation by an indirect instance as an abstract class, and this abstract class has an abstract operation declaration). The importance of this polymorphic operation is that the responsibility of the determining the type of object is converted from the caller to the inheritance mechanism. Not only the caller does not have trouble and expenses that write examples, and the caller does not have to care about which subclass of the abstract class will exist. This means that additional subclasses will be added together with new operations. Therefore, abstract operation, polymorphism, and inheritance do not have to change the Capo behavior code, promote the upgrade of the system by joining new objects and behavior.
This greatly reduces the time of system upgrades, more importantly, it reduces the possibility of accidental uncoordinated. 4. Abstract (abstraction) Abstraction is a behavior that confirms an essential characteristics of a thing, which is separated from this matter from all other things. Abstract involves finding their commonality by observing the essential public characteristics of several things. Abstractions often involve views and purposes of the observers; different purposes lead to different abstractions of the same thing. The modeling process used involves abstraction, usually with different levels of different purposes. Abstract is a dependency that links two elements of the same concept at different levels. See derived, realize, refine, and track. Semantic abstract dependencies are the relationship between two elements on different abstractions, such as in different models, different accuracy, different specificity or different optimization layers. Typically, two descriptions will not be used simultaneously. Normally, an element is more detailed than another, and the customer element is more detailed than the provider element. If it is not clear which element is more detailed, then two elements can build a customer. The structure of abstract dependencies is a tracking (keyword trace), refining (keyword refine), implementing (keyword realize) and export (keyword Derive). Expression Abstract Dependencies are expressed as arrows from customer elements to the provider elements, and with keyword "trace", "refine" or "derive". Implementation of dependencies have its own special representation symbols, indicating that the dotted arrow with a closed triangle is formed to the provider element. The mapping between the elements can be attached as a constraint. Standard Elements Derive, REFINE, TRACE. 5. Access Access is a licensing dependency that allows a packet to reference the elements in another package. See Friend, Import, Visibility. Semantic a package (Customer) If you want to reference the elements within another package (provider), it must introduce a package that includes the "Access" or "Import" dependencies of the client package to the provider package. A package can impose access to the access to the package introduced by any package containing the package (ie, the nested package can see everything that contains the package can be seen). The elements in the package can access all visible elements in the package. The visibility rules can be summarized as follows: * The elements defined in a package are visible in the same package. * If an element is visible in a package, it is visible to all the packages in this package. * If a package access or introduces another package, it is visible to the introduction package in the package to be introduced or accessed. * If a package is another package of children, all elements that are defined in the parent package as public or protected visibility is visible. * Access or introduce dependencies cannot be passed, if a can see B, and B can see C, this does not mean that A can see C. Conclusion: Unless a package can access its nested bag and the content of the nesting package is public visible, this package cannot see its own nesting package. Below is a more step-by-step rule on visibility: * If a class content, such as its attributes and operations, and nested classes, they have public visibility in the class dollars, and they are visible in the package. Please note that unlaminated content of a subsystem is guided by the package rules mentioned above, but the attribute or operation of any subsystem itself is guided by this rule. * If a category has public or protected visibility, they are visible to future generations. * All content of a class element is visible to the elements of the class, including the element of the class or elements in the state machine. Under normal circumstances, it will involve elements in the equal bag. In this case, one element can see all the elements in its own pack and all elements with the public visibility of the package introduced by it. A class can see public characteristics in other classes. A class can also see its protected feature of its ancestors. The representation of the redeementation relationship is represented by a virtual arrow from the client package to the provider package.
Arrow with keyword "access" as a label. Discussions Figure 13-5 is an example of a peer-to-peer access between two packages. Pack P can access package Q, but package Q cannot access package P. The class K and L in the p package can see the class m in the package Q, but they can't see private category N. In addition to class K with public visibility, class M and N can not see any class in the package P, because the package Q cannot access the package P. To think about a class, it is visible to the peer package, this class must have public visibility, and its package must be accessed or introduced by a peer. Figure 13-5 Peer Access Figure 13-6 Access Rules Figure 13-6 is a more complex example relating to visibility and access declarations. The symbol before the element name represents its visibility: represents the public, the # representative is protected (visible to future generations), - the representative is private (not visible to the outside world). Class A can see C and E since they are included in the package Y and X. Class C and A can see D because the package y introduces a package Z. Class A nested in the package y and can see everything you can see. Class A, C and E can see B because they are nested in the package X, and X introduced into the package V containing B, but they can not see f, because f is privacy visibility in its package V . So, class f is not seen outside the package V. Class E does not see D because D is in the package z, and Z is not packet X access. Class C and E have not seen A. Class A is in the package U, u is not accessed by any package. Class B and F can see class D and E, D and E are built in the included package. They can also see C, C in the package y, and the package y is included in the package access. Although F is private, this does not affect it to see other classes, while other classes can't see F. Class B and F can be seen from each other because they are in the same package. The class f on the outside package is private, but the class in its own bag is not the case. 6. Action Action is an active atomic calculation that causes a change in the model state and the return value. Comparison: Activity. See Entry Action, Exit Action, Transition. Semantic Action is an atomic calculation, that is, it will not be interrupted from the outside world. The action can be attached to the convertance in the state machine (between two states or in a state) or in interaction. Typically, it is an operation that is approximately original in the system state, and is often located on a stand-alone object. Typical action has values to assign attribute values, access properties, or links, create new objects or links, simple algorithms, and send signals to other objects. The action is the step outside the behavioral establishment, and the action means "fast" calculation so that the reaction time of the system will not be reduced. The system can perform several actions at the same time, but the execution of the action should be independent. The action can also be attached to the conversion, and the action is performed when the conversion is excited. They can also appear as an inlet action and outlet action as a state. These actions are triggered by transition from entering or leaving. All movements are atoms, ie they do not interfere with other actions at all. Activity is also a calculation, but it can have internal structures and will be interrupted by external events, so activity can only be attached to the state and cannot be attached. Unlike the action, although the activity can be interrupted, if the outside world does not interrupt it, it can continue with indefinitely. The action cannot be interrupted from the outside and can be attached to the entrance or exit of the conversion or state, not the status itself. The structural action includes a set of target objects, a reference (ie, request), a parameter value table, and an optional recursive expression for the signal to be transmitted or the action to be executed, and an alternative to the iteration. * Object collection. Object set expressions generate a collection of objects. In many cases, this collection contains an independent fixed object. A message copy with a given parameter table is sent to each object in the collection, namely broadcast to each object. Each goal is independently received and processes a separate instance of the message. If the collection is empty, then nothing will happen. * Request.
Indicates a signal or declares an operation. The signal is sent to the object, and the operation is called (for the operation with the return value, the object set must contain an object). * Parameter table. Parameter list. When assigning values, the value in the parameter must be consistent with the parameters of the signal or operation. The parameter is used as part of the transmission or call. * Annably. A representative of it, explains how many times you need to do, and specify iterative variables (optional). This expression can also describe a conditional action (ie, once or not). Several action * assignment actions. Assignment Action Sets the property value of an object to a given value. This action contains an expression of the expression of the target object, the name of the object attribute, and an expression that are assigned to the value of the target slot. * Call the action. The calling action causes the occurrence of an object to occur, that is, the call on the object. This action contains a message name, a table of a parameter expression and a set of target objects. The goal may be an object collection. In this case, the call simultaneously occurs and does not return a value. If the operation has a return value, it must have an object as a target. The call action is synchronized. The caller waits for the completion of the called operation before receiving the control again. If the operation is implemented as a calling event, the caller is waiting until the recipient is called triggering. If the execution of the operation returns a value, the caller accepts these values when it receives control again. * Create actions. Creating action results in instantiation and initialization of the object (see Creation). This action contains a reference for classes and an optional class scope operation. The execution of the action creates a new instance of a class whose property value is obtained from the calculated initial value expression. If a clear creation action is given, it will be executed. Operations often overwrite the initial value of the attribute value with the parameter value of the creation action. * Destroy action. Destruction Action leads to the destruction of the target object, which has an expression of an object. There is no other parade in destroying action. The result of performing this action is to destroy the object and all of its links and all components (see Composition). * Return action. The return action causes a control conversion to the operation caller. This action only allows existence in the operation called used. This action contains an optional return value table that is valid when the caller is received when the caller is received. If the included operation is used asynchronously, then the caller must explicitly select the return message (as a signal), otherwise it will lose. * Send actions. The transmit action creates a signal instance and initializes this signal instance with the argument obtained by the parameter expression in the calculation action. The signal is sent to the object in the object collection, which is obtained by calculating the target expression in the action. Each object receives its own signal copy. The sender keeps its own control threads and benefits, and the transmit signal is asynchronous. This action contains the name of the signal, a signal parameter expression table, and an object collection expression for the target object. If the object set is missed, the signal is sent to one or more objects determined by the signal and system configuration. For example, an exception is sent to a scope that is determined by the system policy. * Terminate the action. The termination action causes a certain object destruction. This object has a state machine containing the action, ie the action is a "suicide" behavior. Other objects react to the destruction event of the object. * No explanation action. No explanation action, actions that control construction or other configurations. Indicates that the method UML does not have a fixed action language, which hopes that the modeler uses an actual programming language to write actions. The following to the OCL's adaptation is to write action pseudo code, but this is not part of the standard.
Assignment Action Target: = EXPRESSION Call Action Object-Set.operation-Mane (ArgRMent List,) Create Action NEW Class-Name (Argument List,) Destruction Object.destroy () Returns Return Expression List, Send Action Object-Set. Signa-name (Argument List,) Termination Action Terminate No Interpretation Action If (Expression) Then (Action) Else (action) If you need to clearly distinguish call and send, keyword call and send can be used as an expression prefix, they are optional of. Discussion UML Specifications Define a set of action, while also illustrating that other actions can be added to the actual implementation. This decision is to balance accuracy requirements and developers use a variety of target languages with very broad semantic concepts. The programming language to perform semantic variants are more variants in the data structure and the useful control constructor. Does not consider theoretical feasibility, the small difference is difficult to correspond to the actual way in the language. Choosing a programming language as the foundation of the action language will reduce the role of other languages, and the semantics of the action will leave some incompleteness and erliness, which is also our unwind. If you want to make the semantism more accurate, the UML must be combined with one action language. Some critics say that because UML is too free, it is not accurate, but its inaccuracy will not exceed the inexperity of the action language it selected. UML's true defect is that it does not achieve a multi-language representation of action and other expressions, but it is almost impossible in today's multilingual world. 7. Action Expression Action Expression is an expression that determines an action or action order. Discussion UML does not illustrate a syntax structure of an action expression, which is responsible for this work. We hope that different users can express their actions with programming languages, pseudo symbols, and even natural language. More accurate semantics require detailed design, which is also where many users will use the actual programming language. 8. Action sequence (action order) The order of action is a set of action that is continuously executed, which is one of the action. Semantic action sequence is a set of motions, which are continuously executed. The entire sequence is seen as an atomic unit, ie it can't be interrupted. The order of action is an action, so it can also be attached to the conversion and interaction. The representation of the method is represented by a string that includes a series of actions separated by a semicolon. If a specific programming language is shown, the syntax of the action to the declaration sequence can be replaced. Example count: = 0; reservations.clear (); send kiosk.firstscreen () 9. The use of action state is the active action and converts to another. See Activity State, Completion Transition. The purpose of the semantic operating state is to perform an inlet action, after which it is completed to another state. The operating status is atomic, ie it cannot be interrupted by an external event. In theory, it represents a calculation that can be completed within the ignored time does not have other action interactions. In fact, it takes time to execute, but the time is shorter than the reaction time required to occur. It does not have a conversion triggered by an event. There is no sub-structure, internal conversion or internal activity in the action state. It is a dumb, which can be used to set the state machine to logic. It usually has an output completion conversion. If there is a guard condition, there may be a variety of output completion conversion, which also represents a branch. Indicates that there is no special representation symbol. It can be represented as an original state of the inlet action, or may be represented as an active state.
10. Activation activation is the execution of the operation. Activation (also called the control period) represents an object directly or through the dependent operation of the operation. It models the execution of the duration and execution of the control relationship between its callers. A value of the corresponding stack frame is activated on a conventional computer and language. See Call, SEQUENCE DIAGRAM. Semantic activation is an instance of an operation that includes the process of calling other subordinate operations (see CALL). Its content includes only a collection of local variables that can only access the activated local variable, the current location (or other behavior description) and a reference to the activation of the call content (it will recover when the current activation is terminated). Activation without returning reference must be the result of the conversion on a state machine of a proactive object. When the conversion is completed, the state machine simply waits for the next event. Note that this definition describes a general process into a typical von Norman machine. However, it is represented in an ordinary manner that it is also suitable for distribution environments, and there is no shared memory in this environment, and the stack contains a linked activation table in different memory spaces. The representation is activated in the sequence diagram to indicate with a slender rectangle frame, and its top end is aligned with the activation time and the end end is aligned with the completion time. The active operation of the root of the root is expressed as a text label attached to the activation symbol or on the left. The symbol of entering the message can also represent operations. In this case, the label on the activation can be ignored. If the control flow is procedural, the top of the activation symbol is located at the head of the entry message arrow used to excitation the activity, while the bottom of the symbol is located at the end of the return message arrow. If there are multiple objects of concurrent activities, each activation represents an execution of concurrent objects. If there is no communication between objects, it is independent and its relative execution is not related. In the process code, activation represents a duration, the process of the process call during this time or the initial process is active. In other words, all active nested processes are activated simultaneously. These simultaneous nested activation is a computing stack frame for a conventional computer. For the second call of the activated object, the second activation symbol activates the right side of the symbol, so that they seem to be superimposed. The superimposed call can be nested in any depth. Calls can be targeted for the same operation (ie, recursive calls), or different operations with an object. Example Figure 13-7 shows an activation caused by a call, including recursive calls. Figure 13-7 Activation 11. Active (active / active) active state is already entered and has not exited, and is held by an object. See Active Class, Active Object. Semantics When the conversion enters a state is excited, this state varies more; when the conversion of this state is excited, the status of this activity is no longer active. If an object has a control thread, then at least one state is active (in an example of degradation, the class is only a unique state, in which case the reaction is always the same). If a state is active in the state machine of an object class, then this object is considered to have this state. An object can have multiple states at the same time, and a collection of active status is called active state configuration. If a nested state is active, all of the states containing it are active. If the object allows concurrency, then a plurality of concurrent sub-status can be active. Each transitions to several states in the multi-affected active status configuration. The active state that is not affected in the conversion is still active. A constituent state may be or concurrent. If this status is the order and activity, then its subsequent status is active. If this state is concurrent and active, then each of its subsequent status is active. That is, a constituent state is expanded into or trees in an active sub-state, and each of its layers, a specific state is active. These concurrency constraints must be maintained when constructing the conversion of the constituent state boundary.
The conversion in a sequential composition is usually one source state and a target state. Exciting such a conversion does not change the number of active states. Each subregion of concurrent composition is usually a source state and a target state. Such a conversion is called bifurcation. If one or more areas as destinations are ignored, then the initial state of each ignored area is implicit as a destination; if one of the regions lack the initial state, the model is morbid. This conversion increases the number of active states. When you quit from concurrent composition, just the opposite. See State Machine, which contains a detailed discussion on concurrent status and complex conversion semantics. Examples of the upper portion of Figures 13-8 are examples of a state machine, which exactly the order of computational state. The conversion is ignored. The bottom of the figure indicates a different configuration that can be concurrently active. In this example, there are four possible configurations of possible active states. Only the leaf status is specific, while the higher level of state is abstract, that is, an object may not belong to these states or may not belong to their nested leaf state. For example, objects of sub-status that do not belong to Q may not belong to the status Q. Because Q is concurrent, if Q is active, C and D must also be active. Each leaf state corresponds to a control thread. In a bigger example, the possible number of configurations is exponentially increased, and they are not likely to represent all. Figure 13-8 concurrent active status. Figure 13-8 Concurrent Activity Status 12. An instance of the Active Class Active class is an active object. See Active Object. Examples of Semantic Activity are active objects, and the active class constructor is a process and thread. The method of actively uses a box of dark side lines. Examples of Figure 13-9 show a class diagram of a proactive class and its passive class. Figures 13-10 show a collaboration diagram containing an active object corresponding to this model. Figure 13-9 Active class and passive class Figure 13-10 Active objects and concurrent control between partners 13. Active Object (active object) Active object has a control thread and can initialize the control activity, which is an active instance. See Passive Object, Process, Thread. Semantic An active object is not running in another thread, stack frame or state machine. In the execution of the entire system, it has an independent control period. From some definition, it is a thread. Each active object is a different execution set point; the active object is not re-entered, and if it is not possible to create recursive execution without additional objects. Active objects are the basis for performing stack frames in traditional computer terms. An active object creation initializes a new state machine instance. When the state machine performs the conversion, an execution stack frame is established and has been existed until the conversion action is completed, and the object is waiting for the outside. Therefore, an active object is not running within the scope of another object. It can be created by another object, but once it is created, it exists independently. The creator can be an active or passive object. Active object is driven by event. Other objects should be implemented as an active object as a calling event. Passive objects can be created by another object as part of the action. It has its own address space. The passive object does not control the thread. Its operation is called within the stack frame of an active object. However, it can have a state machine to model, indicating a change in the state caused by its operation. A traditional operating system process is best equivalent to an active object. The operating system thread can be implemented by or not by active objects. Active - passive distinction is basically a semantics that is designed and not restrictive. Active or passive objects can have a state machine, and they can also exchange events. The collaborative role of the active object representation is represented in a collaborative diagram. Typically, the active object role represents a combination of its inner part. Active objects can also be represented by object symbols with heavy edges, and there is an underscore under the name, but the active object is only appearing in the execution example, so it is not that ordinary. Features Keyword {Active} can also be used to represent active objects. Example Figure 13-10 shows three active objects of a factory automation system: a robot, a furnace and a factory manager, where the manager is an control object.
Three objects exist and execute. Factors initialize a control thread in step 1, which is divided into two concurrent control threads (A1 and B1) performed by the furnace and robots, respectively. When each of the execution is completed, step 2 of the factory manager is merged. Each object still exists and keeps state until the next event arrives. 14. Active State Configuration Active Status Configuration is a set of status of active activity in the state machine. A conversion of excitation can change some of this collection, while others constant. See Active, Completion Transition, State. 15. Activity activity is a non-atomic execution in the state machine. Comparison: action. See the Completion Transition, State. Semantic activity is the execution of subsequent structures in the state machine, and the sub-structure allows the existence of interrupt points. If a conversion is forced from the control domain, then the conversion gaves up this activity. The activity is not terminated by internal conversion, because there is no state change. The internal conversion of the internal conversion will explicitly terminate it. The activity can be modeled by a nested state, a subsector reference or a moving expression. Example Figure 13-11 is a alarm system that illustrates the difference between action and activity. When the event detect Intrusion occurs, the system excites a conversion. As part of the conversion, the action Call Police occurs. It is an action, so it is usually atomic. No events are accepted when the action is executed. When the action is executed, the system enters the Sounding state. When the system is in this state, it performs Sound Alarm activity. The activity takes time to complete, and the event of interrupt activity may appear at this time. In this case, the Sound Alarm activity does not interrupt, as long as the system is in a Sounding state it will continue. When the RESET event occurs, the conversion is excited and returns the system to the Monitoring status. When the Sounding status is no longer active, its activity Sound Alarm is also terminated. Figure 13-11 Action and Activity 16. Activity Diagram Activity GRAPH. 17. Activity Expression (Active Expression) Active expression is a text expression for non-atomic calculations and active. This expression can be divided into atomic parts, but allowing text to be more convenient for the entire thing. The execution of the active expression can be terminated by invalid conversion of the control state. Semantic activity expressions are useful processes or algorithms represented by certain languages (such as programming languages or other formal languages). It can also be represented by human language. In this case, the tool cannot perform it, and it cannot be checked and other attributes. But at the beginning of the work, this is enough. It can also represent a continuous real world operation. The representation of the active expression is represented by a text explained by a language (following example.). Example Do / InvertMatrix is limited but Time-Limit is calculated until the time uses the DO / SOUND SIREN continuous operation until the end 18. Activity graph (active diagram) activity graph is a special example of the state machine, in this state machine All or most of the states are active or action status, all or most of the conversion is triggered by the active completion of the source state. The active diagram represents a program or workflow. The active diagram is a complete unit in the model. See the State Machine semantics map is a state machine that emphasizes the order and concurrent steps in the calculation process. Workflow is an example of a process modeling modeling. The activity map usually appears in the design, that is, before all implementation decisions, especially before the object is specified before performing all activities.
This picture is a special case of the state machine, in which the status represents the execution of the activity, just like a calculation or real world uninterrupted operation, and the conversion is triggered by the operation. The activity map can be attached to the implementation of operation and use case. The status in the activity map is mainly active or action status. The active state is a speed of a certain state, which has internal computing and at least one output complete conversion, which is excited by the completion of the activity in the state. If there is a monitoring condition, there can be multiple output conversions. The active status should not have internal conversion or an output conversion based on clarity events. For this condition, the standard state is used. The operating status is atomic state, that is, they will not be converted. Typically, an active state is used to model an execution step of this process. If all the states in the model are active status, then the results of the calculated result will not depend on external events. If the concurrent activity does not access the same object and the relative completion time of concurrent activities does not affect the result, the calculation process is determined. The activity map can contain a normal wait state, which is triggered by an event. But this use has lowered the purpose of focusing on activities. If there are multiple normal conditions, use a normal state model. * Dynamic concurrency. Active concurrency active state represents and executes multiple independent calculations. The activity is simultaneously called with a parameter table set. Each member in the collection is a parameter table for the active parallel call. Call is independent of each other, when all call is completed, the activity ends and triggered its completion conversion. * Object flow. Sometimes checking the relationship between the operation and the object of the object or the result of the result is good. An input and output of an operation can represent a state of flow. It is a structure of a state, indicating the presence of a given object of a specific point during the calculation process. For more accurate, input or output objects can be declared in its class. For example, the "Sign Contract" operation is an object stream of contract classes that have been signed. This object flow state can be an input to several other operations. * Lane. The activities in the activity chart can be divided into several groups in accordance with different criteria. Each group represents some meaningful parts of the active responsibility, for example, the business organization is responsible for a given work. The method is represented according to their graphics, and each group is referred to as a lane. The representation of the representation is one of the state machine, but several short-minded representations are also suitable for active diagrams, such as active status, branch, merge, lane, object flow state, state class, signal transmission, and signal reception representation and Delay event. Look at the control icons for some optional symbols, they can be used for active diagrams representations and. Examples Explanations 13-12 show a activity workflow for processing orders in theater ticket office. It includes a branch and subsequent merge, depending on whether the order is booked or a personal ticket. The concurrent concurrency activity of the bifurcation initialization logically. The actual execution of them can overlap or not overlap. The concurrency is terminated by the subsequently corresponding combination. If only one person is involved, the concurrent activity can be executed in any order (assuming that they cannot be executed simultaneously, this is allowed by the model, but is very difficult in actual). For example, people at the ticket office can allocate a seat, then grant a gift, reuse accounts; or they can first grant a gift, reassign the seat, reuse accounts, but they only debit accounts after the seat is. Figure 13-12 An output section of the fork of the activity map has a guard condition that checks the subscriber is not a member. This is a conditional thread that is only excited when the conditioning condition is satisfied. If this thread is not excited, then the corresponding combined input portion is considered to be completed. If the subscriber is not a member, only one thread is excited, it is responsible for the bits and debit accounts, but will not wait for synchronization at the binding. * Lane. The activity in the activity diagram can be divided into several areas, each of which is screened in the figure, and therefore called a lane. A lane is an organizational unit for the content of the activity map. It does not have inherent semantics, but can be used according to the willingness of the model. Typically, each lane represents an organizational unit within the real world organization.
Example Figures 13-13, the activity is divided into three parts by a lane, each of which corresponds to a different fund storage. Although each part is corresponding to the object in this example, UML does not require this, there will be obvious classes corresponding to each part, and these classes may be performed to implement each activity that has completed the model. Figure 13-13 This picture also represents the use of object stream symbols. The object stream corresponds to a different state of the entire activity. For example, symbol ORDER [Placed] is represented in the calculated position, and a order has been raised to the Request Service active Placed status, but has not been used by Take ORDER. When the Take ORDER activity is completed, the order enters the Entered state, the object stream symbol indicates the state on the output of Take Order activity. All object streams in this example indicate the same object at different times in a statement. Because they represent the same object, they can't exist at the same time. As shown, a continuous control path can be drawn from them. * Object flow. Objects input or output can be represented as a target symbol. The symbol represents an object in a calculated point, which is suitable as an input or an output at that object. One of the dashed lines from the active state activity. The dotted arrow can also represent an input conversion from an object to an object as an input active state. Typically, the same object can be used as an active output and one or more successive inputs. When the target stream arrow (dotted line) meets the redundant constraint, the control flow arrow (solid line) can be ignored. In other words, when the output generated by the action is the input of the subsequent action, the object stream relationship contains a control constraint. * Status class. Typically, the same object is controlled by some subsequent activities that change its state. For more accurate, the object can occur multiple times in the figure, each appearing different states in its life. In order to distinguish between the same object, the state of the object of each point can be placed in the square brackets and attached to the name of the class, such as PurchaseOrder [AppROVED]. This symbol can also be used in collaboration. See the control icons for other symbols that can be used for active graphs. * Delay event. Sometimes, when other activities are processed, there is an event to be delayed for late use (usually, the event that is not immediately processed will be lost). The delay event is placed in the internal queue until it is used or abandoned. If a delay event occurs in a state or activity, the status will be described, and the other events must be processed immediately, otherwise it will be lost when the state machine enters a new state, if the new state does not delay these events, then all The delay event will happen. If the conversion in the new state is triggered by the delay event in the previous state, the conversion immediately stimulates. If several conversion implicitly, which one of them will be excited and unclear, and a rule is performed to select a conversion to which to excite is a semantic change point. If an event occurs in the state it delay, it may trigger a conversion, in which case it does not place in the queue. If this event does not trigger the conversion, it is placed in the queue. If the active status changes, the events in the queue can trigger the conversion in the new state, but if they are still delayed in the new state, they are still in the queue. If an event must be delayed in the constituent state, it can cause conversion in one or more sub-states, so that the event is no longer delayed to trigger the conversion. Otherwise, the event will have to delay in each sub-state without triggering the conversion. Please note that if a delay event is consistent with the conversion trigger event, it does not satisfy the monitoring conditions, then this event does not trigger the conversion, nor does it remove from the queue. A delayed event is represented in the state that there is a backslash and a special operation Defer. If the event occurs and does not trigger the conversion, it is saved and occurs again when the object is switched to another.
When an object arrives at one state it does not be delayed, it must be accepted or ignored. If there is no DEFER declaration, the previous delay can be canceled. The DEFER indicator can be placed on a constituent state so that the event is delayed in the entire constituent state. The action status is atom, so when these state activities are hidden, the event that occurs at this occurs, there is no need to mark them as delay. The event taken is delayed until the action is completed, and the event can trigger the conversion. Figure 13-14 Delay event and control icon Example Figure 13-14 Representative steps representing the coffee. In this example, the outer object is not expressed, and it is only the activities directly executed by people. The action of opening the pot is built into an event to the pot. Activity Get Cups occur after opening the coffee maker. After getting a cup, you need to wait until the light is out. However, there is a problem, if the Light Goes OUT event occurs before the Get Cups is complete, it will be lost because the state machine is not ready for processing events. In order to avoid the risk of loss events, the active state GET CUPS is identified as delayed Light Goes OUT events. If the event occurs when the event is still executed, the event will no longer be lost. Conversely, it is saved in the queue until the state machine leaves the Get CUPS state, and it is executed and the conversion is triggered. Note that the Light Goes OUT event is not a trigger of the GET CUPS state, so it does not terminate the activity when it appears. This event is a trigger who receives a reception state after the Get CUPS activity. * Dynamic concurrency. There is an uncertain value to dynamically concurrently represented by a composite string in the upper right corner of the active symbol (Figure 13-15). This indicates that multiple copies of the activity appear simultaneously. Dynamic activity receives a collection of parameter tables, and details must be described with text. If concurrenuous is applied to multiple activities, they must be included in a constituent activity, which is multiple indication. Figure 13-15 Dynamic concurrency * Figure structure. The state machine must be well nested, ie it is decomposed into a concurrent or sequential sub-state. For a activity map, branch and bifurcation must be nested well. Each branch must have a corresponding merge, each of which must have a corresponding combination. This is sometimes inconvenient for the activity map. Normally, partial ordered graphs, there is no direct loop, but bifurcation and merge do not match. This picture is not well nested, but it can be converted to a good nested diagram through a designated activity to thread and two methods that introduce the synchronization state when the conversion is converted. Decomposition is not necessarily unique, but all decomposition of some ordered maps will produce the same executable semantics. Therefore, there is no need to represent a clear decomposition or synchronization state for a simple part ordered map. More complex graphs involving conditions and concurrency may require more clear decomposition. 19. Activity State Activity Status Indicates a pure calculation of a sub-structure, typically a call or real-world program execution of a declaration within or within it. The active state can be interrupted from the outside event. The status status does not have to be interrupted. It is not limited to how long it can act. See Activity, Completion Transition. Semantic active status is a state with internal calculation and at least one output completion conversion. When the activity in the state is completed, the conversion is excited (if there is a guard condition, there can be several such conversion). The active state should not have internal conversion or output conversion based on the exact event. For this situation, it is required to use a normal state. Active state is usually used to model a step in execution of the algorithm. If all the states in the model are active states and concurrent activities do not access the same value, the calculation is determined, even if it involves concurrency execution. Active state can reference a single machine, usually another active diagram. This is equivalent to extending the active status into a submachine network. It is a subroutine of the state machine. The active state is a state of a program execution process rather than a state of a normal object. The action status is the active state of the atom, even when it is active, it is not interrupted.
It can be built into active status of only one entry action. The active state can be used in a normal state machine, but they are more commonly used in active diagrams. Transitions from one activity state typically do not include an event trigger. Output conversion is implicitly triggered by the completion of the activity in the state. Conversion can include monitoring conditions and actions, pay attention to all possible conditions for transitions against violations, otherwise the control is suspended. If multiple monitoring conditions are true, it is not sure. Use a normal state for other conditions. The status of the active state is indicated by the following shape: the upper and lower side is the straight line, and the left and right is the convex arc (as shown in Figure 13-16). The active expression is placed in the symbol. The active expression in the figure does not have to be unique. Figure 13-16 Active discussion action status is used for short bookkeeping operations for any duration or complexity. This means that the action can be locked the system so it must be short, but the activity can be interrupted, so if some urgent things do not require the system to complete it. UML semantics does not block long actions, but the code generator can reasonably assume that the action is intended to be completed immediately, and the activity is interrupted for other actions. 20. Activity View Active view is an aspect of the system that handles the description of the behavior as an activity by the control stream connection. The active view contains a map and is represented on the active map. It is tissue with other behavior views loosely. See Activity Graph 21. (Participant) Participants are abstract concepts of external entities that interact with the system, subsystems or classes. Participants are involved in the use case or a set of coherent use cases to complete the entire goal. See use case. Semantic participants are scratching and abstracting an external user or a related user collection of a system and class interaction. Participants are idealized forms with centralized purpose and meanings, and do not necessarily have an exact physical object. A physical object can also have a number of unrelated purposes, so it can be modeled by multiple participants. Different physical objects can contain the same purpose, so this aspect can be modeled by the same participant. The user object can be a person, a computer system, another subsystem, or another object. For example, a participant of a computing network system can include Operator, System Administrator, Database Administrator, and ordinary USER, or non-human participants, such as RemoteClient, MasterSequencer, and Networkprinter. Each participant defines a set of roles that use them when the system's users are interacting with the system. A collection of participants describe all the ways of external users and system communications. When a system is implemented, participants are also implemented by physical objects. A physical object If you meet the roles of multiple participants, then it can implement multiple participants. For example, a person can be both a shop owner and a customer. These participants are not essentially related, but they can be implemented by one person. When a system is designed, multiple participants in the system are designated (see restization). The different interaction of participants and systems quantitatively, the use case is the consistent function block of the design system and its participants to complete the meaning of participants. One use case may include one or more participants, one participant to participate in one or more use cases. In the end, participants determine the role of use case and participants in different use cases. Participants who do not participate in any use case are meaningless. The use case model scores a feature of behavior generated when an entity (such as a system, subsystem, or class) is interacting with external entities. External entities are entities participants. For a system, participants can be implemented both human users from other systems. For a subsystem or class, the external element can be the participant of the entire system, or the participant can be other elements within the system, such as other subsystems or classes. Participant instances communicate with the system by transmitting a message instance (signal and call) with the use case instance, transmit a message instance with an object that implements this use case.
This is expressed by the association between the participants and the use cases. Participants can list the set of signals it sent and received. Participants can also have a set of interfaces it supported and needed. Participants' interface must be compatible with each use case that communicates. In other words, participants must accept all signals sent by the use case, and it cannot be sent to the signal that cannot be received. Participants' interface limits how participants are mapped to classes. Participants can also have a set of properties that represent its state. Multiple participants can have the same point in the same manner in the same way. This identity is represented by the generalization relationship with another participant, which models common aspects of participants. Rear generations inherited the relationship between roles and use cases owned by the ancestors. Examples of a descendant participant often use (alternative principles) when the ancestors want to be used (alternative principles). A progeny includes its ancestral properties and operations. Representative participants can be represented by class symbols (rectangular) having a structural entity "actor". Standard participant structure icon is a villain, the name of the participant is below the figure. Participants can use intervals to indicate the properties and events it receives, and it can also use dependencies to represent events it sent. These are the capacity of ordinary categories (as shown in Figure 13-17). Figure 13-17 Participant Symbol 22. Actual Parameter See Argument. 23. Aggregate (aggregation) aggregates the entirety of the entire association (overall and part). 24. AGGREGATION Aggregation is an associated form that indicates an overall relationship between a gathering (overall) and components. See Composition. Semantic a binary correlation can be declared as a polymerization - a whole and partial relationship. One end of the association points out that the gathering and the other end is no mark. At both ends, it is not possible to be aggregated (or composition), but both ends may be no marks at the same time, then it is not aggregation. The chain formed from the polymerization associations will follow several rules. The polymerization relationship is convertible, asymmetric spans all aggregated links, even links those from different aggregation. Convertible means that if there is a path from B to A, it means that "B is part of A" is meaningful. Asymmetry means that there is no cycle in the path to the aggregation link. That is, an object cannot be directly or indirectly as part of its own. The two rules are combined, and a graphic composed of all aggregatedly associated aggregated links form a partial ordered diagram, which is not a cycle (the tree is a specific and common portion of the order). An example is given in Figure 13-18. Figure 13-18 The aggregation of the object is a channelless path from the link from the object B to the object A indicates a channel with the association associated from class B to class A, but the associated path will involve cycling, here Multiple times can occur in the same class. A class to its own aggregately associated channel is a recursive. There is a stronger polymer form called a combination. The composition is a gathering of additional constraints, which is that an object can only be a part of a component and the responsibility of each part of the object is placed, that is, the creation and destruction of them. See Composition. In a normal aggregation, a portion can belong to multiple gatches, and it can be independent of aggregation. Typically, the "need" part is aggregated, that is, it can be considered partial accumulation. But some can exist independently without having to think that it is just a "part". For example, the path can be considered a collection of segments. However, the segment can be independent and whether it is part of the path, and the same segment can appear in different paths. See Accociation and Accociation End to understand more features of aggregation. The representation is represented by one end with an associated line connected to the aggregated class (as shown in Figures 13-19). If the aggregation is a group, then the diamond is solid, see Figure 13-68, Figure 13-68. The associated ends cannot have a aggregation logo at the same time. The polymerization class can have multiple parts.
