Vorlesung Programmieren

Transkript

1 Vorlesung Wintersemester 2006/2007 Computerlinguistik, Campus DU

2 Überblick Seite 2 Methoden Multidimensionale Arrays Verkettete Listen

3 Überblick: Methoden Seite 3 Wichtige Gründe für Methoden Parameter, Kopf, Signatur Lokale, globale Variablen Sichtbarkeitsbereich von Variablen Überladen von Methoden

4 Wichtige Gründe für Methoden (1) Programme sind in der Praxis zu groß, um in einem einzigen Stück geschrieben zu werden Klassen helfen, Programme in überschaubare Teilprogramme zu zerlegen: Problem Teilprobleme Auf Klassenebene kann ebenfalls logisch strukturiert werden: Methoden Zerlegung der Klassenaktionen in kleinere, logisch zusammengehörende Anweisungsfolgen Via Benennung der Anweisungsfolgen (Bezeichner d. Methode) können die Anweisungsfolgen beliebig oft aufgerufen werden Seite 4

5 Wichtige Gründe für Methoden (2) Wiederverwendung von Code Vermeidung von Redundanzen Maximierung der Wartbarkeit Definition benutzerspezifischer Operationen Sie wollen einen Operator, den bspw. Math nicht hat? Kein Problem: Methode mit dieser Funktionalität schreiben Strukturierung von Programmen Komplexität heutiger Software Kontrollierter Zugriff auf Informationen von Objekten Informationen können geschützt werden, um sie ausschließlich über Methoden ansprechen zu können (private) Banksoftware: Kein direkter Zugriff auf das Guthaben, sondern via adäquater Methoden (einzahlen, auszahlen, ) Seite 5

