/media/sda-magnetic/david/Dok-15-2023-11-27/fernuni-hagen/cs-i-ii/old-cs-2-03/java/java4.txt

Gedankliche Konzepte hinter der Objektorientierung:

Objekte, die jeweils eine Identität haben und einander Nachrichten schicken 

Objekte haben Lebensdauer

Referenz: Damit ein Objekt dem anderen eine Nachricht schicken kann, muss es das andere kennen: Es besitzt eine Referenz auf das andere Objekt. 

Objekte: Personen, Dokumente, Zahlen, Wahrheitsbereiche 
Nachrichten: Schreibe dich ein, Drucke Dich aus, +, -

Identität: Objekte verhalten sich wie Gegenstände in der realen Welt. 
(Autos, Lampen, Telefone, Lebewesen, etc.)
Ein Objekt kann nicht an zwei Orten gleichzeitig sein. 
Auto wird umlackiert: Ändert seine Identität 

Nachrichten und Methoden: 
- Auftragserteilung
- Auftragsdurchführung 

K. sagt Buchhandlung: "Möchte Buch". Sie schreibt dafür einen Brief
1. Frau K. lösst Aktion aus. Schickt Nachricht. 
2. Die Buchhandlung besitzt eine Methode, die an sie gesendete Nachricht zu verarbeiten. 

Nachrichtenversand und Zustandsänderung

Klassifikation und Vererbung

Objekte kathegorisieren:

1. Einzelhandelsgeschäft
1.1. Lebensmittelladen
1.2. Buchladen 
1.2.1. Kinderbuchladen
1.2.2. Fachbuchhandlung
1.3. Möbelgeschäft

I.) Superklasse
II.) Subklassen 

Abstrakte Klassen: Keine Objekte, sondern: Gemeinheiten von Subklassen zusammenfassen 

Vererbung: Eigenschaften und Methoden, die mehreren Klassen gemeinsam sind, brauchen nur ein Mal in der übergeordneten Klasse beschrieben werden und können von den Subklassen geerbt werden



1. Objekte
2. Identität
3. Nachrichten und Methoden 
4. Nachrichtenversand und Zustandsänderung
5. Klassifikation und Vererbung 


Gefahr: Prozedurale Programmierung nicht mit Objektorientierung verwechseln!

a) Modellierung von Information und Verarbeitung

Prozedurale Programmierung
1. Modellierung der Information
2. Modellierung der Verarbeitung

Prozedural: Beide stark getrennt. 

Informationen: Grunddaten: Ganze Zahlen, Boolesche Werte, Zeichen, Zeichenketten, ...
In Variablen gespeichert. 
Variablen lassen sich in Arrays und Records organisieren
Grundmodell der Verarbeitung in prozeduralen Programmiersprachen: Zustandsänderung

b) Sicht der Programmierenden

c) Strukturierung und Datenkapselung: 
Erlaubt in natürlicher Weise die Strukturierung der Verarbeitung
Es bietet wenig Möglichkeiten, um die Teile des Zustands mit den auf ihm operierenden Prozeduren zusammen zu fassen
Und: Kapselung von Daten erreichen

d) Erweiterbarkeit:
Strenge Typisierung
Typkonzepte verbessern zwar die statische Überprüfbarkeit eines Programms, erschweren aber die Anpassbarkeit
Die Typen einer Prozedur p sind fest vorgegeben. 
Wird ein Typ erweitert oder modifiziert, entsteht ein neuer Typ, dessen Elemente von p nicht mehr akzeptiert werden. 

e) Zuordnung Prozeduraufruf - Prozedurausführung
Sollen unterschiedliche Daten zu unterschiedlichen Programmabläufen führen, müssen Fallunterscheidungen programmiert werden. 
Objektorientiert: Binden 

f) Parallelität: Die prozedurale Programmierung basiert auf einem sequentiellen Ausführungsmodell. Um Parallelität ausdrücken zu können, muss das Grundmodell erweitert werden.

a) Modellierung von Information und Verarbeitung
b) Sicht der Programmierenden
c) Strukturierung und Datenkapselung: 
d) Erweiterbarkeit:
e) Zuordnung Prozeduraufruf - Prozedurausführung
f) Parallelität: Die prozedurale Programmierung basiert auf einem sequentiellen Ausführungsmodell. Um Parallelität ausdrücken zu können, muss das Grundmodell erweitert werden. 

Objektorientierung:
a) Modellierung von Information und Verarbeitung: 
In der objektorientierten Programmierung bilden Objekte eine Einheit aus Daten und Methoden 
b) Sicht der Programmierenden
c) Strukturierung und Datenkapselung: 
Jedes Objekt hat eine klar festgelegte Schnittstelle, die beschreibt, welche Nachrichten es versteht
d) Erweiterbarkeit: 
e) ...

