Informatik I : Software höhere Programmiersprachen Java Klassen: hat Methoden (Funktionen) und Daten (Variablen) es kann mehrere Klassen geben nur eine

Informatik I : Software

höhere ProgrammiersprachenJava

Klassen:

• hat Methoden (Funktionen) und Daten (Variablen)• es kann mehrere Klassen geben• nur eine Klasse in einer Datei darf public sein• Variablen müssen mit new angelegt werden. Input in = new Input();• Funktionen werden Variablenname.Funktionsname aufgerufen in.readInt() oder in.readDouble()

Matrizen = zweidimensionale Felder


• Deklaration: datentyp[][] variablenname;



• Speicher reservieren: variablenname = new datentyp[größe_x][größe_y];




variablenname = new datentyp[größe_x][]; variablenname[0] = new datentyp[größe_y]; variablenname[1] = new datentyp[größe_y + 1]; .........




variablenname = new datentyp[größe_x][]; variablenname[0] = new datentyp[größe_y]; variablenname[1] = new datentyp[größe_y + 1]; .........

• Elementzugriff: variablenname[i][j];

int[][] d = new int[4][4];d[0][0] d[0][1] d[0][2] d[0][3]

d[1][0] d[1][1] d[1][2] d[1][3]

d[2][0] d[2][1] d[2][2] d[2][3]

d[3][0] d[3][1] d[3][2] d[3][3]

Reale Welt Virtuelle Welt


• Unsere Welt besteht aus Objekten!



• Objekte mit gleichen Eigenschaften und gleichen Verhaltensweisen (Methoden) faßt man in Klassen zusammen.



• Objekte mit gleichen Eigenschaften und gleichen Verhaltensweisen (Methoden) fasst man in Klassen zusammen. Klassen werden vereinbart.

• Ein Objekt aus einer Klasse nennt man eine Instanz der Klasse. Objekte müssen explizit erzeugt werden. Sie existieren dann mit einem persistenten lokalen Zustand. Verallgemeinerung von Prozeduren.

•Eingeschränkter Zugriff auf interne Struktur (Schnittstelle nach außen/ interne Realisierung)

Virtuelle Welt

class Person{ String vorname; String name; String adresse;

Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }

void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}

Virtuelle Welt




Eigenschaften der Klasse werden in Datenfeldern gespeichert.

Virtuelle Welt




Methoden der Klasse.

Virtuelle Welt

Konstruktor der Klasse.




package MyPackage;class Person{ String vorname; String name; String adresse;



import MyPackage.Person;

public class BeispielAnwendungPerson{ public static void main(String[] args) { Person berti = new Person(“Vogts“, “Berti“, “Leverkusen, Trainerstr. 0“);

berti.datenAusgeben(); }}


Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; } Person(String p_name) { name = p_name; } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}

import Person;

public class BeispielAnwendungPerson{ public static void main(String[] args) { Person berti = new Person(“Vogts“); berti.vorname = “Berti“; berti.adresse = „“Leverkusen, Trainerstr. 0“;

berti.datenAusgeben(); }}


Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; } Person(String p_name) { name = p_name; } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}

Eine Klasse kann über viele Konstruktoren verfügen.Sie unterscheiden sich in den Eingabeparametern.

Jeder Konstruktor hat einen eindeutigen Satz vonEingabeparametern.




Person

Student Mitarbeiter Professor

Vererbung




Person


Vererbung

Basisklasse

Abgeleitete Klassen




Person


Vererbung

Basisklasse

Abgeleitete Klassen

Abgeleitete Klassen verfügen über zusätzlicheEigenschaften und Fähigkeiten (Methoden).




Vererbungclass Mitarbeiter extends Person{ float gehalt;

Mitarbeiter(String p_name, String p_vorname, String p_adresse, float p_gehalt) { // Konstruktor der Basisklasse aufrufen super(p_name, p_vorname, p_adresse);

gehalt = p_gehalt; }

void gehaltAusgeben() { System.out.println(“\n“); System.out.println(“Gehalt : “ + gehalt); } void gehaltAendern(int aenderung) { gehalt += aenderung; }}

