OOP

Auslöser für Software Engineering

1. Rasant gestiegener Bedarf an Software

2. Gestiegener Aufwand der Softwareentwicklung —> Komplexität steigt exponentiell mit Größe

3. Entwicklerproduktivität nur langsam gestiegen

—-> Lücke zwischen Aufwand Softwareentwicklung und Entwicklerproduktivität

• Leistung/Qualität

• Zeit

• Kosten

Software Engineering beschäftigt sich mit allen Aspekten der Softwareentwicklung, angefangen bei der initialen Konzeption, über Verwendung bis zur Wartung.

3 Bestandteile:

1. Prozesse

2. Methoden/Techniken

3. Tools

Innerhalb Software Enginering gehört zu Prozesse:

1. Requirements Engineering

2. Design

3. Implementation

4. Testing

5. Maintenance

Vorteile:

• klare einfache Struktur

• es lässt sich (theoretisch) ein (global) optimales Design erarbeiten

Nachteile:

• kein Zurückspringen in frühere Phasen möglich

• langsam: streng sequentielle Abarbeitung

• starr, wenig flexibel

• großer Scope —> sehr große Komplexität

• Fehler werden ggf. zu spät erkannt —> hohe Bereinigungskosten

• keine Reaktion aus sich ändernde Anwendung

• Voraussetzungen für eine erfolgreiche Anwendung oft nicht erfüllt

3 Programmierparadigmen:

1. Imperative: Typische Programmelemente: Befehle (“Wie“), Fokus/Denkweise: Vorgänge, Typische Kontrollstrukturen: Verzweigungen, Schleifen, Strukturierungselement: Funktionen/Prozeduren

2. Deklarative: Typische Programmelemente sind Definitionen

   („Was“), Fokus/Denkweise: Ergebnis, Typische Kontrollstruktur: Rekursion, Strukturierungselement: Funktionen, Regeln

3. Objektorientierte: Ist aus Imperativer Programmierung entstanden, Typische Programmelemente sind Objekte

   (beschreiben „Dinge“), Fokus/Denkweise: Dinge, Beziehungen zwischen diesen Strukturierungselemente: Klassen, Geeignete Methode in Design-Phase: UML,

   z.B. Klassendiagramm, Eigenschaften: Sehr vielseitig einsetzbar, Weit verbreitet

Unified Modelling Language: grafische Modellierungssprache von Software-Systemen für Spezifikationen, Dokumentation und Visualisierung

Statische Beschreibung von Domänenkonzepten und ihrer

Beziehungen

• Vielgestaltigkeit

• setzt “is-a”-Relation um

• polymorph:

  • Klasse kann unterschiedliche Typen haben

  • überschriebene Methoden

    
    

• Wiederverwendung

• Wartbarkeit verbessert

• Übersichtlichkeit

• reduzierter Schreibaufwand

• Vermeidung von Code-Duplizierung

• Vermeidung von Copy & Paste-Fehlern

• keine mehrfachen Anpassungen, nur Änderungen an der zentralen Methode

• einfachere Testbarkeit

• schnellerer Compile-Vorgang

• kosteneffiziente Softwarenentwicklung

Diamond Problem

• Klasse D stammt über zwei verschiedene Vererbungspfade (C, B) von der Basisklasse A ab

• Problem: wenn in B eine Methode auftaucht, diese aber auch in C und A auftaucht, dann weiß man nicht, welche der Methoden an D vererbt werden soll

1. Programmiersprache

2. Java Virtual Machine (JVM): Laufzeitumgebung

3. Java Class Library (Standardbibliothek)

Schritte:

1. Softwareentwickler schreibt Quellcode (.java-Dateien)

2. Entwickler „übersetzt“ den Quellcode mittels Java-Compiler javac in Bytecode (.class-Dateien)

3. Der Bytecode wird auf der Zielplattform mittels „java“-Aufruf durch die JVM ausgeführt („just-in-time compilation“)

Beispiel

Übersetzung des Codes in Java

• Befehl: javac HelloHSBund.java

Ausführung des Codes

• Befehl: java HelloHSBund

Der Java-Compiler übersetzt den Quellcode (*.java-Dateien) in einen plattformunabhängigen Zwischencode, der Bytecode genannt wird (*.class-Dateien). Dieser wird durch die Java Virtual Machine (JVM) auf der Zielplattform ausgeführt. Dadurch ist ein Programm ohne erneute Übersetzung auf allen Plattformen direkt lauffähig („write once, run anywhere“).

Durch den Bytecode wird Plattformunabhängigkeit erreicht.

• Fehler vor Ausführung:

  • Compilefehler (Syntaxfehler, Typfehler)

  • Java ist statisch typisiert: Typ der Variable kann sich nicht ändern, Typfehler werden vor Ausführung erkannt

• Fehler während Ausführung:

  • Laufzeitfehler (Arbeitsspeicher nicht ausreichend, IO-Fehler, NullPointerException)

• Anweisung

• Bezeichner (identifier): Name für Variable, Methode, Klasse

• Schlüsselwort (key word)

• Modifizierer (modifier): sind auch Schlüsselwörter, z.B. Sichtbarkeitsmodifizierer (public, private) oder static

Ziel: Ausgeführt werden soll die Anweisung: System.out.println("Hello world!");

• Anweisungen können in Java nicht einfach in eine Datei geschrieben und dem Compiler übergeben werden. Sie müssen in den passenden Rahmen eingebettet werden:

  • Anweisungen stehen in Methoden

  • Methoden stehen in Klassen.

  • Eine Klasse steht in einer Datei mit demselben Namen und der Endung „.java“. *

• Der Compiler übersetzt komplette Klassendatei (compilation unit).

• Die Klassendeklaration erfolgt mit dem Schlüsselwort class und innerhalb geschweifter Klammern.

Jedes ausführbare Java-Programm muss besitzen:

• Eine main-Methode mit folgender Signatur:

  public static void main(String[] args)

• Eine solche main-Methode innerhalb einer Klasse mit Modifizierer public. Man nennt eine solche Klasse umgangssprachlich auch „Main-Klasse“.

• Magic: Bei Aufruf der JVM mittels „java <CLASS_NAME>“ führt die Laufzeitumgebung die Anweisungen innerhalb der main-Methode aus.

• Strukturierung durch {}

• Code-Einrückung optional

• fast jede Anweisung mit ; beenden

  • Ausnahme: Schleifen, Verzweigungen, Klassen, Methoden

• Anweisungen über mehrere Zeilen sind möglich

• Punktoperator . verbindet Klassen und Objekte mit dazugehörigen Methoden

• String (Zeichenkette) mit “ “

• Java unterscheidet Groß/Kleinschreibung

• Variablen, Parameter, Methoden werden mit Datentyp deklariert (void falls keiner)

• Java macht Speicherverwaltung selbst, Speicherplatz von nicht benötigten Variablen wird automatisch freigegeben

• Klassen, Enums, Interfaces: erster Buchstabe groß

• Methoden, Variablen, Parameter: erster Buchstabe klein, CamelCase

• Konstante: GROSSBUCHSTABEN

• Primitive Datentypen: für Zahlen, Wahrheitswerte und

  (Unicode-) Zeichen

• Referenztypen: für Verweise auf Objekte, d.h. die referenzierten Objekte sind in Klassen implementiert. Bsp.: Strings, Arrays, Listen oder Fahrräder

• Ein Anweisungsblock fasst eine Menge von Anweisungen zusammen, die hintereinander ausgeführt werden.

• Ein Block ist selbst eine Anweisung, die in

  geschweiften Klammern eine Folge von Anweisungen zu einer neuen zusammenfasst.

• Ein Block kann überall dort verwendet werden, wo auch eine einzelne Anweisung stehen kann.

• Blöcke können geschachtelt werden.

Ein Literal (literal) ist ein konstanter Ausdruck.

Beispiele:

1. Wahrheitswerte: true, false

2. Ganzzahlen (int), z.B.: 42

3. Gleitkommazahlen (float, double), z.B.: 3.14159

4. Einzelne Unicode-Zeichen (char), z.B.: 'X' in einfachen Hochkomma

5. Zeichenketten (String), z.B.: "Dauert's noch lange?"

6. Nullreferenz, d.h. eine Variable von einem Referenztyp verweist auf kein Objekt: null

• Anweisung: z.B. Methodenaufrufe, Zuweisungen, Kontrollstrukturen, Anweisungsblöcke, leere Anweisung

• Operator: verknüpft einen oder mehrere sogenannter Operanden und liefert bei Auswertung einen Wert (8 Arten von Operatoren: 1. Arithemetisch, 2. Zuweisungs, 3. Relationale/Gleichheits, 4. Unäres Plus/Minus, 5. Logische, 6. String-Konkatenation, 7. Inkrement/Dekrement, 8. Verbundoperator)

• Schlüsselwort: class, static, void etc.

• Ausdruck: ergibt bei der Auswertung zur Laufzeit ein Ergebnis, hat bestimmten Typ

• Literal: konstanter Ausdruck, Beispiele: Wahrheitswerte/boolean (true, false), Ganzzahlen (int), Gleitkommazahlen (double), Einzelne Unicode-Zeichen (char), Zeichenketten (String), Nullreferenz (null)

• Referenztyp: Verweise auf Objekte, d.h. die referenzierten Objekte sind in Klassen implementiert, Beispiele: Strings, Arrays, Listen

• Bezeichner (identifier): für Benennung und Referenzierung von Variablen, Methoden und Klassen

• Modifizierer (sind auch Schlüsselwörter): für Klassen, Methoden und Attribute angegeben, bspw. um die Nutzung einzuschränken (Sichtbarkeitsmodifizierer)

int i1 = 42;

int i2 = i1;

i1 = 23

System.out.println(i2)

—> Ausgabe: 42

—> Kopiert wird der Wert von i1 (Call-by-value)

• i1 wird zunächst der Wert von 42 zugewiesen

• i2 wird der Wert von i1 = 42 zugewiesen

• DANACH wird i1 auf 23 geändert, aber i2 = 42 bleibt so

———————————————————————————-

int[] a1 = new int[] {42};

int[] a2 = a1;

a1[0] = 23;

System.out.println(Arrays.toString(a2));

—> Ausgabe: 23

—> Referenz auf das Array a1 wird erstellt (Call-by-reference)

• Array a1 wird mit dem Wert 42 angelegt

• Array a2 wird mit einer Referenz auf a1 angelegt

• Array a1 wird von 42 auf 23 geändert

• Da Array a2 auf a1 verweist, ändert sich dadurch auf Array a2

————————————————————————————-

Point p1 = new Point(42, 42);

Point p2 = p1;

p1.x = 23;

p2.x = 23;

System.out.println(p2.createRepresentation());

—> Ausgabe: (23, 23)

—> Referenz auf das Point-Objekt p1 wird erstellt

• Point-Objekt p1 wird mit (42, 42) erstellt

• Point-Objekt p2 wird mit Referenz auf p1 erstellt

• Point-Objekt p1 wird mit neuen Werten (23, 23) belegt

• Da p2 auf p1 verweist, ändert sich dadurch auch p2

• Bei komplexen Ausdrücken mit mehr als einem Operator ist die Anwendungsreihenfolge von Bedeutung.

• Die Anwendungsreihenfolge wird bestimmt durch

  • Operatorrangfolge („operator precedence“): Jeder Operator hat einen bestimmten Rang. Operatoren mit niedrigerem Rang werden zuerst angewendet.

    Beispiel: 3 + 3 * 13 == 42

  • Assoziativität: Operatoren mit demselben Rang sind meist „linkassoziativ“, d.h. sie werden von links nach rechts angewendet. Beispiel: 56 / 4 * 3 == 42

• Klammerung: Teilausdrücke in runden Klammern haben bei

  Anwendung Vorrang.

Manchmal ist es erforderlich, dass Datentypen konvertiert werden müssen. Der Fachbegriff hierfür ist Typumwandlung („casting“).

Zwei Arten:

• Automatische (implizite) Typumwandlung: Daten eines kleineren Typs können automatisch in einen größeren Typ umgewandelt werden („widening conversion“).

• Explizite Typumwandlung: Größerer Typ kann in kleineren Typ konvertiert werden, ggf. mit Informationsverlust. Der Ergebnistyp wird in runden Klammern vorangestellt.

1. Arithmetische Operatoren: z.B. +, -, *, /, %

2. Zuweisungsoperator: =

3. Relationale Operatoren bzw. Gleichheitsoperator: <, >, <=, >=, ==, !=

4. Unäres Plus/Minus: +, -

5. Logische Operatoren, z.B. !, &&, ||, &, |, ^

6. String-Konkatenation: +

7. Inkrement/Dekrement: ++, --

8. Verbundoperator: +=, -=, *=, /=

Methode muss jetzt heißen wie Klasse (Wizard), return-Anweisung notwendig, weil Rückgabetyp Wizard ist (nicht void)

Aufruf über:

Oberklasse

Unterklasse

Gemeinsamkeiten

• Besitzen Programmcode/Anweisungen

• Haben eine Parameterliste (ggf. leer)

• Können auf Objektvariablen zugreifen

• Können die this-Referenz verwenden

• Werden im UML-Klassendiagramm im „Methoden-Unterkästchen“ dargestellt

Unterschiede

• Rückgabetyp:

  • Methoden: muss angegeben werden (ggf. void)

  • Konstruktoren: kein Rückgabetyp

• Name:

  • Methoden: frei wählbarer Name; per Konvention ein Verb/Imperativ und klein geschrieben

  • Konstruktoren: Name ist der Klassenname; daher per Konvention ein Nomen und groß geschrieben

• Aufruf:

  • Methoden: beliebig oft; vom Benutzer aufgerufen

  • Konstruktoren: genau einmal pro Objekt; implizit durch JVM bei Erzeugung eines Objektes via new

Überschreiben der toString()-Methode aus Object

Reihenfolge nach abnehmender Sichtbarkeit:

• public

• protected

• package-private

• private

paketsicher = package-private

• Werden allgemein als Zugriffsmethoden bezeichnet

• Methoden mit Schreib‐ bzw. Lesezugriff für private Attribute

• Festes Namensschema nach JavaBeans‐Konvention

  • getAttribute(); ‐> Getter Methoden

  • setAttribute(); ‐> Setter Methoden

  • Ausnahme bei boolean. Hier sieht man auch oft isAttribute(); anstatt getAttribute();

• Typsicherheit

• Nutzung bei Vergleichen und switch/case

• Enums als interne Klasse

• Jede Konstante (GROSSBUCHSTABEN) als einziges Objekt

• Enums sind Referenztypen

Exceptions sind Fehler, die während der Laufzeit bei der Ausführung auftreten.

• Exception: Checked Exception —> muss behandelt werden: fangen oder weiterwerfen

• RunTimeException: Unchecked Exception —> kann behandelt werden

• Error: harter Fehler —> keine Behandlung möglich

• Throwable: direkte Ableitung unüblich

Immer gleiche Vorgehensweise mit String(message), Throwable(cause) und vier Konstruktoren (1. Standardkonstruktor, 2. K mit String message, 3. K mit String message und Throwable cause, 4. K mit Throwable cause).

Eigene Exception und niedrigere Exceptions werden gecatcht

Keine Duplikate

Typ der Elemente: Object

Wrapper-Klasse (großgeschrieben!) - primitiver Datentyp

1. Byte - byte

2. Short - short

3. Integer - int

4. Long - long

5. Double - double

6. Float - float

7. Boolean - boolean

8. Character - char

Wrapper-Klassen dienen zur Speicherung von primitiven Datentypen in einer Liste. Weil in Listen nur Referenztypen gespeichert werden können und keine primitiven Datentypen, nimmt man Wrapper-Klassen.

• Name lautet wie primitiver Datentyp, der verwendet wird

  • unter Attribut: value : int

Durch Verwendung von sogenannten Wrapper-Klassen, die jeweils ein Attribut vom Typ eines

primitiven Datentyps besitzen, lässt sich die Einschränkung umgehen.

Nachteile:

- Erhöhter Speicherbedarf

- Laufzeit-Overhead

Überall, wo Typ der Oberklasse zulässig ist, ist auch Typ der Unterklasse erlaubt.