Mapeamento uml java

Mapeamento de UML -> JAVA
Como implementar Código JAVA a partir de
algumas notações UML.

// Notes will be used in the
// rest of the presentation
// to contain Java code for
// the attached UML elements
public class Course
{
Course() { }
protected void finalize()
throws Throwable {
super.finalize();
}
};
Course
Representação de notas

public class Student
{
private String name;
public void addSchedule (Schedule theSchedule; Semester forSemester) {
}
public boolean
hasPrerequisites(CourseOffering forCourseOffering) {
}
protected boolean
passed(CourseOffering theCourseOffering) {
}
}
Visibilidade para Atributos e Operações
Student
- name : String
+ addSchedule (theSchedule: Schedule, forSemester: Semester)
+ hasPrerequisites(forCourseOffering: CourseOffering) : int
# passed(theCourseOffering: CourseOffering) : int

class Student
{
private static int nextAvailID = 1;
public static int getNextAvaiIID() {
}
}
Escopo de atributos, operações e classes
Student
- nextAvailID : int = 1
+ getNextAvaiIID() : int

<<utility>>
MathPack
-randomSeed : long = 0
-pi : double = 3.14159265358979
+sin (angle : double) : double
+cos (angle : double) : double
+random() : double
import java.lang.Math;
import java.util.Random;
class MathPack
{
private static randomSeed long = 0;
private final static double pi =
3.14159265358979;
public static double sin(double angle) {
return Math.sin(angle);
}
static double cos(double angle) {
return Math.cos(angle);
}
static double random() {
return new
Random(seed).nextDouble();
}
}
void somefunction() {
. . .
myCos = MathPack.cos(90.0);
. . .
Classe utilitária

Outer
Outer::Inner
class Outer
{
public outer() { }
class Inner {
public Inner() { }
}
}
Inner Class

Schedule
Student
class Student
{
public Student() { }
private Schedule theSchedule;
}
// no need to import if in same package
class Schedule
{
public Schedule() { }
private Student theStudent ;
}
Associações
 Bi-direcional

Schedule
Student
class Student
{
private Schedule theSchedule;
}
class Schedule
{
}
Navegabilidade
 Uma direção

Professor
CourseOffering
instructor
class Professor
{
public Professor() {}
private CourseOffering theCourseOffering;
}
class CourseOffering
{
public CourseOffering() {}
private Professor instructor;
}
Regras nas associações

CourseOffering
Schedule
class Schedule
{
public Schedule() {}
private CourseOffering[] primaryCourses =
new CourseOffering[4]
}
class CourseOffering
{
public CourseOffering() {}
}
0..4 primaryCourses
Associações múltiplas

// No need to import if in the same package
class PrimaryScheduleOfferingInfo
{
public PrimaryScheduleOfferingInfo() {}
public CourseOffering get_theCourseOffering(){
return theCourseOffering;
}
public void set_theCourseOffering(CourseOffering toValue){
theCourseOffering = toValue;
}
private char get_Grade (){ return grade; }
private void set_Grade(char toValue) { grade = toValue; }
private char grade = ‘I’;
private CourseOffering theCourseOffering;
}
Classe associativa
Schedule CourseOffering
0..4
0..*
primaryCourses
PrimaryScheduleOfferingInfo
- grade: char = I
alternateCourses
0..2
0..*
0..*
Schedule CourseOffering
1
1 0..4
0..2
0..*
alternateCourses
primaryCourseOfferingInfo PrimaryScheduleOfferingInfo
- grade: char = I
Design Decisions

Course
prerequisites
0..* import java.util.Vector;
class Course
{
public Course() {}
// The unbounded multiple association
// is stored in a vector
private Vector prerequisites;
}
Associação reflexiva

Schedule
Student
class Schedule
{
private Student theStudent;
}
0..*
1 import java.util.Vector;
class Student
{
private Vector theSchedule;
}
Agregação

Schedule
Student
class Schedule
{
private Student theStudent;
}
0..*
1
import java.util.Vector;
class Student
{
private Vector theSchedule = new Vector();
}
Composição

Serializable
<<Interface>>
Schedule
<<entity>>
interface Serializable {
}
class Schedule implements Serializable {
}
Interfaces and Realizações

GroundVehicle
class Truck extends GroundVehicle
{
public float tonnage;
public void getTax() { }
}
class GroundVehicle
{
public int licenseNumber;
public void register() { }
}
+licenseNumber: int
+register()
Truck
+tonnage: float
+getTax()
Generalização

Amphibious
Vehicle
<<Interface>>
IVehicle
<<Interface>>
IWaterVehicle
Land
Vehicle
{overlapping}
class AmphibiousVehicle
extends LandVehicle
implements WaterVehicle
{
. . .
}
<<realize>>
<<realize>>
interface IWaterVehicle :
implements IVehicle
{
. . .
}
Em Java, uma classe herda somente de
uma classe, porém, ela pode implementar
várias Interfaces.
Herança Múltipla

Herança múltipla (continuação)
AmphibiousVehicle
LandVehicle
IAmphibiousVehicle
<<Interface>>
IHobby
<<Interface>>
IWaterVehicle
<<Interface>>
ILandVehicle
<<Interface>>
In Java, a class can inherit
from one superclass.
It can, however implement
multiple interfaces.
An interface can inherit
from many interfaces.

abstract class Animal
{
public abstract void talk();
}
Animal
{abstract}
Lion
+talk()
Tiger
+talk()
class Tiger extends Animal
{
public Tiger() { }
public void talk() { }
}
+talk() {abstract}
Classe Abstrata

Set
T, n:int
<<bind>>
mySetOfFloats
insert(T)
remove(T)
<float, 100>
Java does not support parameterized classes
Classe Parametrizada

package CourseCatalog;
public interface ICourseCatalog {
public CourseOfferingList
getCourseOfferings();
}
CourseCatalog
<<subsystem>>
ICourseCatalog
Subsistemas

Mapeamento uml java

More Related Content

Similar to Mapeamento uml java (20)

Recently uploaded (20)

Mapeamento uml java

Editor's Notes