public class AnwendungVonMitarbeiter{ public static void main(String[] args ) { Mitarbeiter billy;

billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); billy.gehaltAendern(-2000); billy.datenAusgeben(); billy.gehaltAusgeben(); }}

Vererbungclass Mitarbeiter extends Person{ float gehalt;




Vererbung

Person


Wissenschaftl. Mitarbeiter Nicht-wissenschaftl. Mitarbeiter

class WissenschaftlicherMitarbeiter extends Mitarbeiter{ // Implementierung}

Polymorphismus

class Mitarbeiter extends Person{ float gehalt;




public class FirstTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];

Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;

((Mitarbeiter)personen[0]).gehaltAendern(-1000); ((Mitarbeiter)personen[0]).gehaltAusgeben(); }}

Cast-Operator

public class FirstTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];


((Mitarbeiter)personen[0]).gehaltAendern(-1000); ((Mitarbeiter)personen[0]).gehaltAusgeben(); }}

Cast-Operator




Polymorphismus

public class SecondTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];


((Mitarbeiter)personen[0]).gehaltAendern(-1000); personen[0].gehaltAusgeben(); }}



void gehaltAusgeben() { } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}

Polymorphismus

import Person;import Mitarbeiter;




Polymorphismus

class Mitarbeiter extends Person{ float gehalt;








Polymorphismus

Polymorphismus erlaubt die gleichartige Behandlung verschiedener Objekte untergleichzeitiger Berücksichtigung der speziellen Eigenheiten der einzelnen Objekte





Polymorphismus

Beispiel: In dem Feld „personen“ können Objekte der Basisklasse „Person“ und der abgeleiteten Klassen „Mitarbeiter“ , „Student“usw. gespeichert werden. Für alle Elementeim Feld kann man die Methoden der Basis-Klasse aufrufen, wobei für Elemente abgeleiteter Klassen automatisch die über-schriebenen Versionen aufgerufen werden.

Polymorphismus erlaubt die gleichartige Behandlung verschiedener Objekte untergleichzeitiger Berücksichtigung der speziellen Eigenheiten der einzelnen Objekte

Abstrakte Klassen

abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }

abstract void zeichnen();}

Abstrakte Klassen



class Kreis extends Figur{ float radius; Kreis( float px, float py, float r) { super(px,py); radius = r; }

void zeichnen() { System.out.println(“Zeichne Kreis“); }}

Abstrakte Klassen



class Rechteck extends Figur{ float breite, laenge; Rechteck( float px, float py, float b, float l) { super(px,py); breite = b; laenge = l; }

void zeichnen() { System.out.println(“Zeichne Rechteck“); }}

Abstrakte Klassen



class Rechteck extends Figur{ float breite, laenge; Rechteck( float px, float py, float b, float l) { super(px,py); breite = b; laenge = l; }

void zeichnen() { System.out.println(“Zeichne Rechteck“); }}

Figur

Kreis Rechteck Linie

Abstrakte Klassen

public class ZeichneFiguren{ public static main(String[] args) { Figur[] zeichenobjekte = new Figur[3];

zeichenobjekte[0] = new Kreis(0.0,0.0, 3.0); zeichenobjekte[1] = new Rechteck(1.0,1.0, 5.0, 5.0); zeichenobjekte[2] = new Kreis(0.0, 0.0, 5.0);

for (int i=0; i <zeichenobjekte.length; i++) { zeichenobjekte[i].zeichnen(); } }} Figur


Abstrakte Klassen

public class ZeichneFiguren{ public static main(String[] args) { Figur[] zeichenobjekte = new Figur[3];

zeichenobjekte[0] = new Kreis(0.0,0.0, 3.0); zeichenobjekte[1] = new Rechteck(1.0,1.0, 5.0, 5.0); zeichenobjekte[2] = new Kreis(0.0, 0.0, 5.0);

for (int i=0; i <zeichenobjekte.length; i++) { zeichenobjekte[i].zeichnen(); } }} Figur




Abstrakte Klassen

