UML Klassendiagramm

Das Klassendiagramm bildet ein Kernstück der Unified Modeling Language (UML). Zudem beruht dieses Diagramm auf den Prinzipien der Objektorientierung, wobei der Diagrammtyp vielseitige Anwendung findet.

Beispielsweise wird dieses Modell in der Analysephase als Domänenmodell verwendet, um ein reales Abbild zu erstellen. In der Designphase wird mit diesem Modell eine Software modelliert, wobei in der Implementierungsphase aus dem Modell Code generiert wird.

Ein Domänenmodell ist ein konzeptionelles Modell der Domäne, das sowohl Verhalten als auch Daten enthält. Die Domäne oder english Domain ist der Kontext bzw. das Umfeld in dem sich das Modell befindet.

Anwendungsgebiete von Klassendiagramme

Ein Klassendiagramm wird verwendet, um die Softwarearchitektur einfacher und übersichtlicher darzustellen und diese dann anschließend leichter umsetzen zu können.

Bausteine eines Klassendiagramms

Klassenmodelle unterteilen sich in folgende Komponenten:

• Klassen
• Schnittstellen
• Generalisierung
• Assoziation
  • Komposition
  • Aggregation

Klassen

UML Klasse aus DIA

Klassen werden in UML durch Rechtecke dargestellt, welche ebenfalls den Namen der Klassen innerhalb des Rechtecks geschrieben haben. Zudem kann eine Klasse auch Operationen (Methoden) und / oder Attribute (Eigenschaften/Variablen) haben. Zusätzlich können über dem Klassennamen bestimmte Schlüsselwörter wie "{abstrakt} oder {interface}" stehen. Außerdem besitzen Operationen und Attribute der Klassen bestimmte Sichtbarkeiten (siehe Sichtbarkeit), welche im Folgenden erklärt werden.

Sichtbarkeit

public oder auch +

Bei der public oder auch öffentlichen Sichtbarkeit, wird keine Beschränkung für die Funktionen oder Variablen vergeben. Somit kann ein Zugriff auf diese Komponenten von überall aus erfolgen..

protected oder auch #

Wenn Operationen oder Attribute die Sichtbarkeit protected besitzen, kann auf diese innerhalb der selben Klasse, von Klassen welche von dieser Klasse erben und von Klassen aus dem selben Package zugegriffen werden.

private oder auch −

Wenn eine Klasse eine private Sichtbarkeit aufweist, können die Operationen und Attribute nur in der Klasse mit dieser Sichtbarkeit gesehen (aufgerufen) werden.

package oder auch ~

Bei einer Klasse mit einer package Sichtbarkeit sind die Funktionen und Variablen innerhalb des gleichen Package aufrufbar.

Hier wird im Folgenden Klassen anhand von Beispielen gezeigt:

public

Public Attribute

Diese oben dargestellte Methode verfügt über zwei public Variablen und einer public Methode, wobei der Fokus auf den Variablen liegt. Der Code sieht wie folgt aus:

public class Klasse{

  public int a;
  public int b;

  public int count(){
    return this.a + this.b;
  }
}

Public Methode

Dieses Bild zeigt eine Klasse mit keinen Variablen aber mit einer public Methode. Der Code dieses Bildes wurde folgendermaßen umgesetzt:

public class Klasse{

  public int count(int a, int b){
    return a + b;
  }
}

...

public static void main(String[] args){
  Klasse class = new Klasse[];
  class.count(10,20);
}

protected

protected Variablen

Dieses Bild zeigt zwei protected Variablen und eine protected Methode. Die Umsetzung des Codes sieht wie folgt aus:

protected class Klasse{

  protected int a;
  protected int b;

  protected int divide(){
    return this.a / this.b;
  }
}

protected Methode

Dieses Bild zeigt eine protected Methode ohne Klassenvariablen. Die Klasse wurde in folgenden Code umgesetzt:

protected class Klasse{

  protected int divide(int a, int b){
    return a / b;
  }
}

...

public static void main(String[] args){
  Klasse class = new Klasse[];
  class.divide(10,20);
}

private

private Variablen

Die oben dargestellte UML-Klasse zeigt zwei private Variablen und eine private Methode an. Der Code dieser Klasse sieht wie folgt aus:

private class Klasse{

  private int a;
  private int b;

  private int minus(){
    return this.b - this.a;
  }
}

private Methode

Die im oberen Bild dargestellen Klasse wurde in folgenden Code umgewandelt:

private class Klasse{

  private int count(int a, int b){
    return b - a;
  }
}

...

public static void main(String[] args){
  Klasse class = new Klasse[];
  class.count(10,20);
}

UML Schnittstelle