Objektorientierte Programmiersprachen, 50 Jahre alt
Simula67
Smalltalk

1. Softwaretechnische Simulation 
2. Konstruktion interaktiver, grafischer Benutzeroberflächen
3. Programm-Wiederverwendung
4. Verteilte Programmierung

Begrifflich unterscheiden wir, zwischen:
1. Objekten
2. Werten 

objects
values 

1. Zustand (Objekt, hat Zustand: Auto bekommt Delle, Mensch neue Frisur, ...)
2. Identität: Objekte können sich vollkommen gleichen, ohne denselben Zustand zu haben 
3. Lebensdauer
4. Aufenthaltsort
5. Verhalten: 

Werte, Typen und Variablen in Java:
byte
short
int 
long 
float 
double 
char 
boolean

Konstanten des Typs long haben L als Postfix 

#################################################################################

Ein Wert ist in Java 
- Ein Element eines Basisdatentypen
- Eine Objektreferenz
- die spezielle Referenz null , die auf kein Objekt verweist.

Referenz auf ein Objekt:
- Objekt obj 
- Variablen a, b
- a und b zeigen auf obj 

Am besten stellt man sich eine Referenz als eine Adresse für ein Objekt
vor.
Lokale Referenzen sind das gleiche wie Zeiger in der imperativen Programmierung.

Arrays in Java

Jedes Array(-Objekt) besitzt ein unveränderliches Attribut length vom Typ int 

Wenn die von einem Array referenzierten Arrays nicht alle gleich lang sind, spricht man auch von Ragged Arrays.

char [] a;
char [] b;
char [][] c;

Operationen:

Zuweisung: ...


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

1. Um den Wert eines Ausdrucks auf der Standardausgabe auszugeben,
können Sie die folgende Anweisung verwenden:
System.out.println(Ausdruck);
System.out.print(Ausdruck);
2. Um aus einer Zeichenkette (Typ String), die aus einer Ziffernfolge be-
steht, die entsprechende Ganzzahl (int) zu erhalten, können Sie sich an
folgendem Beispiel orientieren:
String s = "1234";
int i = Integer.parseInt(s);
int i = Integer.parseInt(s);
3. Strings lassen sich mit dem Operator + untereinander und mit anderen
Werten paarweise verketten.


#############################################################

Klassische Kontrollstrukturen.


if (boolescher_Ausdruck) Anweisung
und
if (boolescher_Ausdruck) Anweisung1 else Anweisung2


while (boolescher_Ausdruck) Anweisung
do Anweisung while (boolescher_Ausdruck);
for (Init-Ausdruck ; boolescher_Ausdruck ; Ausdruck) Anweisung
for (Variablendeklaration : Ausdruck) Anweisung




for-each 

int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Lies: Fuer jedes Element im Array ...
for (int elem : arr) {
    System.out.print(elem + " ");
}
System.out.println();




switch-Anweisung.


switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println("31 Tage");
break;
case 2:
System.out.println("28 oder 29 Tage");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println("30 Tage");
break;
default:
System.out.print("Ungueltiger Monat!");
break;
}



Abfangen von Ausnahmen

try
try-Block
catch (AusnahmeTyp Bezeichner) catch-Block1
...
catch (AusnahmeTyp Bezeichner ) catch-BlockN
finally finally-Block


String str = "007L";
int m;
try {
    m = Integer.parseInt(str);
} 
catch(NumberFormatException e) {
    System.out.println("str ist kein int-Wert");
    m = 0;
}
System.out.println(m);



public class Quotient {
    public static void main(String[] args) {
        try {
            int m = Integer.parseInt(args[0]);
            int n = Integer.parseInt(args[1]);
            int ergebnis = m / n;
            System.out.println(ergebnis);
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Falsche Argument-Anzahl.");
        } 
        catch (NumberFormatException e) {
            System.out.println("Mind. ein Argument ist kein int-Wert.");
        } 
        catch (ArithmeticException e) {
            System.out.println("Division durch null.");
        } 
        finally {
            System.out.println("Programmende.");
        }
    }
}

##########################################################################################

Objektorientierte Programmierung mit Java

1. person (Name, birthday)
1.1. student (wie person + matricular number, semester)
1.2. employee (wie person + date of hire, salary bracket)
1.2.1. scientific employee (wie employee + faculty, field of teaching)
1.2.2. administrative employee (wie employee + department)

- Objekte
- Klassen
- Methoden 
- Konstruktoren 

Zustand: Wird durch mehrere Attribute realisiert
Attribute: Objektlokale Variablen - wie Methoden: Funktionen 

