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
