Übergang von funktionaler zu OOP. Algorithmen und Datenstrukturen II 1

Transkript

1 Übergang von funktionaler zu OOP Algorithmen und Datenstrukturen II 1

2 Imperative vs. funktionale Programmierung Plakativ lassen sich folgende Aussagen treffen: funktional: imperativ: Berechnung von Werten von Ausdrücken Berechnung des Kontrollflusses Algorithmen und Datenstrukturen II 2

3 Beispiele zur Unterscheidung: Java vs. Haskell 1. Berechnung des Betrages einer ganzen Zahl n: public static int abs(int n) { if (n >= 0) return n; else return -n; > abs :: (Ord a, Num a) => a -> a > abs n n >= 0 = n > otherwise = -n Algorithmen und Datenstrukturen II 3

4 2. Berechnung von sum(n) = n i=1 public static int sum(int n) { int s = 0; for(int i=1; i<=n; i++) s = s + i * i; return s; i 2 > sum :: (Enum a, Num a) => a -> a > sum n = foldl g 0 [1..n] > where g x y = x + y * y Algorithmen und Datenstrukturen II 4

5 3. Berechnung von nextsquare(n) = min{q q > n, q = s 2, s N public static int nextsquare(int n) { int i = 1; int q = 1; while (q <= n) { i++; q = i*i; return q; > nextsquare :: (Num a, Enum a) => a -> a > nextsquare n = (head.dropwhile (<=n).map (^2)) [1..] Algorithmen und Datenstrukturen II 5

6 Entsprechungen/Unterschiede Es gibt folgende Entsprechungen zwischen beiden Welten: funktional Liste von Zwischenergebnissen (anonym) Listentyp [t] Rekursionsschemata (foldl, map) abstrahiert von Zwischenergebnissen Speicheraufwändig Listen spielen eine zentrale Rolle Algorithmen und Datenstrukturen II 6

7 imperativ Wertabfolgen in Behältern (benannt) Behältertyp t spezielle Anweisungen (while, for) Behälter werden weiterbenutzt Speicherökonomisch Listen sind ein Datentyp wie viele andere Algorithmen und Datenstrukturen II 7

8 Listen in Java Algorithmen und Datenstrukturen II 8

9 public class Node { protected int element; protected Node next; public Node(int val, Node node) { element = val; next = node; public int element() { return element; public Node next() { return next; Algorithmen und Datenstrukturen II 9

10 Algorithmen und Datenstrukturen II 10

11 Knoten zu Listen [1,2] ˆ= 1 2 Algorithmen und Datenstrukturen II 11

12 Die Konstruktoren von IntList public class IntList { private Node first = null; public IntList() { private IntList(Node first) { this.first = first; Algorithmen und Datenstrukturen II 12

13 public IntList () first private IntList (Node first) first 1 2 n Die Methode empty /** Tests whether a list is empty. */ public boolean empty() { return first == null; Algorithmen und Datenstrukturen II 13

14 Die Methode cons /** cons builds up lists. Returns a new reference to the list cons(val,xs), does not change xs. In order to emphasize that cons doesn t change the list it acts upon, it is declared static. */ public static IntList cons(int val, IntList xs) { Node n = new Node(val, xs.first); return new IntList(n); Algorithmen und Datenstrukturen II 14

15 Cons-Beispiel cons(x,xs) wobei in (a) xs leer ist und in (b) xs der Liste [2,3] entspricht. (a) xs.first return value xs.first x (b) xs.first 2 3 xs.first return value 2 3 x Algorithmen und Datenstrukturen II 15

16 Die Methoden head und tail Die Funktionen head und tail sind in Haskell folgendermaßen definiert: head (x:xs) = x tail (x:xs) = xs Algorithmen und Datenstrukturen II 16

17 /** Returns the first element of a list. Returns -1 and prints an error message if the list is empty; does not change the list. */ public int head() { if (empty()) { System.out.println("Error at method head(): Empty List"); return -1; // an exception would be better return first.element(); Algorithmen und Datenstrukturen II 17

18 /** Returns a new reference to the list obtained by removing the first element. Returns null and prints an error message if the list is empty; does not change the list. */ public IntList tail() { if (empty()) { System.out.println("Error at method tail(): Empty List"); return null; // an exception would be better return new IntList(first.next()); Algorithmen und Datenstrukturen II 18

19 Die Methode append Die Definition von append lautet in Haskell: append [] ys = ys append (x:xs) ys = x:append xs ys Algorithmen und Datenstrukturen II 19

20 Append rekursiv /** Returns a new reference to the list obtained by concatenation of xs and ys; does not change the lists. In order to emphasize this, it is declared static. */ public static IntList append(intlist xs,intlist ys) { if (xs.empty()) return ys; else return cons(xs.head(),append(xs.tail(),ys)); Algorithmen und Datenstrukturen II 20

21 ... und nicht-rekursiv private static IntList append2(intlist xs,intlist ys) { Node tmp; if (xs.empty()) return ys; else { for(tmp=xs.first; tmp.next!=null; tmp=tmp.next) ; // Find last node tmp.next = ys.first; return xs; Algorithmen und Datenstrukturen II 21

22 Append-Beispiel Algorithmen und Datenstrukturen II 22

23 xs.first 1 2 ys.first zs = append(xs,ys) bzw. zs = append2(xs,ys) append (rekursiv) (nicht desktruktive Variante) append2 (nicht rekursiv) (desktruktive Variante) xs.first ys.first 1 2 xs.first ys.first 1 2 Algorithmen und Datenstrukturen II 23

24 Seiteneffekte! Das Verhalten von append2 ist destruktiv, denn beim Verketten von xs und ys wird xs zerstört (oder milder ausgedrückt, verändert). Diesen Seiteneffekt muss man bei jeder Anwendung von append2 berücksichtigen! Aber auch die erste Version birgt eine Gefahr: Wenn nach zs = append(xs,ys) die Liste ys verändert wird, verändert sich damit auch zs. Algorithmen und Datenstrukturen II 24

25 Sonderfall xs = ys xs.first 1 2 zs = append(xs,xs) bzw. zs = append2(xs,xs) append append2 Algorithmen und Datenstrukturen II 25

26 xs.first zs.first xs.first 1 2 zs.first Algorithmen und Datenstrukturen II 26

27 Vergleich zwischen Haskell und Java Algorithmen und Datenstrukturen II 27

28 Parametrischer Typpolymorphismus Die Haskell-Funktion swap ist definiert durch: swap (x,y) = (y,x) (der Typ ist (a,b) -> (b,a)) Beispielsweise ist (1,"a") das Ergebnis von swap("a",1). Algorithmen und Datenstrukturen II 28

29 Um diese Funktion in Java zu implementieren, benutzen wir den Typ Object. Algorithmen und Datenstrukturen II 29

30 public class Pair { protected Object x; protected Object y; public Pair(Object x, Object y) { this.x = x; this.y = y; public void swap() { Object tmp = x; x = y; y = tmp; Algorithmen und Datenstrukturen II 30

31 public static void main(string[] args) { Pair p = new Pair("a",new Integer(1)); p.swap(); System.out.println(((Integer)(p.x)).intValue()+(String)p.y); Algorithmen und Datenstrukturen II 31

32 Da elementare Daten keine Objekte sind, müssen sie in Objekte verwandelt werden. Dies geschieht mit Hilfe der Hüllenklassen elementare Daten werden durch einen Hüllenklassenkonstruktor eingehüllt und damit zu Objekten. Object Boolean Char Number Float Double Integer Long Abbildung 1: Klassenhierarchie der Hüllenklassen Algorithmen und Datenstrukturen II 32

33 IntPair Algorithmen und Datenstrukturen II 33

34 public class IntPair { protected int x; protected int y; public IntPair(int x, int y) { this.x = x; this.y = y; public void swap() { int tmp = x; x = y; y = tmp; Algorithmen und Datenstrukturen II 34

35 Funktionen höherer Ordnung In Haskell gibt es keinen Unterschied zwischen Funktionen und Daten: Funktionen können Argumente anderer Funktionen sein, Funktionen können Funktionen als Wert liefern etc. In Java sind Funktionen (Methoden) Bestandteil von Objekten. Da Funktionen Objekte als Argumente oder Rückgabewert haben können, unterstützt Java insofern Funktionen höherer Ordnung. Algorithmen und Datenstrukturen II 35

36 Algebraische Datentypen und Pattern Matching Pattern Matching kann nach einer Idee von Odersky & Wadler (1997) auf sehr elegante Art und Weise simuliert werden. Wir demonstrieren dies an Hand der append-funktion auf Listen. Algorithmen und Datenstrukturen II 36

37 public class List { protected static final int NIL_TAG = 0; protected static final int CONS_TAG = 1; protected int tag; public List append(list ys) { switch (this.tag) { case NIL_TAG: return ys; case CONS_TAG: char x = ((Cons)this).head; List xs = ((Cons)this).tail; return new Cons(x, xs.append(ys)); default: return new Nil(); //an exception would be better Algorithmen und Datenstrukturen II 37

38 public class Cons extends List { protected char head; protected List tail; public Cons(char head, List tail) { this.tag = CONS_TAG; this.head = head; this.tail = tail; public class Nil extends List { public Nil() { Algorithmen und Datenstrukturen II 38

39 this.tag = NIL_TAG; Algorithmen und Datenstrukturen II 39

40 lokale Änderung großer Datenstrukturen ist in Java ohne weiteres möglich; in Haskell simulierbar durch Monaden a. a Monaden stellen in Haskell eine Möglichkeit dar, imperativ zu programmieren, d.h. es wird ein Kontrollfluss simuliert. Algorithmen und Datenstrukturen II 40

41 Klassen, Objekte und Vererbung in Java kein Problem (objektorientierte Programmiersprache); Haskell-Klassen definieren abstrakte Methoden, jedoch keine Objekte. Eine Instanz einer Klasse muss diese abstrakten Methoden implementieren (d.h. eine eigene Definition angeben). Insofern entspricht eine Haskell-Klasse grob gesprochen einer abstrakten Klasse in Java, die nur abstrakte Methoden enthält (genauer einer Schnittstelle). Algorithmen und Datenstrukturen II 41

42 Keine Entsprechung gibt es z.b. in Java für die unendlichen Datenstrukturen in Haskell in Haskell für die von Java unterstützte Nebenläufigkeit Algorithmen und Datenstrukturen II 42