Ein kleines inoffizielles Script zu Allgemeine Informatik 2. Autor: Martin Rickes

Transkript

1 Ein kleines inoffizielles Script zu Allgemeine Informatik 2 Autor: Martin Rickes

2 Ich danke allen, die an diesem Script mitgeholfen haben. Besonderer Dank gilt: Stefanie Mühlsteph, die die Befehlssammlung (Anhang A) geschrieben hat. Thomas Stein, Lektor Henning Janssen, Lektor Florian Bahlke, Lektor

3 1 Vorwort Der zugrunde liegende Gedanke für dieses Script ist nicht ganz uneigennütziger Natur. Es gibt verschiedene Gründe, warum dieses Script überhaupt, und in dieser Form geschaffen wurde. Der wohl wichtigste ist, dass der Autor sich ebenfalls mit AI-2 herumzuschlagen hat und daher zwecks des besseren Lernens eine Zusammenfassung schreibt. Ein weiterer Punkt ist, dass es eine sehr gute Übung ist, L A TEX zu lernen. Nicht zuletzt ist es auch eine hervorragende Übung, eine wissenschaftliche Publikation zu schreiben. Der Autor bittet daher eine etwas hochgestochene Sprache ( der Autor ) und gewisse Spielereien mit den Möglichkeiten von L A TEX zu entschuldigen. Die Programmierbeispiele sind entweder geistiges Eigentum des Autors oder von anderen Stellen dreist geklaut. In der Hauptsache richtet sich dieses Script aber nach den Folien der AI-2-Vorlesung im Sommersemester 2008 von Prof. Koch. Im Gegensatz zur Veranstaltung wird für dieses Script die Eclipse-Entwicklungsumgebung anstelle von BlueJ verwendet werden. Dies liegt in einer tiefen Abneigung seitens des Autors gegenüber BlueJ begründet. Eine wichtige Anmerkung: Dieses Script ist inoffiziell, es besteht keine Garantie auf Vollständigkeit und inhaltliche Korrektheit. Konstruktive Kritik, Erweiterungen, Verbesserungen sind ausdrücklich erwünscht. Beschimpfungen und Drohungen, weil man sich zwei Tage vor der Klausur das Script auf dem Klo mal durchgelesen hat und erstaunlicher Weise durch die Klausur gefallen ist, sind nutzlos. Außer sie sind geistreich oder witzig. Martin Rickes, Darmstadt 2008 i

4 2 Zusammenfassung In der Veranstaltung Allgemeine Informatik 2 geht es um Java. Wer hätte das gedacht... ii

5 Inhaltsverzeichnis 1 Vorwort i 2 Zusammenfassung ii 3 Java - was, wann, warum, wieso Historie der Programmiersprache Java Compiler VS. Interpreter Java-Bytecode und die Java-Virtual-Machine Java-Laufzeitsystem Einsatz von Java-Programmen Was braucht man zum Arbeiten mit Java? Einführung in BlueJ 6 5 Wichtige Regeln für die Programmierung in Java Sprachaufbau Lexikalische Ebene Syntaktische Ebene Semantische Ebene Logische Ebene Spezifikatorische Ebene Einige Grundregeln für das Programmieren in Java Datentypen Eingebaute Datentypen Datentyp char Datentypen float und double Der Standardwert Operatoren Relationale Operatoren Arithmetische Operatoren Logische Operatoren/Short-Circuit Zuweisungsoperatoren Type-Cast Ausdrücke Klassen und Objekte Datenfelder Konstruktoren Methoden Variablen in Klassen Variablen und deren Gültigkeit Konstanten Literale Scope Lebenszeit Garbage Collection Methoden und deren Aufrufe Pakete und Klassenpfade Objekt- und Klassenmethoden Überladung

6 9 Programmfluss Was bedeutet Programmfluss? Schleifen while-schleifen do-while-schleife for-schleife Steuerung im Schleifenrumpf Bedingungen und Verzweigungen Rückgabetypen und Return Seiteneffekte Interne Realisierung von Methoden Rekursion Verweise und Referenzen Das Schlüsselwort this Objekte und Referenzen Erweiterte und Komplexe Datentypen Rekursve Datentypen Bäume Vererbung Abstrakte Methoden und Interfaces Abstrakte Methoden Interfaces und Mehrfachvererbung Das Java Collection Interface Exceptions Schlusswort 44 A Befehlssammlung 45 B Changelog 48 2

7 3 Java - was, wann, warum, wieso Java ist eine objektorientierte Programmiersprache und eingetragenes Warenzeichen der Firma Sun Microsystems. Zu Java im Allgemeinen zählt nicht nur die Programmiersprache, sondern auch weitere Komponenten. Besonders zu nennen sind hier das Java-Runtime-Environment (JRE) und die Java-Virtual-Machine (JVM). Der aktuelle Stand ist die Version Historie der Programmiersprache Java Die Entwicklung von Java begann 1991 bei Sun Microsystems unter dem Arbeitstitel Object Application Kernel (OAK). Dieser wurde später aus rechtlichen Gründen in Java umbenannt. Die Entwicklung des OAK war Teil des Green-Project, welches auf Basis eines portablen Minicomputers (Star-Seven) eine Lösung für interaktives Fernsehen und weitere Produkte der Consumer-Elektronik darstellen sollte. Ende 1991 war der erste lauffähige OAK entwickelt und führte erste Programme aus wurde das Projekt Sun-Intern vorgestellt und stieß auf große Resonanz, die Firma First Person Inc. wurde geschaffen. Bereits 1994 bestand Konsens darüber, dass die Hardwareplattform Star-Seven überholt ist und es wurde begonnen, sich nur noch auf die Software zu konzentrieren wurde die Firma JavaSoft gegründet und Star-Seven damit endgültig begraben. Java ist prinzipiell stark an die deutlich ältere und verbreitete Programmiersprache C/C++ angelehnt, was den Umstieg für C-Programmierer erleichtern und so für eine höhere Akzeptanz sorgen sollte. Als Beispiel wären hier die Zuweisungen bzw. die Überprüfung auf Gleichheit zu nennen. Sowohl Java, als auch C++ benutzen = für Zuweisungen und == für die Überprüfung auf Gleichheit. Pascal/Delphi hingegen benutzt := für Zuweisungen und = für Gleichheit. Der Hauptunterschied zwischen Java und C/C++ besteht im dem Grad der Freiheit, welcher dem Programmierer eingeräumt wird. In C++ hat der Entwickler alle Freiheiten und Möglichkeiten. Dies birgt allerdings viele potenzielle Fehlerquellen und bringt daher ein großes Maß an Eigenverantwortung für den Entwickler mit sich. Bei Java hingegen ist alles Sinnlose von vorne herein verboten. Dies kann sich in manchen, speziellen Situationen als hinderlich erweisen, nimmt dem Entwickler aber einiges an Verantwortung ab. 3.2 Compiler VS. Interpreter Ein großes Problem bei der Programmierung ist die Schnittstelle Mensch-Maschine. Der Mensch (Programmierer) möchte eine möglichst lesbare, Programmiersprache benutzen. Die Maschine versteht nur Maschinensprache, also Assambler/Binärcode. Das heißt, der Programmierer erstellt eine oder mehrere Dateien mit Code, welcher für den Computer übersetzt werden muss. Um diese Lücke zu füllen, existieren zwei unterschiedliche Verfahren: Zum ersten der Compiler und zum zweiten der Interpreter. Der Compiler erstellt aus dem Source-Code, also den vom Programmierer geschriebenen Dateien, eine vom Computer ausführbare Datei in Maschinensprache. Unter Windows wird z.b. der Code in eine.exe-datei umgewandelt. Diese Dateien auszuführen geht sehr schnell, das Compilieren kann hingegen sehr lange dauern, ist aber ein einmaliger Vorgang, der nicht wiederholt werden muss. Die compilierten Dateien können vom jeweiligen Betriebssystem als normaler Prozess ausgeführt werden. Im Gegensatz dazu steht der Interpreter. Der Interpreter schreibt keine ausführbare Datei, sondern führt den Source- Code direkt aus. So wird die Zeit zum compilieren eingespart, allerdings dauert die Ausführung länger. Der Interpreter übersetzt den Quelltext bei jeder Ausführung erneut. Eine Analogie könnte in der Rede eines ausländischen Politikers gefunden werden. Eine Zeitung compiliert die Rede, man kann sie am nächsten Tag in der Zeitung abgedruckt ins Deutsche übersetzt lesen. Eine Fernsehstation mit Live- Übertragung hingegen interpretiert die Rede, hier wird ein Simultanübersetzer eingesetzt. Prinzipiell kann jede Sprache sowohl compiliert als auch interpretiert werden, dies macht aber aus Sicht der Anwendung nicht immer Sinn. HTML z.b. wird immer Interpretiert, der Browser übersetzt den Seiten-Quelltext beim Aufruf in die richtige Formatierung. C/C++ hingegen wird compiliert, da diese Sprachen oft für komplexe und große Programme eingesetzt werden und hier ein Interpreter zu langsam wäre. 3

