Kurzeinführung in Java - ias.uni-stuttgart.de
Transcription
Kurzeinführung in Java - ias.uni-stuttgart.de
Universität Stuttgart Institut für Automatisierungs- und Softwaretechnik Prof. Dr.-Ing. Dr. h. c. P. Göhner Java-Intensivkurs am IAS Kurzeinführung Inhaltsverzeichnis WAS IST JAVA? ........................................................................................................................................................ 2 JAVA UND OBJEKTORIENTIERUNG.................................................................................................................. 4 BLICK IN DIE ZUKUNFT ... .................................................................................................................................... 5 DIE PROGRAMMIERSPRACHE JAVA ................................................................................................................ 6 Werkzeuge des JDK .............................................................................................................................................. 6 Unterschiede zu C und C++ ................................................................................................................................ 7 JAVA – KURZREFERENZ ....................................................................................................................................... 9 Schlüsselwörter .................................................................................................................................................... 9 Kommentare ......................................................................................................................................................... 9 Konstanten............................................................................................................................................................ 9 Einfache Datentypen ............................................................................................................................................ 9 Escape-Sequenzen in Zeichenketten ................................................................................................................... 10 Klassen ............................................................................................................................................................... 10 Methoden ............................................................................................................................................................ 10 Objekt ................................................................................................................................................................. 11 Modifier .............................................................................................................................................................. 11 Arrays ................................................................................................................................................................. 12 if Statement ......................................................................................................................................................... 13 while Statement .................................................................................................................................................. 13 do while Statement ............................................................................................................................................. 14 for Statement ...................................................................................................................................................... 14 switch Statement ................................................................................................................................................. 14 IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 2/15 Was ist Java? Sun: " Java is a simple, object-oriented, distributed, interpreted, robust, secure, architectural neutral, portable, high-performance, multithreaded, and dynamic language." Java ist eine Allzweckprogrammiersprache. 1990 entwickelte James Gosling bei Sun, einem bekannten Hersteller von UNIX-Workstations, eine Programmiersprache namens Oak für sein Projekt „Imagination“, einen SGML-Editor. Sie stellte im Wesentlichen eine Abwandlung von C++ und Objective C dar, in die alle Ideen eingeflossen waren, die frustrierte Entwickler in jahrelanger Erfahrung gesammelt hatten. Im April 1991 gründete Sun die Tochterfirma First Person Inc., die versuchen sollte, Oak als interne Programmiersprache für Heimelektronik vom Videorecorder bis zum Toaster, zu vermarkten. 1993 suchte Time Warner nach Ideen für die Settop-Boxen für das interaktive Fernsehen. Im Hinblick auf diese Anwendungen musste die Programmiersprache gewisse Anforderungen erfüllen. Sie musste in Echtzeit laufen, sicher und zuverlässig sein sowie sehr kompakt. Aus dieser Zeit stammt auch noch das Maskottchen Duke. Leider hatte das Projekt nicht den rechten Erfolg und die Firma wurde aufgelöst. Zu dieser Zeit begann jedoch gerade das WWW seinen Siegeszug und Patrick Naughton programmierte an einem Wochenende einen HTML-Browser, der Oak-Applets starten konnte. Daraus entstand der heutige HotJava-Browser und das neue Zielgebiet der Programmiersprache wurde das Internet. Auch Internet-Programme müssen kompakt sein. Vor allem die Gegenspieler von Microsoft gebrauchen im Zusammenhang mit Windows gern den Begriff Fatware, denn in viele Programme werden doppelt und dreifach Standardbibliotheken eingebunden, die die Programme aufblähen. In Java gibt es ein Standard-API, dessen Klassen auf dem lokalen Rechner liegen, ein kleines Java-Applet kann so auch mit wenigen hundert Bytes auskommen, wogegen z.B. ein leeres Delphi- oder C++-Programm kaum unter 100k groß ist. Außerdem braucht man einen sicheren Schutz gegen Viren oder das Ausspionieren des Rechners. Java-Programme werden vor der Ausführung überprüft, dadurch können z.B. keine Informationen an fremde Rechner geschickt werden und der Rechner kann durch fehlerhafte Programme nicht abstürzen. Fehleranfällige und überflüssige Elemente wie Pointer, Operatorüberladung, Speicherfreigabe oder die Benutzung beliebiger Zahlen als Booleantypen wurden eliminiert, was zu einheitlicheren Programmen und leichterer Pflege führt. Der Name Java entstand in einer Brainstorming-Session bei Sun. Er geht auf das Slangwort für Kaffee in den USA zurück, welches Hauptexportgut der Insel Java ist. Es ist ein Anspielung auf das heiße und aromatische Getränk, welches Programmierer gern und viel trinken. Sun: "Write once, run anywhere, on anything, safely." Java ist portabel. Ein kompiliertes Java-Programm besteht aus dem so genannten Bytecode mit den Befehlen eines virtuellen Prozessors. Bytecode und Klassenformat sind vollkommen hardware-unabhängig. Die JavaPlattform wurde schon von vielen Herstellern in ihre Betriebssysteme integriert. Zu nennen sind hier u.a. Linux, Windows (ab Win95 OSR2), OS/2 4.0 und natürlich Sun Solaris. Was brauche ich zur Java-Programmierung? Die folgenden Erklärungen gehen davon aus, dass sie das kostenlose JDK von JavaSoft [http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html#javasejdk] benutzen. Offizielle Distributionen gibt es für WinXP,Vista,7,8, Solaris, MacOS und Linux. Das Entwicklerkit enthält den Compiler, das API (Application Programming Interface), einen Appletviewer, Debugger und IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 3/15 andere Werkzeuge. Zu allen Programmen und Klassen ist der Sourcecode enthalten. Die aktuelle Version des Entwicklerkits ist 7.9. Auch die im HTML-Format vorliegende Dokumentation wird unbedingt benötigt [http://docs.oracle.com/javase/7/docs/api/]. Wer vorher mit Turbo Pascal o.ä. gearbeitet hat, wird eine integrierte Entwicklungsumgebung mehr vermissen, als jemand der es gewöhnt ist, unter UNIX zu programmieren. Das JDK enthält den Kommandozeilencompiler javac, der mit bestimmten Parametern, z.B. der Quelldatei aufgerufen werden muss und eine .class-Datei erzeugt, bzw. eine Vielzahl von Fehlermeldungen erzeugt. Die Quelldatei wird mit einem normalen Texteditor erzeugt. Es empfiehlt sich natürlich ein Editor, der Autoindent (automatisches Einrücken) beherrscht, wie z.B. der von Turbo Pascal und auch Syntax Highlighting (Schlüsselwörter sowie Kommentare und Zeichenketten werden farbig hervorgehoben) ist ganz nützlich. Es gibt natürlich gerade für Windows auch eine Menge integrierter Umgebungen, die einen guten Editor besitzen und den Compiler automatisch aufrufen können. Zu nennen sind hier u.a. Eclipse [http://www.eclipse.org] und NetBeans [http://netbeans.org/], die beide als OpenSource im Internet zu haben sind. Auch kommerzielle Programme werden angeboten, wie z.B. Forte for Java von Sun, Borland’s JBuilder, Symantec Café und viele andere, diese wurden aber weitgehend von den beiden oben genanngen OpenSource Umgebungen verdrängt. Für den Anfang reichen aber ein guter Editor und das JDK vollkommen. Wenn Ihre Entwicklungsumgebung dies nicht per Mausklick für Sie tut, starten Sie das übersetzte Programm durch Eingabe von „java name“. Applets werden in eine HTML-Seite eingebettet und müssen mit einem Java-kompatiblen Browser betrachtet werden. Der Syntax für das Einbetten von Java-Applets ist folgender: <APPLET CODEBASE = codebaseURL ARCHIVE = archiveList CODE = appletFile ...or... ALT = alternateText // Pfad für Klassendateien // jar-Archive, die Daten // und Klassen enthalten OBJECT = serializedApplet // wenn Java abgeschaltet ist NAME = appletInstanceName WIDTH = pixels HEIGHT = pixels ALIGN = alignment VSPACE = pixels HSPACE = pixels // Fenstergröße // Ausrichtung // Abstand > <PARAM NAME = appletAttribute1 VALUE = value> // zu übergebende // Parameter <PARAM NAME = appletAttribute2 VALUE = value> . . . alternateHTML // wenn Browser kein Java // versteht </APPLET> Programmcode muss leicht lesbar und verständlich sein. Der Compiler sucht beim Übersetzen nach Tokens, dazwischen liegende Zeichen (Leerzeichen, Zeilenumbrüche, ...) und Kommentare werden ignoriert. Nutzen Sie dies, um ihren Quellcode übersichtlich zu gestalten. Rücken Sie dazu Blöcke ein, d.h. z.B. nach einer öffnenden Klammer rücken Sie die folgenden Zeilen mit zwei Leerzeichen oder TAB ein, bis wieder eine schließende Klammer folgt. Dies erhöht die Leserlichkeit drastisch. Weiterhin ist es üblich, Schleifenvariablen i,j,k,... bzw. counter oder Ähnliches zu nennen. Im Gegensatz zu PASCAL ist Java case-sensitiv, d.h. der Compiler unterscheidet Groß- und Kleinschreibung. Vergeben Sie Namen nicht nach Rechtschreibregeln, sondern nach der optimalen Übersicht. Es empfiehlt sich, bei aus mehreren Wörtern zusammengesetzten Namen, den ersten klein und IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 4/15 die folgenden groß zu schreiben, z.B. printScreen(); oder Ähnliches. Per Konvention beginnen Variablennamen mit einem kleinen und Klassennamen mit einem großen Buchstaben. Beachten Sie jedoch, dass Sie eine einmal gewählte Schreibweise im ganzen Programm beibehalten müssen. Eine häufige Fehlerquelle ist auch das Benennen von Variablen mit reservierten Worten. Java und Objektorientierung Programmsprachen kann man zum Beispiel nach ihrer Entfernung von der Maschine einteilen. Der schnellste und kompakteste Code ist zweifelsfrei durch Assemblerprogrammierung zu erreichen. Die Maschine wird direkt programmiert, einzige Erleichterungen bieten Sprungziele, Makros und Trivialnamen für Befehle. Später entwickelten sich Interpretersprachen wie z.B. BASIC, die sehr weit von der Maschine entfernt waren. Im Gegensatz zur Maschinensprache sind die Befehle hier sehr komplex, z.B. wird das „Bildschirm löschen“-Kommando (Cls) intern in viele kleine Einzelaktionen zerlegt. Der Quelltext wird hier zur Laufzeit Befehl für Befehl übersetzt und ausgeführt. Das führt oft zu inakzeptablen Laufzeiten. Compiler setzen hier an. Der Quelltext wird schon vor der Laufzeit übersetzt und als Maschinenprogramm gespeichert. Der Anwender hat mit dem Quelltext nichts zu tun und startet die Binärdatei. Das ist das heute übliche Prinzip z.B. unter DOS oder Windows. Die übersetzten Programme sind natürlich längst nicht so optimiert wie „handprogrammierte“ Maschinenprogramme, aber durch die Komplexität moderner Prozessoren wie z.B. des Pentiums kann nur noch ein Compiler wissen, welcher Code wegen Branch prediction, Register renaming, Cache-Größe und ähnlichem am schnellsten sein wird. Außerdem, wer will schon in einem 60.000 Zeilen-Assemblercode einen Fehler suchen? Objektorientierte Sprachen wie Java haben neue Konzepte zu bieten. Das Ziel ist in erster Linie leicht zu wartender und pflegender Code. Dazu bedient man sich der Art wie auch Menschen die Dinge um sich herum wahrnehmen. Ein elementarer Begriff ist der der Klasse. Klassen enthalten wieder verwendbaren Code zur Erstellung von Objekten. Sie können entweder instantiiert, um individuelle Objekte zu erzeugen oder in Subklassen erweitert werden. Dem menschlichen Verständnis ähnlich ist nun z.B., dass man Objekten auf Grund der Superklassen (übergeordnete Klassen) von denen sie abstammen, Eigenschaften zuordnen kann. Da z.B. ein VW Polo ein VW ist (von der Superklasse VW abstammt), der wiederum ein Auto ist (von der Superklasse Auto abstammt), kann man sagen, dass ein Polo vier Räder hat, da er diese Eigenschaft von der Superklasse Auto erbt. Ein Polo kann wiederum auch aus verschiedenen Objekten zusammengesetzt sein (composite object), z.B. aus vier Rädern (Subsysteme). Ein Beispiel für eine Subklasse ist z.B., dass man schon eine fertige Klasse besitzt, die ein Rechteck behandelt, es z.B. zeichnet, seinen Flächeninhalt berechnet, usw. Will man nun auch farbige Rechtecke zeichnen, kann man eine Subklasse von Rechteck anlegen, in der man die Methoden überschreibt, die anders sind. Alle anderen werden geerbt. Ein Beispiel wäre z.B., die Zeichenmethode des farbigen Rechtecks so zu implementieren, dass man die Systemfarbe ändert, dann die fertige Zeichenmethode von Rechteck aufruft und die Systemfarbe danach wieder zurücksetzt. Die objektorientierte Programmierung beruht auf einer Hierarchie, in der Klassen nach unten hin immer spezieller und nach oben immer abstrakter werden. Ein Objekt ist ein abstrakter Datentyp mit seinen Methoden. Auf private Daten, Instanzvariablen (private Variablen) und private Methoden kann nicht direkt, sondern nur über öffentlichen Methoden zugegriffen werden. Dieses Prinzip nennt man Kapselung. Stellen Sie sich eine Liste vor, die verschiedene Daten enthält. Sie verwalten z.B. Kundendaten. Angenommen die Anzahl der Aufträge pro Kunde ist anfangs auf einen 8bit-Datentyp beschränkt und Sie ändern diesen später in einen 16bit-Datentyp, so müssen Sie alle Funktionen, die auf die Liste zugreifen, umschreiben. Haben Sie nun viele Programme, die dies tun, so können leicht Fehler entstehen. IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 5/15 In der objektorientierten Programmierung werden die Daten lokal zusammen mit dem Methoden in einer Klasse zusammengefasst, die auf sie zugreifen. Um beispielsweise ein Listenelement zu entfernen, würden Sie dem Objekt Liste den Auftrag delete(item) geben. Wie dies jedoch intern realisiert ist, ist für das Hauptprogramm nicht ersichtlich. Ein einzelnes Element erhält man z.B. über den Aufruf der Methode „objectAtIndex(index)“ der Klasse Liste. Direkt auf die Liste zuzugreifen, ist nicht möglich. You must image a system as a collection of classes and methods that knows how to perform tasks. Man kann Methoden in unterschiedlichen Klassen gleiche Namen geben. So kann man komplizierte Methodennamen vermeiden. Dies entspricht auch der menschlichen Wahrnehmung und wird Polymorphie genannt. Wenn man z.B. an einem Radio oder an einer Lampe den Einschalter drückt, können intern ganz unterschiedliche Prozesse ausgelöst werden, dem Benutzer ist dies aber egal, er will nur, dass das Gerät eingeschaltet wird. Was er damit auslöst, ist nur im Zusammenhang mit dem jeweiligen Objekt eindeutig. class Bildschirm { Methode clear { Code für Bildschirm löschen; } Methode write { Code zum auf den Bildschirm schreiben; } } Hauptprogramm { ein Bildschirm-Objekt namens screen anlegen dem screen sagen, er soll seine clear-Methode aufrufen dem screen sagen, er soll seine write-Methode aufrufen (evtl. mit Parameter) ... } Blick in die Zukunft ... Java schafft neue Vertriebsmöglichkeiten. Die vier klassischen Begriffe was das Copyright betrifft, sind bislang Public domain (alle Rechte aufgegeben), Freeware (kostenlose Weitergabe erlaubt), Shareware (kostenlose Testversion, bei intensiver Nutzung muss Vollversion erworben werden) und Vollversion (entgeltlich erworben, Weitergabe verboten). In Zukunft könnte es mit Java auch Software zum Mieten geben, bei der man für jede Nutzung bezahlen muss. Unix- und Internetfans wird der fehlende Sourcecode bei vielen Applets nicht gefallen, da dies mit einer Philosophie kollidiert. Eines von Suns Mottos ist „Think authors not publishers“. Man eliminiert den Mittelsmann zwischen Autor und Kunde. Oft fehlen Firmen Geld und Beziehungen, Software weltweit bewerben und verkaufen zu können. Bisher! Im Internet kann sich jede Firma präsentieren, Produkte und Service anbieten, ohne Mittelsmann. So werden auch viele zeitraubende Vorgänge überflüssig und man kann Software direkt günstiger anbieten. Dies ist die Chance für den besten Autor, zu gewinnen. Java läuft überall. Microsofts Philosophie war immer, dass die Anwendung auf ein Betriebssystem aufsetzt, das wiederum auf eine bestimmte Hardware aufsetzt. In Zukunft könnten die Nutzer in die Situation kommen, wo es genügend Software in Java gibt und man die Hardware wählt, die diese Programme am schnellsten ausführt. Sun: „The network is the computer“ IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 6/15 Zuguterletzt ist es auch für den Programmierer eine Erleichterung, plattformunabhängig entwickeln zu können. Vorbei die Zeit in der man für ein paar unterstützte Plattformen in mühsamer Arbeit ein abstraktes Klassenmodell bauen musste, für jede Plattform eigene Grafik-, Sound- und andere Routinen. Selbst mit dem so portablen C++ kann das echt in Arbeit ausarten. Die Programmiersprache Java Werkzeuge des JDK Sie erhalten immer eine Hilfe zu den Programmen, wenn Sie sie ohne Parameter aufrufen. Des Weiteren befindet sich eine genaue Beschreibung aller Optionen und Programmfunktionen in der HTML-OnlineDokumentation. Die folgenden Informationen stellen nur eine kleine Übersicht dar. Ein Programm mit der Endung „_g“ ist immer die ohne Optimierung compilierte und so besser debugbare Version. Allgemeines: javac- der Java-Compiler übersetzt die Java-Quelltexte in den Bytecode Beispiel: javac -classpath src;src\old -d classes -O -deprecation test.java kompiliert die Quelldatei test.java in src oder src\old, gibt Fehlermeldungen zu veralteten Aufrufen aus, führt eine Optimierung durch und speichert die Klassendatei im Pfad classes. java - der Java-Interpreter führt Programme im Bytecode aus. Beispiel: java -cs ls cpp führt das Programm „ls.class“ mit dem Parameter „cpp“ aus und übergibt an den java-Interpreter die Option -cs. javadoc - Generiert aus im Quellcode enthaltenen DocComments eine API-Dokumentation Beispiel: javadoc -version -author -noindex -notree test.java erzeugt eine Dokumentation zur Klasse test, @version- und @author-Tags werden hierbei berücksichtigt und index.html und tree.html nicht erzeugt. Neben normalem Text können DocComments auch besondere Tags enthalten. @see Klasse#Methode Hyperlink @param Name Text beschreibt Parameter einer Methode @return Text beschreibt Rückgabewert einer Methode @exception Klasse Text beschreibt Ausnahmebehandlung einer Methode @author Text Autor der Klasse @deprecated Klasse oder Methode als veraltet deklarieren @version Text Version bzw. Datum der Klasse appletviewer - einfacher Applet-Anzeiger für Leute ohne Webbrowser Beispiel: appletviewer test.html lädt die HTML-Datei test.html und führt das darin mittels <APPLET>-Tag eingebettete Applet aus. jdb - mit dem Java-Debugger „entwurmt“ man Programme javah - Headerfile- und C-Stub-File-Generator für das Einbinden von C-Code javap - der Java-Profiler disassembliert Klassendateien und zeigt den Bytecode an RMI (Remote Method Invocation) Tools IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 7/15 rmic - generiert Stub- und Skelettklassen für Javaobjekte, die verteilte Programmierung benutzen rmiregistry - wird für verteilte Programmierung benutzt serialver - liefert die Seriennummer einer Klasse Internationalization Tools native2ascii - konvertiert Text ins Unicode-Format JAR (Java Archiver) Tool jar - Packer, der es erlaubt, mehrere Klassen und Ressourcen in einer Datei zu speichern Digital Signing Tool javakey - erzeugt digitale Unterschriften für Archive und verwaltet Schlüssel Unterschiede zu C und C++ Im Unterschied zu C unterstützt die Sprache JAVA nicht alle Standard-C-Operatoren. Es gleichen sich jedoch die Vorrangs- und Assoziativitätsregeln. Java unterstützt jedoch beispielsweise nicht den Operator sizeof. Da es auch keine Pointer gibt (statt dessen Referenzen), existieren auch der Adress- und Pointeroperator nicht. Neu ist beispielsweise, der „+“-Operator zum Verketten von Strings. Der instanceof-Operator liefert true oder false je nachdem, ob ein Object eine Instanz einer angegebenen Klasse ist oder nicht. Zum normalen >> (shift right) Operator kommt der >>>-Operator, der eine Zahl grundsätzlich als nicht vorzeichenbehaftet behandelt. Werden & und | (bitweises AND und OR) auf boolean-Typen angewandt, wirken Sie automatisch wie logisches AND und OR, mit dem Unterschied, dass bei && und || der auf der rechten Seite stehende Operand nicht mehr ausgeführt wird, sobald das Ergebnis der Auswertung des linken Operanden schon feststeht. Boolean ist ein eigenständiger Typ, daher kann nicht jeder Typ als boolean-Typ verwendet werden, sondern andere Typen müssen mittels Vergleichsoperationen umgewandelt werden. In Java werden Zugriffe auf Felder über deren Grenzen hinaus nicht wie in C zugelassen, sondern erzeugen Ausnahmen. Typen sind in Java streng definiert, im Gegensatz zu C, wo man nie weiß, ob beispielsweise char auf dem aktuellen Compiler signed oder unsigned ist. Der Ausweg war oft, eigene Typen zu definieren und dann immer den eigenen Typ, z.B. byte als unsigned char zu benutzen, was für Außenstehende zu schwer lesbaren Programmen führte. Java-Code ist generell sehr gut lesbar, denn durch klar definierte Typen (ein großes Manko von C++), Unterbindung von Operator-Überladung, Pointerarithmetik und anderes (z.B. kann es nicht mehr passieren, dass man bei if(a==0) ein Gleichheitszeichen vergisst), ist alles eindeutig interpretierbar. Einige Eigenschaften von C++ wurden bei Java weggelassen. Operator-Overloading (+,-, ...) typedef Statements (eigene Typen, in Java statt dessen Objekte) Strukturen, Unions und Funktionen (keine globalen Funktionen) Präprozessor (z.B. #define,#ifdef ...) goto (dafür benannte Schleifenendziele, u.ä.) Zeiger (dafür Referenzen) Mehrfachvererbung (Ausnahme: Interfaces) Präprozessor (eigene Typen nur als Objekte, import statt #include) Java bietet auch viel Neues. Thread-Modell (unabhängige Tasks innerhalb eines Programmes) Automatische Speicherverwaltung (kein explizites Freigeben mehr) IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 8/15 dynamisches Laden und Binden (late binding) Sicherheitsmodell (Überprüfung vor Ausführung) portabel ohne Neucompilierung (Bytecode) UniCode-Zeichenketten sowie echte Strings und Felder IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 9/15 Java – Kurzreferenz Schlüsselwörter Java kennt folgende reservierte Wörter, von denen noch nicht alle unterstützt werden: abstract boolean break byte byvalue case cast catch char class const continue default do double else extends false final finally float for future generic goto if implements import inner instanceof int interface long native new null operator outer package private protected public rest return short static super switch synchronized this throw throws transient true try var void volatile while Nicht unterstützt: byvalue, cast, const, future, generic, goto, inner, operator, outer, rest, var Kommentare Java kennt drei Arten von Kommentaren 1. Die C Kommentarzeichen /* welche bis zum nächsten */ gelten. Bsp: /* das ist ein C Kommentar */ 2. Die C++ Kommentarzeichen // welcher am Ende der Zeile endet. Bsp: // das ist ein C++ Kommentar, der am Ende der Zeile endet 3. Die Kommentarzeichen /** welche bis zum nächsten */ gelten. Das Utility javadoc kann aus diesen Kommentaren Online-Hilfen im HTML Format generieren. Konstanten Konstanten werden die Schlüsselwörter static final vorgestellt. Bsp: die Zahl ist wie folgt deklariert: public static final double PI=3.14159; in der Klasse Math Einfache Datentypen Typ boolean char byte short int long float IAS, 2012 enthält true oder false Unicode Zeichen signed integer signed integer signed integer signed integer IEEE 754 floating point Default false Grösse 1 Bit Min Wert false Max Wert true \u0000 16 Bits \u0000 \uFFFF 0 0 0 0 0.0 8 Bits 16 Bits 32 Bits 64 Bits 32 Bits -128 -32768 -2147483648 -9223372036854775808 1.40239846E-45 127 32767 2147483647 9223372036854775807 3.40282347E+38 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS double Seite 10/15 IEEE 754 0.0 floating point 64 Bit 4.94065645841246544E-324 1.79769313486231570E+308 Beachten Sie, dass Strings keine char-Felder, sondern vollwertige Objekte sind (siehe java.lang.String und java.lang.StringBuffer). Spezielle oder nationale Codes können auch mit der Escape-Sequenz „\uxxxx“ im UniCode-Format eingebunden werden, wobei „xxxx“ für eine 16bit-Hexadezimalzahl steht. Escape-Sequenzen in Zeichenketten Darstellung \n \r \b \t \f \’ \“ \\ \uXXXX Bedeutung new line cariage return backspace tabulator form feed Hochkomma Anführungszeichen backslash Unicode-Zeichen Klassen Die Klassendefinition sieht wie folgt aus: class NameDerKlasse { ... } Beispiel: class Figure {...} Wird eine neue Subklasse programmiert, dann muss nach dem Namen das Schlüsselwort extends gefolgt vom Namen der Superklasse folgen: class NameDerSubklasse extends NamerDerSuperklasse {...} Beispiel: class Circle extends Figure {...} Implementiert eine Klasse ein Interface, dann folgt nach dem Namen der Klasse das Schlüsselwort implements gefolgt vom Namen des Interfaces: class NameDerKlasse implements NameDesInterfaces {...} Beispiel: class Computer implements Observer {...} Methoden Beispiel: double doSomething(int n, double x) {...} Eine Methode besteht aus einem Rückgabewert (double), einem Methodennamen (doSomething), einer Parameterliste (int n, double x) und einem Methodenkörper ({...}), der die eigentliche Funktionalität enthält. Optional können weitere Modifier angegeben werden. IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 11/15 Klassenmethoden wird das Schlüsselwort static vorangestellt: Beispiel: Exponenzialfunktion in der Klasse Math: public static double exp(double x) {...} Methoden, denen das Schlüsselwort void vorangestellt wird geben nichts zurück. Objekt Objekte werden mit new erzeugt. Beispiel: Figure fig; fig = new Figure(); Erzeugt ein neues Figure-Objekt. Modifier Modifier beschreiben spezielle Eigenschaften von Klassen, Variablen, Methoden... Die meisten von Ihnen existieren aus Sicherheitsgründen, aber viele haben auch einen starken Einfluss auf Codegröße und Performance. Standardmäßig ist eine Variable im aktuellen Package zugänglich. synchronized Methoden, die Engpassstellen darstellen werden bei mehreren Threads nur exklusiv ausgeführt. So wird verhindert, dass z.B. ein nur halb aktualisierter Eintrag in einer Datenbank gelesen wird. final Finale (endgültige) Variablen sind Konstanten. Finale Methoden können durch keine neue Implementation in Subklassen mehr überschrieben werden und von finalen Klassen dürfen keine Subklassen mehr gebildet werden. Da man z.B. finale Methoden in Subklassen nicht überschreiben kann, sollten Passwortabfragen final deklariert werden, außerdem kann der Compiler finalen Code besser optimieren. abstract Abstrakte Klassen dürfen abstrakte (unvollständig implementierte) Methoden besitzen. Diese müssen dann Subklassen implementieren. Abstrakte Klassen können nicht instantiiert werden. static static- Variablen (Klassenvariablen) und Methoden (implizit final!) gibt es im Gegensatz zu Instanzvariablen nur je einmal pro Klasse und nicht je einmal pro Instanz. Static-Methoden können auch nur mit static-Variablen und Methoden arbeiten. public Öffentliche Klassen, Methoden und Variablen sind überall zugänglich, also sowohl importiert als auch in Subklassen. private Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse verfügbar und wird auch nicht mitvererbt. protected Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse und deren Subklassen verfügbar. IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 12/15 transient Dieser Modifier wird derzeit noch nicht benutzt und in ist späteren Versionen für Low-Level-Funktionen und Datenbankzugriffe gedacht. volatile Dieser Modifier kennzeichnet, dass eine Variable asynchron aktualisiert wird und überwacht Operationen damit besonders. threadsafe Durch dieses Schlüsselwort weiß der Compiler, dass die Variable nicht von mehreren Threads gleichzeitig manipuliert wird und wird versuchen, sie in einem Register statt einem Speicherplatz unterzubringen. native Eine solche Methode wird nicht in Java-Code, sondern in Assembler oder C implementiert (nicht portabel). Siehe dazu die javah-Dokumentation. Arrays Beispiel: double v[] = new double[10]; instanziert einen Array v mit 10 Elementen des Basistyps double. Mit a[0],..., a[9] kann auf die einzelnen Felder des Arrays zugegriffen werden. Allgemein: Typ/Klasse VariablenNamen[] = new Typ/Klasse[Grösse]; Es ist ebenfalls möglich zuerst den Array zu deklarieren und die Grösse später festzulegen. Beispiel: double v[]; // deklariert einen Array ... v = new double[10]; // alloziert 10 Elemente vom Typ double Mehrdimensionale Arrays werden durch Anhängen von mehreren [] deklariert. Beispiel: double m[][] = new double[10][20]; deklariert einen 10x20 Array vom Typ double. Allgemein: Typ/Klasse VariablenNamen[][]..[] = new Typ/Klasse[1 Dim.][2 Dim]..[n Dim]; oder Typ/Klasse VariablenNamen[][]..[]; ... VariablenNamen = new Type/Klasse[1 Dim][2 Dim]...[n Dim]; Alle Bereichsüberschreitungen bei Arrays werden überwacht. Die Länge eines Arrays kann jederzeit abgefragt werden: int arraylaenge = v.length; IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS wichtige Operatoren Operator + (Addition) - (Subtraktion) * (Multiplikation) / (Division) % (Modulo) <,<=,>=, > (arithmetisch) == (Gleichheit) != (Ungleich) && (Boolean Und) || (Boolean OR) = (Zuweisung) Seite 13/15 Beispiel a+b a-b a*b a/b a%b a>b a == b a != b (a > 5) && (b == 7) (a != 2.0) || (b > 2.718) a = 3.141; Klasse/Typ byte, short, int, long, float, double, String byte, short, int, long, float, double byte, short, int, long, float, double byte, short, int, long, float, double byte, short, int, long byte, short, int, long, float, double alle alle boolean boolean alle if Statement if Statements werden gleich wie Pascal IF Statements programmiert, ausser dass die Bedingung geklammert wird und BEGIN durch { und END durch } ersetzt werden. Beispiel: if (a > 5) { System.out.println(“a grösser 5“); } else { System.out.println(“a ist kleiner oder gleich 5“); } Allgemein: if (Bedingung) { // Code falls Bedingung erfüllt ... } else { // Code falls Bedingung nicht erfüllt ... } if Statements können auch kaskadiert werden, wie das folgende Beispiel zeigt: if ( (a > 5) && (b < -3) ) { .... } else if (c == 7) { ... } else { ... } while Statement Beispiel: i = 10; while(i > 5) { System.out.println(“i =“ + i); i = i-1; } Gibt die Zahlen 10 9 8 7 6 auf den Bildschirm aus. IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 14/15 Allgemein: while (Bedingung) { ... // Code falls Bedingung erfüllt } do while Statement Das do while Statement funktioniert wie das Pascalkonstrukt REPEAT ... UNTIL. Beispiel: i = 10; do { System.out.println((“i =“ + i); i = i-1; } while(i > 5); Gibt die Zahlen 10 9 8 7 6 5 auf den Bildschirm aus. for Statement Ähnlich dem FOR-Statement in Pascal. In Klammern stehen 3 Anweisungen: Initialisierung ; Fortsetzungsbedingung ; Inkrement. Beispiel: for(i=0; i < v.length; i=i+1) { v[i] = 1.0; } Setzt alle Felder des 1 dimensionalen Arrays v auf 1.0. Allgemein: for (Initialiserung; Fortsetzungsbedingung; Änderung der Laufvariable) { ... // Schleifencode } switch Statement Beispiel: switch (Scanner.nextCmd) { case Scanner.Error: PrintError(); break; case Scanner.Fire: Fire(); break; default: Debug(); } Entspricht dem Code cmd = Scanner.nextCmd; if (cmd == Scanner.Error) { PrintError(); } else if (cmd == Scanner.Fire) { Fire(); } else { Debug(); } Allgemein: switch (Integerwert) { case Wert1: IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3 Java-Intensivkurs am IAS Seite 15/15 Code für Wert1; break; case Wert2: Code für Wert2; break; ... default: Code für Default; } Soll derselbe Code für mehrere Bedingungen ausgeführt werden, dann können case Statements hintereinander kaskadiert werden. case Wert1: case Wert2: Code für Wert1 und Wert2 break; Bemerkung: Falls Sie in einem switch Befehl einen Fehler vermuten, dann schauen Sie zuerst nach, ob Sie alle notwendigen break Befehle eingegeben haben. Häufig ist das Vergessen dieses Befehles Ursache des Fehlers. Fehlende break -Befehle haben zur Folge, dass der Code aller folgenden caseStatements abgearbeitet wird; solange bis ein break erscheint. IAS, 2012 java-kurzeinfuehrung-v13.docxx, Vers. 1.3