Schnittstellen

Eine Schnittstelle wird nahezu gleich wie eine Klasse dargestellt und zwar mit einem Rechteck. Der Unterschied ist aber, dass bei einer Schnittstelle das Rechteck mit dem Schlüsselwort "interface" gekennzeichnet werden.

Hier wird an aus einem UML-Diagramm ein Programm erstellt:

Interface und Implementierung

In dem oberen Bild sieht man ein Interface mit mehreren Methoden. Diese Methoden werden von einer Klasse namens Rectangle implementiert. Die Programmierung zu diesen zwei Elementen sieht wie folgt aus:

Moveable.java

interface Moveable {

  int left(int x);
  int right(int x);
  int up(int y);
  int down(int y);
  int forwards(int z);
  int backwards(int z);

}

Rectangle.java

public class Rectangle implements Moveable{

    int positionx;
    int positiony;
    int positionz;

    @Override
    public int left(int x) {
        return positionx - x;
    }

    @Override
    public int right(int x) {
        return positionx + x;
    }

    @Override
    public int up(int y) {
        return positiony + y;
    }

    @Override
    public int down(int y) {
        return positiony - y;
    }

    @Override
    public int forwards(int z) {
        return positionz + z;
    }

    @Override
    public int backwards(int z) {
        return positionz - z;
    }
}

Generalisierung

Generalisierung

Durch eine Generalisierung "erben" speziellere Klassen von generelleren Klassen. Dadurch werden bestimmte Merkmale von der generellen Klassen an die spezialisierte Klasse "vererbt". Die Pfeilspitze der Generalisierung zeigt auf die Oberklasse (Klasse von, welcher geerbt wird).

Im Folgenden wird ein Beispiel zum besseren Verständnis von Generalisierungen gezeigt:

Generalisierung

In dem oberen dargestellten Bild sieht man eine Generalisierung zwischen einer abstrakten und einer normalen Klassen. Die Umsetzung in JAVA würde wie folgt aussehen:

Animal.java

package at.htldornbirn.awi3.swp3.animals;

public abstract class Animal {
	private String habitat;
	
	public Animal(String habitat) {
		this.habitat = habitat;
	}
	
	public abstract void move();
	
	public String getHabitat() {
		return habitat;
	}
}

Fuchs.java

package at.htldornbirn.awi3.swp3.animals;

public class Fuchs extends Animal {

	public Fuchs() {
		super("Woods/Forest");
	}
	@Override
	public void move() {
		System.out.println("Running round his " + getHabitat());
	}
}

Assoziation

Eine Assoziation bezeichnet eine Beziehung zwischen zwei oder mehreren Klassen, wobei die häufigsten Verbindungen zwischen genau zwei Klassen auftreffen. Es gibt folgende zwei Arten von Assoziationen:

• n-äre Assoziation

In folgenden Bild sieht man eine Binäre Assoziation. (Binär, weil zwei Klassen miteinander verbunden wurden)

Binäre Assoziation

• reflexive Assoziation

Im hier dargestellten Bild sieht man eine reflexive Assoziation, welche auf sich selbst verweist.

Reflexive Assoziation

Da Assoziationen durch Linien dargestellt werden, müssen diese durch ein Assoziationsende gekennzeichnet werden. Diese Assoziationsenden können folgende Merkmale aufweisen:

• Sie können eine Multiplizität besitzen. Diese gibt Informationen über das Beziehungsverhältnis zweier Klassen. Diese Zahlen befinden sich nur im positiven und ganzzahligen Bereich, wobei der Beginn bei der Zahl 0 liegt.
  • Multiplizitäten werden im folgenden Format angegeben:

untereSchranke..obereSchranke

• • Bei * oder auch 0..* wird die untereSchranke als 0 und die obereSchranke als unendlich angenommen.
  • Beide Schranken dürfen nicht 0 oder unbeschränkt sein. Falls beide Grenzen trotzdem gleich groß sind, wird nur die obereSchranke angegeben.
  • Bei einer Multiplizität von 0..1 wird das Element als optional bezeichnet.
  • Wenn die obereSchranke über dem Wert 1 liegt, wird das Element als mehrwertiges Element bezeichnet, da mehrere Wert annehmbar sind.
• Sie können Namen besitzen.
• Sie können eine Sichtbarkeit aufweisen.
• Es kann spezifiziert werden, ob das Assoziationsende "ordered" und / oder unique ist.

Zudem Assoziationsende kommen oft Multiplizitäten hinzu, welche die Beziehung zwischen den zwei Instanzen regelt. Im folgenden werden auf zwei Arten der Assoziationen genauer eingegangen.

