cse 70 uml overview classes

7/28/2019 CSE 70 UML Overview Classes

1/57

California Institute for Telecommunicationsand Information TechnologiesLa Jolla, CA 92093-0405, USA

Department of Computer Science & EngineeringUniversity of California, San DiegoLa Jolla, CA 92093-0114, USA

CSE 70: Unified Modeling Language Class Diagrams

Design Patterns Strategy

Ingolf Krueger


2/57

Ingolf Krueger, 2010 2CSE

Learning Goals for Today


3/57


Learning Goals

Know the use of the Unified Modeling Language (UML) forrequirements capture and design.

Be able to draw and understand basic UML class diagrams.

Know and be able to apply the Strategy Pattern


4/57


Unified Modeling Language (UML)

source: http://commons.wikimedia.org/wiki/File:UML_Diagrams.jpg


5/57


UML

A visual language for specifying, constructing, anddocumenting system artifacts.

Provides different language elements (diagrams/text)to model systems from various viewpoints

Structure Behavior

OMG standard since 1997, now at version UML 2.2 Especially useful for modeling/documenting object-

oriented systems: requirements, architecture, design but not limited to that


6/57


Basics Covered in CSE 70

StructureBehavior

State Machine

InteractionOverview

ClassObject

Deployment

Package

CompositeStructure

ComponentSequence

Activity

Use case

Communication


7/57


UML Class Diagrams


8/57


Example: ChatServer Class in Java

public class ChatServer extends BaseChatServer {!... !private String[] clients; !private int client_index;!... !public void sign_on(String client_id) {!clients[client_index++] = client_id;!

}!...!

}!!

ChatServer.java


9/57




}!...!

}!!

ChatServer.java

inheritance relationship


10/57




}!...!

}!!

ChatServer.java

fields


11/57




}!...!

}!!

ChatServer.java

methods


12/57


UML Class Diagrams: Basics

SuperclassAttributes/Fields

Inheritance

(extends)Operations/

Methods

Subclass


13/57


UML Class Diagrams: Compare to Java Code

public class ChatServer !extends BaseChatServer {!

... !private String[] clients; !private int client_index;!... !public void !sign_on(String client_id) {!clients[client_index++] = !client_id;!

}!...!

}!!


14/57


Class Diagrams: Inheritance


... !private String[] clients; !private int client_index;!... !public void !sign_on(String client_id) {!clients[client_index++] =!client_id;!

}!...!

}!!


15/57


Class Diagrams: Attributes/Fields


... ! private String[] clients; ! private int client_index;!

... !public void !sign_on(String client_id) {!clients[client_index++] = !client_id;!

}!...!

}!!


16/57


Class Diagrams: Methods


... !private String[] clients; !private int client_index;!... !

public void !sign_on(String client_id) {!clients[client_index++] = !client_id;!

}!...!

}!!


17/57


Class Diagrams: Basics

read:

ChatServeris-a

BaseChatServer


18/57


Classes and Interfaces


19/57


Class Diagrams: Interfaces & Classes

public interface IDispatchTarget {

!public void close();!}!!public interface IController

extends IDispatchTarget {!!public void !

parseCommand(String cmd);!}!!public class Client !implements IController {!

!}!!


20/57






parseCommand(String cmd);!}!!public class Client !implements IController {!

!}!!


21/57


22/57






parseCommand(String cmd);!}!!public class Client ! implements IController {! !}!!


23/57


Associations, Aggregation


24/57


Example: ChatClient

