Mapping Designs to Code
Mapping Design to code
With the completion of interaction diagram
& DCD,
One can start generation of code where in
the interaction diagram & DCD can be used
as the input.
Implementation of OO language requires
writing source code for:
Class & interface definitions
Method definitions
Creating class
definitions from DCDs
At the very least, DCDs depict the class or interface
name, superclasses, operation signatures, and
attributes of a class.
This is sufficient to create a basic class definition in
an OO language.
If the DCD was drawn in a UML tool, it can generate
the basic class definition from the diagrams.
Creating Class Definitions from DCDs
public class SalesLineItem
{
private int quantity ;
private ProductDescription description ;
public SalesLineItem(ProductDescription desc , int qty)
{ ... } public Money getSubtotal () { ... }
ProductDescription
SalesLineItem
description description : Text
quantity : Integer price : Money
1 itemID : ItemID
getSubtotal() : Money
...
Creating Methods from Interaction
Diagrams (Register.enterItem)
{
ProductDescription desc= catalog.ProductDescription(id); enterItem
currentSale.makeLineItem(desc, qty);
} method
of
Collections
• One-to-many relationships are common.
– For example, a Sale must maintain visibility to a group of many
SalesLineItem instances.
– In OO programming languages, these relationships are usually
implemented with the introduction of a collection object, such as a
List or Map, or even a simple array.
• Java libraries contain collection classes such as ArrayList and
HashMap, which implement the List and Map interfaces,
respectively.
• The choice of collection class is influenced by the
requirements;
– key-based lookup requires the use of a Map,
– a growing ordered list requires a List, and so on.
Collections
Sale
public class Sale
{ isComplete :
... Boolean time : SalesLineItem
DateTime
private List lineItems= new ArrayList(); e lineItems
becomeComplet () quantity : Integer
} 1..*
makeLineItem() getSubtotal()
makePayment()
getTtotal()
A collection class is necessary to
maintain attribute visibility to all the
SalesLineItems.
Order of Implementation
• Classes need to be implemented from least-coupled to most-
coupled.
• E.g.,
– possible first classes to implement are either Payment or
ProductDescription;
– next are classes only dependent on the prior implementations—
ProductCatalog or SalesLineItem.
Order of Implementation
Store
7
address : Address
1
name : Text ProductDescription
2
ProductCatalog
3
addSale(...) description : Text
... price : Money
1 itemID : ItemID
1..*
getProductDes c(...)
...
1
1 Sale 5
6
Register isComplete : 4
SalesLineItem
Boolean time :
...
DateTime
becomeComplet e() quantity : Integer
endSale() 1 1..*
makeLineItem(...)
enterItem(...) getSubtotal(
makePayme n(...)
makeNewSale() )
getTotal() t
makePayme n(...)
...
t
1
* Payment
amount :
1 Money
...
How to design makeNewSale ?
by Creator
and
Controller Register creates a
Sale by Creator by Creator, Sale
:Register creates an empty
collection (such as a
List) which will
eventually hold
SalesLineItem
instances
makeNewSale
create
:Sale
create lineItems :
List<SalesLineItem>
this execution specification is implied to be
within the constructor of the Sale instance
enterItem
getTotal
makePayment, getBalance
endSale
Class Payment
// all classes are probably in a package named
// something like:
package com.foo.nextgen.domain;
public class Payment
{
private Money amount;
public Payment( Money cashTendered ){
amount = cashTendered;
}
public Money getAmount() {
return amount;
}
}
Class ProductDescription
public class ProductDescription
{
private ItemID id;
private Money price;
private String
description;
public
ProductDescription
( ItemID id,
Money price,
String
description )
{
this.id = id;
this.price = price;
this.description =
description;
}
public ItemID getItemID() { return id;
Class ProductCatalog
public class ProductCatalog
{
private Map<ItemID, ProductDescription>
descriptions = new HashMap()<ItemID, ProductDescription>;
public ProductCatalog() {
// sample data
ItemID id1 = new ItemID( 100 );
ItemID id2 = new
ItemID( 200 ); Money price =
new Money( 3 );
ProductDescription desc;
desc = new ProductDescription( id1, price, "product 1" );
descriptions.put( id1, desc );
desc = new ProductDescription( id2, price, "product 2" );
descriptions.put( id2, desc );
}
public ProductDescription getProductDescription( ItemID id ) {
return descriptions.get( id );
}
Class SalesLineItem
public class SalesLineItem
{
private ProductDescription description;
private int quantity;
public SalesLineItem
(ProductDescription desc, int quantity
)
{
this.description = desc;
this.quantity = quantity;
}
public Money getSubtotal()
{
return
description.getPrice().ti
mes( quantity );
}
}
Class Sale
public class Sale {
private List<SalesLineItem> lineItems =
new ArrayList()<SalesLineItem>;
private Date date = new Date();
private
boolean isComplete = false;
private Payment payment;
public Money
getBalance()
{
return
payment.getAmount().minus( getTo
tal() );
}
public void becomeComplete()
{ isComplete = true; } public boolean isComplete()
{ return isComplete; }
Class Sale
public Money getTotal()
{
Money total = new Money();
Money subtotal = null;
for ( SalesLineItem
lineItem : lineItems )
{
subtotal = lineItem.getSubtotal();
total.add( subtotal );
}
return total;
}
public void makePayment( Money
cashTendered )
{
payment = new
Payment( cashTendered );
}
} //end of sale
Class Register
public class Register {
private ProductCatalog catalog;
private Sale currentSale;
public Register( ProductCatalog catalog ) {
this.catalog = catalog;
}
public void makeNewSale() { currentSale = new Sale(); }
public void enterItem( ItemID id, int quantity ) {
ProductDescription desc = catalog.getProductDescription(id);
currentSale.makeLineItem( desc, quantity );
}
public void makePayment( Money cashTendered ) {
currentSale.makePayment( cashTendered );
}
public void endSale()
{ currentSale.becomeComplete(); }
Class Store
public class Store
{
private ProductCatalog catalog = new ProductCatalog();
private Register register = new Register( catalog );
public Register getRegister() { return register; }
}
Mapping design to code :example
Working Example: PM:
PM: Use Case Diagram
PM: Class Diagram
PM: Class to Code: they are coded as:
- class WorkPackage;
- class Project;
- class Activity;
- class Task;
- class WorkProduct;
- class Resource;
- class Skill;
- class ResourceXSkill;
class WorkPackage
{ // Details omitted };
class Project : public WorkPackage
{ private: CollectionByVal<Activity> theActivity; };
class Activity : public WorkPackage
{ private: Project *theProject;
CollectionByVal<Task> theTask;
CollectionByRef<WorkProduct>
t
heWorkPro
duct; };
PM: DCD Mapping
PM: DCD Code:
class Project
{ private:
char *Name;
char *Descr;
Date StartDate;
static int NumberOfProjects;
public:
Project (char *Name);
Project (void); ~Project
(void); char *getName (void);
void setName (char
*theName);
void setDescr (char
*Descr); char *getDescr
(void);
void setStartDate (Date
theStartDate)
; Date getStartDate (void);
void
addActivity (const Activity
&theActivity);
CollectionByRef<Activity> getAllAcitivities (void);
static int getNumberOfProjects (void);
void save (void);
void load (char *Name);
protected:
bool hasActivities
(void); };
int
Project::NumberOfProject
s = 0;
PM: Sequence Diagram
PM: Sequence to Main
void main (void)
{ char *Name; char *Descr; Date
StartDate; Project aProject;
// provide project Name, descr, and
startdate
aProject.setName (Name);
aProject.setDescr (Descr);
aProject.setStartDate (StartDate);
aProject.save (); }