8 3.3 Java-Bytecode und die Java-Virtual-Machine Im vorangegangenen Teil wurden die Unterschiede zwischen Compiler und Interpreter dargelegt. Im Falle von Java wird sowohl ein Compiler als auch ein Interpreter verwendet. Dies wird bedingt durch die Forderung, dass Java plattformunabhägig, also auf jedem Betriebssystem, laufen soll. Der Compiler compiliert den Source-Code in den sog. Java- Bytecode, eine spezielle Form des Maschinencodes, welche insbesondere auf die Anforderungen der Java-VM angepasst ist. Zusätzlich enthält der Java-Bytecode noch Informationen, die es gestatten, Sicherheitsroutinen in die Ausführung zu implementieren (z.b. Zugriffsrechte auf Ressourcen). Die Java-VM ist ein virtueller Computer, der auf dem jeweiligen Betriebssystem als Prozess läuft und den standardisierten Java-Bytecode ausführen kann. Durch diese Abstraktion können Java-Programme plattformunabhängig ausgeführt werden: Die auf das jeweilige Betriebssystem angepasste Java-VM bietet eine standardisierte Möglichkeit den Bytecode auszuführen, ohne dass die Besonderheiten des Betriebssystems eine Rolle spielen. Damit ist gewährleistet, dass ein Java- Programm, sofern die JVM korrekt arbeitet, auf allen Rechnerarchitekturen und allen Betriebssystemen gleichermaßen läuft und sich auch identisch verhält. Dies ist insbesondere in der Web-Entwicklung wichtig, da jeder Teilnehmer des Internets, unabhängig von Computer und Betriebsystem, gleichermaßen auf die Inhalte einer Seite zugreifen können soll. Ein weiterer Aspekt ist die Sicherheit. Da Java-Programme in der virtuellen Umgebung laufen, haben sie keinen direkten Zugriff auf das bestehende Betriebssystem. Dies stellt eine Hürde für Viren und Java-Script basierte Angriffe im Internet dar. Im Nachfolgenden Schaubild ist die prinzipielle Abfolge dargestellt: Zuerst wird der Quellcode compiliert und liegt daraufhin als Bytecode vor. Dieser Bytecode wird ein eine Webseite eingebunden und liegt auf dem Server bereit. Dies sind einmalige Vorgänge. Kommt nun ein Nutzer und ruft das Programm auf, so wird der Bytecode in die JVM geladen, interpretiert und ausgeführt. Die JVM übernimmt die Interaktion mit dem Betriebssystem. Diese Vorgänge werden bei jedem Aufruf des Programms erneut durchlaufen. Abbildung 3.1: Prinzipschaubild der Ausführung eines Java-Programms auf einer Webseite 4

