Was ist Java?
Werbung
Universität Stuttgart
Institut für Automatisierungs- und Softwaretechnik
Prof. Dr.-Ing. Dr. h. c. P. Göhner
Einführung in Java
(Original Titel der Folien: JavaIntensivkurs am IAS)
Vorlesung Informatik I, 15.11.2005, Daniel Huson
© 2000, IAS
1
Überblick
Teil 1:
Erster Überblick
Java Grundlagen
Teil 2:
Grundlagen der Objektorientierung
Klassen und Objekte in Java
Teil 3:
Overloading, Konstruktoren, Vererbung
Ausnahmebehandlung
Teil 4:
Datenstreams und Dateien
Teil 5:
Applet-Grundlagen
Teil 6:
Elemente des AWT
© 2000, IAS
Überblick
Teil 1:
Erster Überblick
Java Grundlagen
Teil 2:
Grundlagen der Objektorientierung
Klassen und Objekte in Java
© 2000, IAS
Erster Überblick
Was ist Java?
ein Projekt von Sun:
• Programmierumgebung
• WWW-Browser
die Programmierumgebung (JavaDevelopersKit) besteht
aus:
•
•
•
•
einem Java-Compiler
verschiedenen Bibliotheken
einem Laufzeitsystem
einem Debugger
Kennzeichen der Java Programmiersprache:
•
•
•
•
•
objektorientiert
plattformunabhängig
streng typisiert
sicher in Netzen
ähnliche Syntax wie C++
© 2000, IAS
Erster Überblick
Geschichtliches ...
August 1991: James Gosling (SUN) entwickelt Oak (Java)
Entwicklungsziel: einfache Programmiersprache für
Consumer Electronics (z.B Interactive TV, Settop-Boxes)
Anfang 1994: Nach Misserfolgen im Bereich Consumer
Electronics und zunehmendem Erfolg des WWW Neuausrichtung auf Internet
Februar 1995: Erste Version von Oak (jetzt: Java) und
einem Java WWW-Browser (Hotjava) werden veröffentlicht
August 1995: SUN lizensiert Java an Netscape, IBM und
Microsoft
Dezember 1998: JDK 1.2
Juni 2004: aktuelle Version J2SE 5.0
© 2000, IAS
Erster Überblick
Allgemeine Konzepte
Java wird interpretiert (schneller Entwicklungszyklus)
Hohe Zuverlässigkeit und Robustheit durch
• Speichermanager
• Verzicht auf (herkömmliche) Zeigertechniken
• strikte Typenüberprüfung zur Kompilier- und Laufzeit
hohe Verfügbarkeit - Code kann jederzeit über das
Netzwerk nachgeladen werden
Portabilität - “Write once, run everywhere”
GUI-Klassenbibliothek (AbstractWindowingToolkit)
© 2000, IAS
Erster Überblick
Plattformunabhängigkeit
JavaInterpreter
(Pentium)
Java-Compiler
(Pentium)
JavaBytecode
(plattformunabhängig)
JavaCode
JavaInterpreter
(SPARC)
Java-Compiler
(SPARC)
*.class
*.java
JavaInterpreter
(...)
...
© 2000, IAS
Erster Überblick
Vergleich mit C++ (1)
Java baut auf C++ auf:
• größtenteils identische Syntax
• Ausnahmebehandlung (exception handling)
• Meta-Objekt-Informationen
Java vermeidet folgende (teilweise “kritische”) C++
Elemente:
•
•
•
•
Zeiger (Pointer)
Mehrfachvererbung
Präprozessor, keine Header-Dateien
generischen Klassen, Templates
Java enthält zusätzliche Elemente
•
•
•
•
Garbage Collection
Interface-Konzept
Unicode
Threads
© 2000, IAS
Erster Überblick
Werkzeuge des JDK
Interpreter (Java Virtual Machine): java
Testumgebung für Applets:
appletviewer
Java-Compiler: javac
Generierung von HTML-Dokumentation
für Klassen: javadoc
Java-Debugger: jdb
Headerfile-Generator zur Einbindung
von
C-Funktionen: javah
Disassembler für Java-Bytecode: javap
JDK kostenlos verfügbar:
http://java.sun.com/j2se/
© 2000, IAS
werden im Rahmen
des Kurses nicht
behandelt!
Erster Überblick
Applikation contra Applet
Applikation:
• “normales”, Java-Programm, vergleichbar mit anderen
(interpretierten) Programmiersprachen
• Bytecode wird von einem Interpreter ausgeführt
Applets:
• werden in HTML-Seiten eingebunden und von Web-Browsern
ausgeführt
• können über das Netz geladen werden
• unterliegen strengen Sicherheitsanforderungen
(z.B. kein Schreiben im lokalen Dateisystem)
• ermöglichen interaktive Web-Seiten
© 2000, IAS
Erster Überblick
HelloWorld-Applikation (1)
// Datei: HelloWorld.java
public class HelloWorld {
public static void main( String[] args ) {
System.out.println(“Hello World!”);
}
}
das gesamte Programm befindet sich innerhalb der
Klassendefinition public class HelloWorld {}
Java-Programm = Menge von Klassendefinitionen
die Klassendefinition HelloWorld muss in einer
gleichnamigen Datei HelloWorld.java abgespeichert
main()-Methode ist der Einstiegspunkt des Programms
Bildschirmausgabe mit System.out.println()
© 2000, IAS
Erster Überblick
HelloWorld-Applikation (2)
Übersetzung der Applikation (Compiler):
% javac HelloWorld.java
nach fehlerfreier Übersetzung entsteht
die Bytecode-Datei: HelloWorld.class
ausführbares Programm = Menge von .class-Dateien
Ausführen der Applikation (Interpreter):
% java HelloWorld
Ausgabe von “HelloWorld” auf dem Bildschirm
© 2000, IAS
Erster Überblick
HelloWorld-Applet (1)
// Datei: HelloWorld.java
import java.awt.Graphics;
public class HelloWorld extends java.applet.Applet {
public void paint( Graphics g ) {
g.drawString(“Hello World!”, 50, 25);
}
}
import ermöglich Zugriff auf AWT-Bibliothek
(Abstract Windowing Toolkit, JDK)
keine main-Methode
Überschreiben von vorgegebenen Methoden (paint),
die in der AWT-Klasse Applet definiert sind
Compiler-Aufruf wie bei Applikation
© 2000, IAS
Erster Überblick
HelloWorld-Applet (2)
// minimale HTML-Datei mit eingebundenem Applet
<HTML>
<HEAD>
<TITLE>HelloWorld Applet</TITLE>
</HEAD><BODY>
<APPLET CODE=“HelloWorld.class” WIDTH=100 HEIGHT=100>
</APPLET>
</BODY>
</HTML>
CODE gibt Name der Appletklasse an
WIDTH und HEIGHT bestimmen die (Pixel-)Größe des Applets
HTML-Datei und HelloWorld.class sollten im gleichen
Verzeichnis liegen
HTML-Datei in Java-fähigen Browser oder mit
appletviewer aufrufen
© 2000, IAS
Überblick
Teil 1:
Erster Überblick
Java Grundlagen
Teil 2:
Grundlagen der Objektorientierung
Klassen und Objekte in Java
© 2000, IAS
Java Grundlagen
Prinzip: Die Syntax von Java ist stark an C/C++
angelehnt und größtenteils identisch.
Anweisungen
einzelne Java-Operationen:
•
•
•
•
•
Zuweisungen (int i = 1)
Ablaufsteuerung (if/else, do-while)
Methodenaufrufe (System.out.println(“Hallo”))
Instanziierungsaufrufe (Date today = new Date())
sonstige Anweisungen (import java.awt.Font)
Wichtig: Anweisungen werden durch Semikolon (;)
getrennt, z.B.:
import java.awt.Font;
int i = 1;
System.out.println(“Hallo”);
© 2000, IAS
Java Grundlagen
Variablen (1)
Stellen im Speicher, die Werte aufnehmen können
bestehen aus Typ, Namen und Wert:
int i = 12;
müssen vor der Benutzung deklariert werden:
zaehler = 7;
// Fehler: Variable zaehler unbekannt!
Deklaration mit Anfangswerten erlaubt:
boolean muede = false;
Mehrfachdeklarationen in einer Zeile möglich:
int i = 0, j = 3, k = 5;
Variablennamen müssen mit einem Buchstaben, einem
Unterstreichungsstrich (_) oder einem Dollarzeichen ($)
beginnen
© 2000, IAS
Java Grundlagen
Variablen (2)
Java unterscheidet Groß/Kleinbuchstaben
aussagekräftige Variablennamen wählen!
Variablentyp darf sein:
• primitiver Datentyp
• Klassenname
• Array
neue (benutzerspezifische) Variablentypen können nur
durch neue Klassen erzeugt werden (kein typedef wie in
C/C++!)
© 2000, IAS
Java Grundlagen
Primitive Datentypen
Typ
Bedeutung
boolean
true oder false
char
Unicode-Zeichen
16 Bits
byte
Ganze Zahl mit Vorzeichen
8 Bits
short
Ganze Zahl mit Vorzeichen
16 Bits
int
Ganze Zahl mit Vorzeichen
32 Bits
long
Ganze Zahl mit Vorzeichen
64 Bits
float
IEEE 754-Fließkommazahl
32 Bits
double
IEEE 754-Fließkommazahl
64 Bits
keine Implementierungsabhängigkeiten
© 2000, IAS
Größe
1 Bit
Java Grundlagen
Kommentare
// Text Kommentar bis zum Ende der Zeile
/* Text */ mehrzeilige Kommentare möglich, aber kein
Verschachteln von Kommentaren!
/** Text */ spezielle Kommentare für javadoc
Zeichenketten
keine Zeichen-Arrays sondern Objekte der Klasse String
bestehen aus mehreren Zeichen zwischen doppelten
Anführungszeichen (“Hallo”)
Verkettung (+) möglich (“Hallo” + “, World”)
können Escape-Zeichen enthalten (Auszug):
neue Zeile
\b
Rückschritt
\\
Backslash
\xdd Hexadezimal
\n
\t
\r
\”
\uddd
© 2000, IAS
Tab
Return
doppeltes Anführungszeichen
Unicode-Zeichen
Java Grundlagen
Operatoren (1)
Arithmetik
Operator
Bedeutung
Beispiel
+
*
/
%
Addition
Subtraktion
Multiplikation
Division
Modulo
3 + 4
5 - 7
5 * 5
14 / 7
20 % 7
Zuweisungen
Aus druck
Bedeut ung
x
x
x
x
x
x
x
x
+=
-=
*=
/=
y
y
y
y
=
=
=
=
x
x
x
x
© 2000, IAS
+
*
/
y
y
y
y
Java Grundlagen
Operatoren (2)
Inkrement/Dekrement
Ausdruck
x++
x-++x
--x
Bedeutung
x = x + 1,
x = x – 1,
x = x + 1,
x = x - 1,
Inkrementieren (postfix)
Dekrementieren (postfix)
Inkrementieren (prefix)
Dekrementieren (prefix)
Bsp.: y = x++ und y = ++x
Vergleiche und Boolean
Operator
==
!=
<, >
<=, >=
&&
||
Bedeutung
Gleich
Ungleich
Kleiner als, Größer als
Kleiner gleich, Größer gleich
Und
Oder
© 2000, IAS
Beispiel
x == 3
x != 3
x < 3, x > 3
x <= 3, x >= 3
(x > 0) && (x < 1)
(x > 0) || (x < 1)
Java Grundlagen
Operatoren (3)
Bitweise Operatoren
• Operationen auf einzelne Bits in Ganzzahlen (z.B. Verschiebungen,
Komplement, AND, OR, ...)
• spielen in diesem Kurs keine Rolle
Operatorpräzedenz
• Reihenfolge, in der Ausdrücke mit Operatoren bewertet werden,
z.B y = 6 + 4 / 2 ist 8 und nicht 5 !
• Reihenfolge (kann durch Klammerung geändert werden):
1) Klammern ([], ()) und Methoden- und Variablenzugriffe (.)
2) Inkrement/Dekrementausdrücke (++, --)
3) Multiplikation, Division, Modulo (*, /, %)
4) Addition, Subtraktion (+, -)
5) Bitweise Operationen
6) Vergleiche (<, >, ==, !=)
7) Logische (Boolsche) Operatoren (&&, ||)
8) Zuweisungen (=, +=, -=, *=, /=, ...)
© 2000, IAS
Java Grundlagen
Operatoren (4)
Beispiel:
// Datei: OperatorTest.java
class OperatorTest {
public static void main(String[] args) {
int x = 6;
int y = 4;
System.out.println(“x +
System.out.println(“x /
System.out.println(“x %
System.out.println(“++x
System.out.println(“--x
}
}
© 2000, IAS
y
y
y
:
:
=
=
=
“
“
“
“
“
+
+
+ (x + y));
+ (x / y));
+ (x / y));
(++x));
(--x));
//
//
//
//
//
=
=
=
=
=
10
1
2
7
6
Java Grundlagen
Ablaufsteuerung (1)
if-Anweisung
if( wert >= 1 ){
summe = summe + wert;
}
else {
wert = 0;
}
// Bedingung
// Anweisungen
// alternativer Zweig
// Anweisungen
• else-Zweig ist optional
• bei nur einem Befehl im if/else-Zweig kann die {}Klammerung weggelassen werden:
if( wert >= 1 )
summe = summe + wert;
© 2000, IAS
Java Grundlagen
Ablaufsteuerung (2)
switch-Anweisung
switch( wert ){
case 1:
summe++;
case 2:
summe = summe + 2;
break;
default:
summe = 0;
// wert = 1!
// wert = 2!
// springt aus der {}-Klammer
// Vergleich immer erfüllt!
}
• zur Variablen wert passender Ausdruck und/oder DefaultAusdruck wird ausgeführt
© 2000, IAS
Java Grundlagen
Ablaufsteuerung (3)
while-Schleife
while( summe >= 1 ){
summe--;
}
// Schleifen-Bedingung
// Anweisungen
• Wiederholung der Anweisungen bis Schleifen-Bedingung falsch
do-while-Schleife
do{
summe--;
} while( summe >= 1 );
// Anweisungen
• wie while-Schleife, Anweisungen werden jedoch mindestens
einmal durchlaufen
© 2000, IAS
Java Grundlagen
Ablaufsteuerung (4)
for-Schleife
for( int i = 0; i < 10; i++ ){
System.out.println(i);
}
// Anweisungen
• zunächst Ausführung der Initialisierungsanweisung (int i =
0)
• Auswertung des Boolschen Ausdrucks ( i < 10 ):
– falls wahr, wird zunächst die Anweisung
(System.out.println(i)) und dann die
Inkrementierunganweisung (i++) ausgeführt
– Ablauf wiederholen solange Boolscher Ausdruck wahr ist
• in der for-Schleife deklarierte Variablen sind nur innerhalb der
Schleife gültig
© 2000, IAS
Java Grundlagen
Ablaufsteuerung (5)
continue-Anweisung
for( int i = 0; i < 10; i++ ){
if( i > 6 )
continue;
System.out.println(i);
// continue springt hierher
}
• springt an das Ende des Schleifenrumpfes
return-Anweisung
return i;
• beendet Methode und liefert (falls vorhanden) Rückgabewert
der Methode
© 2000, IAS
Java Grundlagen
Zusammenfassung
Java ist eine objektorientierte Sprache von Sun, die für den
Einsatz in Netzen konzipiert ist
Portabilität wird durch plattformunabhängigen Bytecode
erreicht:
“Write once, run everywhere”
Java vereinfacht C++ (Zeiger, Präprozessor) und bietet
zusätzliche Elemente (Garbage Collection)
mit Java können sowohl “normale” Programme als auch
Applets geschrieben werden
Anweisungen, Variablen, Operatoren und Ablaufsteuerung
sind bis auf wenige Ausnahmen mit C/C++ identisch
das JDK ist kostenlos verfügbar
© 2000, IAS
