Upload
friederike-gibert
View
114
Download
2
Embed Size (px)
Citation preview
FH-Hof
Java: Grundlagen der Objektorientierung
Richard Göbel
FH-Hof
Grundlagen der OO-Programmierung- Beispiel: Hochschule
class Person { String name; int alter;
String getName() { return name;}
void setName(String na) { name = na;}
int getAlter() { return alter;}
void setAlter(int al) { alter = al;}}
class Student extends Person{ Vorlesung[] teilnahme;
Vorlesung[] getTeilnahme() { return teilnahme; }
void setTeilnahme (Vorlesung[] t)
{ teilnahme = t; }}
FH-Hof
class Test
{
public static void main (String[] args)
{
Person p;
p = new Person();
p.setName(“Meier“);
p.setAlter(19);
System.out.println(p.getName());
System.out.println(p.getAlter());
}
}
Grundlagen der OO-Programmierung- Erzeugen von Objekten einer Klasse
FH-Hof
Grundlagen der OO-Programmierung- Definition eigener Konstruktoren
class Vorlesung
{
String bezeichnung;
int stunden;
Vorlesung (String bez)
{
bezeichnung = bez;
}
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Verwendung von Konstruktoren
. . .
Student s;
s = new Student();
s.setName(“Meier“);
s.setAlter(19);
Vorlesung[] v;
v = new Vorlesung[2];
v[0] = new Vorlesung(“Datenbanksysteme“);
v[1] = new Vorlesung(“Betriebssysteme“);
s.setTeilnahme(v);
. . .
FH-Hof
Grundlagen der OO-Programmierung- Statische Elemente: Konzept
Statische Variable und Funktionen:
sind direkt einer Klasse zugeordnet.
können direkt über den Klassennamen
angesprochen werden, ohne dass ein Objekt der
Klasse verwendet werden muss.
Der Wert einer statischen Variable ist identisch
für alle Objekte der Klasse.
Für statische Variablen und Funktionen spielt
die Klasse ausschließlich die Rolle eines
„Behälters“!
FH-Hof
Grundlagen der OO-Programmierung- Statische Variablen: Deklaration
class Person {
static int numGen = 1;
int nummer;
String name;
Person () {
nummer = numGen++;}
Person (String na) {
nummer = numGen++;
name = na;}
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Statische Variablen: Anwendung
class Test
{
public static void main (String[] args)
{
Person p1 = new Person(“Meier“),
p2 = new Person(“Becker“);
System.out.println(p1.nummer);
System.out.println(p2.nummer);
}
}
FH-Hof
Grundlagen der OO-Programmierung- Statische Variablen: Initialisierung
class Person
{
static int numGen;
int nummer;
String name;
. . .
static
{
numGen = 1;
}
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Statische Funktionen: Deklaration
class Person
{
static int numGen = 1;
static void setGenWert (int wert)
{
numGen = wert;
}
static int getGenWert ()
{
return numGen;
}
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Statische Funktionen: Anwendung
class Test
{
public static void main (String[] args)
{
Person.setGenWert(10);
Person p1 = new Person(“Meier“),
p2 = new Person(“Becker“);
System.out.println(p1.getGenWert());
System.out.println(Person.getGenWert());
}
}
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Funktionssymbolen
In praktisch allen objektorientierten Sprachen
lassen sich verschiedene Funktionen und
Methoden mit identischem Namen definieren.
Funktionen oder Methoden mit identischem
Namen unterscheiden sich mindestens
bezüglich einer der folgenden Kriterien:
Zughörigkeit zu einer Klasse
Anzahl der Argumente
Typ der Argumente
Begriff für dieses Konzept: Overloading
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Methoden in einer Klasse
class Person
{
String name;
String name()
{
return name;
}
void name(String na)
{
name = na;
}
. . .
}
. . .
Person p;
p = new Person(“Meier“);
System.out.println(p.name);
p.name(“Becker“);
System.out.println(p.name());
. . .
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Methoden der Oberklasse I
class Person { int alter;
void alter(int al) { alter = al; }
. . .}
class Student extends Person
{ . . . void alter(int al) { if (al > 17) { alter = al; } } . . .}
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Methoden der Oberklasse II
class Student extends Person
{ . . . void alter(int al)
{ if (al > 17) { super.alter(al); } } . . .}
Zugriff auf Funktionen
der Oberklasse mit dem
Schlüsselwort super
Vorteil: kein direkter
Zugriff auf Attribute der
Oberklasse in der
Unterklasse.
FH-Hof
Grundlagen der OO-Programmierung- Konstruktoren und Vererbung
Konstruktoren werden nicht vererbt!
Konstruktoren der Oberklasse lassen sich mit
dem Schlüsselwort super aufrufen.
Enthält ein Konstruktor der Unterklasse keinen
Aufruf eines Konstruktors der Oberklasse, dann:
erfolgt automatisch ein Aufruf des Default-
Konstruktors der Oberklasse
vor der Bearbeitung der Anweisungen des
aktuellen Konstruktors
Wird kein eigener Konstruktor definiert, dann
erzeugt Java automatisch einen Konstruktor
ohne Argumente.
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Konstruktoren I
class Vorlesung {
String bezeichnung = ““;
int stunden = 0;
Vorlesung (String bez) {
bezeichnung = bez;
stunden = 4;}
Vorlesung (String bez, int std) {
bezeichnung = bez;
stunden = std;}
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Konstruktoren II
class Vorlesung{ String bezeichnung; int stunden;
Vorlesung (String bez) { this(bez,4);}
Vorlesung (String bez, int std) { bezeichnung = bez; stunden = std;} . . .}
Der Aufruf eines
anderen Konstruktors
ist mit dem
Schlüsselwort this
möglich.
Damit ist die
Wiederverwendung
des Programmcodes
aus dem anderen
Konstruktor möglich!
FH-Hof
Grundlagen der OO-Programmierung- Überladen von Konstruktoren der Oberklasse
class Person { String name; int alter;
Person(String na, int al) { name = na; alter = al; } . . .
}
class Student extends Person{ String studiengang;
Student(String na, int al) { super(na,al); studiengang = “BWL“; }
. . .}
FH-Hof
Grundlagen der OO-Programmierung- Weitere Möglichkeiten in Java
Deklarationen mit dem Schlüsselwort abstract:
Für eine mit ‘abstract‘ deklarierte Klasse können
keine Objekte erzeugt werden.
Eine mit ‘abstract‘ deklarierte Klasse kann
Deklarationen von Funktionen ohne Rumpf
enthalten, die in allen Unterklassen entsprechend
der Deklaration definiert werden müssen.
Deklarationen mit dem Schlüsselwort final:
Der Wert einer mit ‘final‘ deklarierter Variablen
oder eines Attributs kann nicht mehr geändert
werden.
Eine mit ‘final‘ deklarierte Methode oder Funktion
darf in einer Unterklasse nicht ersetzt werden.
FH-Hof
Grundlagen der OO-Programmierung- Beispiel für eine ‚abstrakte‘ Klasse
abstract class Person
{
. . .
abstract void setID(String id);
abstract String getID();
. . .
}
FH-Hof
Grundlagen der OO-Programmierung- Beispiel für die Deklaration von Konstanten
class Student extends Person{ int Studiengang; final static int VWL = 1; final static int BWL = 2; final static int PHYSIK = 3;
Student(int sg) { Studiengang = sg; } . . .}
. . .
Student s;
s = new
Student(Student.BWL);
. . .