9 3.4 Java-Laufzeitsystem Das Java-Laufzeitsystem ist eine Komponente des Interpreters (der Java-VM), welches im Hintergrund verschiedene Dienste zur Verfügung stellt, welche nicht explizit im Quellcode geschrieben werden müssen. Dadurch wird auch ohne besondere Vorsichtsmaßnahmen eine gesicherte Umgebung gewährleistet, welcher dem Programmierer Sicherheit gibt. So fängt das Laufzeitsystem viele Ausnahmen (Exceptions) ab, die unter C/C++ zu einem Totalabsturz des Prozesses oder gar des Betriebssystems geführt hätten. Beispiele sind hier die Division durch Null, ein Array-Überlauf oder eine Null-Pointer-Exception. Der Quellcode: public class ArrayUeberlauf public static void main(string[] args) int[] array = new int[2]; array[5] = 23; Produziert eine Fehlermeldung des Laufzeitsystems: Exception in thread "main" java.lang.arrayindexoutofboundsexception: 5 at ArrayUeberlauf.main(ArrayUeberlauf.java:6) Dies ist auch selbstverständlich, denn es wird dem Array array am Index 5 ein Wert zugewiesen, obwohl array nur 2 Elemente hat. Sobald das Laufzeitsystem einen Fehler abgefangen hat, wird die weitere Ausführung des Programms abgebrochen. Eine weitere wichtige Funktion des Laufzeitsystems ist die Speicherbereinigung. Auf diese wird in einem späteren Kapitel genauer eingegangen. 3.5 Einsatz von Java-Programmen Die weiteste Verbreitung hat Java im Internet als Java-Applets und Java-Serverlets. Dies macht Java zu einer wichtigen Programmiersprache in der heutigen Welt des Internets. Es gibt auch verschiedene Anwendersoftware, die auf Java-Basis geschrieben wurde, Matlab z.b. Nicht eingesetzt wird Java in hardwarenaher Umgebung, sowie bei zeitkritischen Anwendungen. Insbesondere bei schnellen Echtzeitanwendungen kommt es durch die Garbage-Collection unter Umständen zu Verzögerungen und damit zu Fehlern. 3.6 Was braucht man zum Arbeiten mit Java? Sun Microsystems stellt die Java Virtual Machine (JVM) und das Java Runtime Environment (JRE) für die Ausführung von Programmen und das Java Development Kit (JDK) als Entwicklungsumgebung zur Verfügung. Zum eigentlichen Programmieren benötigt man lediglich einen Texteditor, in dem man den Quelltext schreiben kann. Mittels diesem erstellt man eine Datei namens MeineKlasse.java. Dieser Quelltext muss nun natürlich compiliert, also in Bytecode übersetzt, werden. Dafür wird unter Linux das Konsolenkommando javac MeineKlasse.java verwandt. Dieses erzeugt eine Datei MeineKlasse.class. Mittels java MeineKlasse.java kann dieses Programm nun ausgeführt werden. Texteditoren beinhalten allerdings lediglich die grundsätzlichen Textbearbeitungsfunktionen. Auch wenn es viele gibt, die gewisse Funktionen für das Programmieren unterstützen (z.b. VIM, Kate), gibt es doch deutlich komfortablere Lösungen: Das so genannte Integrated Development Environment (IDE). In diesen IDEs wird eine Vielzahl von Einzelfunktionen vereint. So besitzen sie in der Regel zumindest einen Texteditor, Compiler bzw. Interpreter, Debugger, Linker und eine Quelltextformatierungsfunktion. Fortschrittlichere IDEs haben wesentlich mehr Funktionen und automatische Korrekturmechanismen. Das bekannteste und am weitesten verbreitete IDE für Java ist Eclipse. In dieser Veranstaltung wird eine sehr stark minimierte IDE, BlueJ, verwandt. Dieser fehlen, verglichen mit Eclipse, die meisten Möglichkeiten und Mechanismen. Ein aus Allgemeine Informatik I bekanntes IDE ist KarelJ. Ein weiterer wichtiger Punkt ist das Application Programming Interface (API), die Schnittstellenbeschreibung, von Sun Microsystems. In dieser stehen sämtliche Informationen zu den zur Verfügung stehenden Klassen. 5

10 4 Einführung in BlueJ Dieses Kapitel wird verglichen mit der Vorlesung stark gekürzt werden, da die Bedienungsanleitung für die IDE bereits in den Hilfe-Dateien zu finden ist. BlueJ ist eine reine Lern-IDE, daher fehlen ihr viele Funktionen, die das Arbeiten im praktischen Alltag beschleunigen. Beispielsweise verfügt BlueJ über keine Autovervollständigung. Der Sinn dahinter ist, dass man mit dieser IDE alle Handgriffe erlernen soll, auch wenn sie einem später von den IDEs abgenommen werden. Eine Besonderheit von BlueJ ist die Pseudo-UML-Darstellung im Hauptfenster. Hier wird das Programm in Form von Kästen für jede Klasse und jedes Paket dargestellt. Abhängigkeiten untereinander werden durch Pfeile symbolisiert. Objekte werden ebenfalls in dem Hauptfenster grafisch dargestellt. Eine weitere Besonderheit ist, dass BlueJ kein fertiges Java-Programm benötigt, sondern einzelne Methoden ad hoc mit vorgegebenen Werten ausführen kann. Dies erleichtert das Testen von einzelnen Methoden erheblich. Für erweiterte Tests müssen aber ohnehin Testklassen geschrieben werden und mit diesen ist dieser Vorteil hinfällig. Wie Methoden können auch Objekte direkt angesprochen und betrachtet werden (Option: Inspect ). BlueJ verfügt über einen internen Texteditor mit Syntax-Highlighting. Ein großer Nachteil von BlueJ ist, dass diese UML-Darstellung in eigenen Konfigurationsdateien gespeichert wird und so ein Import von Programmen aus anderen IDEs (z.b. Eclipse) unter Umständen problematisch ist. Ein Import von BlueJ-Quelltext in Eclipse ist aber problemlos möglich. Abschließend lässt sich sagen, dass BlueJ zwar für das Handwerkliche (Einrücken, Schreibweisen etc.) eine gute Lern-Umgebung ist, zum echten Programmieren aber nur bedingt hilfreich. Abbildung 4.1: BlueJ Hauptfenster 6

11 5 Wichtige Regeln für die Programmierung in Java In diesem Kapitel werden die wichtigsten und grundlegensten Regeln beim Programmieren mit Java beschrieben. Allen, die Allgemeine Informatik I besucht haben, sollten diese bereits bekannt sein. 5.1 Sprachaufbau Der sprachliche Aufbau von Java unterteilt sich in 5 Abstraktionsebenen: 1. Lexikalische Ebene 2. Syntaktische Ebene 3. Semantische Ebene 4. Logische Ebene 5. Spezifikatorische Ebene Lexikalische Ebene Die lexikalische Ebene stellt die unterste Ebene dar. Auf dieser Ebene befinden sich die grundlegenden Anweisungen und Operatoren. Diese werden zu primitiven Anweisungen, wie int ii = 1; zusammengefügt. Zu den lexikalischen Elementen gehören: Schlüsselwörter, wie int, if, for etc. Bezeichner, also Namen von Klassen, Variablen, Methoden etc. (Diese dürfen nicht mit einer Ziffer beginnen) Operatoren der Grundrechenarten (+,-,*,/) Vergleichsoperatoren (<,>,==,<=) Logische Operatoren (&&, ) Klammern (), [], Literale (explizite Werte), z.b. 23, 42, 1234, a, "Hallo" Seperatoren, wie Tab, Leerzeichen, Zeilenumbruch Syntaktische Ebene Die syntaktische Ebene ist die korrekte Gruppierung von lexikalischen Elementen und damit die Erzeugung von Ausdrücken. Zu beachten ist hier die korrekte Benutzung von Klammern (die Öffnende steht vor der Schließenden). void zahl(int num) int zahl = num; if(zahl < 10) zahl++; In diesem Beispiel sind die Lexikalischen Elemente zahl++; (Addition von 1) und int zahl = num; (Zuweiseung der übergebenen Variable num) durch eine If-Abfrage if(zahl < 10)... getrennt und damit zu einem Ausdruck mit zwei Anweisungen gruppiert. Zu beachten sind auch die Strukturen der geschweiften Klammern. Ein Paar umfasst die komplette Methode und definiert so deren Anfangs- und Endpunkt, ein weiteres Paar definiert den Anfangs- und Endpunkt der If-Abfrage. 7

