8. Programmieren mit Objekten - auf Matthias-Draeger.info

8. Programmieren mit Objekten
8.1 Objektgeflechte,
8.2 Lineare Listen
8.3 Spezielle Objekte: Felder
8.4 Spezielle Objekte: Zeichenketten

Objektoriente Programmierung
(object oriented progeramming)
besitzt drei Merkmale:
1. Klassenbasierung: Klassentyp fasst Attribute (Felder)
und auf den Werten des Typs vorgesehene Operationen
zusammen. Das Sprachkonstrukt heißt Klasse.
2. Datenabstraktion: Operationsschnittstelle (interface)
macht von Implementierung der Methoden und
Repräsentation der Daten als Attribute unabhängig.
Später!
3. Vererbung ("Gemeinsamkeiten von Klassen / Objekten
ausnutzen")
Später!
hs / fub - alp2-08 2

Beispiel: Bankkunden und ihre Konten
checking
saving
2
owner
owner
public class Account {
public int accNo;
private Customer owner;
private int balance;
public double getBalance() {
return (double) balance;
}...
public void withdraw(…){…}
public void deposit(double amount){
..}
public Account(int accNo,
Customer c){
}
public class Customer {
int custNo;
name long; // encrypted
Account checking, saving;
...}
hs / fub - alp2-08 3

Verkettete Datenstruktur (Geflecht) der Objekte
Customer
Account
c1 = new Customer(...);
c2 = new Customer(...);
c3 = new Customer(...)
c1.checking = new Account(4711,this);
c2.checking = c1.checking;
c2.saving = new Account(553,this);
c3.checking = new Account(6536,this);
c3.saving = new Account(777,this);
public Account(int acc, Customer c){
accNo=acc;
owner = c;
balance = 0;
}
hs / fub - alp2-08 4

Andere mögliche Initialisierungen …
Account acc1= new Account (4711, new Customer(…));
acc11.owner.checking = acc11;
anonym, zeigt
aber in jedem
Fall ein Objekt.
… im Gegensatz zu public Account(int acc, Customer c)
Objektverweis
was kann schief gehen?
hs / fub - alp2-08 5

Rekursiver Datentyp:
Objekt vom Typ K verweist auf Objekt vom Typ K (?)
Beispiel: Polygonzug
public class Poly {
private static int
count=0;
Point p;
Poly next;
polyStart =
new Poly(new Point(3,4),
new Poly(new Point(5,10),
new Poly(new Point(10,10),
new Poly (new Point(10,13)null))));
public Poly(Point p,
Poly next);
...
}
Liste wird "von hinten" hinten nach
vorne konstruiert".
hs / fub - alp2-08 6

Vergleich mit Listen in funktionalen Sprachen
• Liste als Sprachelement:
Haskell: [5,3,7]
abkürzende Schreibweise für (5:(3:(4:[])))
Konstruktor
"null" (leere Liste)
Elemente vorne an die Liste anfügen:
cons:: a -> [a] -> [a]
cons x liste = (x:liste)
cons identisch mit dem
infix-Operator (:)
LISP: cons
• Generische Listen: Basistyp als Parameter ("a")
hs / fub - alp2-08 7

Lineare Liste
public class IList {
final Type head;
final IList tail;
null
Leere Liste
IList (Type x,IList rest){
head = x;
tail = rest;
}
// pre: nichtleere Liste
boolean find(int x){
if (head==x) {return true;}
else {if (tail==null) {return false;}
else {return tail.find(x);}
}
}
... }
"Eine Liste ist leer oder besitzt ein
erstes Element und eine Restliste"
einelementige
Liste
tail: null
head: 3
hs / fub - alp2-08 8

cons lineare Listen
class IList{...
// pre: Liste nicht leer
public IList cons (Type elem){
return (new IList(elem, this));
}...
}
tail:
head: 5
tail:
head: 3
5:(3:(4:[]))
tail: null
head: 4
hs / fub - alp2-08 9

Veränderbare lineare Listen, einfach verkettet mit Wächter
null
public class LList {
Node first, last;
null
Liste existiert
nicht (!)
public LList(){
first = new Node();
last = first;
}...
public void insert(Object x){
//vorne Einfügen
first=new Node(x,first);
val: -
next: -
first
} val: o val: -
next next: -
public class Node {
Object val;
Node next;
first last
}
last
leere
Liste
hs / fub - alp2-08 10

Vorteile eines Wächterelements
boolean find (Object o){
last.val = o;
Node ptr=first;
do {
if (ptr.val.equals(o)){
return ptr!=last;}
ptr = ptr.next;
} while (ptr !=last);
// never beyond this point..
return ptr != last;
}
val: x
next
first
val: y
next
Suche negativ ("nicht gefunden") : ptr==last
val: o
next: -
last
Vorteil: keine Sonderfälle zu beachten.
hs / fub - alp2-08 11

Variante: zirkuläre einfach verkettete Liste
last entbehrlich. Ende erreicht, wenn node.next == first
public class CLList {
Node first;
public CLList () {
first.next = last;
}
...
}
Wächterelement am Anfang(?) der
Liste.
Noch mal Konstruktor:
public CLList (Object x) {
this.insert(o);
}
hs / fub - alp2-08 12

Einfügen in lineare zirkuläre Liste mit Wächter
Mit dem Knoten-Konstruktor:
public Node(Object x,Node n){
val=x;
next=n;
}
public void insert(Object x){
//insert at front;
first.next=new Node(x,first.next);
}
hs / fub - alp2-08 13

Suchen eines Elements
public boolean find (Object x){
Node ptr=first.next;
while ( ptr!=first) {
if ( ptr.val.equals(x)) {return true;}
else ptr=ptr.next;
}
return false;
}
Leere Liste?
hs / fub - alp2-08 14

Wichtige Variante: Doppelt verkettete zirkuläre Liste
class DLList {…
public DLList(){
head = new Node2();
head.next=head;
head.previous=head;
}
...
}
class Node2{
Object val;
Node2 next, previous;
}
Variable
vom Typ
DLList
hs / fub - alp2-08 15

8.2 Felder
Feld (array) a:
Repräsentation der Werte eines Produkttyps T n mit
beliebigem aber gleichem Basistyp T und beliebiger aber
fester natürlicher Zahl n > 0 .
Java-Spezifika:
- ein Feldtyp wird mit T[] bezeichnet.
Bsp: double[] ist ein Feldtyp mit Basistyp Float,
Point[] ist Feldtyp mit Basistyp Point (!)
- Felder sind Objekte und müssen erzeugt werden.
hs / fub - alp2-08 16

Erzeugung eines Felds
double[] myArray = new double[4];
0.0
0.0
0.0
0.0
myArray[0]
myArray[3]
⇒ Feldvariable hat Verweistyp.
- Indexierte Feldvariable myArray[i] bezeichnet das
i+1-te Feldelement (erstes: myArray[0])
-Typ der Indexmenge: int oder verträglich mit int
- Feldelemente werden gemäß Basistyp voreingestellt.
(Autoinitialisierung)
hs / fub - alp2-08 17

Initialisierung..
int[] a = {3,7,2};
… schließt Erzeugung ein.
Man vermutet, dass
vom Übersetzer
initialisiert wird -
mitnichten! Also aufwändig!
Zuweisung …
int[] b = a;
… erzeugt keine Kopie
Zuweisung…
short[] s={4,6,5};
int[] f = s;
nicht erlaubt, obwohl short mit int verträglich.
Warum??
a
b
…
hs / fub - alp2-08 18

Kein Feld:
Point [] pFeld;
null
Leeres Feld:
Point [] pFeld = new Point[0];
Kein leeres Feld
Nicht zu gebrauchen…
Point [] pF = new Point[4];
pF
null nullnull null
Feldelemente sind Objektverweise vom Typ Point.
hs / fub - alp2-08 19

Traversieren von Feldern
int[] f = new int[10];
for(int i = 0; i=
ArrayIndexOutOfBounds
f.length
hs / fub - alp2-08 20

Traversieren (2)
for(int i = 0; i< f.lengthi++) {
if (f[i] > AVG){count++;}
}
kann ersetzt werden durch:
for (int x: f) { //Java 1.5
if (x > AVG){count++;}
}
Nicht immer hilfreich:
for (int x: f) {
x*=2;
} verändert x, nicht f (!)
hs / fub - alp2-08 21

Methoden (nur einige)
Kopieren eines Felds f :
fType a = f.clone();
a enthält Verweis auf eine Kopie von f (*)
Diverse Methoden in java.util.Arrays, z.B.:
Vergleich zweier Felder f1,f2 gleichen Typs:
boolean b = equals(f1,f2);
Gleichheit ⇔ gleicher Typ und gleiche Länge und
alle Elemente gleich.
(*) (genauer: eine flache Kopie)
aber das kann man
auch selbst programmieren…
hs / fub - alp2-08 22

Programmieren mit Feldern (Beispiele)
Gleichheit von Feldern: equals
static public boolean equals (Object[] p, Object[] q ){
if (p==null || q== null) {return false;}
if (p.length != q.length) {return false;}
for (int i=0; i < p.length; i++){
if (p[i] != q[i]){return false;}
}
return true;
}
Verglichen werden Objektverweise, nicht Objekte!
hs / fub - alp2-08 23

Suchen eines Feldelements mit Wächter (sentinal):
final int MAX=…;
int[] a = new int[MAX+1] // a[0] bleibt leer!
public boolean find (int n){
a[0] = n;
for (int i = a.length-1; i==0; i--){
if (a[i] == n) return i!=0;
}
return false;
}
hs / fub - alp2-08 24

Polynomauswertung nach Horner:
p n (x) = a n *x n +…+a 1 *x 1 + a 0 = (…( 0*x+a n )*x +a n-1 )*x +…+a 1 )*x +a 0
static double horner (double x, double[] a){
// a != null, a.length = n+1
double p=0;
for (int i=a.length-1; i==0; i--){
p = p*x + a[i];
}
return p;
}
hs / fub - alp2-08 25

Mehrdimensionale Felder
Beispiele:
2D-Matrix : double[][] matrix = new double [100] [100];
Bildpunkte: byte[][] screen = new byte [1280] [1024];
Elementzugriff durch Doppelindex:
for (int z = 0; z < 1280; z ++) {
for (int s = 0; s < 1024; s++) {
screen[z] [s] = (byte)0xff;
}}
hs / fub - alp2-08 26

8.4 Zeichenketten
In vielen Programmiersprachen als Feld von Zeichen
realisiert.
Java:
Klassentyp, der Standardtyp der Sprache ist.
String s; ist Verweis (mit undefiniertem Wert)
String h = "Hello", w = "world"; //Literale "…"
sind zwei konstante(!) Zeichenketten.
String hw = h+w;
kopiert beide Zeichenketten und fügt die Kopien zusammen,
also neues Zeichenkettenobjekt!
Operation + (Konkatenation) hochgradig überladen.
String s = 3 + "-mal Hello " + "world";
Alle Typen werden in String bewandelt, hier int
hs / fub - alp2-08 27

Beachte:
int[] q = {0,1,2,3,4};
int[] p = {0,1,2,3,4};
boolean b = p==q; // false
String s1 = "Hello";
String s2 = "Hello";
boolean b = s1==s2 // true(!)
s1
s2
Hello
Literal gleiche Strings werden nur
einmal als Konstante gespeichert.
hs / fub - alp2-08 28

Weiteres Besonderheiten … oder auch nicht:
String s1 = "Hello";
String s2 = new String(s1);
boolean b = s1==s2; // false
Hier wird also eine
echte Kopie angelegt!.
String s1;
String s2="";
if (s1!=s2) …;
String s = null;
String t = "";
boolean b = s == t; //false
Fehlermeldung des
Übersetzers: nicht
initialisiert.
Kein Wunder,
wie bei allen
Verweistypen.
hs / fub - alp2-08 29

Viele Operationen auf String-Objekten
(siehe java.lang.String)
s.length()
Länge der Zeichenkette x
s.charAt(i)
Zeichen an Position i
String.valueOf(x)
Zeichenkettendarstellung für beliebigen Typ
(also auch vielfach überladen)
s.toCharArray()
Zeichenkettenfelddarstellung von s
damit:
s.equals(new String(s.toCharArray())
hs / fub - alp2-08 30