In aceasta sectiune sunt prezentate cateva exemple de conversie a unei diagrame de clase in program java, si invers.

Interpretand notatiile standard UML, putem converti diagrama de clase de mai sus in clasa Java urmatoare:

public class Car {
    private String carColor;
    private double carPrice = 0.0;
    public String getCarColor(String model) {
        return carColor;
    }
 
    public double getCarPrice(String model) {
        return carPrice;
    }
}

Dupa cum se observa diagrama de clase nu specifica codul metodelor, ci doar semnatura acestoara. Diagramele de clase nu sunt utilizate pentru a descrie comportamentul unui modul din program, unei clase sau unei metode, ci dor pentru a reprezenta structura claselor si relatiile dintre clase. Pentru descrierea comportamentului UML pune la dispozitie ale tipuri de diagrame cum ar fi diagramele de activitati, de stare, de secvente.

In UML un atribut sau o metoda statica este subliniata. In StarUML pentru a defini un atribut sau o metoda statica (pentru a aparea subliniata) se va selecta elementul dorit, iar in ferestra Properties, se selecteaza campul Details:OwnerScope si apoi se alege valoarea CLASSIFIER pentru acesta.

public class Employee {
    private static String department = "R&D";
    private int empId;
    private Employee(int employeeId) {
        this.empId = employeeId;
    }
    public static String getEmployee(int emplId) {
        if (emplId == 1) {
            return "sample employee";
        } else {
            return "Employee not found";
        }
    }
    public static String getDepartment() {
        return department;
    }
}

Sensul sagetii semnifica faptul ca elementul din capatul de pornire al sagetii poate invoca (accesa) elementul din varful sagetii. Aceasta inseamna ca in cadrul clase Car, vom avea acces la un obiect de tip Customer. Numele asociat pe varful sagetii este rolul pe care clasa din acel capat il joaca in cadrul clasei din capatul opus. Dupa cum se vede avem intradevar in cadrul clasei Car un atribut owner de tip Customre. Un posibil mod de interpretare al diagramei de clase de mai sus este acesta:

public class Customer {
private String name;
private String address;
private String contactNumber;
}
 
public class Car {
    private String modelNumber;
    private Customer owner;
}

Asocierea bidirectionala este reprezentata printr-o dreapta fara sens. Aceasta inseamna ca cele doua clase au acces reciproc una la alta. In exemplul de fata in cadrul clasei Customer avem un atribut car de tip Car (deci clasa Custmomer are acces la un obiecte de tip Car si poate accesa metodele acestuia) si in cadrul Car avem un atribut de tip Customer (deci clasa Customre are acces la un obiecte de tip Car si poate accesa metodele acestuia).

public class Customer {
private String name;
private String address;
private String contactNumber;
private Car car;
}
 
public class Car {
    private String modelNumber;
    private Customer owner;
}

Exista situatii in care o clasa are acces la mai multe obiecte de un alt tip. In acest caz , pentru a reprezenta numarul de obiecte se poate utiliza gradul de multiplicitate ce poate fi atasat la o asociere.

public class Car {
    private String brand;
 
    Car(String brands){
        this.brand = brands;
    }
    Car() {
    }
    public String getBrand() {
        return brand;
    }
 }
 
public class Customer {
    private Car[] vehicles;
 
    public Customer(){
        vehicles = new Car[2];
        vehicles[0] = new Car("Audi");
        vehicles[1] = new Car("Mercedes");
 
        carList.add(new Car("BMW"));
        carList.add(new Car("Chevy"));
    }
}

Generalizarea (sau mostenirea) este reprezentata printr-o sageata de tip triunghi gol care are originea in clasa derivata (clasa mostenitoare) si varvul in clasa de baza (clasa mostenita).

public class Point {
 
	int x,y;
 
	Point(int a,int b){
		x = a;
		y = b;
	}
 
	void draw(){
		System.out.println("Drawing point: "+x+":"+y);
	}
 
}
 
public class Circle extends Point{
	int r;
 
	Circle(int a, int b, int c){
		super(a,b);
		r = c;
	}
 
	void draw(){
		System.out.println("Drawing circle: "+x+":"+y+":"+r);
	}
 
}

O varianta alternativa a reprezentarii relatiei de implementare este prin reprezentarea interfetei ce este implementata print-un cerc simplu (avand doar numele interfetei, fara lista de metode definite).

interface Instrument {
                               void play();
               }
 
class Pian implements Instrument {
                               public void play() {
                                              System.out.println("Pian play");
                               }
               }
 
class Vioara implements Instrument {
                               public void play() {
                                              System.out.println("Vioara play");
                               }
               }

Agregarea este o forma de relatie de tip asociere. Aceasta specifica faptul ca un tot este compus (format) din parti. Cand componenta care agregeaza sub-componentele este distrusa, partile componente nu sunt si ele distruse si isi pot continua existenta.

public class Student {
    String name;
}
 
class School {
    private ArrayList<Student> students = new ArrayList<Student>();
 
    public void addStudent(Student s){
        students.add(s);
    }     
}

Compozitia, la fel ca si agregarea, reprezinta tot o forma de asociere. Relatia dintre tot si partile componente este mult mai stransa decat in cazul agregarii. Ciclul de viata ala sub-componentelor este strans legat de cel al componentei care le include.

public class Body {
 
	Arm[] arms = new Arm[2];
	Leg[] legs = new Leg[2];
	Head head;
 
	Body(){
		head = new Head();
		arms[0] = new Arm();
		arms[1] = new Arm();
		legs[0] = new Leg();
		legs[1] = new Leg();
	}
 
	public static void main(String[] args) {
		Body b = new Body();
	}
 
}
 
class Head{
}
 
class Leg{
 
}
 
class Arm{
 
}