12 5.1.3 Semantische Ebene Unter der semantischen Ebene versteht man die Prioritätsverteilung zwischen einzelnen syntaktisch korrekt angeordneten lexikalischen Elementen. Ein einfacher Satz der Semantik ist beispielsweise Punkt- vor Strichrechnung. int ii = 4*2 + 6; ergibt ii == 14; int ii = 4*(2 + 6); ergibt hingegen ii == 32; Durch die Klammern wurde die Reihenfolge der Berechnung verändert und damit auch das Ergebnis Logische Ebene Mit der logischen Ebene verlässt man den Bereich, in dem Fehler durch den Compiler entdeckt werden können. Logisch fehlerhafte Programme werden anstandslos compiliert, liefern aber falsche Ergebnisse. Die Suche nach logischen Fehlern kann beliebig aufwändig werden und ist nur durch unentwegtes Testen zu bewerkstelligen. Ein in der Vorlesung angesprochenes Beispiel ist das Fencepost Syndrom : 20 Meter Zaun und alle 2 Meter ein Pfosten. Es scheint offensichtlich, dass sich die Anzahl an Pfosten durch 20 2 = 10 errechnet. Vergegenwärtigt man sich allerdings die Platzierung der Pfosten wird einem schnell folgendes auffallen: P(f osten)[1] 0M eter, P[2] 2m, P[3] 4m,..., P[10] 18m An dieser Stelle wird klar, die Anzahl der Pfosten muss 11 sein. Der vorherige Algorithmus war falsch. Die meisten Programmierfehler finden auf der logischen Ebene statt. In vielen Fällen handelt es sich dabei aber streng genommen nicht um Programmierfehler, sondern um Fehler in verwendeten Algorithmen. Ein weiteres Beispiel stammt aus der Übung 8: public static int mult(int a,int b) if(b > 0) a = a + a; b--; mult(a,b); return a; Hierbei handelt es sich um einen rekursiv ausgeführten Algorithmus, welcher zwei Zahlen multiplizieren soll. Das Prinzip ist folgendes: Solange der Multiplikator b größer Null ist, wird a um a erhöht und der Multiplikator um eins erniedrigt. Dies findet b-mal statt, wäre also eine Multiplikation. Leider ergibt diese Multiplikation vollkommen falsche Ergebnisse. Der Grund dafür liegt daran, dass a bei jeder Rekursion bereits um a erhöht wurde, das heißt wir erhalten die Folge: a 2a 4a 8a... also f b (a) = 2 b a. Umgehen lässt sich dieses Problem lediglich, in dem wir zwei Methoden schreiben. Eine, die zwei Variablen erwartet und als Return dann eine Methode mult(a,b,a); aufruft. Die dritte Variable wird in der Rekursion einfach durch gereicht und die Addition wird als a = a + c; ausgeführt. Dadurch erhalten wir die Folge a 2a 3a 4a... also die gewünschte f b (a) = ba Spezifikatorische Ebene Die spezifikatorische Ebene beschreibt die Diskrepanz zwischen der Intention des Programms und den tatsächlichen Spezifikationen. Ein Beispiel für dieses Problem ist der Millenium-Bug. Jahrzehntelang wurde, um Speicher zu sparen, ein Datum in folgender Form angegeben DD.MM.JJ. Der entspricht also dem 23. Februar Mit dem war diese Spezifikation ungültig, denn es konnte nicht mehr zwischen 1900 und 2000 differenziert werden. Prinzipiell werden die Spezifikationen zu jedem erdenklichen Produkt angegeben. Bei einem Müsli ist es die Nährwerttabelle und die Zutatenliste, bei einem Fernseher die technischen Daten. 8

13 5.2 Einige Grundregeln für das Programmieren in Java Es gibt einige Konventionen, die das Programmieren und vor allem das Lesen von geschriebenem Quellcode erleichtern sollen. An dieser Stelle weicht die Vorlesung an einigen Stellen von den Ansichten des Autors ab. Der erste Punkt dieser Konvention betrifft die Nutzung von Zeilenumbrüchen, Leerstellen und Tabs. Für den eigentlichen Quellcode ist nur ein absolutes Minimum an Leerstellen nötig und keine Tabs oder Zeilenumbrüche. Der hier dargelegte Code würde von einem Compiler anstandslos übersetzt werden: public class Syntaktikervoid zahl()int zahl=5;if(zahl<10)zahl++;else zahl--; Wie unschwer zu erkennen ist, handelt es sich um das Beispiel aus Kapitel Verglichen mit dem dort abgedruckten Code ist dieser hier natürlich deutlich schwerer zu verstehen. Die Funktionalität wäre allerdings nicht eingeschränkt. Die in der Vorlesung vorgeschlagene Konvention sieht folgendes vor: Nach einem Semikolon folgt immer ein Zeilenumbruch, die öffnende geschweifte Klammer befindet sich am ende der Zeile und die nachfolgenden werden um ein Tab (oder einige Leerstellen) eingerückt. Schließende Klammern befinden sich allein stehend in einer Zeile. Diese Konvention erhöht die Lesbarkeit massiv, aber insbesondere bei verschachtelten Schleifenkonstruktionen verliert man schnell den Überblick wo, welche Schleife auf geht und geschlossen wird. Ein Beispiel für diese Problematik: static void schleife() int a = 5; boolean z; while(false) schleife(); if(true) schleife(); Insbesondere im ersten Teil ist nicht sofort ersichtlich, wo sich die öffnenden Klammern befinden. Die vom Autor favorisierte Konvention sieht vor, dass jede geschweifte Klammer nach einem Zeilenumbruch allein steht. Obriger Code sähe dann wie folgt aus: static void schleife() int a = 5; boolean z; while(false) schleife(); if(true) schleife(); Zweifelsohne wird der Code dadurch um einiges länger, aber die Schleifen Anfangs- und Endpunkte sind auf den ersten Blick direkt ersichtlich. Die nächste Konvention betrifft die Namensgebung innerhalb des Quellcodes. Grundsätzlich zu beachten gilt, dass Java zwischen Groß und Kleinbuchstaben unterscheidet. Gibt man beispielsweise int Int; ein, so wird die Interger-Variable Int deklariert, int int; hingegen gibt einen Fehler aus. Auch für Bezeichner gibt es einige Regeln. Wortanfänge werden auch innerhalb eines Wortes groß geschrieben MeineTolleNuklearoptimaleKlasse, der Underscore ist zu vermeiden. Namen von Klassen beginnen immer mit einem Großbuchstaben, Namen von Variablen und Methoden hingegen immer mit Kleinbuchstaben: int var;, Object.methode();. Eine weitere Regel für Bezeichner ist es, sprechende Namen zu benutzen, gettime ist beispielsweise eine Methode die eine Zeit abfragt. Variablen sollten auch Namen erhalten, die über ihre Funktion etwas aussagen, also nicht einfach a, b, c, sondern count, timer, pages. Zähler in Schleifen werden in der Vorlesung üblicherweise mit i bezeichnet. Empfehlenswert ist eher ii oder jj. Wer den Sinn darin nicht erkennen kann, der möge mit der Volltextsuche (Strg + f) ein beliebiges längeres Programm nach i durchsuchen. 9