6 Parameter, Kopf, Signatur Methodenkopf mit Parameterliste bildet die Schnittstelle der Methode (Signatur) Definiert, wie die Methode benutzt werden kann Parametrierte Methoden können in verschiedenem Kontext verwendet werden: public static void printit ( String thestring ) { System.out.println( thestring ); printit( "Hallo"); printit( "Hello" ); printit ("Hy"); // Seite 6

7 Lokale, globale Variablen Neben Anweisungen können Methoden auch Deklarationen enthalten Alle in einer Methode deklarierten Variablen sind lokal zu dieser Methode Alle außerhalb einer Methode deklarierten Namen sind global Globale Variablen (Instanz- und Klassenvariablen) können weiter spezifiziert werden mit Sichtbarkeitsmodifiern (public, private, ) static Es gibt jedoch lokale Konstanten, die mit final deklariert werden ( final int a;). Dazu jedoch später mehr Seite 7

8 Lokale Variablen In einer Methoden können Variablen (und Konstanten) deklariert werden, jedoch nicht weitere Methoden! Bsp.: public static void test( int z ){ int x; double y; /*... */ Die Methode deklariert drei lokale Variablen: z, x, und y Können und dürfen nur in dieser Methode verwendet werden Sind außerhalb von test nicht sichtbar. Speicherplatz für lokale Variablen wird bei jedem Aufruf der Methode, in der sie deklariert wurden, aufgerufen wird. Lokale Variablen leben also nur während der Ausführung ihrer Methode! Seite 8

9 Globale Variablen Eine Variable ist global, wenn sie außerhalb einer Methode, also auf Klassenebene (direkt im Klassenrumpf), deklariert wurde. Beispiel: public class GlobalVars { public static int a; public double b; public static void test( int z ){ // public static void main(string[] args) { //... Globale Variablen (static oder nicht) können in allen Methoden der Klasse verwendet werden, in der sie deklariert wurden a und b können demnach in test und main verwendet werden Statische glob. Var. erhalten ihren Speicherplatz bei Programmstart und existieren, solange das Programm läuft»normale«globale Variablen erhalten ihren Speicherplatz bei der Erzeugung des Objekts und existieren so lange, wie das Objekt existiert Freigabe des Speicherplatzes erst nach Beendigung d. Prog. Werte globaler Variablen bleiben über Methodenaufrufe hinweg erhalten Seite 9

10 Wann lokale oder globale Variablen verwenden? Nach Möglichkeit lokal statt global definieren Verschiedene Methoden können so Variablen mit selben Bezeichnern verwenden Man muss sich keine Gedanken machen, welche Namen bereits vergeben sind Deklaration und Verwendung liegen bei lok. Var nah beisammen Förder die Strukturierung und Lesbarkeit des Programms Bei lok. Var. kann man sich sicher sein, dass keine anderen methoden sie irrtümlich zerstören Man kann so eine Methode afür sich alleine verstehen und verifizieren, ohne auf andere Methoden Rücksicht nehmen zu müssen Global sollte eine Variable nur dann sein, wenn sie in mehreren Methodenb benutzt wird, oder wenn ihr Wert über mehrere Aufrtufe einer Methode hinweg erhalten bleiben soll Seite 10

11 Sichtbarkeitsbereich von Variablen Def.: Jenes Programmstück einer Variablen, in dem auf die Variable zugegriffen werden kann. Erstreckt sich von ihrer Deklaration bis ans Ende jenes Blocks, in dem Variable deklariert wurde Sichtbarkeitsbereich lok. Variablen: Anfang bis Ende der Methode Globale Var.: Anfang bis Ende der Klasse, bzw. für das gesamte Programm (static) Es ist erlaubt, dass glob. und lok. Variablen gleichnamig bezeichnet wurden: Lokale Var. verdeckt dann die glob. temporär Zugriff auf glob. Variable via this Deklaration von Var. innerhalb des Rumpfs einer Schleife oder einer if-kontrollstruktur Var. existiert nur bis zum Ende des Code-Blocks Var. muss mit anderem Bezeichner als die lok. Var. deklariert werden! Bspw. Laufvariablen (for ( int i=0;i<10;i++) { ) existieren nur innerhalb des Schleifen-Code-Blocks Seite 11

12 Sichtbarkeitsbereiche illustriert Seite 12 class MyProg{... int x; int y; x y static void P( int par ) { int x; while (... ) { int y; x y par x y

13 Überladen von Methoden Methoden lassen sich ebenso wie Konstruktoren mehrfach mit identischem Bezeichner definieren Auch bei Methoden gilt: Die verschiedenen Definitionen müssen anhand der Typsignatur unterscheidbar sein Parameternamen und Rückgabewerte dienen nicht der Unterscheidung Ein alter Bekannter als gutes Beispiel für eine überladene Methode: System.out.println() System.out.println() ist u.a. definiert für keine Parameter int, long, double, etc. String Seite 13

14 Überladungsprinzipien im Detail Unterscheidung der Methoden anhand der Parametertypen Jede Kombination von Typen muss einmalig sein Beim Aufruf einer Methoden erkennt Java anhand der Typsignatur automatisch, welchen Konstruktor es verwenden muss Die Bezeichner der Parameter spielen zur Unterscheidung keine Rolle Überladung von Konstruktoren funktioniert genauso! Seite 14

15 Überladung illustriert Seite void dosomething( int i ) {... ; void dosomething( String s, int j ) {... ; void dosomething( int i, int j ) {... ;... dosomething(5);... dosomething("hello", 3+4);... dosomething( 17, 25 );...

16 Überladung: Quiz Seite void dosomething ( int i ) {... ; void dosomething( String i ) {... ; String dosomething( int i ) {... ; void dosomething( int j ) {... ; String dosomething( int j ) {... ; void dosomething( int i, int j ) {... ;

17 Überladung: Konstruktoren Seite 17 //... Student ( String name, int day, int month, int year ){ /* Anweisungen */ Typsignatur: ( String, int, int, int ) //... Typsignatur: ( String, int, int, int ) Student ( String name, int tag, int monat, int jahr ){ /* Anweisungen */ //...

18 Wozu eigentlich Überladung? Bankkonto.java Seite 18 public class BankAccount { public String owner; public int euro; public int cent; //... public void einzahlen ( int euro, int cent ){ this.euro += euro; this.cent += cent; public void einzahlen ( int euro ){ einzahlen( euro, 0 ); public void auszahlen ( int euro, int cent ) { //... public void auszahlen ( int euro ) { //... Aufruf der 'anderen' einzahlen-methode. Erkennt Java anhand der übergebenen Argumente beim Aufruf.

19 Überblick: (Mehrdimensionale) Arrays Seite 19 Mehr zur Benutzung von Arrays (Nicht-literale) Indizes Arrayvariable und Referenz Mehrdimensionale Arrays

20 Benutzung von Arrays (Teil II) Arrayelemente werden über den Index angesprochen Der Index in eckigen Klammern kann eine Konstante (hier Numeral) sein, eine Variable, oder sogar ein Methodenaufruf sein. Für alle gilt: Der Typ des Indexausdrucks muss ganzzahlig sein (long, int, short, byte) myarray[ 4 ] = 43; myarray[ 3*countVar+4 ] = myarray[ nextpos ] myarray[getlastinsert( myarray, mycount )]=5; Seite 20

21 Arrays und Referenzen (1) Angenommen a sei ein int-array der Länge 3 mit nicht-initialsierten Elemente. a referenziert/zweigt auf das Array mit 3 Elementen! b ist ebenfalls ein int-array, wurde deklariert, jedoch nicht initialisiert, zeigt also auf null ( ) Seite 21 a a[0] a[1] a[2] b

22 Arrays und Referenzen (2) Beide Arrays verwalten Objekte von identischem Typ int, man kann also b a zuweisen: b = a; Es wird niemals das Array (mit Speicher) zugewiesen, sondern die in a gespeicherte Adresse (die Referenz/der Zeiger) des Arrays: Seite 22 a a[0] a[1] a[2] b b[0] b[1] b[2]

23 Arrays und Referenzen (3) Zugriffe auf a wie bspwa[0], oder a[2] sind nun gleichbedeutend mit b[0], bzw. b[2] Sie zeigen auf die selben Elemente des selben Arrays Die Zuweisung eines Werts, bspw. a[0] = 19;, wirkt sich synchron auf den Wert in b[0] aus: Seite 23 a a[0] a[1] a[2] b b[0] b[1] b[2]

24 Arrays und Referenzen (4) Wird a ein neues Array zugewiesen, bspw. via a = new int[5], ergibt sich folgendes Bild: Seite 24 a a[0] a[1] a[2] a[3] a[4] 0 0 b b[0] b[1] b[2]

25 Arrays und Referenzen (5) Eine andere Möglichkeit, die Referenz zur Array- Variable zur»verlieren«, ist die Zuweisung von null, also bspw. so: b = null;. Resultat: Seite 25 a a[0] a[1] a[2] a[3] a[4] 0 0 b b[0] b[1] b[2]

26 Mehrdimensionale Arrays (1) Ein Array ist eine Tabelle von Werten Wenn Arrayelemente wiederum Arrays sind, spricht man von einer zweidimensionalen Tabelle (Matrix) Die Matrix ist ein Array aus Zeilen, jeder Zeile ist wiederum ein Array aus Spalten. Für int[][] a = new int[4][3]; ergibt sich folgendes Bild: a[0][0] a[0][1] a[0][2] Seite 26 a[0] a[1] a[2] a[3] 0 0 0

27 Mehrdimensionale Arrays (2) Da Arrayvariablen Referenzen sind, wird die Matrix wie folgt im Speicher dargestellt, und sieht (vereinfacht) dann so aus: a a[0][0] a[0][1] a[0][2] a[0] Seite 27 a[1] a[1][0] a[1][1] a[1][2] a[2][0] a[2][1] a[2][2] a[2] a[3][0] a[3][1] a[3][2] a[3]

28 Mehrdimensionale Arrays (3): Deklaration u. Initialisierung Auch mehrdimensionale Arrays können beim Deklarieren gleichzeitig (Elemente) initialisieren: int[][] a = { {1,2,3, {4,5,6, {7,8,9, {10,11,12 ; Das Vier-Spalten-und-drei-Zeilen Array illustriert: a[0][0] a[0][1] a[0][2] Seite 28 a[0] a[1] a[2] a[3]

29 Überblick: Verkettete Listen Seite 29 Dynamische Datenstrukturen Verkettete Listen

30 Dynamische Datenstrukturen Verkettete Listen gehören zu den dynamischen Datenstrukturen, analog zu Bäumen und Graphen Kernprinzip: Die Datenstruktur besteht aus miteinander verketteten Objekten (Knoten) Die Knoten werden zur Laufzeit (also dynamisch) mittels new erzeugt und dann verkettet Nicht so bei Arrays: Größenangabe vor der Laufzeit Die erzeugte Knoten-Datenstruktur wächst und schrumpt dynamisch Nicht so bei Array: Neu-Erzeugung eines Arrays nötig Seite 30

31 Dynamische Datenstrukturen illustriert Seite 31 In einer Liste hat jeder Knoten außer dem letzten genau einen Zeiger auf seinen Nachfolger. Liste Baum In einem Baum kann jeder Knoten mehrere Zeiger auf Nachfolger haben. Jeder Knoten wird aber nur durch höchstens einen Vorgängerknoten referenziert. Knoten in Graphen können im Gegensatz zu Bäumen durch mehrere Vorgängerknoten referenziert werden! Graph

32 Node (Liste): Wrapper für Daten Seite 32 public class Node { int value; Node next; Node( int value){ this.value = value; Die zu verwaltenden Daten. Möglich sind hier auch komplexe Typen (Student, Auto, ) Feld für die Verkettung: Der Zeiger auf das Nachfolger-Objekt Konstruktor zur Initialisierung von value Wrapper-Klasse. Die eigentlichen Daten werden in einer Klasse 'umhüllt'/'verpackt' Rekursion

33 Verkettung (1) Angenommen, es gibt zwei Node-Objekte, deren Adressen (Referenzen) in den Variablen a und b gespeichert sind: Node a = new Node( "Node 1" ); Node b = new Node( "Node 2" ); Seite 33 a b data "Node 1" data "Node 2" next next

34 Verkettung (2) Die beiden Objekte a und b können nun miteinander verkettet werden, indem wird a.next auf das Objekt zeigen lassen, das an b hängt: a.next = b; Der next-zeiger von b soll das Ende der Liste darstellen, also null zuweisen (hier redundant) b.next = null; Seite 34 a b data next "Node 1" "Node 2" data next

35 Verkettung, Quelltext: NodeTest.java Seite 35 public class NodeTest { public static void main ( String[] args ){ Node a = new Node("Node 1"); // Knoten 1 Node b = new Node("Node 2"); // Knoten 2 a.next = b; // Verkettung der Knoten b.next = null; // Ende der verketteten Liste System.out.println( "a: "+a.data+"\na's Nachfolger: "+a.next.data ); Ausgabe a: Node 1 a's Nachfolger: Node 2

36 Mit den Knoten arbeiten Es fehlen nun noch die Möglichkeiten, die Liste effizient verwenden zu können. Dazu zählen Aktionen wie bspw: Hinzufügen Löschen Länge Elemente abrufen Seite 36

37 NodeList.java public class NodeList { String data; NodeList next; NodeList( String data ){ this.data = data; next = null; NodeList( String data, NodeList next ){ this.data = data; this.next = next; NodeList rest() { return next; String firstelement() { return this.data; String lastelement() { if (next == null) return data; else return rest().lastelement(); String lastelementiterative() { NodeList tmp = this; while (tmp.next!= null) { tmp = tmp.rest(); return tmp.firstelement(); Seite 37

38 NodeListTest.java Seite 38 public class NodeListTest { public static void main(string[] args) { NodeList nodelist= new NodeList("Knoten 1", new NodeList("Knoten 2", new NodeList( "Knoten 3") ) ); System.out.println( nodelist.firstelement() ); System.out.println( nodelist.lastelement() ); System.out.println( nodelist.lastelementiterative() );

39 Verwendete Literatur Mössenböck, Hanspeter Sprechen Sie Java?, 3. Auflage. dpunkt.verlag. Seite 39