In vielen Situationen möchte der Programmiererdas Polymorphismus-Konzept nutzen, in denendie entsprechende Funktionen für die Basis-Klassekeine sinnvolle Funktionalität besitzen.In solchen Situationen definiert man abstrakteKlassen und Funktionen.

Figur




Wie entwirft man geeignete Klassenhierarchien?

In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.



Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.




Beschreibungen der Funktionalität der wichtigsten Klassen findet man zum Beispiel im WWW unter der folgenden Adresse:

http://java.sun.com/j2se/1.3/docs/api/overview-summary.html











Frage: Kann man die zu entwickelnde Klasse von bereits implementierten Klassen ableiten?

Gewagte Konstruktionen?

Abgeleitete2

Basis

Abgeleitete1a Abgeleitete1b


Abgeleitete2

Basis


Mehrfachvererbung


Abgeleitete2

Basis


Auf Mehrfachvererbung wird in Java verzichtet. Java bietet dafür das Konzeptder sogenannten Interfaces (für Fortgeschrittene).

Datenkapselung (Information Hiding)

Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar.



Möglichst wenig von der Implementierung der Klasse wirdnach außen sichtbar gemacht.



Möglichst wenig von der Implementierung der Klasse wirdnach außen sichtbar gemacht.

Man bietet dem Nutzer eine wohldefinierte Schnittstellen zur Klasse an. Diese Schnittstelle sollte sich auch bei Änderungen der Implementierung nicht ändern.


class Chamaeleon {

int wert;

BerechneResultat() {

wert = ......; }}


class Chamaeleon { int wert; int resultat;

BerechneResultat() {

resultat = ......; }}


class Chamaeleon { private int wert; private int resultat;

private BerechneResultat() { resultat = ......; }

public ResultatAusgabe() { System.out.println(resultat); }}

Zugriffsmodifizierer: public, protected, private

class Basisklasse { public int resultat;

// in jeder Methode der Basisklasse { resultat = ......; }}


class BasisKlasse { public int resultat;

// in jeder Methode der Basisklasse { resultat = ......; this.resultat = .....; }}

this ist eine spezielle Instanzvariable, die der Compiler automatisch anlegt und die immer auf die aktuelle Instanz der Klasse, in der Sie sich gerade befinden, verweist.





class AbgeleiteteKlasse extends BasisKlasse{

// in jeder Methode der Abgeleitete.. { resultat = ......; }}



import BasisKlasse.*;

class ExterneKlasse{

// in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat = ......; }}









Auf Klassenvariablen und Methoden, die als „public“deklariert sind, kann aus jeder Methode der Klasse,aus jeder Methode der abgeleiteten Klassen undaus jeder Methode von „externen“ Klasse zugegriffen werden.




class BasisKlasse { protected int resultat;





Auf Klassenvariablen und Methoden, die als „protected“deklariert sind, kann aus jeder Methode der Klasse undaus jeder Methode der abgeleiteten Klassen zugegriffenwerden.





class BasisKlasse { private int resultat;







Auf Klassenvariablen und Methoden, die als „private“deklariert sind, kann aus jeder Methode der Klasse zugegriffen werden.

Definition von n!

Durch n! wird die Zahl der Permutationen einer Menge mit n Elementen bestimmt. Eine Permutation ist dabei eine beliebige lineare Anordnung der n Elemente.

n! ist definiert durch:1 falls n = 0n*(n-1)! falls n > 0

Methoden n! zu berechnenclass Fac{

long compute (long n){ Fac f = new Fac(); if (n == 0)

return 1; else return n*f.compute(n-

1);}

long computeWhile (long n){ long a = n, b = 1; while (a != 0) { b = a*b; a--; } return b;}

long compute (long n1, long n2){ if (n1 == 0)

return n2; else return compute(n1-1,n1*n2);}

class Fac{

long compute (long n){ if (n == 0)

return 1; else return n*compute(n-1);}

long computeFor (long n){ long b = 1; for (long a = n; a != 0; a--)

b = a*b; return b;}

}

Documents

Informatik I : Software höhere Programmiersprachen Java Klassen: hat Methoden (Funktionen) und Daten (Variablen) es kann mehrere Klassen geben nur eine