14 Ein letzter aber nicht weniger wichtiger Punkt ist die Kommentierung. Java bietet das so genannte JavaDoc an, welches automatisch eine Dokumentation im Stile der Java-API (Siehe Kapitel 3.6) erzeugen kann. Näheres unter: Unter Java werden Kommentare mit // gekennzeichnet, mehrzeilige Kommentare sind auch möglich Code //Kommentar /* * Kommentar * Kommentar */ Code Wenn diese einfachen Konventionen beachtet werden, sind die meisten Programme schon hinreichend lesbar: /** * Martin * */ public class Schleifentest /** * Rekursive Schleife, die zum Absturz des Laufzeitsystems führt. a - Nutzloser Integer-Wert */ static void schleife(int a) if(true) //true: Wird immer ausgeführt. schleife(a); //Rekursiver Aufruf! /* * Main-Methode: * Ruft Schleife mit dem Integer 1 auf, wenn args leer ist. */ public static void main(string[] args) if(args.length < 1) schleife(1); In diesem Beispiel kommt sowohl konventionelle Kommentierung, als auch Javadoc zur Anwendung. 10

15 6 Datentypen Bei Datentypen wird zwischen zwei Haupttypen unterschieden. Einerseits die eingebauten, primitiven Datentypen, wie int, char, double, die Grundlegende Basis eines Java-Programms. Mit ihnen werden sämtliche konkreten Datenveränderungen durchgeführt. Andererseits zusammen gesetzte Datentypen (Klassen). In ihnen können mehrere primitive Datentypen zusammengefasst und verwandt werden. Diese sind im Übertragenen Sinne als Bausteie zu sehen, mit welchen komplexere Programme aufgebaut werden können, ohne dass eine gewisse Funktion explizit immer wieder geschrieben werden muss. Dadurch ist es in vielen Fällen nicht nötig, selbst zu entwickeln, sondern es kann auf Bestehendes zurück gegriffen werden. Ein weiterer Vorteil ist, dass bestimmte Bereiche für sich eingekapselt, also abgeschlossen sind. Das bewirkt, dass ein Entwickler auch ohne eine genaue Kenntnis eines gewissen Detailgebietes auf vorgefertigte Funktionen zurückgreifen kann. 6.1 Eingebaute Datentypen Zu erst eine Übersicht über die eingebauten Datentypen und ihre Eigenschaften: Typ Länge Wertebereich Standardwert in Byte boolean 1 True, False False char 2 Alle Unicode-Zeichen \u0000 byte short int long float 4 ±3, double 8 ±1, long double 10 ±1, Tabelle 6.1: eingebaute Datentypen In den meisten Anwendungen spielen lediglich boolean, char, int, double eine Rolle. Die anderen Variablentypen sind heutzutage nur noch bei sehr speicherkritischen Anwendungen von Belang Datentyp char Der eingebaute Datentyp char wird benutzt, um Zeichen zu speichern. In vielen Programmiersprachen werden ASCII- Zeichen gespeichert, in Java hingegen Unicode, daher ist ein char in Java 2 Byte (statt einem Byte) lang. Unicode-Zeichen werden in der Form \uxxxx gespeichert, wobei x jeweils für einen hexadezimalen Wert steht. char-literale werden in einfache Hochkommata gesetzt, z.b. A, z, Datentypen float und double Bei float und double handelt es sich um Fließkommawerte, das heißt, sie werden in der Form x, x x x y gespeichert. Der Hauptunterschied zwischen diesen beiden Datentypen besteht in ihrer Größe und damit ihrem Wertebereich. float (=Floating-Point-Numbers) ist 4 Byte, also 32 Bit, lang. Davon werden 23 für die Mantisse, 8 für den Exponent und eines für das Vorzeichen verwendet. Das ergibt, wie auch der Tabelle zu entnehmen ist, einen Wertebereich von ±3, float war ursprünglich (in anderen Programmiersprachen) als kompakter Datentyp für reelle Zahlen gedacht. double (=double precision) verwendet die doppelte Anzahl an Bits, 64, um reelle Zahlen zu speichern. Diese teilen sich wie folgt auf: 53 Bit für die Mantisse, 10 für den Exponent und eines für das Vorzeichen. So wird ein Wertebereich von ±1, abgedeckt. Da man heutzutage in den meisten Anwendungen keinerlei Speicherprobleme mehr zu befürchten hat, wird gewöhnlicher Weise nur noch double verwendet. 11

16 6.1.3 Der Standardwert Wird ein Objekt eines eingebauten Datentyps bei seiner Einrichtung nicht explizit mit einem Wert initialisiert, so wird es automatisch mit dem dazugehörigen Standardwert initialisiert. Dies bedeutet, dass Folgende Deklarationen prinzipiell äquivalent sind: int ii; int jj = 0; Für numerische Datentypen (int, float, double etc.) ist der Standardwert immer Null, für char ist er das Nichtzeichen (Unicode-Wert 0) und für boolsche Datentypen false. Da alle Werte quasi Null sind, false sieht man auch als Null an, werden diese Standardwerte auch als Nullwerte bezeichnet. In neuen Versionen des Java-Compilers wird trotz dieser Tatsache eine explizite Initialisierung lokaler Datentypen gefordert. Dies wurde von den Compiler-Entwicklern eingeführt um im Quellcode einen konsistenten Stil zu erzwingen. Das bedeutet, dass der Compiler einen Fehler wegen fehlender Initialisierung ausgibt, obwohl die Datentypen prinzipiell bereits einen Standardwert besitzen. Betrachtet man beispielsweise dieses Beispiel einer lokalen Integer-Variable: int ii; ii++; So wird man bei der zweiten Zeile eine Fehlermeldung erhalten. Zwar besitzt ii prinzipiell bereits den Standardwert 0, dieser wird aber nicht anerkannt. Dies hingegen funktioniert fehlerlos. jj nimmt in diesem Fall den Wert 1 an: int jj = 0; jj++; Oder alternativ: int jj; jj = 0; jj++; Wie bereits gesagt, gilt dies aber nur für lokale Variablen. So ergibt eine als Klassenvariable deklarierte Integer-Variable (static int ii;) trotz fehlender expliziter Initialisierung keine Fehlermeldung. 12