package simplechat.client;!import simplechat.server.*;!...!public class ChatClientImp {!!private String name;! private ChatServer server;! public void setName(String name) {!

this.name = name!}!...!

ChatClientImp.java


25/57


Example: ChatClient

!public ChatClientImp(String client_id, !String server_id) {!

! !try {!! ! !Registry registry = !

LocateRegistry.getRegistry();!! ! !server = !

(ChatServer) !registry.lookup(server_id);!

! ! !!! ! !server.sign_on(client_id);! ...!! ! !!


26/57


Undirected Association

Association

(undirected)

any numberof

exactlyone


27/57



role/field

name


28/57



read:

every object of class ChatClientImphas exactly one ChatServer

every object of class ChatServerhas many ChatClientImps


29/57


public class ChatClientImp {!...!private ChatServer server;!

...!}!



30/57


public class ChatClientImp {!...!private ChatServer server;!

...!}!



31/57


public class ChatServer {!...!private ChatClientImp[] clients;!

...!}!



32/57


Frequently Used Multiplicities

Symbol Meaning

1 exactly one

n exactly n

n..m at least n and at most m* any number of


33/57


Design Patterns:

Proven solutions forrecurring design problems

in specific contexts


34/57


Why bother?

Lets Design a Chat Server

that can Handle Messages


35/57


First Design


36/57


Customer wants: Serverwith Message Logging

Capability


37/57


Second Design: Message Logging Server


38/57


Customer also wants:Server with MessageEncryption Capability


39/57


Third Design: Logging OR Encryption


40/57


Customer reallywants:Logging Server withEncryption Capability


41/57


Fourth Design: Logging with Encryption


42/57


Pros and Cons of Fourth Design

Pro: Customer requirement can be fulfilled

Cons: Unclear design decomposition strategy:

why should message handling dominate logging? why should logging dominate encryption?

Tight coupling between message handling, logging andencryption capability!

Addition of further capabilities leads to exponential spread ofthe class hierarchy

What if we want to replace the logging/encryption algorithmat runtime: requires restart of entire server!


43/57


Separation of Concerns

Let me try to explain to you, what to my taste is characteristic forall intelligent thinking. It is, that one is willing to study in depth anaspect of one's subject matter in isolation for the sake of its ownconsistency, all the time knowing that one is occupying oneselfonly with one of the aspects. [] But nothing is gained on thecontrary! by tackling these various aspects simultaneously. It is

what I sometimes have called "the separation of concerns", which,

even if not perfectly possible, is yet the only available technique foreffective ordering of one's thoughts, that I know of.1

1E. W. Dijkstra: "On the role of scientific thought", in E.W. Dijkstra, Selected Writings on Computing: APersonal Perspective, New York, NY, USA: Springer-Verlag New York, Inc., pp. 6066


44/57


What are the separateconcerns of the Server

design?

Message Handling,Logging, Encryption


45/57


How can we separate themout?


46/57


Chat Server Interfaces: MessageHandler


47/57


Chat Server Interfaces: Encryptor and Logger


48/57


How can we bring themback together?


49/57


Chat Server with Composition


50/57


Example: Server with Composition

public class Server {!!private MessageHandler handler;!!private MessageLogger logger;!!private MessageEncryptor encryptor;!public Server() {!handler = null;!logger = null;!encryptor = null;!

} ...!

ChatServer.java


51/57



...!public void setHandler(MessageHandler handler){this.handler = handler;!

}!

public void setLogger(MessageLogger logger) {!this.logger = logger;!

}!

public void setEncryptor(MessageEncryptor en) {this.encryptor = en;!

}!...!

Server.java


52/57



...!public void doHandleMessage(Message msg) {!this.handler.handleMessage(msg);!

}!

public void doLogMessage(Message msg) {!

this.logger.handleMessage(msg);!}!

public void doEncryptMessage(Message msg) {!

this.encryptor.handleMessage(msg);!}!

}!

Server.java


53/57


Example: RSAFileServer

public class RSAFileServer {!public RSAFileServer() {!super();!setHandler(new BasicHandler());!setLogger(new FileLogger());!setEncryptor(new RSAEncryptor()); !

} ...!

}!

RSAFileServer.java


54/57


Key OO Design Principles

Develop Against Interfacesrather than

Implementations

Favor Composition overInheritance


55/57


Separation of Concerns: Variability vs. Stability

Separate what varies from what doesnt.

OO Mechanisms:

Encapsulation (Classes/Interfaces)InheritanceAssociation/Aggregation/Composition

How to do it?Design Patterns to the Rescue


56/57


What have you learnedtoday?


57/57


Learning Goals

Know the use of the Unified Modeling Language (UML) forrequirements capture and design.

Be able to draw and understand basic UML class diagrams.

Know and be able to apply the Strategy Pattern

cse 70 uml overview classes

Documents