public class Person {
    String name;
    int birthday; /* in der Form JJJJMMTT */
}

Default-Konstruktur 

new Person()

Konstruktor hin zu fügen:

public class Person {
    String name;
    int birthday; /* in der Form JJJJMMTT */

    Person(String name, int birthday) {
        this.name = name;
        this.birthday = birthday;
    }
}


Das Schlüssel-wort this steht dabei für das „das Objekt, in dem wir uns gerade befinden“,
this.name bezeichnet also das Attribut name dieses Objekts. 

public class Person {
    String name;
    int birthday; /* in der Form JJJJMMTT */
    Person(String name, int birthday) {
        this.name = name;
        this.birthday = birthday;
    }
    void print() {
        System.out.println("Name: " + this.name);
        System.out.println("Geburtsdatum: " + this.birthday);
    }
    boolean isBirthday(int date) {
        return birthday % 10000 == date % 10000;
        // Das Prozentzeichen ist der Modulo-Operator, welcher
        // den Rest einer ganzzahligen Division liefert.
    }
}


this-Object = self-Object




Spezialisierung und Vererbung

Dass eine Klasse eine Erweiterung einer anderen Klasse (deren Subklasse) ist, wird mit dem Schlüsselwort extends aus-
gedrückt.

Da eine Klasse in Java eine spezielle Art Typ ist, wird durch dieses Subclassing gleichzeitig festgelegt, dass der Typ der Subklasse Subtyp des Typs der Superklasse ist. 


public class Student extends Person {
    int matriculationNr;
    int semester;}
    
    Student(String name, int birthday, int matriculationNr, int semester) {
        super(name, birthday);
        this.matriculationNr = matriculationNr;
        this.semester = semester;
    }
    void print() {
        super.print();
        System.out.println("Matrikelnr: " + matriculationNr);
        System.out.println("Semesterzahl: " + semester);
    }
    int getMatriculationNr() {
return matriculationNr;
}


Man bezeichnet dies als Überschreiben der Methode der Superklasse. 

Schlüsselwort super 

super.print(); 


public class PersonPrintTest {
    public static void main(String[] args) {
        Person[] persons = new Person[3];
        persons[0] = new Person("Meyer", 19831007);
        persons[1] = new Student("Mueller", 19641223, 6758475, 5);
        persons[2] = new Student("Planck", 18580423, 3454545, 47);
    }
    for (int i = 0; i < persons.length; i = i + 1) {
        persons[i].print();
        System.out.println();
    }
}



Wichtige Schreibweisen:

public class Progname {}
public static void main(String[] args) {}
System.out.prinln();
System.out.print();
String gross geschrieben 
this
super 
extends 
class subclass extends superclass {}



########################################## Objekte ###############################################

1. Klassenkonzept
2. Prototyp-Konzept 

1. Klassenkonzept
Nicht, die Objekte werden beschrieben, sondern die Klassen 
2. Prototyp-Konzept
Neue Objekte werden durch klonen existierender Objekte erzeugt. 
Klonen eines Objekts nennt man erzeugen eines Objekts. 

Eigenschaft und Verhalten 

- Welche Zustände kann ein Objekt annehmen 
- Auf welche Nachrichten kann und soll es reagieren 
- Wie sehen die Methoden, bei Nachrichten aus. 

Eine Klasse beschreibt eine Menge gleichartiger Objekte. 


Klassendeklarationen, Attribute und Objekte. 

Schlüsselwort class

class 


Modifikatorenliste class Klassenname {
   Liste von Attribut-, Konstruktor und Methodendeklarationen 
}


Typen, die durch eine Klasse deklariert sind, nennen wir Klassentypen 

Objektlokale Variable: Ein Objekt einer Klasse besitzt für jedes Attribut der Klasse eine objektlokale Variable     

Komponenten einer Klasse: Attribute, Konstruktoren, Methoden 

Instanzen: Die Objekte einer Klasse werden häufig als Instanzen bezeichnet.     


############################################

Methodendeklaration 

1. Erweiterte Methodensignatur
2. Methodenrumpf 

Methodenrumpf: Anweisungsblock 

Methodensignatur:

Modifikatorenliste Ergebnistyp Methodenname (Parameterliste) throws-Definitionen 


Modifikatorenliste - wie bei Klassen:
Liste von Schlüsselworten: public, static 

Ergebnistyp:
void, ...

throws-Deklaration 


#########################################

Konstruktor-Deklaration:

Modifikatorenliste Klassenname (Parameterliste) throws-Definitionen 

############################################

Objekt-Erzeugung, Attributzugriff und Methodenaufruf

Syntaktisch ist eine Objekterzeugung ein Ausdruck mit dem Schlüsselwort new