17 6.2 Operatoren Ein Operator ist ein Lexikalisches Element, welches der Steuerung von Befehlsfolgen dient. Grundsätzlich wird zwischen folgenden Arten von Operatoren unterschieden: Relationale Operatoren, Arithmetische Operatoren, Logische Operatoren, Short Circuit Operatoren, sowie Zuweisungsoperatoren Relationale Operatoren Relationale Operatoren dienen dem Vergleich von numerischen Werten auf boolscher Ebene, das heißt sie geben lediglich ein true oder false zurück. Releationale Operatoren sind: Operator Bezeichnung Bedeutung == Gleich a == b ergibt true, wenn a gleich b!= Ungleich a!= b ergibt true, wenn a ungleich b < Kleiner a < b ergibt true, wenn a kleiner b <= Kleiner-Gleich a <= b ergibt true, wenn a kleiner oder gleich b > Größer a > b ergibt true, wenn a größer b >= Größer-Gleich a >= b ergibt true, wenn a größer oder gleich b Tabelle 6.2: Relationale Operatoren Arithmetische Operatoren Arithmetische Operatoren erwarten Numerische werte und liefern ebenfalls numerische Werte zurück. Bei diesen Operatoren handelt es sich überwiegend um die mathematischen Grundrechenarten. Werden verschiedene numerische Datentypen mit einem arithmetischen Operator verknüpft, so wird das Ergebnis in Form des größeren der beiden Datentypen zurück gegeben. So wird int Int; double Double; public void calc() System.out.print(this.Int + this.double); immer einen double-wert ausgeben, obwohl einer der Operanden vom Datentyp her ein int ist. Dies bedeutet, es wird bei arithmetischen Operatoren immer automatisch ein Type-Cast (=Konvertierung) zum größten verwendeten Datentyp durchgeführt. Neben den Grundrechenarten der arithmetischen Operatoren gibt es noch eine Vielzahl weiterer mathematischer Methoden in Java, diese können über java.lang.math.befehl(...) aufgerufen werden. Math.sqrt(...) errechnet beispielsweise die Quadratwurzel (Squareroot). Es gibt zwei Datentypen, die einer Ausnahme bedürfen. Der erste ist der komplexe Datentyp String. Man kann zwei Strings addieren, das ist äquivalent des Anhängens des einen an den anderen: public class StringAdder public static void main(string[] args) String str1 = "Hallo"; String str2 = " Welt"; String str3 = str1 + str2; System.out.println(str3); 13

18 Dies ergibt als Ausgabe: Hallo Welt Der zweite Sonderfall ist char. Werte des Datentyps char können addiert und subtrahiert werden. Dabei werden diese automatisch (also implizit) in einen Integer-Wert konvertiert. Um das Ergebnis wieder als char darstellen zu können ist ein expliziter Type-Cast erforderlich. char a = f ; char b = (char)(a - a + A ); In diesem Beispiel wird von f der Wert von a abgezogen und der von A addiert, eine Verschiebung dieses Offsets ergibt F. Operator Bezeichnung Bedeutung + Pos. Vorzeichen +n ist gleich n - Neg. Vorzeichen -n kehrt Vorzeichen von n um + Summe a + b ergibt die Summe a + b - Differenz a - b ergibt die Differenz a - b * Produkt a * b ergibt das Produkt a * b / Quotient a / b ergibt den Quotionten a b % Restwert a % b ergibt den restwert der Ganzzahligen Division von a durch b. ++ a+1 a++ == a+1, Präinkrement und Postinkrement beachten! -- a-1 a-- == a-1, Prädekrement und Postdekrement beachten! Tabelle 6.3: Arithmetische Operatoren Beispiel für Prä- und Postinkrement: int a = 1; int b = a++; //b == 1, a == 2 Das bedeutet, die Addition von 1 erfolgt nach der Zuweisung. int a = 1; int b = ++a; //b == 2, a == 2 Beim Präinkrement wird zuerst die Addition a+1 ausgeführt und das Ergebnis anschließend b zugewiesen Logische Operatoren/Short-Circuit Operator Bezeichnung Bedeutung! logisches Nicht Invertiert den boolschen Wert && Und mit Short-Circuit a && b ergibt true, wenn a und b zutreffen. Ist a bereits falsch, wird b nicht ausgewertet. Oder mit Short-Circuit a b ergibt true, wenn entweder a oder b zutrifft. Trifft a bereits zu, wird b nicht mehr ausgewertet. & Und ohne Short-Circuit Ergibt true, wenn a und b zutreffen. Beide Teilausdrücke werden ausgewertet Oder ohne Short-Circuit Ergibt true, wenn entweder a oder b zutrifft. Beide Teilausdrücke werden ausgewertet ^ Exor Ergibt true, wenn a und b einen unterschiedlichen Wahrheitswert haben. Wird bitweise Ausgewertet. Tabelle 6.4: Logische Operatoren/Short-Circuit 14

19 Weitergehend gilt es zu beachten, dass eine Auswertung auch Bit-weise erfolgen kann, und so deutlich andere Ergebnisse liefert: int ii; ii = 1 2 //ii == 3 Der Grund hierfür liegt auf der binären Ebene. Die Operation 1 2 lässt sich auch schreiben als 01 10, denn binär betrachtet is 1 == 01 und 2 == 10, das Ergebnis der bitweisen Oder-Verknüpfung ist nun 11 und damit im dezimalen System Zuweisungsoperatoren Zweisungen werden immer mit einem einfachen Gleichheitszeichen gekennzeichnet. Die Zuweisung ii = jj weist ii den Wert von jj zu. Zusätzlich kann die zuweisung noch mit einem Operator versehen werden. So weist ii ^= jj ii den Wert ii jj (ii Exor jj) zu. Rückgabewert ist immer der jeweils zugewiesene Wert. In diesen Beispielen kann jj ein beliebiger Wert sein, dessen Datentyp lediglich zu ii muss. 6.3 Type-Cast Unter einem Type-Cast versteht man eine Konvertierung zwischen zwei Datentypen. Bei einer Berechnung mit unterschiedlichen numerischen Datentypen, wird ein automatischer Type-Cast auf den größten verwendeten Datentypen ausgeführt. Werte vom Typ char werden ebenfalls Automatisch Konvertiert, da sie als Unicode-Zeichen einen eindeutigen Zahlenwert (vom Typ int) repräsentieren. Anzumerken ist, dass der Type-Cast von int zu float eine gewisse Unsicherheit birgt. Dies ist durch den Begrenzten Speicherplatz der Mantisse bedingt. Während int eine ganze Zahl mit 32Bit darstellt hat float lediglich 23 Bit für die Mantisse vorgesehen. Das bedeutet, dass es bei sehr großen Integer-Werten zu einer gewissen Veränderung bei der Konvertierung kommt. Trotzdem wird dieser Vorgang als sicher betrachtet und ein Type-Cast implizit ausgeführt Ein anderer Fall ist der explizite Type-Cast. Hier wird von einem Datentyp zu einem anderen Konvertiert, der nicht jeden Wert darstellen kann, z.b. von double nach int. Die Syntax des expliziten Typ-Casts sieht wie folgt aus: int ii = z ; //impliziter Type-Cast von char nach int char chr = (char)(ii-1); //expliziter Type-Cast von int nach char //chr == y Auch Literale haben einen Standardtyp, so muss bei der Eingabe ggf. ein Type-Cast ausgeführt werden. Zeichen haben immer den Typ char, ganzzahlige Literale den Typ int und nicht-ganzzahlige Literale den Typ double. Will man nun ein Literal direkt zuweisen und es kann kein impliziter Type-Cast ausgeführt werden, so muss ein expliziter Type-Cast durchgeführt werden: float ii = 23.42; Ergibt eine Fehlermeldung, da ein impliziter Type-Cast von double nach float nicht möglich ist. Richtig würde der code lauten: float ii = (float) 23.42; 6.4 Ausdrücke Ein Ausdruck besteht prinzipiell aus einem Rückgabetyp, einem Rückgabewert und ggf. Seiteneffekten. Beispiel: float ii = 23+42; Bei diesem Beispiel ist der Rückgabetyp int, der Rückgabewert 65 und der Nebeneffekt ein impliziter Type-Cast von int nach float. 15

