Introduction to UML Diagrams

Transcription

1 Bern University of Applied Sciences H T I Bienne Department I Basic Programming Introduction to UML Diagrams J.-P. Dubois Content State Machine Diagrams Class Diagrams Object Diagrams Sequence Diagrams Package Diagrams Based on "UML Distilled", by M. Fowler, 3rd Ed., Addison Wesley,

2 State Machine Diagrams Example transition can delivered Delivering state initial pseudostate Idle entry / lamp off return key / return coin Selecting coke selected / deliver can off-line switch 1fr. introd. [store not full] / lamp on coffee selected / fill cup final state milk key / add milk cup full Filling 3 State Machine Diagrams A State Machine describes the lifetime behavior of a single object (here a drink machine). It is based on the concept of finite automaton. The machine states are represented with rounded rectangles (here: Idle, Selecting, Filling, Delivering) The initial and final states indicate where the state machine starts, resp. where it is completed (implying the deletion of the state machine object) 4

3 State Machine Diagrams A transition indicates a movement from one state to another and has a label that comes in three parts (all optional): Full form: trigger-signal [guard] / activity trigger-signal: event that triggers change of state 1) guard : condition that must be true for the transition to be taken activity: some behavior that is executed during the transition ("action") Each transition must be unequivocal (deterministic behavior) A "self-transition" does not change the machine state (loop-back) Events that occur where no valid transition exists are ignored 1) If not present, the transaction is taken immediately (see also do-activities) 5 State Machine Diagrams Special activities: Internal activity: allows a state to react to events without transition. Event, guard and activity are defined in the state box itself. Entry / Exit activity: is executed whenever a state is entered / left. These activities are triggered by self-transitions (but not when an internal activity is executed). Example: Idle entry / lamp off exit / lamp on 1fr. introd [store full] / Return coin Other coin introd. / Return coin 6

4 State Machine Diagrams Do-activity: ongoing activity executed within a state ("activity state"). It is marked with "do/". A do-activity is not instantaneous and can be interrupted by a regular event. If present, a transition without trigger signal will be executed, when the do-activity is completed. Example: Waiting Search Searching do / search for file with spec. content Cancel Displaying file 7 State Machine Diagrams Implementation of a state machine: With nested switch (or if) statements By interpreting a state table By using the state pattern State pattern: very general, object oriented implementation, that uses polymorphism with a separate class for each state. State table: captures the state diagram information as data. It can then be used by an interpreter at runtime or by a code generator that generates classes based on it. Nested switches: use a state-oriented or (rather rarely used) an event-oriented structure. 8

5 State Machine Diagrams Example: state table From state To state Event Guard Activity Idle Selecting 1fr. introd. store not full lamp on Idle (final) off-line switch Selecting Filling coffee selected --- fill cup Selecting Delivering coke selected --- deliver can Selecting Idle return key --- return coin lamp off Filling Idle cup full --- lamp off Filling Filling milk key --- add milk Delivering Idle can delivered --- lamp off 9 State Machine Diagrams Example: nested switches (state-oriented structure): public void processevent(int event) { switch (state) { case IDLE: switch (event) { case FR1_INTR: if (!storefull) {lampon(); state = SELECTING;} break; case OFF_LINE: state = FINAL; break; } break; case SELECTING: switch (event) { case COFFE_SELECTED: fillcup(); state = FILLING; break; case COKE_SELECTED: delivercan(); state = DELIVERING; break; case RETURN_KEY: returncoin(); lampoff(); state = IDLE; break; } break; 10

6 State Machine Diagrams case FILLING: switch (event) { case CUP_FULL: lampoff(), state = IDLE; break; case MILK_KEY: addmilk(); break; } break; case DELIVERING: switch (event) { case CAN_DELIVERED: lampoff(), state = IDLE; break; } break; } } 11 Class Diagrams A UML class diagram describes the type of objects in the system and the various kinds of static relationships that exist among them. shows the properties and operations of a class and the constraints that apply to the way objects are connected. Representing a class Student Student Student Student class name attributes name address birthdate getinitials() getabbreviation() billschoolfees() operations name address birthdate getinitials() getabbreviation() billschoolfees() 12

7 Class Diagrams Class name: in bold Attribute: notation to represent a property of a class. Full form: visibility name: type [multiplicity] = default {property-string} visibility: + : public, # : protected, ~ : package, - : private name: attribute field name (mandatory) type: attribute type multiplicity: indicates how many objects may fill the property, in the form: lower bound..upper bound (the game of "Jass" may two 2, 3 or 4 players) - 1 (a student may have exactly one name): default - * (no upper bound, same as 0..*) default value: value of the newly created field property-strg: indicates additionnal properties for the attribute Example: # address: String[1..2] = null {readonly} 13 Class Diagrams Association: represents a class property, using a solid line between two classes (poss. with opened arrow). Much of the same infos showed on an attribute appears on an association The property name (role name) and infos are indicated at the target end of the association. If needed, the direction of the association is shown by a navigability arrow Name {readonly} Student birthdate Date 1 address 1..2 String 14

8 Class Diagrams Bidirectional Association: With navigability arrows Person owner cars 0..1 Car make:string (Representing properties as attributes) Without showing navigability Person owner cars 0..1 Car make:string Showing an assocation with a verb: Arrow is optional Person owns 0..1 Car make:string Person cars:car[ ] Car owner:person[0..1] make:string 15 Class Diagrams Operations: actions that a class knows to carry out methods Full form: visibility name (parameter-list): return-type {property-string} visibility: + : public, # : protected, ~ : package, - : private name: operation name (mandatory) parameter-list: notated as attributes. For each parameter, the full form is: (direction) name: type = default direction: in (for input par.), out (for output par.), inout (for both) return-type: type of return-value property-strg: indicates additionnal properties appliying to the operation Example: + transfer(other: BankAccount, amount: double): boolean 16

