The document shows examples of how to implement Java code from UML diagrams, including: 1) Implementing classes like Student and Course from UML class diagrams with attributes, operations, and visibility. 2) Translating associations like between Student and Schedule into Java code with references between classes. 3) Demonstrating generalizations, interfaces, compositions, and other UML constructs in Java code.

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

2. // 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

3. 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

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

5. <<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

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

7. 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

8. Schedule
Student
class Student
{
public Student() { }
private Schedule theSchedule;
}
class Schedule
{
public Schedule() { }
}
Navegabilidade
 Uma direção

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

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

11. // 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

12. 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

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

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

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

16. 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

17. 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

18. 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.

19. 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

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

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