20 6.5 Klassen und Objekte Neben den eingebauten Datentypen gibt es weitergehend noch Klassen, welche ebenfalls einen Datentyp repräsentieren. Klassen und Objekte bilden den Grundstock einer jeden objektorientierten Programmierung und damit auch von Java. Dies steht im Gegensatz zur prodezualen Programmierung, bei der die Grundstruktur aus einzelnen Prozessen besteht. Die Definition einer Klasse ist eine Beschreibung gemeinsamen Verhaltens, sowie gemeinsamer Struktur von Objekten. Die Datenstrukturen der Klassen sind in sich geschlossen, Zugriffe sind nur über so gennante get- bzw. set-methoden gestattet. Durch diese Schnittstellen ist gewährleistet, dass unvorhersehbares Verhalten des Objekts durch einen direkten Zugriff auf interne Daten nicht auftreten kann. Klassen ermöglichen eine Entwicklung auf einer Abstraktionsebene, welche unabhängig von den realen Ausprägungen des Objekts sind. Dies bedeutet beispielsweise, dass man mit der Klasse Hausnummer arbeiten kann, unabhängig davon, ob diese nun den Wert 53 oder 324 repräsentiert. Die Klasse String speichert unveränderliche Zeichenketten und stellt diverse Methoden zur Inspektion, Konvertierung und Bearbeitung zur Verfügung. Im Gegensatz zu char, ein Datentyp für einzelne Literale, handelt es sich bei String nicht um einen eingebauten Datentyp. Dies ist bereits am Namen zu erkennen, da String mit einem Großbuchstaben geschrieben wird. Die Deklaration eines Strings kann auf zwei Wege erfolgen: oder String str = new String ("Dies ist der Text"); String str = "Dies ist ein Text"; Ein String kann auch nicht-druckbare Zeichen enthalten, für diese gibt es besondere Befehlcodes: Zeichen Bedeutung \t Tabulator \n Zeilenumbruch (newline) \f Seitenumbruch (formfeed) \ Anführungszeichen \ Hochkomma \\ Backslash Tabelle 6.5: Zeichencodes Es gibt verschiedene Methoden der Klasse String, um Eigenschaften abzufragen, diese nun aufzuzählen ist nicht sinnvoll, sie sind im Anhang oder in der Java-API zu finden. Grundsätzlich lassen sich Klassen in zwei Bestandteile aufteilen, einmal den äußeren und einmal den inneren Teil. Der äußere Teil legt die Bennenung der Klasse fest, sowie ggf. die Vererbungen: public class Klasse extends UrKlasse //Hier steht der innere Teil Vererbungen werden in einem späteren Kapitel behandelt. Im inneren Teil einer Klasse befinden sich die Definitionen der Datenfelder, Konstruktoren und Methoden, die den jeweiligen Instanzen oder Objekten ihre Struktur oder ihr spezifisches Verhalten geben. In Java ist die Reihenfolde innerhalb des inneren Teils nicht festgelegt, es hat sich mit der Zeit aber folgende Konvention herausgebildet: 1. Datenfelder 2. Konstruktoren 3. Methoden 16

21 6.5.1 Datenfelder Die Datenfelder einer Klasse werden häufig auch als Klassenattribute oder Instanzvariablen bezeichnet. Datenfelder werden benötigt um innerhalb eines Objekts Daten zu speichern. In Methoden erfolgt der Zugriff auf diese Datenfelder immer mit this.variablennahme. Im Falle von KarelJ aus AI-I waren dies Beispielsweise die Anzahl der Beeper, die Koordinaten des Roboters oder die Blickrichtung. Beispielhafte Deklaration von Klassenattributen: public class Klasse int zahl; char chr; double zahl2; //Hier kommen Konstruktoren und Methoden Konstruktoren Konstruktoren ermöglichen es, ein Objekt nach seiner Erzeugung in einen gültigen Zustand zu versetzen und überdies, direkt bei der Erzeugung des Objektes Code auszuführen. Bei dieser sog. Initialisierung werden Objekte zu einer konkreten Ausprägung einer abstrakten Klasse. Dies bedeutet am Beispiel des Strings erklärt, dass die Deklaration String str = new String ("Dies ist der Text"); einen String initialisiert mit einer konkreten Ausprägung. Der String str bekommt den Inhalt Dies ist der Text zugewiesen. Der unterschied zwischen Objekten und Klassen liegt in der Form der Definition und der Art, wie sie vom Compiler behandelt werden. Klassen werden durch class definiert und vom Compliler übersetzt. Objekte hingegen werden mittels new definiert und innerhalb der Laufzeit angelegt. Für Konstruktoren einer Klasse gibt es bestimmte syntaktische Eigenschaften. So muss der Name des Konstruktors gleich dem der Klasse sein. Desweiteren darf ein Konstruktor keinerlei Angaben über Rückgabetypen enthalten. Eine Methode, welche den gleichen Namen wie die Klasse hat, wird automatisch als Konstruktor dieser Klasse behandelt. Eine Klasse kann auch über mehrere Konstruktoren verfügen, da diese aber zwangsweise über den gleichen Namen verfügen, kann nur mittels Überladung zwischen ihnen unterschieden werden. Ein Konstruktor einer Klasse wird mit new in einer spezifischen Situation aufgerufen. Hinter dem new folgt der Name der Klasse, oder aus anderer Sicht, der Name des Konstruktors. In der folgenden Klammer sind die für den jeweiligen Konstruktor erforderlichen Parameter angegeben. Ein anschauliches Beispiel ist die Klasse String. Diese kann sowohl als Objekt als auch als Klasse Initialisiert werden. Dies erklärt die beiden parallelen Möglichkeiten einen String zu erzeugen, welche zu Beginn dieses Kapitels vorgestellt wurden. Im folgenden ein Beispiel für einen Konstruktor, einschlißlch des Aufrufs in der Main-Methode. public class Klasse int zahl; //Klassenattribut Klasse(int a) //Konstruktor this.zahl = a; //Übergabe an das Klassenattribut System.out.println("Klasse erzeugt!"); //Hier folgen Methoden. public static void main(string[] args) Klasse name = new Klasse(23); //Aufruf des Konstruktors mit dem Parameter 23 vom Typ int 17