9 Class Diagrams Generalization: represents a class hierarchy between two classes, using a solid closed arrow. Vehicle Applet Car Bike WelcomerApplet Comments: can be linked with a dashed line to the element they are commenting Includes pick-ups and vans but not motorbikes Car 17 Class Diagrams Dependency: exists between two elements, if changes to the definition of one element may cause changes to the other. In particular, a class depends on another class if it uses objects of that other class. A dependency is represented by a dashed opened arrow. E.g. an Applet depends on a Graphics object: Applet paint(graphics) Graphics Note If a class is associated with another, you can navigate from its objects to objects of the other class. Hence, association is a stronger form of dependency To outline the type of dependency, you can label the arrow with a «keyword» (e.g. «uses», «creates», «calls», etc.) Many UML relationsships imply a dependency 18

10 Class Diagrams Aggregation: association that builds a "part-of" relationship. It is represented with an empty diamond: Engine Car Wheel Composition: "strong" version of aggregation, in which any class instance must be a component of only one owner. It is represented with a full diamond: Head 1 1 Person 1 2 arm 2 leg Deleting one Person should also delete one Head, two Arm and two Leg instances. 19 Class Diagrams Static operations and attributes are underlined on a class diagram; e.g.: CarTest PI: double {final} main Derived properties can be calculated based on other values. They are noted with /; e.g.: DateRange start: Date end: Date /duration: int duration = end - start 20

11 Class Diagrams Abstract classes and operations are indicated by italicizing the name, or by adding the keyword {abstract} (abbreviated: {A}). Interfaces are indicated by the keyword «interface» (abbr.: «I»). A class provides an interface, by implementing it. This is indicated with a dashed closed arrow. A class requires an interface, if it has a dependency on the interface. As for class dependencies, this is indicated with a dashed opened arrow. An interface hierarchy is represented, as by classes, by a solid closed arrow (see "generalization"). 21 Class Diagrams Example: «interface» Collection equals add Order lineitems[ ] «interface» List get AbstractList equals get add ArrayList get add 22

12 Class Diagrams A more compact notation represents the implemented interfaces by using "lollipops" (ball icons): Order lineitems[ ] List ArrayList Collection Enumerations: fixed set of values without any particular properties. They are shown as the class with the keyword «enumeration» «enumeration» Color red green blue 23 Object Diagrams A UML object (instance) diagram is a snapshot of the objects in a system at a point of time. shows values for attributes and links as by class diagrams. Representing an object john:student john:student :Student john name = "John F." address birthdate 24

13 Object Diagrams Example: Class diagram: Module Course term studlist Student studlist 1 special Topic Object diagram: prog1:course term = "Fall" :Module prog2:course term = "Spring" dupond dupont haddock tournesol special security:topic web:topic special 25 Sequence Diagrams A UML sequence diagram describes how groups of objects collaborate in some behavior. captures the behavior of a single scenario. is part of the UML interaction diagrams In a sequence diagram: objects are named as in object diagrams (without attributes), but are not underlined (UML 2). the object life duration is indicated by a dashed vertical line ("lifeline") each lifeline has a bar that shows when the object is activ (optional). invoking an operation on an object is indicated by a solid closed arrow returning a value from an operation is indicated by a dashed opened arrow (optional). naming often is useful to correlate objects on the diagram. 26

14 Sequence Diagrams Example: order orderline product calculateprice calculateprice getprice(quantity: int) customer price price getdiscountedvalue(order) getbasevalue discountedvalue orderprice 27 Sequence Diagrams Creating and deleting objects: query DBhandler new querycmd new execute DBstat extract results results close 28

15 Sequence Diagrams Static calls and return values: «metaclass» :TriangleTest «metaclass» :Math main new triangle getperimeter perimeter a = sqrt(a x a x + a y a y ) b = sqrt(b x b x + b y b y ) c = sqrt(c x c x + c y c y ) 29 Sequence Diagrams Structures: To represent structures within a sequence diagram, use interaction frames Frames consist of some region of a sequence diagram that is divided into fragments. Each frame has an operator and each fragment may have a guard. Common operators are: alt: alternative multiple fragments (if..else) opt: optional fragment (if alone) par: parallel, each fragment is run in parallel loop: fragment may execute multiple times region: critical region sd: refers to another sequence diagram 30

16 Sequence Diagrams Example: Pseudo-code: dispatch() { for each lineitems { if (prod.value > 1000) careful.dispatch else regular.dispatch } if (needsconfirmation) messenger.confirm } loop order dispatch alt [for each lineitem] [value > 10000] dispatch careful: Distributor regular: Distributor :Messenger [else] dispatch opt [needsconfirmation] confirm 31 Package Diagrams A UML package diagram allows to represent class packages (in the Java sense) and their dependencies. Representing packages: util util Date util Date java::util java util nested packages Date Date java::util::date 32

17 Package Diagrams Packages dependencies Package pack1 depends on package pack2, if any class of pack1 has a dependency to any class of pack2. Example bank BankAccount Purse bank::currency Coin 33 Package Diagrams Implementation of packages It is quite common for an interface and its implementation to be in separate packages. You can indicate such relationship using the same notation as for class diagrams Example control control Button CheckBox «I» Switch turnon turnoff furnace lighting furnace::heater lighting::light 34

18 Finite State Machines - Implementation State Design Pattern 35