Informatik I : Software höhere Programmiersprachen Java 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;

Matrizen = zweidimensionale Felder Deklaration: datentyp[][] variablenname; Speicher reservieren: variablenname = new datentyp[größe_x][größe_y];

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];

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]; 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 WeltVirtuelle Welt

Reale WeltVirtuelle Welt Unsere Welt besteht aus Objekten!

Reale WeltVirtuelle Welt Unsere Welt besteht aus Objekten! Objekte mit gleichen Eigenschaften und gleichen Verhaltensweisen (Methoden) faßt man in Klassen zusammen.

Reale WeltVirtuelle Welt Unsere Welt besteht aus Objekten! 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 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); } Eigenschaften der Klasse werden in Datenfeldern gespeichert.

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); } Methoden der Klasse.

Virtuelle Welt Konstruktor der Klasse. 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); }

package MyPackage; 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); } import MyPackage.Person; public class BeispielAnwendungPerson { public static void main(String[] args) { Person berti = new Person(“Vogts“, “Berti“, “Leverkusen, Trainerstr. 0“); berti.datenAusgeben(); }

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; } 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(); }

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; } 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 von Eingabeparametern.

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); } Person StudentMitarbeiterProfessor Vererbung

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); } Person StudentMitarbeiterProfessor Vererbung Basisklasse Abgeleitete Klassen

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); } Person StudentMitarbeiterProfessor Vererbung Basisklasse Abgeleitete Klassen Abgeleitete Klassen verfügen über zusätzliche Eigenschaften und Fähigkeiten (Methoden).

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); } Vererbung class 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(); } Vererbung class 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; }

Vererbung Person StudentMitarbeiterProfessor Wissenschaftl. MitarbeiterNicht-wissenschaftl. Mitarbeiter class WissenschaftlicherMitarbeiter extends Mitarbeiter { // Implementierung }

Polymorphismus class 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 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 billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy; ((Mitarbeiter)personen[0]).gehaltAendern(-1000); ((Mitarbeiter)personen[0]).gehaltAusgeben(); } Cast-Operator 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); } Polymorphismus

public class SecondTestPolymorphism { 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); personen[0].gehaltAusgeben(); } 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 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; public class SecondTestPolymorphism { 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); personen[0].gehaltAusgeben(); } Polymorphismus class 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; }

import Person; import Mitarbeiter; public class SecondTestPolymorphism { 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); personen[0].gehaltAusgeben(); } Polymorphismus Polymorphismus erlaubt die gleichartige Behandlung verschiedener Objekte unter gleichzeitiger Berücksichtigung der speziellen Eigenheiten der einzelnen Objekte

import Person; import Mitarbeiter; public class SecondTestPolymorphism { 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); personen[0].gehaltAusgeben(); } Polymorphismus Beispiel: In dem Feld „personen“ können Objekte der Basisklasse „Person“ und der abgeleiteten Klassen „Mitarbeiter“, „Student“ usw. gespeichert werden. Für alle Elemente im 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 unter gleichzeitiger 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 abstract class Figur { float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; } abstract void zeichnen(); } 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 abstract class Figur { float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; } abstract void zeichnen(); } 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 abstract class Figur { float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; } abstract void zeichnen(); } 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 KreisRechteckLinie

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 KreisRechteckLinie

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 KreisRechteckLinie abstract class Figur { float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; } abstract void zeichnen(); }

Abstrakte Klassen In vielen Situationen möchte der Programmierer das Polymorphismus-Konzept nutzen, in denen die entsprechende Funktionen für die Basis-Klasse keine sinnvolle Funktionalität besitzen. In solchen Situationen definiert man abstrakte Klassen und Funktionen. Figur KreisRechteckLinie abstract class Figur { float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; } abstract void zeichnen(); }

Wie entwirft man geeignete Klassenhierarchien? In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr viel Funktionalität zur Verfügung stellen.

Wie entwirft man geeignete Klassenhierarchien? In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr viel Funktionalität zur Verfügung stellen. Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.Objekt

Wie entwirft man geeignete Klassenhierarchien? In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr viel Funktionalitä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:

Wie entwirft man geeignete Klassenhierarchien? In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr viel Funktionalitä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:

Wie entwirft man geeignete Klassenhierarchien? In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr viel Funktionalitä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: Frage: Kann man die zu entwickelnde Klasse von bereits implementierten Klassen ableiten?

Gewagte Konstruktionen? Abgeleitete2 Basis Abgeleitete1a Abgeleitete1b

Gewagte Konstruktionen? Abgeleitete2 Basis Abgeleitete1a Abgeleitete1b Mehrfachvererbung

Gewagte Konstruktionen? Abgeleitete2 Basis Abgeleitete1a Abgeleitete1b Auf Mehrfachvererbung wird in Java verzichtet. Java bietet dafür das Konzept der sogenannten Interfaces (für Fortgeschrittene).

Datenkapselung (Information Hiding) Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar.

Datenkapselung (Information Hiding) Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar. Möglichst wenig von der Implementierung der Klasse wird nach außen sichtbar gemacht.

Datenkapselung (Information Hiding) Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar. Möglichst wenig von der Implementierung der Klasse wird nach 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.

Datenkapselung (Information Hiding) class Chamaeleon { int wert; BerechneResultat() { wert =......; }

Datenkapselung (Information Hiding) class Chamaeleon { int wert; int resultat; BerechneResultat() { resultat =......; }

Datenkapselung (Information Hiding) 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 =......; } Zugriffsmodifizierer: public, protected, private

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. Zugriffsmodifizierer: public, protected, private

class BasisKlasse { public int resultat; // in jeder Methode der Basisklasse { resultat =......; } Zugriffsmodifizierer: public, protected, private class AbgeleiteteKlasse extends BasisKlasse { // in jeder Methode der Abgeleitete.. { resultat =......; }

class BasisKlasse { public int resultat; // in jeder Methode der Basisklasse { resultat =......; } import BasisKlasse.*; class ExterneKlasse { // in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat =......; } Zugriffsmodifizierer: public, protected, private class AbgeleiteteKlasse extends BasisKlasse { // in jeder Methode der Abgeleitete.. { resultat =......; }

class BasisKlasse { public int resultat; // in jeder Methode der Basisklasse { 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 und aus jeder Methode von „externen“ Klasse zugegriffen werden. Zugriffsmodifizierer: public, protected, private class AbgeleiteteKlasse extends BasisKlasse { // in jeder Methode der Abgeleitete.. { resultat =......; }

class BasisKlasse { protected int resultat; // in jeder Methode der Basisklasse { resultat =......; } import BasisKlasse.*; class ExterneKlasse { // in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat =......; } Auf Klassenvariablen und Methoden, die als „protected“ deklariert sind, kann aus jeder Methode der Klasse und aus jeder Methode der abgeleiteten Klassen zugegriffen werden. Zugriffsmodifizierer: public, protected, private class AbgeleiteteKlasse extends BasisKlasse { // in jeder Methode der Abgeleitete.. { resultat =......; }

Zugriffsmodifizierer: public, protected, private class BasisKlasse { private int resultat; // in jeder Methode der Basisklasse { resultat =......; } 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 „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: 1fallsn = 0 n*(n-1)!fallsn > 0

Methoden n! zu berechnen class 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;}