22 6.5.3 Methoden Der letzte Teil einer Klasse sind die Methoden. Diese ermöglichen es, den Zustand der Datenfelder einer Klasse zu verändern (auf diese darf nicht direkt zugegriffen werden!), oder ein bestimmtes Verhalten der Klasse zu bedingen. Methoden bestehen aus einem Kopf und einem Rumpf, dies ist äquivalent zum inneren bzw. äußeren Teil einer Klasse. Im Methodenkopf befindet sich ein Kommentar über die Funktionen der Methode und die Signatur der Methode. Im Rumpf der Methode stehen die Deklarationen und Anweisungen. Diese legen fest, welches Verhalten die Methode beim Aufruf an den Tag legt. Die Methodensignatur enthält den Rückgabe- bzw. Ereignistyp, den vollständigen Namen der Methode, sowie die Namen und Typen der bei Aufruf zu übergebenden Parameter. Der Unterschied zwischen der Signatur einer Methode und dem eines Konstruktors besteht darin, dass eine Methode einen Rückgabetyp enthält. In diesem Beispiel sollen verschiedene Arten von Methoden erläutert werden: public class Klasse int zahl; //Klassenattribut //Hier wäre der Konstruktor //Methode zur veränderung des Klassenattributs public void zahlhoch(int zaeler) this.zahl = this.zahl + zaeler; //Methode zum Auslesen des Klassenattributs public int getzahl() return this.zahl; //Methode mit lokaler Variable public int addzahl(int adder) int add = this.zahl + adder; return add; 6.6 Variablen in Klassen Im Vergangenen Kapitel wurden bereits verschiedene Arten von Variablen eingesetzt. Einerseits Datenfelder, welche außerhalb von Konstruktoren und Methoden erzeugt werden und so von der gesamten Klasse aus eingesehen werden können. Andererseits noch formale Parameter, die im Kopf eines Konstruktors oder einer Methode angegeben sind. Diese sind lediglich für die jeweilige Methode einsehbar, ihre werte erhalten sie aber von Außen. Schließlich noch die lokalen Variablen, welche innerhalb des Methodenrumpfes deklariert werden. Diese sind nur innerhalb des jeweiligen Blocks einsehbar. Der Begriff Variable allgemein ist in der Informatik deutlich anders definiert als in der Mathematik, in der praktischen Verwendung aber ähnlich. In der Mathematik steht eine Variable für eine Menge von Zahlen, z.b. y = x 2, xεr. Das bedeutet, y ist die Menge der Zahlen für die x 2 zutrifft und x ist ein Element der Menge der reellen Zahlen. Trägt man nun y über x auf, so erhält man eine Normalparabel. In der Informatik hingegen repräsentiert eine Variable einen Zeiger auf eine eindeutig bestimmte Speicheraddresse. Weißt man nun der Variable einen wert zu, so wird dieser an genau dieser Speicheraddresse abgespeichert. Eine Variable in der Informatik ist also nichts anderes als eine Art Wegweiser auf eine Speicheraddresse. 18

23 7 Variablen und deren Gültigkeit Bei den Datenkomponenten einer Klasse wird grundsätzlich zwischen Objekt- und Klassenvariablen bzw. -Konstanten unterschieden. Syntaktisch findet diese Unterscheidung durch ein vorgestelltes static statt. Dieses Schlüsselwort deklariert Klassenkonstanten und -variablen. Semantisch lassen sich Objekt und Klassen dadurch unterschieden, dass Klassenvariablen ein einmaliges Objekt sind. Sie werden in der Klasse selbst gespeichert und nicht in den Objekten. Eine Objektvariable hingegen wird mit jeder Objektinstanz neu erzeugt und ist damit Bestandteil des Objektes. Auf Klassenvariablen und -Objekte kann auch ohne konkretes Objekt zugegriffen werden: Klassenname.klassenvariable. Dies lässt sich auch an einem Beispiel verdeutlichen: public class Klasse public int zahl; //Klassenattribut public static int zahl2; //Klassenvariable Klasse(int ii, int jj) this.zahl = ii; this.zahl2 = jj; public static void main(string[] args) Klasse a = new Klasse(1,2); Klasse b = new Klasse(3,4); System.out.println("a: " + a.zahl + ", " + a.zahl2); System.out.println("b: " + b.zahl + ", " + b.zahl2); Dieses Ergibt die Ausgabe: a: 1, 4 b: 3, 4 Bedenkt man, dass es sich bei zahl2 um eine Klassenvariable handelt, so ist dies wenig verwunderlich. Diese wird bei der Initialisierung des Objekts b auf 4 gesetzt. Hätte es sich dabei um eine Objektvariable gehandelt, so wäre die Ausgabe: a: 1, 2 b: 3, 4 Hier sieht man deutlich den Unterschied zwischen Objekt- und Klassenvariablen. Während eine Objektvariable mit jedem Objekt neu erzeugt wird und nur für dieses und genau dieses gilt, gilt eine Klassenvariable für alle Objekte dieser Klasse gleichermaßen. Das heißt: Ändert man eine Objektvariable so hat dies nur einen Effekt auf das jeweilig zugreifende Objekt. Ändert man eine Klassenvariable, so hat dies einen Effekt auf alle Objekte der Klasse. Bei der Compilierung wird die Speicheraddresse der zwei Variablentypen unterschiedlich berechnet. Bei obrigem Beispiel wird die Speicheraddresse von zahl, dem Klassenattibut, berechnet, in dem die Position von zahl auf die Addrese des jeweiligen Objektes (a oder b) aufaddiert wird. die Addresse von zahl2 hingegen wird eine globale Addresse direkt eingesetzt. Im Compiler wird die Addresse von Klasse.zahl2 intern gespeichert. 19