Kap.1: HALLO Java !
Kapitel-Index
1.1 Download, Installation und Aufruf
1.1.1 Direkter Aufruf der Java-Kommandos
1.1.2 Aufruf der Entwicklungsumgebung NetBeans
1.2 Einführende Beispiele
1.2.1 Das erste Text-Programm
1.2.2 Das erste Graphik-Programm
1.3 Schreibweisen
1.3.1 Verwendung der Syntaxdiagramme, siehe Syntax
1.3.2 Signifikanz von Groß- und Kleinschreibung
1.3.3 Namenskonventionen
1.3.4 Kommentar
1.4 Testfragen
1.1 Download, Installation und Aufruf
Man lade die zum Betriebssystem passende Java Standard Edition
(Java SE) mit Entwicklungsumgebung NetBeans (in bundle).
Folgt man den Download- und Installations-Hinweisen, so werden
das Java Runtime Environment (JRE), das Java Development Kit (JDK)
und die Entwicklungsumgebung NetBeans (IDE) wie folgt installiert:
----------------------------------------------------------------
-------------- Verzeichnis ---------------
-- Unterverzeichnis --------
C:\Programme\Java\jdk1.8.0_121\bin\java.exe Kommando
javac.exe Kommando
appletviewer.exe Kommando
-- ... ---------------------
------------------------------------------
-------------- Verzeichnis ---------------
C:\Programme\Java\jre1.8.0_121 Java Runtime Environment
-------------- ... -----------------------
-------------- Verzeichnis ---------------
-- Unterverzeichnis --------
C:\Programme\NetBeans IDE 8.2 \bin\netbeans.exe Kommando
-- ... ---------------------
-------------- ... -----------------------
---------------------------------- ... -------------------------
Fig. 1.1: Verzeichnisse für Java und NetBeans in Windows
Die Java SE Dokumentation (Docs) mit Application Programming Interface (API) Specification steht im Online-Zugriff zur Verfügung,
falls gewünscht mit "Index" und ohne Rand-Information "NO FRAMES":
http://docs.oracle.com/javase/8/docs/api
1.1.1 Direkter Aufruf der Java-Kommandos
In Windows gelangt man über
Start, Alle Programme, Zubehör, Eingabeaufforderung bzw.
Start, Ausführen, Öffnen: cmd, OK
in eine DOS-Emulation, in der Kommandos auflistbar sind, erläutert werden können, und deren Pfade abfragbar sind:
mit set | more Umgebungsvariablen, u.a. Path, auflisten
mit help | more DOS-Kommandos auflisten
mit help Kommando DOS-Kommandos erläutern
mit Kommando Java-Kommando erläutern
Man setze den Pfad auf das Verzeichnis der Java-Kommandos
java.exe, javac.exe, appletviewer.exe und auf das Verzeichnis des
Editor-Kommandos notepad++.exe (download siehe Lit.2) wie folgt:
Start, Systemsteuerung, System, Systemeigenschaften, Erweitert,
Umgebungsvariablen, Systemvariablen, Path, Bearbeiten, Anhängen
;C:\Programme\Java\jdk1.8.0_121\bin;C:\Programme\Notepad++
dann OK OK OK , DOS-Neustart durch neue Eingabeaufforderung.
Ich richte mir mit cd\ (change directory to C:\) und mit md my
(make directory my) mein Verzeichnis C:\my ein und wechsle mit
cd\my in mein Verzeichnis.
Fig. 1.1.1: Direkter Aufruf der Java-Kommandos
In C:\my kann man z.B. die Applikation HelloWorld (1.2.1) editieren, kompilieren und laufen lassen:
mit notepad++ HelloWorld.java die Applikation editieren,
mit javac HelloWorld.java zu HelloWorld.class kompilieren und
mit java HelloWorld die Applikation laufen lassen.
Argumente von main, z.B. bei der Applikation UmsatzSteuer (siehe
3.1), können an das Laufkommando angefügt werden .
In C:\my kann man auch z.B. das im HTML-Dokument CupApplet.html
(1.2.2) genannte Applet editieren und kompilieren, dann das Dokument editieren und das Applet mit appletviewer laufen lassen:
mit notepad++ CupApplet.java das Applet editieren,
mit javac CupApplet.java zu CupApplet.class kompilieren,
mit notepad++ CupApplet.html das HTML-Dokument editieren und
mit appletviewer CupApplet.html das Applet laufen lassen.
Vorteile des direkten Aufrufs der Java-Kommandos sind der unmittelbare Zugang zur Java-Programmierung für Anfänger, insbesondere
zu Applets, und die einfache Archivierung und Portierung der
.class-Dateien auf andere Java-fähige Betriebssysteme.
1.1.2 Aufruf der Entwicklungsumgebung NetBeans
Durch Doppelklick auf das Desktop-Symbol ruft man die Entwicklungsumgebung NetBeans auf.
Fig. 1.1.2: Aufruf der Entwicklungsumgebung NetBeans
NetBeans IDE (Integrated Development Environment) wurde 2000 zur
ersten offenen (open source) von SUN empfohlenen Entwicklungsumgebung für JSE (Java Standard Edition) und JEE (Java Enterprise Edition). NetBeans ist hauptsächlich bestimmt für die Unterstützung
der Entwicklung von Java-Applikationen. Die Anwendungen reichen
vom Server-Großunternehmen (Enterprise) bis zum Klienten am Desktop (Standard) oder Java-fähigem Handgerät (hand held device).
In NetBeans kann man z.B. die Applikation HelloWorld (1.2.1)
editieren, kompilieren und laufen lassen.
T e r m i a l B e n u t z e r K o m m e n t a r
---------------------------
-----------------------------------
edit Application (.java) z.B. HelloWorld.java
File New Project klick klick
Choose Project
Java Java Application klick
Next klick
Name and Location default Location
Project Name: HelloWorld
Create Main Class HelloWorld kopier
Finish klick
HelloWorld.java schreib in main-Rumpf:
----------
-------------------------
System.out.println("Hello World!");
------------------------------------------------------------
compile to .class (javac) z.B. HelloWorld.class
"blauer Hammer" (F11) klickBuild Main Project
finished building, BUILD SUCCESSFUL Build, Output
---------------------------
-----------------------------------
Arguments of main z.B. UmsatzSteuer
Projects klick
UmsatzSteuer klickrechtsklick
Properties Run klick klick
Arguments: 19.0 0.55 String[] args
OK klick
--------------------------------------------------------------
run Application (java) z.B. HelloWorld
"grüne Pfeilspitze" (F6) klick Run Main Project
Hello World! Output
--------------------------------------------------------------
Fig. 1.1.2a: Applikation in NetBeans
Argumente von main, z.B. 19.0 0.55 bei der Applikation UmsatzSteuer (3.1), werden als Project-Properties vorgegeben, siehe
Figur. 1.1.2a oben.
In NetBeans kann man (mit etwas mehr Aufwand) auch Applets erzeugen. Z.B. kann man das im Dokument CupApplet.html (1.2.2) genannte
Applet editieren und kompilieren, dann das Dokument editieren und
anschliessend das Applet (mit appletviewer) laufen lassen.
T e r m i n a l B e n u t z e r K o m m e n t a r
--------------------------------------------------------------
edit Applet (.java) z.B. CupApplet.java
File | New Project klick klick
Choose Project
Java | JavaClassLibrary klick
Next klick
Name and Location default Location
Project Name: CupApplet
Finish klick
Projects klick
CupAppletSource Packages klickrechtsklick blend ein [+]
New | Other klick
Choose File Type
Java Applet klick klick
Next klick
Name and Location Location gesetzt
Class Name: CupApplet
Finish klick
CupApplet.java schreib in class-Rumpf:
------------------------------------------------------
public void paint(java.awt.Graphics g)
{int width=getWidth(),height=getHeight();
g.drawOval(0, 0, width*3/4, height/2);
g.drawOval(width*3/4, 0, width/4, height/2);
g.drawArc (0,-height/2,width*3/4,height*3/2,180,180);}
------------------------------------------------------------
compile to .class (javac) z.B. Cup.Applet.class
Run Set Main Project klick klick
CupApplet such klick in Fettdruck
"blauer Hammer" (F11) klickBuild Main Project
finished building, BUILD SUCCESSFUL Build, Output
--------------------------------------------------------------
edit Document (.html) z.B. CupApplet.html
File New File klick klick
Choose File Type
Other HTML File klick klick
Next klick
Name and Location Location gesetzt
File Name: CupApplet
Finish klick
CupApplet.html schreib in <body>-Rumpf:
--------------------------------------------------------------
<applet code="CupApplet.class" width="636"height="318"></applet>
--------------------------------------------------------------
run Applet (appletviewer) z.B. CupApplet
Projects klick
CupApplet Source Packages <default package> blend ein [+]
CupApplet.java klickrechtsklick
Run File (Shift+F6) klick
Darstellung einer Tasse ggf. wiederholen ohne HTML-Text
--------------------------------------------------------------
Fig. 1.1.2b: Applet in NetBeans
Vorteile des Aufrufs der Entwicklungsumgebung NetBeans sind die
Java-bezogenen Editoren, die Einhaltung der Java-Kodierungskonventionen, die Hilfen und Unterstützungen bei den NetBeans-eigenen
Projekten und die Möglichkeit, Projekte aus anderen Entwicklungsumgebungen, wie z.B. Eclipse, zu importieren. Siehe Literatur
(Lit.1) zu NetBeans.
1.2 Einführende Beispiele
1.2.1 Das erste Text-Programm
Der Leser begrüßt die Java-Welt mit dem schon aus anderen Programmiersprachen bekannten HelloWorld Programm, auch 'Icebreaker
Party' genannt.
//************************ HelloWorld.java ***********************
// Ausgabe des Textes "Hello World!" *
//****************************************************************
class HelloWorld
{public static void main(String[] args) // args ungenutzt
{System.out.println("Hello World!");
}
}
//****************************************************************
Output
------------
Hello World!
Nach Klassen-Baukastenprinzip muss jedes Programm als Klasse vereinbart werden. Die Haupt-Methode main(String[] args) wird innerhalb der Klasse vereinbart und dann unter dem Namen der Klasse
aufgerufen. Dazu muss der Name der Klasse HelloWorld mit dem Dateinamen HelloWorld.java übereinstimmen, abgesehen von der Erweiterung .java . Die Methode main muss vereinbart werden als
public static void main(String[] args) {...} .
public ist ein Zugriff-Modifizierer (Syntax.070) für freien Zugriff in sichtbarem Paket, static ist ein Methoden-Modifizierer
(Syntax.070) für den Aufruf ohne speicheraufwendige Objektbildung
und void ist der leere Ergebnistyp (Syntax.031), d.h. main liefert
keinen Ergebniswert, sondern druckt nur. Der Parameter String[]
args muss vereinbart sein, auch wenn args nicht genutzt wird (siehe UmsatzSteuer 3.1).
println() ist die Druckmethode mit anschließendem Zeilenvorschub (ln steht für line) des PrintStream out der Klasse System.
Die qualifizierte Schreibweise
java.lang.System.out.println()
kann auf Grund des impliziten Imports des Standardpakets java.lang
abgekürzt werden zu System.out.println() und könnte durch vorangesetzten import static java.lang.System.out; (10.2) weiter abge-
kürzt werden zu out.println().
Anfang und Ende des Klassen-Rumpfs (Syntax.091) von HelloWorld
und des Methoden-Rumpfs (Syntax.083) von main() sind durch geschweifte Klammern gekennzeichnet, Anfang und Ende der Parameter
-Klausel (Syntax.081) der Methode main() und der Argument-Klausel
der Methode println() durch runde Klammern.
Einige Zeilen des Programms enthalten // . Der darauf folgende
Text bis zum Zeilenende ist für den Rechner überflüssiger, aber
für den Leser nützlicher Kommentar (1.3.4).
Die gemäß 1.1.1/2 erzeugte Binär-Datei (8.2) HelloWorld.class
für die "Java Virtual Machine" (Vorwort) besteht aus maschinenunabhängigem ByteCode.
1.2.2 Das erste Graphik-Programm
Graphikprogramme schreibt man am kürzesten als Applet, das in
HTML-Dokumente eingefügt werden kann (14.1). Dazu importiert man
die Klasse Graphics aus dem Paket java.awt (abstract window toolkit) und die Klasse Applet aus dem Paket java.applet.
Die im HTML-Dokument definierte Breite width und Höhe height
des Applets lassen sich in Component (Superklasse von Applet) mit
getWidth() und getHeight() abfragen. Die in der Klasse CupApplet
programmierte Methode paint(Graphics) überschreibt die gleichnamige Methode in Component und zeichnet eine "Kaffetasse" aus zwei
Ovalen (lat. ovum) und einem Oval-Bogen (lat. arcus).
//*********************** CupApplet.java *************************
// Graphik "Kaffeetasse" *
//****************************************************************
// java.lang . Object
import java.awt .Graphics; // Graphics'`Component
import java.applet.Applet; // `Applet
public class CupApplet extends Applet
{public void paint(final Graphics g) // overrides Component
{int width =getWidth(), // Component
height=getHeight(); // Component
g.drawArc ( 0,-height/2,width*3/4,height*3/2,180,180);
g.drawOval(width*3/4, 0,width /4,height /2);
g.drawOval( 0, 0,width*3/4,height /2);
}
} // implicite start() of Applet calls paint()
//****************************************************************
Fig. 1.2.2: CupApplet Darstellung
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" >
<!--***************** CupApplet.html **************************-->
<meta http-equiv="content-type"
content="text/html;charset=ISO-8859-15" >
<title> CupApplet </title>
<applet code="CupApplet.class" width="636" height="318" >
CupApplet </applet>
<!--***************** width=Hochformat height=width/2 *?*******-->
Der appletviewer (1.1.1/2) stellt das Applet ohne den umgebenden
Text des Html-Dokuments graphisch dar und liefert im Fehlerfall
Fehlermeldungen auf dem Desktop-Output. Ein Browser, z.B. Mozilla
Firefox oder der Internet Explorer, stellt das Applet mit dem umgebenden Text des Html-Dokuments graphisch dar, liefert aber keine
Fehlermeldungen. Mausklick auf das "Abbruch"-Symbol (X-Kreuz)
bricht den appletviewer bzw. das Browsen ab.
width
----------------------
width/4
----
(0,0) (width*3/4,0)
-----------------------
x - -
- height/2
----- - - height
----------------------- -
g.drawOval(width*3/4, 0 ,width/4,height/2);
y ------ -- ---- -----
x y Breite Höhe
Ein Oval (eiförmig, Ellipse) wird durch sein umgebendes Rechteck
definiert. Z.B. wird das kleine kreisrunde Oval (Fig.1.2.2) beschrieben durch seine linke obere Ecke (x,y)=(width*3/4,0) und
die Breite width/4 und Höhe height/2 seines umgebenden Rechtecks.
Ein Bogen (Arcus) eines Ovals wird durch die Parameter des Ovals
und zwei weitere Parameter definiert: den nicht dargestellten Anfangswinkel und den dargestellten Winkel des Bogens, beide im mathemathisch positiven Sinn von rechts in Bogengrad gemessen.
Die für CupApplet benötigten Klassen wurden hierarchisch im Kommentar des Programms aufgelistet: CupApplet ist Subklasse von Applet und Applet ist (indirekt) Subklasse von Component. Object ist
direkt oder indirekt Superklasse aller Klassen. Falls keine einschränkenden Modifizierer (Syntax.070) vereinbart sind, erbt jede
Subklasse die Eigenschaften ihrer Superklasse. Insbesondere erbt
CupApplet die Methoden paint(Graphics), getWidth(), getHeight()
aus Component und draw...(...) aus Graphics und darüber hinaus die
von start() bis stop() ablaufende Fenster/Rahmen-Verwaltung aus
Applet.
1.3 Schreibweisen
1.3.1 Verwendung der Syntaxdiagramme, siehe Syntax
Das Wort "Syntaxdiagramm" setzt sich zusammen aus den griechischen Worten "syn" (zusammen), "tattein" (stellen), "dia" (durch)
und "graphein" (schreiben). Nach Hammurabi (17. Jhv.) und Moses
(13. Jhv?) erließ Solon (6. Jhv.) Gesetze, die er "Syntax" nannte.
Ein Syntaxdiagramm ist demnach ein "gezeichnetes Gesetz".
Zur besserer Lesbarkeit empfehlen wir nicht die in der 'Java Language Specification' ISBN 0-312-24678-0 von Gosling et al. verwendeten Regeln in Backus-Naur-Form (ALGOL 1960), wie z.B.
Identifier:
IdentifierChars
but not a Keyword or BooleanLiteral or NullLiteral
IdentifierChars:
JavaLetter
IdentifierChars JavaLetterOrDigit
sondern deren gleichwertige graphische Repräsentation in Form von
Wirth-Syntaxdiagrammen (Pascal 1971) mit deutscher Übersetzung.
Ein Syntaxdiagramm sollte auch für den unvorbereiteten Leser wie
ein "Stadtplan aus Einbahnstraßen" lesbar sein. Man beginne mit
dem Eingangspfeil links und durchlaufe das Diagramm in einem Zug
bis zum Ausgangspfeil rechts. Schleifen dürfen beliebig oft durchlaufen werden.
Erreicht man im Diagramm nacheinander alle Zeichen des zu prüfenden Worts, dann ist das Wort syntaktisch korrekt, sonst nicht.
028: Identifier Bezeichner
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H ------------------------------------- H
H H
H ----------------- H
H ------------ ------------ H
H -- JavaLetter -- JavaDigit - - H
H ------------ ------------ H
H H
H ------------------- H
H H
H An Identifier shall not be Ein Bezeichner darf nicht H
H identical with a Keyword, Boo- mit einem Schlüsselwort, ei- H
H leanLiteral or NullLiteral. nem BooleanLiteral oder einem H
H NullLiteral übereinstimmen. H
H H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
Das Syntaxdiagramm kann verbal wie folgt beschrieben werden:
"Ein Bezeichner ist eine nichtleere endliche Zeichenfolge
aus JavaBuchstabe und/oder JavaZiffer
mit einem JavaBuchstabe am Anfang".
---------------
------
z.B. -- K -- 2 - - , KK22 ist syntaktisch korrekt,
--------
aber 22KK ist syntaktisch inkorrekt,
denn es führt kein Weg von
links direkt zur JavaZiffer 2.
Im Anhang finden sich die passenden Anschluß-Diagramme für JavaLetter (Syntax.025), u.a. große A...Z und kleine a...z Buchstaben,
und für JavaDigit (Syntax.026), u.a. Ziffern 0...9. Aus Tradition
sind auch das Dollar-Zeichen '$' und das Unterstrich-Zeichen '_'
JavaLetter. Darüber hinaus sind in Bezeichnern Buchstaben oder
Ziffern aus fast allen natürlichen Sprachen zugelassen, z.B. der
deutsche Buchstabe ß (char)223, der griechische Buchstabe alpha
(char)945 oder die arabische Ziffer Akhad (Eins) (char)1633, vorausgesetzt, der Editor kann diese Zeichen darstellen.
1.3.2 Signifikanz von Groß- und Kleinschreibung
In Java-Programmen sind groß und klein geschriebene Buchstaben
signifikant verschieden! Das fordert vermehrte Aufmerksamkeit beim
Schreiben von Programmen, z.B. darf nicht Class für class geschrieben werden, gibt aber mehr Möglichkeiten der Namenswahl,z.B.
final int VALUE=4711;int value=VALUE;value++;
VALUE ist eine Konstante besetzt mit dem Wert 4711 und value ist
eine Variable, die zunächst mit dem Wert 4711 von VALUE initialisiert und dann um 1 auf 4712 inkrementiert wird.
Namenskonventionen (naming conventions), nachfolgend tabellarisch
zusammengestellt, sind Empfehlungen zur Groß- oder Kleinschreibung
(WORD/word) und der Länge von Bezeichnern in Java-Programmen.?
------------------------------
VVVVVVVVVVVVVVVVV Namenskonventionen (Tabelle) VVVVVVVVVVVVVVVVV
VV ------------------------------ VV
VV Namensart Beispiel Konvention VV
VV ---------------------------------------------------------- VV
VV Paket VV
VV Internetbereich COM.author ABC.word (3 upp.letter) VV
VV Länderkennung UK.author AB.word (2 upp.letter) VV
VV JavaSoft java.lang java.word VV
VV Benutzer toolsVers2 wordSubstantive VV
VV Klasse MyTool WordSubstantive VV
VV Schnittstelle Usable Verbable VV
VV MyListener WordListener VV
VV Typ-Parameter T,T1,T2,S T(ype generic) VV
VV Methode VV
VV logisch isEqual isCondition VV
VV Lesen getString getType VV
VV Konvertieren toMyTool toType VV
VV Setzen setPriority setSubstantive VV
VV allgemein findResult verbSubstantive VV
VV Datenfeld oder lokal VV
VV Konstante WERT WORD (min.4 upp.letter) VV
VV Variable/Parameter VV
VV Grundtyp b,c,d,f,l,s b(yte),c(har),d(ouble), VV
VV f(loat),l(ong),S(tring) VV
VV Puffer buf buf(fer) VV
VV Ausnahme e e(xception) VV
VV ganzzahlig i,j,k i(nt),j,k VV
VV Eingabe in in(put) VV
VV Länge len len VV
VV Versatz off off(set) VV
VV Ausgabe out out(put) VV
VV beliebiger Typ v v(alue) VV
VV Variabl-allgem. x2 abbr(eviaton) VV
VV Paramet-allgem. number word VV
VV Sprungziel loop word VV
VV VV
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
Wie man sieht, beginnen die Namen von
Konstanten mit mind. 4 Großbuchstaben
Internetbereich -Paketen mit genau 3 Großbuchstaben
Länderkennung -Paketen mit genau 2 Großbuchstaben
Klassen, Schnittstellen,
generischen Typparametern mit genau 1 Großbuchstaben
Sonst. Paketen, Methoden,
Variablen und Parametern mit mind. 1 Kleinbuchstaben
Kommentar, d.h. eine Programm-Erläuterung für den Leser, die für
das Programm selbst keine Bedeutung hat, ist nach Syntaxdiagramm
005 (für EndOfLine, Traditional, Documentation) von der Form
005: Comment Kommentar
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H E n d O f L i n e C o m m e n t H
H ---------------------- H
H empty or nonempty ---------------- H
H -- // -- EndOfLineCommentText - LineTerminator ---- H
H of InputCharacter ---------------- H
H ---------------------- H
H Kommentar für den Leser, aus C++ übernommen. H
H Empfehlenswert, da man den End-Begrenzer H
H LineTerminator nicht vergessen kann. H
H H
H T r a d i t i o n a l C o m m e n t H
H ------------------------------------- H
H nonempty TradionalCommentText H
H - /* -- of InputCharacter or LineTerminator - H
H not containing */ H
H ------------------------------------- H
H Kommentar für den Leser, aus C übernommen. H
H Nicht empfehlenswert, da man den H
H End-Begrenzer */ vergessen kann. H
H H
H D o c u m e n t a t i o n C o m m e n t H
H ------------------------------------- H
H nonempty DocumentationCommentText H
H - /** - of InputCharacter or LineTerminator -- */ - H
H not containing */ H
H ------------------------------------- H
H Kommentar für die Dokumentation (10.3) mit H
H Entities für deutsche Zeichen (13.1.1). H
H End-Begrenzer */ darf man nicht vergessen! H
H H
H empty DocumentationComment H
H - /**/ -------------------------------------------------- H
H H
H Comment must not occur in a Kommentar darf nicht in einem H
H CharacterLiteral or StringLi- ZeichenLiteral oder einem Zei- H
H teral. chenkettenLiteral vorkommen. H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
zu Frage abdeckbare Antwort
-----------------------------------------------------------------
1.2.1 Zu HelloWorld:
Ändere "Hello World!" individuell ab!
Setze zusätzliche Kommentare!
1.2.2 Zu CupApplet:
In welcher Klasse wird die Methode in Component verein-
paint(Graphics) zuerst vereinbart und bart,in CupApplet
in welcher Klasse wird sie überschrie- überschrieben
ben?
1.2.2 Zu CupApplet: R(ot),G(rün),B(lau)
jeweils 0..255
Fülle die Tasse mit "Kaffee" durch
g.setColor(new Color(255*3/4,255/4,0)); Rot*3/4 und Grün/4
g.fillOval(0,0,wid*3/4,hih/2); ergibt "Braun",
an Stelle von vgl. Fig. 14.1.5
g.drawOval(0,0,wid*3/4,hih/2);
1.2.2 Zu CupApplet: int width=
getWidth()-1,
Kompensiere die Graphics-Randpixel- height=
fehler rechts und unten ! getHeight()-1;
1.3.1 Wieviel E in einer Kette erzeugt 1,3,5,...
das folgende Syntax-Diagramm? d.h. ungerade
Anzahl von E
WievielE
---E
--
----E-----
1.3.2 Was ist falsch?
Class HelloWorld Class statt class
{public static void main(string[] args) string statt String
{system.out.println("Hello World!");} system statt System
}
1.3.3 Von welcher Art sind (nach Namens-
konvention) die folgenden Namen?
java.applet Paket von JavaSoft
MouseEvent Klasse
Runnable Schnittstelle
ActionListener Schnittstelle
T2 TypParameter
getSize Methode
TEXT Konstante
wid Variable
profit Parameter oder
Sprungziel
1.3.4 Von welcher Art sind die Kommentare?
/**/ DocumentationComment
/*/*/ TraditionalComment
//**//**// EndOfLineComment