Komposition und Aggregation

Um Beziehungen mit Ganzen und Teilen darzustellen werden die Aggregation und die Komposition verwendet.

Komposition und Aggregation

Die graphische Darstellung einer Komposition ist eine Linie mit einer ausgefüllten Raute, welche mit der Kardinalität 1 beschriftet wird und mit dem Ganzen Teil der Beziehungspartner verbunden ist. Bei einer Komposition können die Teile nicht ohne das Ganze existieren. Das bedeutet, dass das Teil Element existenziell abhängig von Ganz Element ist.

Die graphische Darstellung einer Aggregation ist eine Linie mit einer nicht ausgefüllten Raute, welche die Kardinalität 0..* besitzt und mit dem Ganzen Teil verbunden ist. Die Elemente in einer Aggregation besitzen keine Exisitenzabhängigkeit, da die Teil Elemente auch ohne die Ganz Elemente bestehen können.

Die Assoziationsarten werden prinzipiell mittels der Kardinalität unterschieden. Zudem sind die Teil Elemente Bestandteil genau eines Ganz Elementes, da sie NIE zu mehrere Ganz Elementen gehören.

Stelle in einem anschaulichen Beispiel ein Klassendiagramm Code gegenüber

Diese Umsetzung erfolgte mit der Programmiersprache JAVA.

Fahrzeuge in einem UML Klassendiagramm

Vehicle.java

package at.htldornbirn.swp4.hue2.vehicle;

public abstract class Vehicle {
    private int maxSpeed;
    private int wheels;

    public Vehicle(int maxSpeed, int wheels) {
        this.maxSpeed = maxSpeed;
    }

    public void move() {
        System.out.println("I am moving at " + maxSpeed + " with " + wheels + " wheels.");
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public abstract void start();
}

Bike.java

package at.htldornbirn.swp4.hue2.vehicle.unmotorized;

import at.htldornbirn.swp4.hue2.vehicle.Vehicle;

public class Bike extends Vehicle {
    public Bike(int maxSpeed, int wheels) {
        super(maxSpeed, wheels);
    }

    @Override
    public void start() {
        System.out.println("I start to step into the pedals!");
    }
}

Rollerblades.java

package at.htldornbirn.swp4.hue2.vehicle.unmotorized;

import at.htldornbirn.swp4.hue2.vehicle.Vehicle;

 public class Rollerblades extends Vehicle {
    public Rollerblades(int maxSpeed) {
        super(maxSpeed, 8);
    }

    @Override
    public void start() {
        System.out.println("I start skate!");
    }
}

Skateboard.java

package at.htldornbirn.swp4.hue2.vehicle.unmotorized;

import at.htldornbirn.swp4.hue2.vehicle.Vehicle;

 public class Skateboard extends Vehicle {
    public Skateboard(int maxSpeed) {
        super(maxSpeed, 4);
    }

    @Override
    public void start() {
        System.out.println("I step with one feet on the ground to start!");
    }
}

MotorizedVehicle.java

package at.htldornbirn.swp4.hue2.vehicle.motorized;

import at.htldornbirn.swp4.hue2.vehicle.Vehicle;

 public abstract class MotorizedVehicle extends Vehicle {
    private float kw;

    public MotorizedVehicle(int maxSpeed, int wheels, float kw) {
        super(maxSpeed, wheels);
        this.kw = kw;
    }

    @Override
    public void start() {
        System.out.println("I am starting my engine with " + kw + " kw.");
    }
}

EBike.java

package at.htldornbirn.swp4.hue2.vehicle.motorized;

public class EBike extends MotorizedVehicle {
    public EBike(int maxSpeed, float kw) {
        super(maxSpeed, 2, kw);
    }
}

Lkw.java

package at.htldornbirn.swp4.hue2.vehicle.motorized;

public class Lkw extends MotorizedVehicle {
    public Lkw(int maxSpeed, int wheels, float kw) {
        super(maxSpeed, wheels, kw);
    }
}

Pkw.java

package at.htldornbirn.swp4.hue2.vehicle.motorized;

public class Pkw extends MotorizedVehicle {
    public Pkw(int maxSpeed, float kw) {
        super(maxSpeed, 4, kw);
    }
}

Quellen

https://de.wikipedia.org/wiki/Klassendiagramm#Notation_in_der_Unified_Modeling_Language

https://www.sparxsystems.de/ressourcen/literatur/leseprobe-zu-projektabwicklung-mit-uml-und-enterprise-architect/klassendiagramm-class-diagram/

https://de.wikipedia.org/wiki/Assoziation_(UML)

https://de.wikipedia.org/wiki/Multiplizit%C3%A4t_(UML)