CCWiki - Benutzerbeiträge [de]

Objektorientierte Programmierung

2021-02-26T11:05:58Z

Sam:

<cite>Die objektorientierte Programmierung (kurz OOP) ist ein auf dem Konzept der Objektorientierung basierendes Programmierparadigma. Die Grundidee besteht darin, die Architektur einer Software an den Grundstrukturen desjenigen Bereichs der Wirklichkeit auszurichten, der die gegebene Anwendung betrifft. Ein Modell dieser Strukturen wird in der Entwurfsphase aufgestellt. Es enthält Informationen über die auftretenden Objekte und deren Abstraktionen, ihre Typen. Die Umsetzung dieser Denkweise erfordert die Einführung verschiedener Konzepte, insbesondere {{AL|Klasse|Klassen}}, {{AL|Vererbung}}, [[{{PAGENAMEE}}#Polymorphismus|Polymorphie]] und [[{{PAGENAMEE}}#Has_A|spätes Binden (dynamisches Binden)]].</cite><ref>https://de.wikipedia.org/wiki/{{PAGENAMEE}}</ref>
{{TOC limit|4}}
= Java =
Java ist eine objektorientierte Programmiersprache. In einigen Punkten nimmt Sie die '''Objektorientierung''' nicht so streng wie andere Sprachen. Ein Beispiel hierfür wären die {{Link|Primitive_Datentypen|primitiven Datentypen}}. Somit ist in Java nicht alles ein '''Objekt''' {{Link|Objekt.2FInstanz_VS._Klasse|(Was ist ein Objekt?)}} . 
== Primitive Datentypen ==
In Java gibt es eine vielzahl von '''primitiven Datentypen'''. Sie unterscheiden sich darin, dass Sie kein '''Objekt''' sind. Sie haben keine {{AL|Methoden}} und auch keine {{AL|Attribute}}. Wird eine Variable mit einem '''primitiven Datentyp''' erstellt und dieser Variable ein Wert zugewiesen, so enthält diese Variable den wirklichen '''Wert''' und nicht nur eine '''Referenz''' auf das eigentliche '''Objekt''':
{{JML|code=//Variable a enthält den Wert 10
int a = 10;
//Variable b enthält nur den Verweis auf das Integer Objekt mit dem Wert 10
Integer b = Integer.valueOf(10);
}}
Zu jedem primitiven Datentyp gibt es eine entsprechende Klasse:
{| class="wikitable"
|+ Entsprechende Klasse für primitive Datentypen
|-
! primitiver Datentyp !! Klasse/Komplexer Datentyp !! Beschreibung
|-
| {{JSL|int}} || {{JSL|java.lang.Integer}} || Ganzzahl in Zweierkomplent Darstellung, max: 231-1, min: -231
|-
| {{JSL|long}} || {{JSL|java.lang.Long}} || Ganzzahl in Zweierkomplent Darstellung, max: 263-1, min: -263
|-
| {{JSL|float}} || {{JSL|java.lang.Float}} || Fließkommazahl
|-
| {{JSL|double}} || {{JSL|java.lang.Double}} || Fließkommazahl mit doppelter Genauigkeit
|-
| {{JSL|char}} || {{JSL|java.lang.Character}} || Einzelnes Zeichen
|-
| {{JSL|boolean}} || {{JSL|java.lang.Boolean}} || Wahrheitswert, {{JSL|true}} oder {{JSL|false}}
|}
Primitive Datentypen können automatisch in ihr entsprechendes Klassenäquivalent (in ein '''Objekt''') umgewandelt werden und natürlich umgekehrt. Dieser Prozess nennt sich '''Autoboxing'''. Dies ist vor allem von Vorteil, wenn mit '''Collections (Listen,...)''' gearbeitet wird, da diese nur mit '''Objekten''' funktionieren.
{{JML|code=
//Umwandlung der Zahl 10 in ein Integer Object
Integer b = 10;
//Integer Object wird in primitive Zahl 10 umgewandelt
int c = b;
}}

== Klasse ==
<cite>Unter einer Klasse (auch Objekttyp genannt) versteht man in der objektorientierten Programmierung ein abstraktes Modell bzw. einen Bauplan für eine Reihe von ähnlichen Objekten. Die Klasse dient als Bauplan für die Abbildung von realen Objekten in Softwareobjekte und beschreibt Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der Objekte. Verallgemeinernd könnte man auch sagen, dass eine Klasse dem Datentyp eines Objekts entspricht.<ref>https://de.wikipedia.org/wiki/Klasse_(Objektorientierung)</ref></cite> 
Wir sehen, eine '''Klasse''' kann man sich wie eine Vorlage vorstellen, aus dieser dann '''Instanzen''' bzw. '''Objekte''' mittels des Schlüsselworts {{JSL|new}} erstellt werden. Weiters sei erwähnt, dass jede '''Klasse''' egal ob es hingeschrieben wird oder nicht, von der Java '''Klasse''' {{JSL|java.lang.Object}} erbt.
=== Konstruktor ===
Jede '''Klasse''' hat einen Konstruktor, ist dieser leer, d.h. er nimmt keine Parameter, muss dieser nicht geschrieben werden. Der Konstruktor heißt immer gleich wie die '''Klasse''' selbst.
{{JML|code=
public class Animal {
private String name;

//Standardkonstruktor wird verwendet.
}
...
//Instanz von Animal erstellen
Animal a = new Animal();
}}
Wollen wir nun beispielsweise garantieren, dass ein '''Animal''' bei der Instanzierung einen Namen hat, so könnten wir den '''Konstruktor''' verändern.
{{JML|code=
public class Animal {
private String name;

public Animal(String name) {
this.name = name;
}
}
...
//Instanz von Animal erstellen
Animal a = new Animal("Alfons");
}}
Es können auch mehrere '''Konstruktoren''' existieren. Diese können sich auch gegenseitig aufrufen. Sobald ein '''Konstruktor''' definiert wird, so kann der '''Standardkonstruktor''' nicht mehr zur Instanzierung verwendet werden. Soll der '''Standardkonstruktor''' weiter verfügbar sein, so muss dieser explizit hingeschrieben werden. Haben wir mehrere '''Konstruktoren''' so können wir auch von '''Konstruktor {{Link|Überladen_von_Methoden|Überladung}}''' sprechen.
{{JML|code=
public class Animal {
private String name;

public Animal() {
this("John Doe")
}

public Animal(String name) {
this.name = name;
}
}
...
//Instanz von Animal erstellen
Animal a = new Animal(); //John Doe
//Weitere Instanz mit gewähltem Namen
Animal b = new Animal("Alfons"); //Alfons
}}

=== Attribute ===
'''Klassen''' haben '''Attribute''' (Eigenschaften). Hier werden zwei Varianten von '''Attributen''' unterschieden. '''Instanzattribute''' und '''Klassenattribute'''.
==== Instanzattribut ====
{{JML|code=
public class Animal {
public String name;
}
...
//Korrekter Zugriff
Animal a = new Animal();
System.out.println(a.name);
}}
Jede '''Instanz''' einer '''Klasse''' verfügt über eigene '''Instanzattribute''', diese werden nicht untereinander geteilt. Das heißt, gibt es mehrere '''Instanzen''' der selben '''Klasse''', so haben die '''Instanzattribute''' unterschiedliche Werte.

==== Klassenattribut ====
{{JML|code=
public class Animal {
public static double PI = 3.14;
}
//Korrekter Zugriff
System.out.println(Animal.PI);
}}
'''Attribute''' die mit dem Schlüsselwort '''static''' gekennzeichnet werden, existieren nur einmal. Vereinfacht gesagt, diese '''Attribute''' sind an die '''Klasse''' und nicht an die '''Instanz''' gebunden.

=== Methoden ===
'''Methoden''' sind Abläufe oder Verhaltensweisen die in '''Klassen''' definiert werden. Durch Methoden können '''Objekte''' miteinander interagieren, bzw. deren Zustand kann modifiziert werden. Genauso wie bei den '''Attributen''' können '''Methoden''' für eine '''Instanz''' mit dem Schlüsselwort {{JSL|static}} für die '''Klasse''' definiert werden. 
'''Methoden''' haben zumindest:
* Methodennamen
* Rückgabetype
* 0 - * Übergabeparameter
* Methodenrumpf (Code der Ausgeführt wird)

==== Methodensignatur ====
Die '''Methodensignatur''' einer Methode, besteht aus '''Methodenname''' und '''Übergabeparameter'''. Weiters muss die Signatur jeder '''Methode''' in der '''Klasse''' in der sie definiert wurde eindeutig sein. 
Warum gehört der '''Rückgabetyp''' nicht zur '''Methodensignatur'''? Dies soll anhand von folgendem Beispiel illustriert werden:
{{JML|code=
public class Calc {
public int add(float a, float b) {
return (int) (a + b);
}

public float add(float a, float b) {
return a + b;
}
}
}}
In '''Java''' ist es nicht zwingend nötig den '''Rückgabewert''' einer '''Methode''' zu verarbeiten:
{{JML|code=
public static void main(String[] args) {
Calc c = new Calc();
c.add(10.0f, 20.0f);
}
}}
Der '''Compiler''' hat keine Möglichkeit herauszufinden, welche '''Methode''' in {{JSL|Calc}} nun verwendet werden soll. Deswegen gehört der '''Rückgabetyp''' nicht zur '''Methodensignatur''' und das Beispiel würde nicht compilieren.

==== Instanzmethode ====
Folgendes Beispiel zeigt den klassischen '''getter''' und '''setter''', {{AL|Attribute}} sollten nach Möglichkeit nur über diese abgerufen und verändert werden und die {{AL|Attribute}} sollten nach außen hin nicht {{AL|Sichtbarkeit|sichtbar}} sein {{JSL|private}}. Warum? Durch den '''setter''' ist es möglich, eine inkorrekte Modifikation des '''Attributs''' zu unterbinden. Das heißt, es kann verhindert werden, dass ein {{AL|Attribute|Attribut}} auf einen Wert gesetzt wird, den es nicht annehmen sollte (z.B.: das Gewicht eines Tieres wird auf -10 gesetzt).
{{JML|code=
public class Animal {
private String name;

public void setName(String name) {
this.name = name;
}

public String getName() {
return this.name
}
}
...
//Korrekter Aufruf
Animal a = new Animal();
a.setName("Alfons");
System.out.println(a.getName());
}}

==== Klassenmethode ====
'''Klassenmethoden''' werden oft verwendet, um Operationen zu realisieren die nicht direkt mit nur einer '''Instanz''' zu tun haben. Oftmals werden '''Helper Methoden''' so realisiert. Diese '''Methoden''' werden direkt über die '''Klasse''' selbst aufgerufen, sie existieren nur einmal. Es ist möglich, aber die '''Methode''' soll nicht über eine '''Instanz''' der '''Klasse''' aufgerufen werden. Weiters sei angemerkt, das '''Klassenmethoden''' oder '''statische Methoden''' durch {{AL|Vererbung}} nicht '''überschrieben''' werden können.
{{JML|code=
public class Animal {
private float weight;

public Animal(float weight) {
this.weight = weight;
}

public static float calculateWeight(List<Animal> animals) {
float weight = 0;
for(Animal a : animal) {
weight += a.weight;
}
return weight;
}
}
...
//Korrekter Aufruf
List<Animal> animals = new ArrayList<>();
animals.add(new Animal(10));
animals.add(new Animal(20));
animals.add(new Animal(30));
System.out.println(Animal.calculateWeight(animals));
}}

== Objekt/Instanz VS. Klasse ==
Jede {{AL|Klasse}} erbt von {{JSL|java.lang.Object}}. Somit ist jede {{AL|Klasse}} ein {{JSL|java.lang.Object}}. Wenn jedoch von einem '''Objekt''' gesprochen wird, so meint man meist die '''Instanz''' einer {{AL|Klasse}}.

== Abstrakte Klasse ==
'''Abstrakte Klassen''' sind unfertige {{AL|Klasse|Klassen}}. Sie können nicht direkt '''instanziert''' werden. Es können nur '''Subklassen''' ({{AL|Klasse|Klassen}} die davon {{AL|Vererbung|erben}}) '''instanziert''' werden. Zusätzlich besteht die Möglichkeit eine '''Instanz''' durch eine '''Anonyme Implementierung''' der '''abstrakten Klasse''' zu erstellen.
 Sie einzusetzen ist sinnvoll, wenn sich eine Gruppe von {{AL|Klasse|Klassen}} Funktionalität teilt, doch gewisse Funktionalität von jeder einzelnen {{AL|Klasse}} implementiert werden muss. 
Die noch zu implementierenden '''Methoden''' und die {{AL|Klasse}} selbst werden mit dem Schlüsselwort {{JSL|abstract}} gekennzeichnet.
{{JML|code=
public abstract class Animal {
private String name;
private float weight;

public Animal(String name, String weight) {
this.name = name;
this.weight = weight;
}

//Abstrakte Methode, muss implementiert werden
public abstract void eat();

//Normale Methode
public void sleep() {
System.out.println("My name is: " + name + " and i sleep!");
}
}

public class Cat extends Animal {
public Animal(String name, String weight) {
//Konstruktor der Superklasse muss aufgerufen werden
super(name, weight);
}

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

public class Bird extends Animal {
public Animal(String name, String weight) {
//Konstruktor der Superklasse muss aufgerufen werden
super(name, weight);
}

@Override
public void eat() {
System.out.println("I eat worms!");
}
}
...
//Instanzierung
Bird b = new Bird('Tweety');
b.eat();
//Folgendes ist auch möglich weil, durch die Vererbung, ein Bird ein Animal ist
Animal b1 = new Bird('Tweety');
b1.eat();
//Anonyme Implementierung
Animal a = new Animal("Anonymous", 30) {
public void eat() {
System.out.println("I eat nothing.");
}
};
}}

== Interface ==
'''Interfaces''' oder auch '''Schnittstellen''' bieten die Möglichkeit {{AL|Methoden}} zu definieren welche von {{AL|Klasse|Klassen}} die diese '''Schnittstelle''' implementieren, implementiert werden müssen. Eine {{AL|Klasse}} implementiert eine '''Schnittstelle''' mittels des Schlüsselworts {{JSL|implements}}, weiters müssen dann noch die {{AL|Methoden}} überschrieben bzw implementiert werden. Der Vorteil von '''Schnittstellen''' gegenüber der '''Vererbung''' ist, dass eine {{AL|Klasse}} mehrere '''Interfaces''' implementieren kann. Genauso wie bei der {{AL|Abstrakte_Klasse|abstrakten Klasse}} gilt, '''Interfaces''' können nicht direkt '''instanziert''' werden, eine '''anonyme Implementierung''' ist jedoch möglich. Ein '''Interface''' ist also eine Zusicherung dass eine {{AL|Klasse}} eine gewisse Funktionalität beherrscht.
{{JML|code=
public interface CanDrive {
void drive();
}

public interface CanFly {
void fly();
}

public class Car implements CanDrive {
@Override
public void drive() {
System.out.println("Driving on the road");
}
}

public class Plane implements CanFly {
@Override
public void fly() {
System.out.println("Flying in the sky");
}
}

public class KnightRider implements CanDrive, CanFly {
@Override
public void drive() {
System.out.println("Driving on the road");
}

@Override
public void fly() {
System.out.println("Flying in the sky");
}
}
...
//Neues Flugzeug wird instanziert
Plane plane = new Plane();
//Zuweisung ist möglich, da die Klasse Plane CanFly implementiert
CanFly canFly = plane;
canFly.fly();

//Neues Auto wird instanziert
Car car = new Car();
//Zuweisung ist möglich, da die Klasse Car CanDrive implementiert
CanDrive canDrive = car;
canDrive.drive();

//Neuer KnightRider wird instanziert
KnightRider kitt = new KnightRider();
kitt.drive();
kitt.fly();
//Zuweisung ist möglich, da die Klasse KnightRider CanDrive implementiert
canDrive = kitt;
canDrive.drive();
//Nicht möglich obwohl Kitt fliegen kann, aber die Variable hat den Typ CanDrive, dieser kann nicht fliegen
//canDrive.fly();
//Zuweisung ist möglich, da die Klasse KnightRider CanFly implementiert
canFly = kitt;
canFly.fly();
//Nicht möglich obwohl Kit fahren kann, aber die Variable hat den Typ CanFly, dieser kann nicht fahren
//canFly.drive();
}}

== Vererbung ==
Bei der '''Vererbung''' gibt es immer zwei Beteiligte, die '''Subklasse''' und die '''Superklasse'''. Die '''Subklasse''' erbt von der '''Superklasse'''. Das heißt Sie übernimmt alle {{AL|Attribute}} und alle {{AL|Methoden}}. Die '''Instanzmethoden''' können auch überschrieben werden, wenn diese nicht mit dem Schlüsselwort {{JSL|final}} markiert wurden. Vererbung geschieht mittels des Schlüsselworts {{JSL|extends}}, das heißt eine {{AL|Klasse}} erweitert eine andere {{AL|Klasse}}. In '''Java''' ist keine '''Mehrfachvererbung''' möglich. D.h. eine {{AL|Klasse}} kann nur von einer {{AL|Klasse}} erben.
Die '''Superklasse''' kann entweder eine normale {{AL|Klasse}} oder eine {{AL|Abstrakte_Klasse|abstrakte Klasse}} sein. Von einem {{AL|Interface}} wird nicht geerbt, dieses wird '''implementiert'''.
{{JML|code=
public class Animal {
private String name;

public Animal(String name) {
this.name = name;
}

//Kann nicht überschrieben werden
public final String getName() {
return this.name
}

public void sayHello() {
System.out.println("Hallo, ich bin " + name);
}
}

public class Cat extends Animal {
public Cat(String name) {
//Der Konstruktor der Superklasse muss aufgerufen werden
super(name);
}

@Override
public void sayHello() {
System.out.println("Hallo mein Name ist " + getName() + " und ich bin eine Katze!");
}
}

public class Dog extends Animal {
public Dog(String name) {
//Der Konstruktor der Superklasse muss aufgerufen werden
super(name);
}

@Override
public void sayHello() {
System.out.println("Hallo mein Name ist " + getName() + " und ich bin eine Dog!");
//Aufruf der Methode in der Superklasse.
super.sayHello();
}
}
}}
Folgendes ist wichtig bei der Vererbung zu erwähnen. Die '''Subklasse''' muss den '''Konstruktor''' der '''Superklasse''' aufrufen, dies geschieht mittels {{JSL|super(...)}}. Wenn es nur den '''Standardkonstruktor''' (keine Parameter) gibt, muss {{JSL|super()}} nicht aufgerufen werden.

== Package ==
{{AL|Klasse|Klassen}} und {{AL|Interface|Interfaces}} sind in '''Java''' immer in '''Packages''' unterteilt. Diese dienen zum Gruppieren nach verschiedenen Zugehörigkeiten. Die '''Package''' Definition befindet sich immer bei der {{AL|Klasse}} oder dem {{AL|Interface}} ganz oben. Die Dateien werden intern in Ordnern abgelegt.
{{JML|code=
package at.drlue.matura;

public class Matura {
public void printNote() {
System.out.println("Eins");
}
}
}}
Die {{AL|Klasse}} {{JSL|Matura}} befindet sich in der Datei '''Matura.java''', diese Datei befindet sich im Ordner '''at/drlue/matura/'''.

== Sichtbarkeit ==
Die Sichtbarkeit einer [[{{PAGENAMEE}}#Klasse|Klasse]], [[{{PAGENAMEE}}#Methode|Methode]] oder eines [[{{PAGENAMEE}}#Attribute|Attributs]] kann über Schlüsselwörter verändert werden. Diese beschreiben von wo aus der Zugriff darauf erfolgen darf. Die Folgende Tabelle zeigt diese Schlüsselwörter und von wo aus der Zugriff erfolgen kann:
[[Datei:Sichtbarkeit.png|mini|ohne|400px|Sichtbarkeit<ref>https://wuselsnej.wordpress.com/coding/android/android-sichtbarkeit-java/</ref>]]

'''Datei: at/drlue/matura/packageA/A.java'''
{{JML|code=public class A {
public String hi() {
System.out.println("Hallo");
}

private String bye() {
System.out.println("Bye");
}

protected String what() {
System.out.println("Was geht?");
}

//Ohne Sichtbarkeitsmodifier ist es Default
String howDoYouDo() {
System.out.println("Wie geht es dir?");
}
}
}}
'''Datei: at/drlue/matura/packageB/B.java'''
{{JML|code=public class B {
private A a = new A();

public String hiAccess() {
a.hi();
}

public String byeAccess() {
//Nicht möglich da Zugriff private
//a.bye();
}

public String whatAccess() {
//Zugriff möglich, da nicht im selben Package
a.what();
}

public String howDoYouDoAccess() {
//Zugriff nicht möglich, da nicht im selben Package
a.howDoYouDo();
}
}
}}
'''Datei: at/drlue/matura/packageA/C.java'''
{{JML|code=public class C {
private A a = new A();

public String hiAccess() {
a.hi();
}

public String byeAccess() {
//Nicht möglich da Zugriff private
//a.bye();
}

public String whatAccess() {
//Zugriff möglich, da selbes Package
a.what();
}

public String howDoYouDoAccess() {
//Zugriff möglich, da selbes Package
a.howDoYouDo();
}
}
}}
'''Datei: at/drlue/matura/packageD/D.java'''
{{JML|code=public class D extends A {
private A a = new A();

public String hiAccess() {
a.hi();
}

public String byeAccess() {
//Nicht möglich da Zugriff private
//a.bye();
}

public String whatAccess() {
//Zugriff möglich, da geerbt wird
a.what();
}

public String howDoYouDoAccess() {
//Zugriff nicht möglich, da nicht im selben Package obwohl geerbt wird
a.howDoYouDo();
}
}
}}
== Casten ==
Mittels '''Casting''' können untereinander '''kompatible Datentypen''' umgewandelt werden.
=== Casten von primitiven Datentypen ===
{{Link|Primitive_Datentypen|Primitive Datentypen}} enthalten, werden Sie einer Variable zugewiesen, wirklich den Wert den Sie repräsentieren. Ein '''casten''' führt wirklich zu einem neuen Wert (verändert aber nicht den alten). Alle {{Link|Primitive_Datentypen|primitiven Datentypen}} können untereinander umgewandelt werden, außer {{JSL|boolean}}.
{{JML|code=long a = 10;
//long wird in int umgewandelt
int b = (int)a;
//einem long kann aber ohne Casting ein int zugewiesen werden
a = b;
}}

=== Casten von Objekten ===
'''Objekte''' können nur in den Datentyp anderer kompatibler {{AL|Klasse|Klassen}} '''gecastet''' werden. Vereinfacht gesagt, es muss möglich sein, dass der '''Cast''' erfolgreich ist. Weiters ist hier zu erwähnen, dass keine Umwandlung der Daten erfolgt. Wird ein '''Objekt''' einer Variable zugewiesen, so ist dies '''nicht''' der Wert selbst, sondern nur eine '''Referenz''' darauf. Mit dem '''Cast''' wird nur das erwartete geändert, dass sich an der Stelle befindet, an die diese Referenz zeigt.
{{JML|code=
public class A {}

public class B {}
...
public static void main(String[] args) {
A a = new A();
//Zuweisung nicht möglich, da A niemals ein B sein kann
//B b = (B)a;

//Jede Klasse erbt von java.lang.Object kein Cast ist erforderlich da A ein Object ist
Object obj = a;
//Dieser Cast ist möglich, wir wissen zwar dass dies zu einer ClassCastException führt
B b = (B) obj;
}
}}

== Exceptions ==
'''Exceptions''' oder '''Ausnahmen''' können von {{AL|Methoden}} und auch von {{Link|Konstruktor|Konstruktoren}} geworfen werden. Eine '''Exception''' tritt auf, wenn eine {{AL|Methoden}} außerhalb ihrer gewünschten Funktionalität operiert. Jede '''Exception''' ist ein {{JSL|java.lang.Throwable}}, d.h. Sie kann mittels des Schlüsselworts {{JSL|throw}} geworfen werden. Weiters unterscheiden wir zwei Arten von '''Exceptions'''.
=== Checked Exceptions ===
Dazu gehört jede '''Exception''' die von {{JSL|java.lang.Throwable}} erbt, aber keine {{JSL|java.lang.RuntimeException}} und kein {{JSL|java.lang.Error}} ist. Wenn '''Checked Exceptions''' geworfen werden, so muss dies in der {{AL|Methoden|Methode}} mittels {{JSL|throws ExceptionName}} deklariert werden. Zusätzlich muss die geworfene '''Exception''' auch immer von der Aufrufenden {{AL|Methoden|Methode}} behandelt, oder weitergeworfen, werden.

=== Unchecked Exceptions ===
Dazu gehören Alle '''Exceptions''' welche von {{JSL|java.lang.Error}} oder von {{JSL|java.lang.RuntimeException}} erben. Diese '''Exceptions''' müssen nicht in der {{Link|Methoden}} Definition deklariert werden. Sie können abgefangen und behandelt werden, normalerweise sollten diese aber überhaupt nicht auftreten.
{| class="wikitable"
|+ Beispiele für RuntimeExceptions
|-
! Klasse !! Code
|-
| {{JSL|java.lang.IndexOutOfBoundsException}} ||
{{JML|code=
int[] arr = new int[]{1,2,3,4};
//Index existiert nicht
System.out.println(arr[5]);
}}
|-
| {{JSL|java.lang.NullPointerException}} ||
{{JML|code=
Animal a = null;
//Die Referenz ist null, beim Zugriff crashts
System.out.println(a.toString());
}}
|}
{| class="wikitable"
|+ Beispiele für Errors
|-
! Klasse !! Code
|-
| {{JSL|java.lang.OutOfMemoryError}} ||
{{JML|code=
//Tritt auf wenn keine weiteren neuen Objekte mehr erstellt werden können
List<int[]> list = new LinkedList<>();
while(true) {
list.add(new int[10000]);
}
}}
|}

=== Exceptions selbst definieren ===
Natürlich können auch eigene '''Exceptions''' erstellt werden. Sinnvoll ist dies, wenn die eigene '''Exception''' einen Mehrwert an Information liefert.
{{JML|code=
public class HttpStatusCodeException extends Exception {
private int statusCode;
private String url;

public HttpStatusCodeException(int statusCode, String url) {
//Text für die Exception wird erstellt
super("Beim Aufruf von "+url+" ist ein Fehler mit dem Statuscode ["+statusCode+"] aufgetreten");
this.statusCode = statusCode;
this.url = url;
}

public int getStatusCode() {
return statusCode;
}

public String getUrl() {
return this.url;
}

}
...
public static void main(String[] args) {
try {
executeRequest("https://drlue.at");
} catch(HttpsStatusCodeException exc) {
if(exc.getStatusCode() == 401) {
login();
}
}
}

private static void executeRequest(String url) throws HttpStatusCodeException {
Response resp = ...//network request
if(!resp.isSuccessfull()) {
throw new HttpStatusCodeException(resp.statusCode(), url);
}
}
}
}}

=== Beispiele ===
Im folgenden Beispiel wird eine {{Link|Methoden|Methode}} erstellt, welche einen Dateinamen nimmt und die Länge der Datei zurückgibt. Existiert die Datei nicht, so wird eine {{JSL|java.lang.FileNotFoundException}} geworfen:
{{JML|code=
public static long getFileLength(String fileName) throws FileNotFoundException {
File f = new File(fileName);
if(!f.exists()) {
throw new FileNotFoundException();
}
return f.length();
}
}}
Die {{Link|Methoden|Methode}} können wir folgendermaßen verwenden, bei dieser Variante fangen wir die '''Exception''' ab:
{{JML|highlight='2,5-7'|code=
public static void main(String[] args) {
try {
long length = getFileLength("wichtig.txt");
System.out.println("Die Datei ist: "+length+"Bytes lang");
} catch(FileNotFoundException exc) {
System.out.println("Die Datei wurde nicht gefunden!");
}
}
}}
Eine weitere Variante ist, dass die Aufrufende {{Link|Methoden|Methode}}, die '''Exception''' weiter wirft.
{{JML|highlight='1'|code=
public static void main(String[] args) throws FileNotFoundException {
long length = getFileLength("wichtig.txt");
System.out.println("Die Datei ist: "+length+"Bytes lang");
}
}}
Es kann auch zuerst die '''Exception''' gefangen, und dann weitergeworfen werden.
Eine weitere Variante ist, dass die Aufrufende {{Link|Methoden|Methode}}, die '''Exception''' weiter wirft.
{{JML|highlight='2,5-8'|code=
public static void main(String[] args) throws FileNotFoundException {
try {
long length = getFileLength("wichtig.txt");
System.out.println("Die Datei ist: "+length+"Bytes lang");
} catch(FileNotFoundException exc) {
System.out.println("Die Datei wurde nicht gefunden!");
throw exc;
}
}}

== Weitere wichtige Dinge ==
Hier sollen noch einige weitere Dinge abgeklärt werden.
=== Überladen von Methoden ===
Wir sprechen von '''überladen''' einer {{AL|Methoden|Methode}}, wenn mehrere {{AL|Methoden}} in einer {{AL|Klasse}} existieren die den selben Namen haben, sich aber die '''Übergabeparameter''', entweder in ihrem Datentyp, oder der Anzahl unterscheiden. Ein {{Link|Konstruktor}} kann ebenfalls überladen werden. 
Im folgenden Beispiel wird die {{AL|Methoden|Methode}} {{JSL|add(...)}} überladen. Der '''Compiler''' entscheidet anhand des Datentyps der Parameter welche {{AL|Methoden|Methode}} verwendet werden soll, '''der Rückgabetyp spielt keine Rolle.'''
{{JML|code=
public class Calc {
public int add(int a, int b) {
return a + b;
}

public float add(float a, float b) {
return a + b;
}
}
...
public static void main(String[] args) {
Calc c = new Calc();
//Die add Methode mit den floats wird verwendet, weil die Parameter floats sind
float a = c.add(3.0f, 2.0f);
//Die add Methode mit den ints wird verwendet, weil die Parameter ints sind
float a = c.add(3, 2);
}
}}

=== Polymorphismus ===
'''Polymorphismus''' oder '''Vielgestaltigkeit''' beschreibt den Sachverhalt, wenn ein '''Objekt''' des Typs {{JSL|A}} vorhanden ist, in Wirklichkeit ein {{JSL|B}} sein kann (natürlich nur wenn {{JSL|B}} von {{JSL|A}} {{Link|Vererbung|erbt}} bzw. {{JSL|A}} '''implementiert''', ansonsten kann das nicht sein). Die '''Vielgestaltigkeit''' bezieht sich somit auf das Aufrufen von {{AL|Methoden}}. Wird eine Methode von {{JSL|A}} aufgerufen, so kann dies in Wirklichkeit die {{AL|Methoden|Methode}} in {{JSL|B}} aufrufen, wenn {{JSL|B}} diese überschreibt. Eine Methode ist '''Polymorph''' wenn diese in der '''Subklasse''' die selbe {{Link|Methodensignatur}} aufweist wie in der '''Superklasse'''.
{{JML|code=
public class A {
public void doSomething() {
System.out.println("My name is A and I do something!");
}
}

public class B extends A {
@Override
public void doSomething() {
System.out.println("My name is B and I do something!");
}
}
...
public static void main(String[] args) {
reallyDoSomething(new B());
}

public static void reallyDoSomething(A a) {
a.doSomething();
}
}}
Obwohl in der Methode {{JSL|reallyDoSomething(A a)}} eine '''Instanz''' von {{JSL|A}} als Parameter erwartet wird, ist es in Wirklichkeit eine '''Instanz''' von {{JSL|B}}. Ein Aufruf von {{JSL|a.doSomething()}} führt nicht den Code in {{JSL|A}} sondern den Code in {{JSL|B}} aus, da {{JSL|doSomething()}} in {{JSL|B}} überschrieben wurde.

=== Beziehungen ===
Hier sollen noch die Beziehungen zwischen [[{{PAGENAMEE}}#Klasse|Klassen]] bzw. '''Objekten''' geklärt werden.
==== Is A ====
Wenn eine {{AL|Klasse}} {{JSL|Cat}} eine {{AL|Klasse}} {{JSL|Animal}} erweitert, d.h. von ihr {{Link|Vererbung|erbt}}. Somit '''ist''' {{JSL|Cat}} ein {{JSL|Animal}} und die folgende Zuweisung ist möglich:
{{JML|code=
Cat cat = new Cat();
Animal animal = cat;
}}
Umgekehrt ist das nicht zwingend so. Wenn ein '''Objekt''' vom Typ {{JSL|Animal}} vorhanden ist, so könnte es ein '''Objekt''' vom Typ {{JSL|Cat}} sein, muss es aber nicht. Um dies zu prüfen gibt es das Schlüsselwort {{JSL|instanceof}} und es kann ein {{Link|Casten|Cast}} erfolgen. Die Umwandlung ist auch ohne Prüfung möglich, dies kann jedoch zu Abstürzen durch eine {{JSL|java.lang.ClassCastException}} führen.
{{JML|code=
public void doSomething(Animal animal) {
if(animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.miau();
} else {
System.out.println("Can't miau");
}
}
}}
Das selbe gilt genau gleich, wenn eine {{AL|Klasse}} ein {{AL|Interface}} implementiert. 
'''Is A''' ist somit eine Erweiterung einer {{AL|Klasse}}, oder eine Implementierung einer {{AL|Interface|Schnittstelle}}.
Es handelt sich hierbei um eine '''starke Bindung''', d.h. diese kann zur Laufzeit des Programmes '''nicht''' verändert werden.

==== Has A ====
Eine '''Has A''' Beziehung wird auch '''Komposition''' oder '''Zusammenstellung''' genannt. '''Komposition''' ist eine '''schwache Bindung'''. Sie kann während der Laufzeit des Programmes verändert werden. Folgendes Beispiel soll eine '''Has A''' Beziehung verdeutlichen:
{{JML|code=
public class Cat {
private List<Spielzeug> spielzeuge = new ArrayList();

public void addSpielzeug(Spielzeug spielzeug) {
this.spielzeuge.add(spielzeug);
}

public void removeSpielzeug(Spielzeug spielzeug) {
this.spielzeuge.remove(spielzeug);
}
}

public class Spielzeug {

}
...
public static void main(String[] args) {
Cat cat = new Cat();

Spielzeug ball = new Spielzeug();

cat.addSpielzeug(ball);

cat.removeSpielzeug(ball);
}
}}
Hier wird gezeigt, dass '''Objekten''' zur Laufzeit andere '''Objekte''' hinzugefügt und entfernt werden können.
'''Has A''' Beziehung ist eine schwache Bindung.

== Multithreading ==
'''Threading''' oder '''Nebenläufigkeit''' bezeichnet den Vorgang in einem Programm das unterschiedliche Handlungsstränge aufweist. D.h. verschiedene Programmabläufe laufen parallel. Diese Parallelität kann wirklich parallel ablaufen, d.h. 2 oder mehr '''CPUs''' sind involviert, oder es kann pseudo parallel Ablaufen, zwischen den unterschiedlichen Abläufen wird sehr schnell hin und her gewechselt, aber alles läuft auf einer '''CPU'''. Je nach Implementierung der '''J'''ava '''V'''irtual '''M'''achine läuft es wirklich parallel oder nur pseudo parallel ('''green Threads'''). Folgendes Beispiel soll einen parallelen Ablauf verdeutlichen:
{{JML|code=
public static void main(String[] args) {
Thread a = new Thread(new Runnable() {
public void run() {
for(int i=0; i<10; i++) {
System.out.println("Hallo von Thread A: "+i);
try {
Thread.sleep(100);
} catch(InterruptedException exc) { }
}
}
});

Thread b = new Thread(new Runnable() {
public void run() {
for(int i=0; i<10; i++) {
System.out.println("Hallo von Thread B: "+i);
try {
Thread.sleep(100);
} catch(InterruptedException exc) { }
}
}
});

a.start();
b.start();
}
}}
Zuerst werden die '''Threads''' erstellt, diesen wird ein '''Objekt''' des Typs {{JSL|java.lang.Runnable}} mitgegeben. Alternativ kann auch eine {{AL|Klasse}} erstellt werden, welche von {{JSL|java.lang.Thread}} erbt und die {{JSL|run()}} {{AL|Methoden|Methode}} überschreibt. Nach dem initialisieren, können die {{JSL|Thread}} '''Instanzen''' mittels {{JSL|start()}} gestartet werden, {{JSL|run()}} wird nun jeweils in einem anderen '''Thread''' aufgerufen, der Ablauf ist dadurch ''parallel'', also ''gleichzeitig''.

=== Synchronisierung ===
Verwendet ein Programm mehrere '''Threads''' so kann dies zu Problemen führen, wenn '''kritische Bereiche''', welche '''nicht atomare Operationen''' enthalten gleichzeitig verwendet werden.
Atomare Operationen sind nicht Teilbar. Eine int Variable zu erhöhen ist Teilbar. 
1) Nimm die Zahl und erhöhe sie um 1
2) Überschreibe den Speicherbereich der Zahl
{{JML|code=
private static int count = 0;

public static void main(String[] args) {
Thread a = new Thread(new Runnable() {
public void run() {
for(int i=0; i<1000; i++) {
count++;
}
}
});

Thread b = new Thread(new Runnable() {
public void run() {
for(int i=0; i<1000; i++) {
count++;
}
}
});

a.start();
b.start();

//Warten bis die Threads beendet wurden
try {
a.join();
} catch(InterruptedException exc) {}
try {
b.join();
} catch(InterruptedException exc) {}
System.out.println("Increments: "+(2000));
System.out.println("Actual count: "+count);
System.out.println("Difference: "+(2000 - count));
}
}}
In diesem Beispiel ist ersichtlich, dass die Variable am Ende nicht ''2000'' ist, aufgrund dieser '''nicht atomaren''' Erhöhung der Zahl um 1. 
Um '''nicht atomare Bereiche''' sicher zu machen, kann das Schlüsselwort {{JSL|synchronized}} verwendet werden. {{JSL|synchronized}} verwendet ein sogenanntes '''Object Lock''' um einen kritischen Bereich abzusichern. Beim Betreten wird dieses geholt, beim Verlassen zurückgegeben. Dieses '''Lock''' existiert bei jedem '''Objekt''' nur einmal. Kann es nicht geholt werden, so wird gewartet bis es verfügbar ist und erst dann wird der geschützte Bereich betreten.
{| class="wikitable"
|+ Wie kann {{JSL|synchronized}} verwendet werden
|-
! Code !! Beschreibung
|-
|
{{JML|code=
synchronized(object) {
//kritischer Bereich
}
}}
|| Das '''Lock''' wird von einem bestimmten '''Object''' geholt.
|-
|
{{JML|code=
public synchronized void doSomething() {
//kritischer Bereich
}
}}
|| Das '''Lock''' wird von der '''Instanz''' geholt, zu der dieser '''Methodenaufruf''' gehört.
|-
|
{{JML|code=
public static synchronized void doSomething() {
//kritischer Bereich
}
}}
{{Space30}}{{Space30}}{{Space30}}{{Space30}}
|| Synchronized kann auch bei '''statischen Methoden''' verwendet werden. Das '''Lock''' wird von der {{AL|Klasse}} selbst geholt. Die geladene {{AL|Klasse}} ist ebenfalls eine Instanz (von der eigenen Definition), diese existiert aber nur einmal.
|}
Somit kann das oben genannte Beispiel gelöst werden:
{{JML|code=
private static int count = 0;

private static synchronized void increment() {
count++;
}

public static void main(String[] args) {
Thread a = new Thread(new Runnable() {
public void run() {
for(int i=0; i<1000; i++) {
increment();
}
}
});

Thread b = new Thread(new Runnable() {
public void run() {
for(int i=0; i<1000; i++) {
increment();
}
}
});

a.start();
b.start();

//Warten bis die Threads beendet wurden
try {
a.join();
} catch(InterruptedException exc) {}
try {
b.join();
} catch(InterruptedException exc) {}
System.out.println("Increments: "+(2000));
System.out.println("Actual count: "+count);
System.out.println("Difference: "+(2000 - count));
}
}}

Letztes Semester

2021-02-19T09:17:58Z

Sam: /* Jahresnote */

Da wir ja im letzten Semester wieder den super 50/50 Anwesenheitsmodus haben, hab ich mir folgendes überlegt.

= Unterricht an der Schule =
Wir gehen pro Einheit 2 Bereiche vom Wiki durch. Am Nachmittag in der letzten Stunde gibts dann dazu eine Mitarbeitsüberprüfung, angepasst auf das was wir gelernt haben.
= Zuhause =
Ihr macht ein cooles Softwareprojekt, was euch gefällt. Voraussetzungen dazu:
* Ihr macht euch ein git Repository dafür
* Wenn ihr das Projekt angebt muss es für mich möglich sein das Projekt über das git Repository zu starten.
 
Irgend was feines mit React wäre eine gute Idee.

= Notengebung =
== Noten zweites Semester ==
Siehe folgenden krassen Berechnungscode.
{{JML|code=
package at.htldornbirn.swp.grade;

public class GradeCalculator {
public static int calculateGrade(float textGradeAvg, ProjectScore projectScore) {
int grade = Math.round(textGradeAvg);

switch (projectScore) {
case COOL:
grade--;
break;
case AVERAGE:
if (grade == 5) {
grade--;
}
break;
case WEEK:
if (grade < 4) {
grade++;
}
break;
default:
if (grade < 3) {
grade = 3;
} else if (grade < 4) {
grade++;
}
}

return grade < 1 ? 1 : Math.min(grade, 5);
}
}

}}
== Jahresnote ==
Machma alle 1er...guade Ideeee

Letztes Semester

2021-02-19T09:17:42Z

Sam: /* Jahresnote */

UML Sequenzdiagramm

2021-01-29T10:57:52Z

Sam:

'''* Was ist ein Sequenzdiagramm?'''
Ein Sequenzdiagramm ist ein Verhaltensdiagramm, welches eine Interaktion im Sinne der UML grafisch darstellt.
[[Datei:WIN 20181009 14 01 22 Pro.jpg|mini]]
'''* Wozu wird es benötigt?'''
Sequenzdiagramme dienen zur dynamischen Modellierung von Kommunikationsabläufen und Interaktionen zwischen Systemkomponenten. Der zeitliche Verlauf bekommt in dieser Darstellungsform eine besondere Bedeutung.

Auch Sequenzdiagramme haben unterschiedliche Usecases. In der Entwicklung von Medizingeräten eignen sich Sequenzdiagramme besonders in den folgenden Szenarien:

'''Verhaltensweise von Methoden:'''
Während der Softwareentwicklung werden Sequenzdiagramme überwiegend verwendet, um die Funktionsweise von Methoden bzw. Funktionen zu modellieren. Die Modellierung kann reverse stattfinden oder bereits zur Entscheidungsfindung zum Aufbau von Methoden verwendet werden.

'''Zeitlicher Ablauf von Testfällen:'''
Auch die Dokumentation von Testfällen ist wichtig, um später Tests und mögliche Fehler reproduzieren zu können. Mithilfe des Sequenzdiagramms kann der zeitliche Ablauf der Tests beschrieben werden. Bilder sagen oft mehr als tausend Worte. Denken Sie aber daran, das Diagramm möglichst einfach zu gestalten, sodass es gut lesbar und leicht verständlich ist.

'''System Usecases:'''
Auch in der obersten Modellierungsebene, der Systemebene, können Sequenzdiagramme verwendet werden, um die Usescases (z. dt. Anwendungsfälle) des Systems abzubilden. Besonders schwierige oder unklare Anwendungsfälle können so dokumentiert werden.

'''* Welche Elemente gibt es? Erkläre dies so detailliert und anschaulich wie möglich'''

'''• Option:'''

Optionen sind mit dem Struktogrammelement „einseitige Verzweigung“ vergleichbar. Der eingerahmte Bereich
wird bei Nichterfüllung der Bedingung
(genannt „Guard“) übersprungen. Es
muss aus dem Kontext erkennbar sein,
woher die Daten für die Bedingungsprüfung stammen.
Zur Kennzeichnung wird in den oberen
linken Bereich „opt“ notiert.
[[Datei:Option.jpg|mini|none]]

'''• Alternative:'''

Alternativen kann man am Besten mit einer Merhfachauswahl
in der Struktogrammnotation
vergleichen. Sie haben mindestens zwei Zweige, wobei für jeden Zweig eine eigene Bedingung („Guard“) Formuliert
werden kann. Wichtig ist, dass
diese Bedingungen sich nicht
überschneiden („disjunkt
sind“). Bspw. „errorCount <=
3“ und „errorCount >= 3“
währe eine Verletzung dieser
Forderung.
[[Datei:Bbb.jpg|mini|none]]

'''• Schleife:'''

Struktogramme kennen drei verschiedene Schleifen – kopfgesteuerte, fußgesteuerte und
Zählschleifen. Beim Sequenzdiagram unterscheidet nicht zwischen kopfgesteuerten und fußgesteuerten Schleifen – diese
muss aus dem Kontext gelesen
werden – bzw. mit der Annahme
„kopfgesteuert“ kommt man
meist gut hin.
[[Datei:A.jpg|mini|none]]

'''
* Erstelle ein paar anschauliche Beispiele'''

'''Sequenzdiagramm für das Datenverwaltungssystem eines Krankenhauses:'''

Wie in vielen anderen Wirtschaftsbereichen auch hat der technische Fortschritt in der Medizin traditionelle Arbeitsabläufe und Berufsbilder einem grundlegenden Wandel unterworfen. Heute werden sämtliche Aktivitäten und Daten, die den Betrieb eines Krankenhauses ausmachen, mithilfe eines Datenverwaltungssystems gesteuert. Dazu zählen ärztliche Untersuchungen und andere klinische Verfahren, Verschreibungen für Medikamente, Termine, Krankenakten und weitere Informationen zu Patienten und ihren jeweiligen Betreuungspersonen. Das unten stehende Diagramm stellt die Beziehungen zwischen den Primärverfahren im Zeitverlauf in einer vereinfachten Übersicht dar. Mit Lucidchart können Sie das Diagramm beliebig anpassen und für Kollegen und Projektbeteiligte zur gemeinsamen Nutzung freigeben.

[[Datei:1.jpg|mini|none]]

'''Sequenzdiagramm für Geldautomatensysteme:'''

Am Geldautomaten können Bankkunden über einen komplett automatisierten Prozess auf ihre Konten zugreifen. Die einzelnen Schritte, aus denen dieser Prozess besteht, lassen sich anhand eines Sequenzdiagramms auf übersichtliche Weise darstellen. Das nachstehende Beispiel veranschaulicht die Reihenfolge der einzelnen Interaktionen des Geldautomatensystems. Sie können diese Vorlage bearbeiten und das Sequenzdiagramm entsprechend Ihren eigenen Bedürfnissen anpassen.

[[Datei:2.jpg|mini|none]]

Zusatzmaterial für die Füchsle unter uns:

[[Datei:Awd.jpg|mini|none]]
[[Datei:Aaa.jpg|mini|none]]
[[Datei:Amana.jpg|mini|none]]

Objektorientiertes Design und UML

2021-01-08T13:23:00Z

Sam:

Im folgenden wird zuerst auf die Begriffe '''UML''' und '''modellieren''' eingegangen. In weiterer Folge werden wir uns mit zwei gebräuchlichen Diagrammtypen, dem '''Klassendiagramm''' und dem '''Sequenzdiagramm''' beschäftigen.
= Modellieren =
TODO: Hier soll beschrieben werden was '''modellieren''' im allgemeinen und dann speziell in der Softwareentwicklung bedeutet. 
Modellieren allgemeine Definition: 
plastisch formen, gestallten, bearbeiten, durch Modellieren bilden 
Modellieren in der Softwareentwicklung: 
Modellieren in der Softwareentwicklung wird auch Softwaredesign genannt. Softwaredesign ist oft wichtig wegen der Komplexität der Computerprogramme, um das Risiko der "Fehlentwicklung" zu minimieren. Bevor die Software modelliert wird, werden im Zuge der Anforderungserhebung zunächst die einzelnen Anforderungen designiert. Diese werden meistens von Auftraggeber und Auftragnehmer gemeinsam ausgesucht. 

Modellieren wird also zur visuellen Darstellung von Programmen verwendet.

= UML =

Die Unified Modeling Language (UML), ist eine grafische Modellierungssprache zur Beschreibung von Softwaresystemen. Der Grundgedanke der UML besteht darin, eine einheitliche Notation für viele Einsatzgebiete zu haben.

UML gilt als Standard zur Analyse und Design Objektorientierter Anwendungen. Sie bietet ein Gerüst, um so unterschiedliche Applikationen wie Datenbankanwendungen, Echtzeitsysteme oder Grafikprogramme einheitlich darstellen zu können. Die Aufgabe der UML ist Spezifikation, Visualisierung und Dokumentation von Modellen für Softwaresysteme.

Die Diagramme in UML lassen sich in zwei Hauptgruppen aufteilen: Strukturdiagramm und Verhaltensdiagramme.

'''Strukturdiagramme:'''
* '''Klassendiagramm'''
** Beschreibt die statische Struktur von Objekten in einem System und ihre Bezeichnung untereinander

* '''Kompositionsstrukturdiagramm'''
** Zeigt einheitlich das Innere eines Klassifizierers (Metaklasse = Klasse einer Klasse) und dessen Wechselwirkung mit seiner Umgebung

* '''Komponentendiagramm'''
** Atellt die Zusammenhänge der einzelnen Komponenten einer zu erstellenden Softwarelösung dar.
** Die Darstellung umfasst dabei typischerweise Komponenten mit deren Schnittstellen bzw. Ports und wie Komponenten über Abhängigkeitsbeziehung und Konnektoren miteinander verbunden sind.

* '''Verteilungsdiagramm'''
** Beschreibt, welche Komponenten (Objekte) auf welchen Knoten ablaufen
** Zeigen daher, wie Komponenten konfiguriert sind und welche Abhängigkeiten bestehen
** Die Darstellung umfasst dabei typischerweise Rechnerknoten, Komponenten, Artefakte, Ausprägungsspezifikationen, Verbindungen und Verteilungsbeziehungen.
* '''Objektdiagramm'''
** Zeigt die Struktur des modellierten Systems für einen limitierten Zeitabschnitt bzw. konkreten Zeitpunkt (Momentaufnahme).
** Die Darstellung umfasst dabei typischerweise Ausprägungsspezifikationen von Klassen und Assoziationen.
* '''Paketdiagramm'''
** Dient der Strukturierung der verschiedenen Darstellungen.
** Pakete ermöglichen einen guten Überblick über ein Gesamtsystem (für große Systeme sehr wichtig)
** Die Darstellung umfasst dabei typischerweise Pakete, Paketverschmelzungen, Paketimports und Abhängigkeitsbeziehungen.
* '''Profildiagramm'''
** Wird in der Metamodellebene verwendet, um sogenannte Stereotype mit Klassen anzuzeigen
** Diese haben dann die Bezeichnung <<stereotype>> oder bei Profilen und Paketen <<profile>> bekommen.
'''Verhaltensdiagramme'''
* '''Aktivitätsdiagramm'''
** Es wird meist der Ablauf eines Anwendungsfalls beschrieben, es eignet sich aber zur Modellierung aller Aktivitäten innerhalb eines Systems.
* '''Anwendungsfalldiagramm''' (Use-Case Diagramm)
** Beschreibt das Zusammenwirken von Personen (Aktoren) mit einem System.
** Es stellt Anwendungsfälle und Akteure mit ihren jeweiligen Abhängigkeiten und Beziehungen dar.
* '''Interaktionsübersichtsdiagramm'''
* '''Kommunikationsdiagramm'''
** Stellt den Austausch von Nachrichten dar.
* '''Sequenzdiagramm'''
** Stellt die einzelnen Objekte und ihre Interaktion (auf zeitlichen Ablauf bezogen) dar
* '''Zeitverlaufsdiagramm'''
** Ist ein zweidimensionales Diagramm, wobei auf der x-Achse die Zeit, und auf der y-Achse Zustände von Objekten aufgetragen werden.
** Dieser Diagrammtyp ähnelt damit der Anzeige eines Oszilloskops, wird also seit langem in der Elektrotechnik verwendet.
* '''Zustandsdiagramm'''
** Visualisiert die unterschiedlichsten Zustände, die Objekte in ihrem Leben annehmen können
** Wird benutzt, um das Verhalten eines Systems oder die zulässige Nutzung der Schnittstellen eines Systems zu spezifizieren

== Diagramme ==
[[UML_Klassendiagramm|UML Klassendiagramm]]
 
[[UML_Sequenzdiagramm|UML Sequenzdiagramm]]

= TODO: Bitte Beachten =
Wenn möglich versuche die Quellen für die Information zu nennen. Wir nehmen das hier nicht so genau, aber es sollte möglich sein die entsprechende Seite aus der die Information entnommen wurde zu finden.
 
Bilder bitte direkt mit Quelle (Beispiel)
[[Datei:Bubble-sort-example-300px.gif|mini|none|Funktionsweise Bubblesort. Quelle: https://de.wikipedia.org/wiki/Bubblesort]]

Objektorientiertes Design und UML

2021-01-08T11:08:27Z

Sam:

Im folgenden wird zuerst auf die Begriffe '''UML''' und '''modellieren''' eingegangen. In weiterer Folge werden wir uns mit zwei gebräuchlichen Diagrammtypen, dem '''Klassendiagramm''' und dem '''Sequenzdiagramm''' beschäftigen.
= Modellieren =
TODO: Hier soll beschrieben werden was '''modellieren''' im allgemeinen und dann speziell in der Softwareentwicklung bedeutet. 
Modellieren allgemeine Definition: 
plastisch formen, gestallten, bearbeiten, durch Modellieren bilden 
Modellieren in der Softwareentwicklung: 
Modellieren in der Softwareentwicklung wird auch Softwaredesign genannt. Softwaredesign ist oft wichtig wegen der Komplexität der Computerprogramme, um das Risiko der "Fehlentwicklung" zu minimieren. Bevor die Software modelliert wird, werden im Zuge der Anforderungserhebung zunächst die einzelnen Anforderungen designiert. Diese werden meistens von Auftraggeber und Auftragnehmer gemeinsam ausgesucht.

= UML =

Die Unified Modeling Language (UML), ist eine grafische Modellierungssprache zur Beschreibung von Softwaresystemen. Der Grundgedanke der UML besteht darin, eine einheitliche Notation für viele Einsatzgebiete zu haben.

UML gilt als Standard zur Analyse und Design Objektorientierter Anwendungen. Sie bietet ein Gerüst, um so unterschiedliche Applikationen wie Datenbankanwendungen, Echtzeitsysteme oder Grafikprogramme einheitlich darstellen zu können. Die Aufgabe der UML ist Spezifikation, Visualisierung und Dokumentation von Modellen für Softwaresysteme.

Die Diagramme in UML lassen sich in zwei Hauptgruppen aufteilen: Strukturdiagramm und Verhaltensdiagramme.

'''Strukturdiagramme:'''
* '''Klassendiagramm'''
** Beschreibt die statische Struktur von Objekten in einem System und ihre Bezeichnung untereinander

* '''Kompositionsstrukturdiagramm'''
** Zeigt einheitlich das Innere eines Klassifizierers (Metaklasse = Klasse einer Klasse) und dessen Wechselwirkung mit seiner Umgebung

* '''Komponentendiagramm'''
** Atellt die Zusammenhänge der einzelnen Komponenten einer zu erstellenden Softwarelösung dar.
** Die Darstellung umfasst dabei typischerweise Komponenten mit deren Schnittstellen bzw. Ports und wie Komponenten über Abhängigkeitsbeziehung und Konnektoren miteinander verbunden sind.

* '''Verteilungsdiagramm'''
** Beschreibt, welche Komponenten (Objekte) auf welchen Knoten ablaufen
** Zeigen daher, wie Komponenten konfiguriert sind und welche Abhängigkeiten bestehen
** Die Darstellung umfasst dabei typischerweise Rechnerknoten, Komponenten, Artefakte, Ausprägungsspezifikationen, Verbindungen und Verteilungsbeziehungen.
* '''Objektdiagramm'''
** Zeigt die Struktur des modellierten Systems für einen limitierten Zeitabschnitt bzw. konkreten Zeitpunkt (Momentaufnahme).
** Die Darstellung umfasst dabei typischerweise Ausprägungsspezifikationen von Klassen und Assoziationen.
* '''Paketdiagramm'''
** Dient der Strukturierung der verschiedenen Darstellungen.
** Pakete ermöglichen einen guten Überblick über ein Gesamtsystem (für große Systeme sehr wichtig)
** Die Darstellung umfasst dabei typischerweise Pakete, Paketverschmelzungen, Paketimports und Abhängigkeitsbeziehungen.
* '''Profildiagramm'''
** Wird in der Metamodellebene verwendet, um sogenannte Stereotype mit Klassen anzuzeigen
** Diese haben dann die Bezeichnung <<stereotype>> oder bei Profilen und Paketen <<profile>> bekommen.
'''Verhaltensdiagramme'''
* '''Aktivitätsdiagramm'''
** Es wird meist der Ablauf eines Anwendungsfalls beschrieben, es eignet sich aber zur Modellierung aller Aktivitäten innerhalb eines Systems.
* '''Anwendungsfalldiagramm''' (Use-Case Diagramm)
** Beschreibt das Zusammenwirken von Personen (Aktoren) mit einem System.
** Es stellt Anwendungsfälle und Akteure mit ihren jeweiligen Abhängigkeiten und Beziehungen dar.
* '''Interaktionsübersichtsdiagramm'''
* '''Kommunikationsdiagramm'''
** Stellt den Austausch von Nachrichten dar.
* '''Sequenzdiagramm'''
** Stellt die einzelnen Objekte und ihre Interaktion (auf zeitlichen Ablauf bezogen) dar
* '''Zeitverlaufsdiagramm'''
** Ist ein zweidimensionales Diagramm, wobei auf der x-Achse die Zeit, und auf der y-Achse Zustände von Objekten aufgetragen werden.
** Dieser Diagrammtyp ähnelt damit der Anzeige eines Oszilloskops, wird also seit langem in der Elektrotechnik verwendet.
* '''Zustandsdiagramm'''
** Visualisiert die unterschiedlichsten Zustände, die Objekte in ihrem Leben annehmen können
** Wird benutzt, um das Verhalten eines Systems oder die zulässige Nutzung der Schnittstellen eines Systems zu spezifizieren

== Diagramme ==
[[UML_Klassendiagramm|UML Klassendiagramm]]
 
[[UML_Sequenzdiagramm|UML Sequenzdiagramm]]

= TODO: Bitte Beachten =
Wenn möglich versuche die Quellen für die Information zu nennen. Wir nehmen das hier nicht so genau, aber es sollte möglich sein die entsprechende Seite aus der die Information entnommen wurde zu finden.
 
Bilder bitte direkt mit Quelle (Beispiel)
[[Datei:Bubble-sort-example-300px.gif|mini|none|Funktionsweise Bubblesort. Quelle: https://de.wikipedia.org/wiki/Bubblesort]]

Objektorientiertes Design und UML

2021-01-08T10:28:13Z

Sam: