Get these flashcards, study & pass exams. For free! Even on iPhone/Android!

Methoden und Prinzipien zur Erstellung von Computerprogrammen.

Event Handling wird zur Interaktion zwischen Nutzer und Applikation verwendet. Der Computer muss auf die Nutzereingaben wie das drücken der ESCAPEtaste reagieren können.

- Während eine Oberfläche angezeigt wird, liegt Programmsteuerung bei Java-Fenstersystem

- Tritt das Event ein, informiert das Fenstersystem zuerst die Komponente (z.B. Button)
‐ die Komponente informiert anschließend alle ihre angemeldeten  Listener

- Programmsteuerung wird an unseren Code abgegeben
‐ am Ende von  actionPerformed kehrt Programmsteuerung zurück zum Fenstersystem

Ein Event ist eine Aktion, die der Nutzer beim Arbeiten mitgrafischen Oberflächen auslösen kann.

Eine Ereignisquelle auch Event Source ist  jede beliebige Komponente einer grafischen Oberfläche.

1.Realisierung der Listener-Klasse als innereKlasse
2.Realisierung der Listener-Klasse als anonymeKlasse
3.Container-Klasse wird selbst zur Listener-Klasse
4.Realisierung der Listener-Klasse als separate Klasse

1.  Quelle das heißt GUI
2. Event : der Nutzer interagiert, z.b. durch klicken eines        Taste/Buttons
3. Listener: Swing/AWT stellt  Listener-Interfaces zur Verfügung

1. Schritt : Button wird vom Nutzer angeklickt
2. Schritt: nimmt das Event entgegen(=> Java Fenstersystem )
3. Schritt: leitet Event weiter
4. Schritt: die Komponente Button informiert dann den Listener
5. Schritt: der Listener implementiert

Eine Aufgabe ist das ein passendes Listener-Interface implementiert werden muss.

Eine weitere Aufgabe ist das der Listener bei einer Komponente z.b. Button angemeldet werden muss.
Die Komponenten informieren alle angemeldeten Listener, wenn Event auftritt.

Ein Getter ist ein Zugriffsmethode, die eine Eigenschaft eines Objekts abfragt, auch Abfragemethode genannt.

Ein Setter ist eine Zugriffsmethode, die eine Eigenschaft eines Objekts(Werte von Instanzvariablen) ändert. Es liefert keine Werte zurück.

- Hinweisen auf Syntaxfehler
- Optimierung des Quelltextes
- Übersetzung von Java-Quelltext (Input) in Bytecode (Output)
- Liefert ein maschinennahes Zwischenformat
- ist plattformunabhängig und damit portabel

Ein Programm, das Quellcode während der Laufzeit einliest, analysiert und ausführt.

- Keine direkte Ausführung auf echter Maschine
- Interpretation auf virtueller Maschine bewirkt, die Unabhängigkeit von der Maschine
- Java-Bytecode-Interpreter = Java-Virtuelle-Maschine (JVM)
- Effizienzsteigerung durch Just-in-time-compilation (JIT)

Folge von Anweisungen, die auf einem Computer zur Ausführung gebracht werden können, um eine bestimmte Funktionalität zu erzeugen.

Eine Folge von Anweisungen

Eine fest definierte Folge von (einfachen) Anweisungen zur Lösung eines konkreten Problems. (Vgl. Kochrezept)

- Bestimmtheit
- Effektivität
- Input
- Output
- Endlichkeit

Vorgegebener Aufbau zur Speicherung von Daten.

- legt Möglichkeiten für Zugriff und Verwaltung fest
- Beispiele: Graph, Liste, Baum
- legt fest WIE etwas gespeichert wird, nicht WAS

- Komplexe Befehle lassen sich nicht / schwer in Maschinensprache programmieren.
- Das Übersetzen der menschlichen Sprache in Maschinensprache wäre zu komplex und nicht eindeutig.

Schreiben des ersten Computeralgorithmus (1843).

- hardwareabhängig
- wenig Abstraktion (d.h. nah an der Maschinensprache)

a) Entwicklungsplattform
    zur Entwicklung und Ausführung von Programmen

b) objektorientierte Programmiersprache

- einfache, klare, objektorientierte Konzepte
- die Programmiersprache des Internets (Web-Services, E-Commerce, E-Banking, Applets, Servlets,...)
- große Auswahl an Programmbibliotheken für
  - grafische Benutzeroberflächen
  - Computerkommunikation
  - verteilte Anwendungen
  - Datenbanken
- hohe praktische Relevanz
- plattformunabhängig

- hohe Echtzeitperformance (Computerspiele,...)
- individuelle Benutzungsinterfaces
- Zugriff auf Hardware
- CD auswerfen
- Zugriff auf USB
- Bildschirm auf der Textkonsole löschen, Curser positionieren und Farben setzen
- Verknüpfungen löschen

1. Programmierung
   -> Java Code
2. Übersetzung durch Compiler
   -> Bytecode
3. Interpretation durch Interpreter
   -> Ausführung

=Übersetzer

Programm, das ein Quellprogramm in ein Zielprogramm (Assemblersprache, Bytecode oder Maschinensprache) übersetzt (Kompilierung).

aus einer oder mehreren Klassen

- als Block
- besteht aus beliebig vielen Membern
- Member kann Methode oder Variable sein

Man kann sich eine Klasse als "Gerüst" oder "Schablone" vorstellen.

Methode = Verhalten einer Klasse (Was kann die Klasse?)
Variable = Daten einer Klasse (Was weiß die Klasse?)

- Von einer Klasse können beliebig viele Instanzen erzeugt werden.
- Daten sind je Instanz variabel -> Variablen
- Verhalten ist für alle Instanzen einer Klasse gleich -> Methoden

- bezeichnen "Dinge", z.B. Variablen, Methoden, Typen

- bestehen aus
   - Buchstaben
   - Ziffern
   - '_' und '$'

- zu beachten:
   - Erster Buchstabe muss Zeichen, Buchstabe, '_' oder '$' sein
   - case-sensitive (Groß-/Kleinschreibung beachten!)

- spezielle Namen
- sind von Java reserviert und dürfen nicht für eigene Namen genutzt werden
- werden zur Einleitung oder Hervorhebung von Programmteilen genutzt (int, class, new, void, for,...)
- werden in Java immer klein geschrieben

<TYP>  <BEZEICHNER> = <WERT>

Die Wertzuweisung ist dabei optional.

Legt fest, von welcher Art die Daten sein können, die eine Variable annimmt.

in Java integrierte Schlüsselwörter.


Eselsbrücke für die Reihenfolge der Zahlentypen:
Beiß kurz ins lange Floß - zweimal!

- Primitiver Typ char basiert auf Unicode
- wird mit einfachen Hochkommata '...' initialisiert
- zur Verwaltung einzelner Zeichen gedacht

- Java ist statisch typisierte Sprache (mögliche Werte sind vorbestimmt)
- größere Fehlersicherheit
- höhere Laufzeiteffizienz
- geringere Flexibilität
- aufwendige Compiler
- Es gibt auch dynamisch typisierte Sprachen (Ruby, PHP).

- beliebiger, eindeutiger Name
- kein Java-Schlüsselwort verwenden
- Kann $, _ und Ziffern enthalten, sollte aber vermieden werden
- Immer mit einem Buchstaben beginnen

- Vorgang der Variable einen Typ zuzuordnen
- legt Wertebereich und Typ fest
- Aufbau:
- macht Variable im Programm bekannt

Konstanter Ausdruck
- kann verwendet werden, um Variable zu initialisieren
- Wert, der einer Variablen zugewiesen wird

- kein primitiver Typ, sondern Referenzdatentyp
- Verwaltung nicht änderbarer Zeichenketten
   Sammlung von Zeichen des Typs char
- Deklaration analog zu Variablen des primitiven Typs
- Initialisierung mit Anführungszeichen "..."

- Operatoren verknüpfen Operanden
- Operanden sind Variablen oder Literale
- Operation = Anwendung eines Operators auf mindestens einen Operanden
- jede Operation liefert einen Ergebniswert
- Operatoren sind typisiert, d.h. erwarten einen Operanden eines bestimmten Typs

- arithmetische Operatoren
- Vergleichsoperatoren
- logische Operatoren
- bitweise Operatoren
- Zuweisungsoperatoren
- bedingte Operatoren
- New-Operator

- unäre (Bsp.: Vorzeichenoperatoren)
- binäre
- ternäre

Operanden:
- entweder numerisch
(byte, short, int, long, float, double)
- oder (Ausnahmefall) char

Ergebisse:
- immer numerisch
(double, float, long, int)

- zum Vergleich von Wahrheitswerten

- Operanden- + Ergebnistyp: boolean

- unäre Operatoren (beziehen sich auf einen Operator)
- wie in Mathematik (Plus/Minus-Zeichen)

Beispiel:

float hoehe = 1.25f;                      / / ist identisch mit...
float hoeheAlternativ=+1.25f      / /...dieser Variante

int negativHohe=-hoehe;           / /Operant ist hier eine Variable
int temperatur=-5;                      / /... hier das Literal 5

-binäre Operatoren (zwei Operanden)
- Platzierung zwischen Operanden (wie in Mathe)

Beispiel:
int summe = 3 + 4;   / / 3 + 4 wird berechnet und summe zugewiesen
int produt = summer * summe;    / /operanden sind diesmal Variablen

Modulo-Operator (%) bestimmt ganzzahligen Divisionsrest

ACHTUNG: Modulo-Rechnung und Division können dasselbe Ergebnis erzielen, sind aber grundlegend verschieden!

- implizite Wertveränderung einer Variablen
zb:

   int zaehler = 0;
   zaehler = zahler + 1; is das selbe wie zaehler++

- kann nicht auf Literale angewandt werden, nur auf Variablen!

- können vor und nach Operand platziert werden
- Verarbeitungsreihenfolge ist aber unterschiedlich!
- Preinkrement/dekrement ändert Wert nachdem Weiterverarbeitung

- binäre Operatoren
- zum Wertevergleich

- Operanden
  entweder numerisch
  oder char

- Ergebnis
  immer boolean

- binäre Operatoren
- Kurzschreibweise
- Operatoren sind
  - numerisch
  - char
  - Objektreferenzen (nur einfache Zuweisung!)

- durch Assoziativität (bei Operatoren gleicher Priorität)

- durch Prioritäten:

Implizite Typumwandlung
Werte kleineren Typs werden an Werte größeren Typs übergeben
-> automatische Konvertierung durch Java

Explizite Typumwandlung
- Konversion von Werten größeren Typs in kleineren Typ wird erzwungen.
- Kann zu Informationsverlust führen.

- in Blöcken
- "Methoden-Böcke"  können sich gegenseitig aufrufen
- "main" ruft den ersten Methoden-Block auf.
- Methoden = untergeordnete Struktureinheiten einer Klasse

1) Wiederverwendbarkeit
2) Definition benutzerspezifischer Operationen
3) Strukturierung von Programmen
4) Lokalität

Die Anweisungen, die in einer Methode ausgeführt werden sollen, stehen im sog. Rumpf.

Klassen bestehen aus verschiedenen Membern.

Diese Member können METHODEN (Verhalten) oder VARIABLEN (Daten) sein

- JVM startet ein Programm immer in der main-Methode
- main-Methode ist eine Ausnahme, da sie von der JVM aufgerufen wird
- Signatur (Aufbau) ist entscheidend, damit die JVM die Methode findet!

             public static void main (String[ ] args) {
              }

(Signatur ist hier alles vor der ersten geschweiften Klammer)

- main-Methode: immer innerhalb einer Klasse
- Klasse mit main-Methode = "Start-Klasse"

NUR Start-Klassen besitzen "main" !!!

Als Beispiel eine main-Methode:
      public static void main (String[] args) {
      // Inhalt
       }

- Signatur der Methode ( auch Kopf genannt)
- Signatur indentifiziert Methode eindeutig
(gilt für alle Methoden in Java)


-Rumpf beinhaltet Anweisungen
(gilt auch für alle Methoden in Java)

public an erster Stelle
= Modifizierer (Schlüsselwort)
macht Methode öffentlich
d.h. können von anderen Klassen aufgerufen werden
      main sollte ausschließlich von JVM aufgerufen werden

static an zweiter Stelle
= Modifizierer (Schlüsselwort)
macht Methode statisch verfügbar
d.h. Aufrufer (bei main-Methode: JVM) kann Methode aufrufen, ohne Objekt der Klasse erzeugen zu müssen

void an dritter Stelle
= spezieller primitiver Datentyp(Schlüsselwort)
Rückgabetyp der Methode
d.h Methode gibt einem Aufruf keine Antwort
      Methoden können ihrem Aufrufer prinzipiell eine Antwort geben
Hier benötigt der Aufrufer (bei einer main-Methode ist der Aufrufer die JVM) keine Antwort; also ist der Rückgabetyp "void".
(void = engl. = Lücke)

main an vierter Stelle
= Bezeichner der Methode (quasi reservierter Begriff)
- keine andere Methode darf main heißen !!!

Parameterliste in runden Klammern nach Methoden-Bezeichner
main hat einen Parameter namens args(argument string)
JVM kann bei Programmstart Informationen an Programm geben

- steuern Ablauf, d.h  legen Ausführungsreihenfolge fest
- sind zusammengesetzte Anweisungen, bestehend aus mehreren einfachen, untergeordneten Anweisungen
- gehören zu wichtigsten Bestandteilen der Programmierung

=> Basis für jede Programm

Verzweigungen
   welche Programmstrukturen werden ausgeführt ( "wenn-sonst")

Schleifen
   Anweisungen werden wiederholt abgearbeitet ("solange-bis")

if- Anweisung :
mächtiger als switch-case

switch-case- Anweisung:
performanter, in bestimmten Fällen eleganter

   if( <Bedingung> ) {
         <Anweisung>
    }

if-Schlüssel leitet if-Anweisung ein

<Bedingung> Ausdruck, der von Compiler ausgewertet wird
entweder "true" oder "false"  -> "boolscher Ausdruck"
steht immer in runden Klammern

<Anweisung>: was soll gemacht werden, wenn Bedingung zutrifft?
in geschweiften Klammern als Block gekennzeichnet


Beispiel:

if( Kamin.temperatur <100) {
   brennholz = neuesBrennholz();
   Kamin.nachlegen(brennholz);
   Kamin.Luftzufuhr.oeffnen();
                                            }



if -Anweisung kann weitere Alternativzweige besitzen

else-if-Schlüsselwörter leiten weiteren Zweig ein


if-Anweisung kann am Ende Standardverhalten haben

else-Schlüsselwort leitet Standardverhalten-Zweig ein
keine Bedingung !!! Wird immer ausgeführt, wenn keine der vorherigen Bedingungen zutrifft.
<Anweisung>: Was soll gemacht werden, wenn Bedingung zutrifft?

If-Anweisung ist selbst auch eine Anweisung.
Schachtelung bei if-Anweisungen möglich!

      switch  ( <Schalter> ) {
          case <Konstante>:
                   <Anweisung>
       }

switch-Schlüssel leitet Anweisung ein

Schalter-Ausdruck definiert den Schalter, der den Ablaufsteuert
in runden Klammern
muss immer Variable vom Typ int sein ( byte, short, char und enum auch möglich- werden vom Compiler in int überführt)

case-Blöcke = einzelne Fallunterscheidungen
wird ausgeführt, wenn der Schlater den Wert der case-Konstante hat
in geschweiften Klammern

Standardfall (vgl. else-Zweig) durch default abgedeckt

Fälle müssen mit break ( Schlüsselwort) explizit beendet werden, ansonsten werden alle nachfolgenden Fälle mit abgearbeitet.

switch-case hat "Durchfall"
-> Fall Through

d.h die nachfolgenden Fälle werden mit abgearbeitet

ja!

Jede switch-case-Anweisung kann in eine gleichbedeutenden if-Anweisung überführt werden.

Andersrum ist es jedoch nicht möglich, da eine if-Anweisung zu kompiliziert und verschachtelt agieren kann um sie auf eine "einfache" switch-case-Anweisung runter zu brechen.

Kontrollstrukturen zur wiederholten Ausführung von Anweisungen

Anweisungen werden solange wiederhoilt, bis eine bestimmte Bedingung nicht mehr erfüllt ist

Alle Schleifen müssen eine Bedingung enthalten!

while-Schleife (Prä-Bedingung)

do-while-Schleife (Post-Bedingung)

for-Schleife (Prä-Bedingung, zwei Varianten)

zur kompakten Darstellung umfangreicher Aufgaben

Beispiel:

auflisten von Zahlen von 1 bis 100

was ist praktischer?
100 Befehle schreiben - oder - Verwendung einer Schleife
Bei einer Zählung von 1 bis 1000 wären es ohne Schleife 900 Zeilen mehr zu schreiben ... mit einer Schleife nur 1 Zeichen ;)

              while ( <Bedingung> ) {
                        <Anweisung>
              }

while-Schlüsselwort leitet while-Schleife ein

Bedingung: vom Compiler ausgewertet
entwerder true oder false
in runden Klammern

Anweisung
Was soll gemacht werden, wenn Bedingung zutrifft?
in geschweiften Klammern als Block gekennzeichnet

1) Schleife wird betreten
2) nach letzer Anweisung springt Schleife zurück zu Bedingung
3) Verlassen der Schleife, wenn Zustand des Progammes bezüglich der Bedingung irgendwann geändert wird

        do { 
                <Anweisung>
              }
              while ( <Bedingung> );


do-while-Schlüsselwort leitet Schleife ein
while steht hinter Anweisungsblock vor der Bedingung
Semikolon am Ende!!

Anweisung
Was soll gemacht werden, wenn Bedingung zutrifft?
in geschweiften Klammern als Block gekennzeichnet

Bedingung: vom Compiler ausgewertet
entweder true oder false
in runden Klammern

Bedingung wird am Ende der Schleife geprüft
-> jede do-while-Schleife wird mindestens ein mal durchlaufen

       for (<Initialisierung>; <Bedingung>; <Fortschaltung>) {
            <Anweisung>
        }

for-Schlüsselwort leitet for-Schleife ein

Initialisierung  von Zähler-Variable
- immer nur einmal ausgeführt
- es können mehrere Initialisierungen vorgenommen werden
- Variablen müssen vom selben Typ sein
- nicht zwingend erforderlich!

Bedingung: boolscher Ausdruck

Fortschaltung Anweisung die nach Schleifeninhalt ausgeführt wird
- meist zur Fortschaltung der Zähler-Variable
- nicht zwingend erforderlich!

Anweisung: Was soll gemacht werden, wenn Bedingung zutrifft?
in geschweiften Klammern als Block

Schleifen springen automatisch am Anweisungsende zur Bedingung.
Sprünge können aber auch erzwungen werden.

break

continue

- beides eigenständige Anweisungen
- dürfen nur im Schleifenrumpf verwendet werden (Ausnahmen in switch-case-Anweisungen)

die Schleife wird sofort verlassen

Programm beginnt mit der ersten Anweisung nach der Schleife

Schleifenabbruch mit break sollte möglichst vermieden werden, stattdessen lieber geeignete Abbruchsbedingungen

bei Abbruch wegen Fehlern

bei mehreren Aussprüngen an verschiedenen Stellen der Schleife

bei echten Endlosschleifen ( zB in Echtzeitsystemen )

primitive Typen (Werttypen, einfache Datentypen):
byte, short, int, long, float, double, char, boolean
Variable primitiven Typs enthält Wert direkt.

Referenzdatentypen
◦Felder
◦Klassen
->ermöglichen es, neue, komplexere Typen zu definieren
Variable eines Referenztyps,enthält Verweis auf ein Objekt.

• Definition
‐Werttypen haben feste Größe -> Definition erledigt Compiler
◦z.B.: int -> 4 Byte
‐Referenztypen müssen explizit mit new-Operator definiert werden!
◦Ausnahme: Direkte Feldinitialisierung!

for (int zahl : lottoZahlen) {
   ...
}

Flache Kopie:
•Zuweisungsoperator (=) kopiert lediglich Verweis auf Feld, nicht den Inhalt
•Beispiel:
char[] film = { 'a', 'v', 'a', 't', 'a', 'r'};
char[] spiel = film;
•Beide Referenzvariablen (film und spiel) verweisen auf selbes Objekt und den selben Speicherbereich
•Änderungen am Feld über eine Referenz beeinflussen Inhalt für beide Referenzen!

Tiefe Kopie:
•Um eine "echte" Kopie zu erstellen, muss elementweise kopiert werden.
•Dazu muss mit new-Operator neuer Speicherbereich reserviert werden!
•Änderungen an Original haben keine Auswirkungen auf Kopie.
•Beispiel:
char[] film = { 'a', 'v', 'a', 't', 'a', 'r'};
char[] spiel = new char[6];

for (int i = 0; i < spiel.length; i++) {
spiel[i] = film[i];
}

Beispiel:
boolean[][] konjunktion= { {false, false, false},
                                              {false, true, false},
                                              {true, false, false},
                                              {true, true, true} };

‐Länge der Felder wird implizitdurch Anzahl der Elemente festgelegt.
‐In diesem Fall handelt es sich um eine 4x3 Matrix: 4 Zeilen, 3 Spalten.

entspricht:
boolean[][] konjunktion= new boolean[4][3];

boolean[][] konjunktion= new boolean[4][3];

/* ... Initialisierung ... */

äußere Schleife zerlegt Matrix in Zeilen (-> Referenzen!)
for (boolean[] zeile : konjunktion) {
innere Schleife durchläuft jede Zeile elementweise
for (boolean element : zeile) {
GraphicIO.output(element+"\t");
}

Zeilenumbruch am Ende jeder Zeile
GraphicIO.output("\n");
}

•Eclipse ist integrierte Entwicklungsumgebung
‐Programm, das bei der Entwicklung von Programmen hilft
•vereint Entwicklungskomponenten
‐Texteditor
‐Compiler
‐Interpreter
‐Debugger
•unterstützt Entwickler
‐visuell: Code-Highlighting
‐Tipparbeit: Code-Completion
•sehr mächtig, da modular (viele Funktionalitäten)

UML steht für Unified Modeling Language.

UML ist eine formale Beschreibungssprache zur Spezifikation, Visualisierung, Konstruktion und Dokumentation von Modellen für Softwaresysteme.

Teile der UML sind z.B.
- Klassendiagramm
- Sequenzdiagramm: Laufzeitbeschreibung eines Programms (-> Objekte!)

Ein UML-Diagramm besteht aus einem Bezeichner (Name der Klasse), den Daten (Variablen der Klasse) und dem Verhalten (Methoden der Klasse)

Die Sichtbarkeit wird mit Minus & Plus dargestellt  (minus=private, plus=public).

Eine gerichtete Assoziation ist eine Klasse, die eine andere Klasse referenziert.
Die Assoziation funktioniert nur in eine Richtung, d.h. Daten fließen nur in eine Richtung.

“besteht aus”-Beziehung zwischen Ganzem( Raute) und seinen Teilen.

Vererbung ist eine Beziehung zwischen generellen und speziellen Klassen. Dabei zeigt der Pfeil von der Subklasse auf die Klasse.

Sie ist eine Beziehung zwischen Spezifikation und der Umsetzung.
Eine Klasse ist Interface, die andere die realte Umsetzung

•Klasse gibt mögliche Daten und Verhalten vor
‐beschreibt statische Struktur einer "Sache"
‐statische Struktur ist Referenzdatentyp!

•Objekte sind Instanzen der Klasse
‐mit konkreten Daten (z.B. ist Farbe grün)
‐existieren nur während Programm läuft
‐beschreibt einen konkreten Gegenstand
‐das Objekt einfachGruen ist vom Typ Wecker
-Zugriff auf Objekte ist nur durch bestimmte interne Schnittstellen möglich.

‐Unterteilung eines großen Problems in Teilprobleme (Objekte)
‐Teilprobleme weiter unterteilen, usw.
-> klare Struktur
-> einfache Aufteilung der Arbeit
-> gute Pfleg- und Erweiterbarkeit
-> Teillösungen lassen sich wiederverwenden

Die Definition der Objekte erfolgt durch eine Kombination aus new-Operator und Konstruktor-Aufruf

Deklaration der Referenz
Wecker einfachGruen;

Definition mit new-Operator und Konstruktor-Aufruf
einfachGruen= newWecker();

Konstruktoren sind Methoden, die immer den Namen ihresTyps tragen. Wobei Rückgabetyp und Bezeichner ein und dasselbe bzw. verschmolzen sind und die neuen Platz im Speicher für ein Objekt "ihres" Typs reservieren.

Die Besonderheit bei Standardkonstruktoren ist, dass sie leere Parameterlisten enthalten.

Außerdem erzeigt ein Konstruktur ein neues Objekt und der Konstruktor kann überladen werden (mehrere Konstruktoren in einer Klasse)

Das Schlüsselwort this wird immer verwendet, um Instanzmember anzusprechen.
Es ist eine Referenz, welche auf das aktuelle Objekt (Exemplar) zeigt.
This wird benötigt, wenn die Instanzvariable von der lokalen Variable verdeckt wird.

Kapselung wird als Schutz des inneren Zustands vor unerwünschtem Zugriff gebraucht. (durch private Member)

Durch öffentliche Member werden Schnittstellen vorgegeben, die den Zugriff erlauben.

Schnittstellen sind durchlässige Stellen der "Kapsel", die Kommunikation zwischen den Objekten erlauben.

Z. 2: package-private (Standardeinstellung)

•Akzessoren (auch: Get-bzw. Gib-Methoden): "Zugreifer"
‐fragen Informationen einer Klasse ab
‐lesender Zugriff

•Mutatoren (auch: Set- bzw. Setze-Methoden): "Veränderer“
‐verändern Werte von Instanzvariablen und somit Zustand eines Objekts
‐liefern keine Werte zurück (Rückgabetyp void)
‐erhalten zu setzenden Wert als Parameter

der reguläre Ablauf der Schleife wird unterbrochen und der nächste Schleifendurchgang wird sofort gestartet

sofortige Neuprüfung der Abbruchbedingungen

Ausführung von Anweisungen innerhalb einer Schleife kann teilweise ausgesetzt werden

Der Kopf der Methode heißt Signatur und identifiziert die Methode EINDEUTIG!

Hier der nicht grünmarkierte Bereich ;)

Generalisierende, allgemeinere Klasse heißt Superklasse
- enthält alle gemeinsamen Attribute

untergeordnete Klasse heißt Subklasse
- enthält nur individuelle Attribute und Methoden



Pfeil kann als "ist-ein"-Beziehung gelesen werden

Bilden gemeinsamer Schnittstellen

Effizienz
Gemeinsame Attribute und Methoden nicht mehrfach implementiert

hierarchische Struktur sorgt für mehr Übersicht

Lesbarkeit
trotz Auslagerung von Codeteilen in Superlassen ist Verteilung durch klare Beziehungen nachvollziehbar

Struktur erweiterbar:
neue Klassen können einfach eingegliedert werden

Generalisierung
- vom Besonderen zum Allgemeinen
- Gemeinsamkeiten in Superklasse auslagern
- Subklassen von Superklassen ableiten (-> Vererbung)

Spezialisierung
vom Allgemeinen zum Besonderen
- neue Subklassen erzeugen
- von Superlasse erben lassen

Weitergabe von Daten, Verhalten und Benutzbarkeit einer Superklasse an Subklasse

in OOP zwei Arten von Vererbung
  °Implementierungsvererbung (-> Daten und Verhalten)
  °Schnittstellenvererbung (-> Benutzbarkeit)

in Java zwei Arten von Vererbung
- Schlüsselwort extends => alles wird vererbt
  ° Daten
  ° Verhalten
  ° Benutzbarkeit

- Schlüsselwort implements
=> lediglich Schnittstellenvererbung

Subklasse erbt konkrete Implementierung der Superklasse

bindet Klassen dicht aneinander
- Änderung der Superklasse wirkt sich auf alle Subklassen aus
- Erweiterung der Superklasse muss für alle Subklassen auch gültig sein

Jede Klasse hat maximal eine Superklasse (Einfachvererbung), kann aber beliebig viele Subklassen haben


Syntax
Neu deklarierte Klasse erweitert durch Schlüsselwort extends andere Klassen und erbt von ihr

vererbte Eigenschafte müssen nicht neu deklariert werden


Beispiel
public class Banane extends Obst{
     //...
}

Subklasse hat Zugriff auf alle öffentlichen und geschützten Member

Private und package-private (default) sind nicht aufgreifbar

der "big Daddy "

implizite Basisklasse aller Klassen in Java

ohne extends-Anweisung*+ hinter Klassenname erbt Klasse automatisch von Object

alle Klassen ** haben  - direkt oder indirekt - Object als Basisklasse
- erben Reihe von Methoden, u.a toString()


Beispiel

public class Lebensmittel {
    // Klasse erbt von Object, da keine explizite extends-Anweisung
}

Bei Objekterzeugung zunächst von oben nach unten ausgeführt
- notwendig, um alle Eigenschaften (auch die geerbten) zu initialisieren



Auch parametrisierte Konstruktoren rufen Standard-Konstruktor der Superklasse auf.

Wenn Superklasse keinen Standard-Konstruktor hat, muss expliziter Aufruf erfolgen

public class Obst {
     ....
           public Obst(Color farbe, boolean istReif) {
               ...
           }
}


public class Apfel extends Obst {
     //...
          public  Apfel(boolean hatWurm) {
               super(Color.green, true);
          }
}

Um Vererbung zu verhindern hat Java Schlüsselwort final

Manche Klassen sollten vor Vererbung geschützt werden

Syntax:

public final class SecuritySystem{
}

Gemeinsame Eigenschaften müssen nur einmal modelliert werden
-> Wiederverwendbarkeirt

erleichert Fehlersuche und -korrektur - > kann zentral durchgeführt werden

reduziert Programmieraufwand und Coderedundanz

kein Allheilnittel
- wahre Welt nicht immer hierarchisch
- Vererbung oft inflationär eingesetzt

starke Kopplung zwischen Super- und Subklassen
- Änderung an Super- wirkt sich auf Subklasse aus
- auch über viele Ebenen hinweg

viel Fehlerpotential
- falscher Featureeinsatz
- kaum Schutz vor Fehlverwendung

Generalisierungen führen oft zu Klassen, die nie selbst initialisiert werden.

Schlüsselwort abstract verhindert Initialisierbarkeit
- können nicht mit new erzeugt werden

Abstrakte Klassen
- können nicht erzeugt werden
- können abstrakte Methoden beinhalten
- können konkrete Methoden beinhalten

Abstrakte Methoden
- haben keinen Rumpf
- müssen in Subklasse implementiert werden
- spielen bei Polymorphismus noch eine große Rolle
- können nicht in konkreten Klassen definiert werden

Programmiere an eine Schnittstellen, nicht an eine Implementierung!

Programmteile (Modul) sollten nur die Schnittstellen voneinander kennen , nicht die Implementierung

"Baukastenprinzip"



Analogie:
USB-Schnittstelle an Computer
- alles mögliche kann angeschlossen werden
( Stcik. Drucker, Maus...)

- dem PC ist das egal
---> lose Kopplung

Gegenbeispiel:
Mikrofon-Eingang
- hier kann auch Lautsprecher angeschlossen werden
-> Schnittstelle passt !
- Lautsprecher realisiert Schnittstelle "Aufnahme" aber nicht!
- so kann nichts aufgenommen werden !

Modul Computer ist von Implementierung des angeschlossenen Gerätes (Mikrofon) abhängig
=> Enge Kopplung

- Software ist nie "fertig"
- Anforderungen können sich jeder Zeit ändern
- Software wird ständig erweitert/ verändert
- Enge Kopplung zwischen Klassen erschwert Erweiterbarkeit/ Veränderbarkeit
- kleine Änderung kann aufgrund enger Kopplung ganze Systeme lahm legen

     "Domino-Effekt"
- Lose Kopplung wünschenswert

-> Interfaces

Grad der Abhängigkeit zwischen Teilen eines Programms

entspricht einer engen Kopplung

- Klassen nehmen in vielen Details Bezug aufeinander

Problem: Änderungen an Basisklasse können Funktionalität von Subklasse beeinträchtigen.

- Klassen innerhalb einer Anwendung (fast) unabhängig voneinander
- Verzicht auf vererbte Funktionalität ermöglicht flexiblen Programmentwurf
- Implementierungen sind gezwungen, Interface-Methoden zu überschreiben, bleiben dabei aber austauschbar
- immer zu bevorzugen !!!

Objekte können oft mehr als einer Kategorie zugeordnet werden. Das ist mit extends nicht möglich, weil jede Klasse maximal eine Superklasse hat.

NEIN

Implementierungsvererbung mit bedacht einsetzen!
- bei wahrer Spezialisierung einer Klasse
- Wenn Programm nicht erweiterbar sein soll
- Wenn große Coderedundanzen vorhanden

zusätzliche Sprachfeature in Java
- "Klasse " ohne Daten und Implementierung

Sammlung abstrakter Methoden und (ggf.) Konstanten

enthält Keine Konstruktoren
-> keine Objekterzeugung möglich

Realisierung loser Kopplung

beinhalten ausschließlich öffentliche , abstrakte Methoden sowie Konstanten

können sich gegenseitig erweitern (extends)

können nicht erzeugt werden

Klassen können beliebig viele Interfaces implementieren

mit Schlüsselwort interface statt class

Konvention: Interface-Bezeichner beginnen immer mit Großem   "I" gefolgt von weiterem Großbuchstaben

Methoden sind implizit abstrakt und öffentlich
( public abstract)
- Modifizierer können weggelassen werden
- deklariert nur Kopf einer Methode ohne Rumpf
- Am Ende abgeschlossen durch Semikolon


Interface für strombetriebene Geräte:
public interface IStrombetrieben{
    <RÜCKGABETYP><BEZEICHNER> ( <PARAMETER>);
      void einschlaten (int spannung);
      void ausschalten();
}

mit Schlüsselwort "implements"

Beispiel:

Mixer hat (mind) selbe Schnittstelle wie IStrombetrieben

public class Mixer implements IStrombetrieben{
     private boolean istAn = false;
     private static final int
          MAXIMALE_SPANNUNG = 240;

     public void einschlaten(int spannung){
          if(spannung <= MAXIMALE_SPANNUNG) {
               this.istAn = true;
          }
     }
    
     public void ausschalten(){
          this. istAn = false;
     }
}

Interface kann als Vertrag betrachtet werden.

Interface-Entwickler legt einzuschaltende Schnittstelle fest

Interface-Nutzer ist verpflichtet, alle Methoden des Interfaces zu implementieren
- falls nicht, gibt Compiler Fehlermeldung aus
- Interface-Entwickler kann sich frühzeitig auf Schnittstelle verlassen -> Polymorphismus

Objekt kann zu Laufzeit Verhalten ändern

Wir unterscheiden:

Überladen von Methoden (statischer Polymorphismus)
z.B.
- beim Überladen von Konstruktoren (VL05)
- Überladene Funktionen in java-API oder GraphicIO

Überschreiben von Methoden (dynamischer Polymorphismus)

- Methoden eines Objektes tragen gleichen Namen und gleichen Rückgabetyp
- müssen unterschiedliche Parameterliste haben
- Methoden befinden sich in gleicher Klasse oder Subklasse.
- Methodensignatur unterscheidet sich lediglich in Parameterliste
-Compiler vergleicht bei Aufruf übergebene Parameter mit Methodensignatur und wählt die am besten passende Methode
- Methoden können beliebig oft überladen werden
-GraphicIO setzt stark auf Überladen von Methoden!
=> Gute Quelle!

Beispiel für unterschiedliche Parameteranzahl:



Beispiel für unterschiedliche Parametertypen:

public void print(int intValue) {
     ...
}

public void print(String stringValue) {
     ...
}

public void printTest(){
     print(137);                    wählt erste "print"-Methode
     print("TEST");              wählt zweite "print"-Methode
}

Polymorphismus im engeren Sinn

beruht auf 3 Prinzipien
- Überschreiben von Methoden
- Substitutionsprinzip
- späte Bindung/ dynamische Bindung

- Subklasse erbt Methoden der Superklasse
-Methode, welche in Superklasse definiert ist, wird in Subklasse überschrieben
- komplett gleiche Signatur (Name und Parameterliste), nur Rumpf wird geändert
- Subklasse blendet geerbtes Verhalten aus.

Verhalten kann so genauer an Subklasse angepasst werden.

Ausnahme :
Methoden nicht überschreibbar, wenn sie mit private, final, oder static definiert wurden.

Objekttypen:
polymorphe Referenzen - können potentiell verschiedene Typen annehmen .
- den deklarierten Typ und alle seine Subtypen

Objekt von Typ kann also zur Laufzeit substituiert (ersetzt) werden
- Figur kann Kreis, Rechteck, Dreieck oder Kugel sein
- Figur kann sich also entsprechend unterschiedlich verhalten

Erlaubt, weil Subklasse das Verhalten der Superklasse erbt!

‐ statischer Typ legt Zugriffsmöglichkeiten auf Methoden fest

‐ Methode einer Klasse kann nur von Objekt mit statischem Typ dieser Klasse aufgerufen werden

Beispiel
Kugel kugel;  Deklaration legt statischen Typ fest
kugel = new Kugel() ; Definition legt Laufzeittyp fest

‐ Kugel ist statischer Typ und Laufzeittyp

Figur andereKugel; statischer Typ ist Figur andereKugel
= new Kugel(); Laufzeittyp ist Kugel
andereKugel.rolle(); NEIN! Figur kennt "rolle" nicht!

Aufruf der Methode eines Objekts stößt Methodensuche an

Fall1
Klasse des Objektes hat KEINE Superklasse -> in Klassendefinition des Objekts beschriebene Methode wird ausgeführt.

Fall 2
Klasse des Objekts hat Superklasse
a) Klasse des Objekts hat gewünschte Methode überschrieben
-> überschriebene Methode (und nur diese!) wird aufgerufen

b) Klasse des Objekts hat gewünschte Methode NICHT überschrieben -> Methodensuche wird bei Superklasse fortgeführt, usw.

Bessere Abbildung der Wirklichkeit:
ermöglicht variable Anpassung des Verhaltens von Methoden an Kontext

ermöglicht hohe Wiederverwendbarkeit

lose Kopplung

Austausch von Objekten führt zu Verhaltensänderung
- ein und derselbe Code kann unterschiedliche Aufgaben abarbeiten
- für Entwurfsmuster sehr wichtig