1/17/2014. UML Help and Details (from: UML for cse UML for a class. UML and project clarifications

Transcription

1 UML Help and Details (from: Sharma Chakravarthy Information Technology Laboratory (IT Lab) Computer Science and Engineering Department The University of Texas at Arlington, Arlington, TX URL: UML for cse Projects These projects are not like the ones in cse 1320 where every detail was given to you (because it was the first course and the design methodology was not separate) In CSE 1325, you will do the design first and then proceed to implementation Not all the classes are defined for you explicitly Think of yourself as a consultant who interacts with a client who does not know anything about OO, but gives his requirements YOU have to map the requirements into meaningful classes and design to satisfy you client s requirements 1 UML UML and project clarifications Each class should be represented using appropriate notation for public, private, protected, and static attributes and methods Constructors should be identified as such Make sure parameters, return types are properly indicated Relationships between classes should be represented using labels, cardinality information (where appropriate) Later, Is a, has a, and uses a need to be represented Later, abstract classes and interfaces need to be represented See (but make sure you use modifiers and constructors, parameters and return types) UML for a class Consists of A box containing (in this order): Class name and whether it is abstract or concrete All attributes with type, visibility, class or instance, initial value if any, final specification (if applicable) All constructors using the right notation (<< >>) All methods with visibility, class or instance, final specification (if applicable), parameters, and return type + for public, for private, # for protected, and ~ for default (or package private), / for derived Underline class/static attributes and methods Include {abstract if it is an abstract class next to class name 1

2 UML for the Date class <<interface>> +DateConstants ABNORMAL_EXIT : int BASE_INDEX: int FIRST_MONTH :int <<class>> +Date final DAYS[] : int final LEAP_YEAR : int final NON_LEAP_YEAR : int month : int day : int year : int <<constructor>> Date(m,d,y : int) <<constructor>> Date(sDate : String) <<constructor>> Date(y : int) <<constructor>> Date(m,y : int) isvalid(m,d,y : int) : boolean isleapyear(y : int) : boolean isleapmonth(m,y : int) : boolean + next() : Date + isafter(b : Date) : boolean + isbefore(b : Date) : boolean + compareto(b : Date) : int + addmonths(m : int) : Date + monthsbetween(enddate : Date) : int + daysbetween(enddate : Date) : int + tostring() : String A Link is the basic relationship among objects It is represented as a line connecting two or more class boxes A link is an instance of an association In other words, it creates a relationship between two classes The UML representation of an association is a line with an optional arrowhead indicating the role of the object(s) in the relationship, and an optional notation at each end indicating the multiplicity of instances of that entity (the number of objects that participate in the association) 0 1 No instances, or one instance (optional, may) 1 Exactly one instance 0 * or * Zero or more instances 1 * One or more instances (at least one) min max Cardinality specification An interface that is implemented by a class is shown with a broken (or dotted) line with an arrow at the interface box Specification inside the interface box is very similar to the class box An association represents a family of links Binary associations (with two ends) are normally represented as a line, with each end connected to a class box Higher order associations can be drawn with more than two ends In such cases, the ends are connected to a central diamond An association can be named, and the ends of an association can be adorned with role names, ownership indicators, multiplicity, visibility, and other properties There are four different types of association: bi directional, uni directional, Aggregation (includes Composition aggregation) and Reflexive Bi directional and uni directional associations are the most common ones For instance, a flight class is associated with a plane class bi directionally Association represents the static relationship shared among the objects of two classes Example: "department offers courses", is an association relationship 2

3 Person Subscribes to 100 * 0 5 Class diagram of association between two classes A person subscribes to 0 to 5 magazines A magazine is subscribed by 100 or more persons Magazine Aggregation is a variant of the "has a" or association relationship; aggregation is more specific than association It is an association that represents a part whole or part of relationship As a type of association, an aggregation can be named and have the same adornments that an association can However, an aggregation may not involve more than two classes Aggregation can occur when a class is a collection or container of other classes, but where the contained classes do not have a strong life cycle dependency on the container essentially, if the container is destroyed, its contents are not In UML, it is graphically represented as a hollow diamond shape on the containing class end of the tree with lines that connect contained classes to the containing class Class A contains 1 or more class B objects A 1 * B Aggregation differs from ordinary composition in that it does not imply ownership In composition, when the owning object is destroyed, so are the contained objects In aggregation, this is not necessarily true For example, a university owns various departments (eg, chemistry), and each department has a number of professors If the university closes, the departments will no longer exist, but the professors in those departments will continue to exist Therefore, a University can be seen as a composition of departments, whereas departments have an aggregation of professors In addition, a Professor could work in more than one department, but a department could not be part of more than one university University owns Department Has Professor A P * 0 5 Composition is a stronger variant of the "owns a" or association relationship; composition is more specific than aggregation Composition usually has a strong life cycle dependency between instances of the container class and instances of the contained class(es): If the container is destroyed, normally every instance that it contains is destroyed as well (Note that a part can (where allowed) be removed from a composite before the composite is deleted, and thus not be deleted as part of the composite) The UML graphical representation of a composition relationship is a filled diamond shape on the containing class end of the tree of lines that connect contained class(es) to the containing class Composition Aggregation 3

4 Java: aggregation and composition How do we implement these relationships in Java? Aggregation is pretty straightforward! You have Professor as a class and you have Department as a class You create a collection of professors in the Department class using An array An ArrayList List Other collection types However, implementation of composition relationship (if you want to do it to its exact semantics) requires some thinking! Even if you do not implement it, you should specify the relationships (Composition and aggregation) correctly in the UML diagram Let us take a look at aggregation as you will need it in project 2 Java: aggregation and composition Aggregation is implemented by including a number of aggregation objects in another Object class Department { private static int dindex = 0; private String dname; // Aggregation, NOT composition private Professor[] faculty = new Professor[5]; public Department (String dn, Professor p){ dname = dn; if (dindex < facultylength) faculty[dindex++] = p; else throw new RuntimeException("Invalid number of faculty"); public class Professor { private String fname, lname; private String highestdegree; public Professor(fn, ln, hd){ fname = fn; lname = ln; highestdegree = hd; Java: composition In composition, you have to make sure that you can only construct a composed object as part of the object containing it class Department { private static int dindex = 0; private String dname; // Aggregation private Professor[] members = new Professor[5]; Department (dn, Professor p){ dname = dn; if (dindex < memberslength) members[dindex++] = p; else throw new RuntimeException("Invalid Department"); public class University { private static int uindex = 0; private String unamme; private final department udepts[] = new Department[5]; public University (String un, String dn, Professor p){ uname = un; if (uindex < departmentslength) udepts[uindex++] = new Department(dn, new Professor(p)); else throw new RuntimeException("Invalid University"); ; Aggregation, composition Composition can also be implemented using inner/nested classes The key is to make sure the object reference is not available outside of the container object I would like you to show whether it is a composition or an aggregation in the UML diagram 4

5 UML: Abstraction, Generalization and realization Abstraction is specifying the framework and hiding the implementation level information Concreteness will be built on top of the abstraction It is a blue print for following the implementation details Abstraction reduces complexity In the UML diagram, specify a class to be abstract (as {abstract) Generalization uses a is a relationship from a specialization to the generalization class Common structure and behavior are used from the specialization to the generalized class At a very broader level you can understand this as inheritance In the UML diagram an arrow goes from specialization to generalization Realization is a relationship between the blueprint class and the object containing its respective implementation level details This object is said to realize the blueprint class In other words, you can understand this as the relationship between the interface and the implementing class Dependency is also represented using the same symbol Change to the structure of one class affects the other UML: uses a relationship Uses a or dependence relationship indicates that the process of doing x always involves doing Y at least once (or many times) It is also called executes relationship Represented as a solid arrow Dependence in terms of usage Order object uses Account object Student object uses Course object to check for registered courses Thank You! January 13, 2010 cse 1325: chakravarthy 19 5