Kap.2: GRUNDTYPEN, ZEICHENKETTE (String), FORMAT
Kapitel-Index
2.1 Abfragbare Typ-Eigenschaften, Typ-Konvertierung
2.2 boolean Logik
2.3 char Unicode-Zeichen
2.4 byte/short/int/long Ganzzahlen
2.5 float/double Gleitpunktzahlen
2.6 String als Referenztyp, Zeichenketten-Literale
2.7 Format-String
2.8 Testfragen
In diesem Kapitel werden Grundtypen (PrimitiveType, 2.1-5) und
Zeichenketten (String, 2.6) behandelt, sowie formatierte Zeichenketten und formatierte Ausgabe mit System.out.printf(,) (2.7).
030: Type Typ
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H -
-
boolean ----
- H
H 
- char -------
- - - 
H
H - byte ------- -Integral- Integral- H
H - short ------ NotLong- -Type Numeric- Primi- H
H - int -------- -
Type -Type -tive- H
H - long ------- - Type H
H - float ------ - FloatingPoint- H
H - double ----- -
-Type - - H
H - Boolean ---- - - - H
H - Character -- - Integral- H
H - Byte ------- -NotLong- H
H - Short ------ ClassType Wrapper- H
H - Integer ---- - -Class- H
H - Long ------- Type H
H - Float ------ ClassOr- H
H - Double ----- - special Interface- H
H - String ----- --Class- -Type H
H - Throwable -- - Type H
H - Iterable --- - special Refe- H
H - Annotation ---------- --Interface -rence- H
H 
-------------------- Type Type H
H -ClassOrInterfaceType-
----------- - Array- H
H 
-------------------- --Type H
H ---------- TypeVar. - [ - ] - - H - H
H -Identifier----------- bounded --Type- H
H ---------- gen.Class- WildCard - Identifier H
H OrInterface
forbidden H
H - no name --------------- --Null- H
H type null - Type - H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
2.1 Abfragbare Typ-Eigenschaften, Typ-Konvertierung
Die Wertebereiche numerischer Typen sind abfragbar. Im folgenden
Programm MinMaxValue werden die Konstanten MIN_VALUE und
MAX_VALUE der numerischen Typen als Datenfelder ihrer Hüll-Klassentypen abgefragt und ausgegeben.
//*********************** MinMaxValue.java ***********************
// MIN/MAX_VALUE fuer numerische Typen *
// SMALL ist die kleinste float/double Differenz zu 0.0 *
// EPSILON ist die kleinste float/double Differenz zu 1.0 *
//****************************************************************
class MinMaxValue
{public static void main(String[] args) // args ungenutzt
{long n=10l;
float Ef=1f/n; while(1-Ef<1 && 1+Ef>1) {Ef=1f/(n*=10);}
double Ed=1d/n; while(1-Ed<1 && 1+Ed>1) {Ed=1d/(n*=10);}
System.out.print
(" char:"+(int)Character.MIN_VALUE+
" ... "+(int)Character.MAX_VALUE+"\r\n"
+" byte:"+ Byte.MIN_VALUE+
" ... "+ Byte.MAX_VALUE+"\r\n"
+" short:"+ Short.MIN_VALUE+
" ... "+ Short.MAX_VALUE+"\r\n"
+" int:"+ Integer.MIN_VALUE+
" ... "+ Integer.MAX_VALUE+"\r\n"
+" long:"+ Long.MIN_VALUE+
" ... "+ Long.MAX_VALUE+"\r\n"
+" float:"+ -Float.MAX_VALUE+
" ... "+ Float.MAX_VALUE+"\r\n"
+" SMALL="+ Float.MIN_VALUE+", EPSILON="+Ef*10+"\r\n"
+"double:"+ -Double.MAX_VALUE+
" ... "+ Double.MAX_VALUE+"\r\n"
+" SMALL="+ Double.MIN_VALUE+", EPSILON="+Ed*10+"\r\n"
);
}
}
//****************************************************************
Der Leser kann das Programm zunächst übergehen und nur die im
Output aufgelisteten Wertebereiche betrachten:
Output
---------------------------------------------------------
char:0 ... 65535
byte:-128 ... 127
short:-32768 ... 32767
int:-2147483648 ... 2147483647
long:-9223372036854775808 ... 9223372036854775807
float:-3.4028235E38 ... 3.4028235E38
SMALL=1.4E-45, EPSILON=1.0E-7
double:-1.7976931348623157E308 ... 1.7976931348623157E308
SMALL=4.9E-324, EPSILON=1.0E-15
In der folgenden Übersicht wird verlustfreie totale Konvertierbarkeit für alle Werte eines Quell-Typs in einen Ziel-Typ durch
Pfeile angezeigt. Totale Konvertierbarkeit erfordert, dass der
Zieltyp mindestens so viel Speicher-Bit bereitstellt und mindestens so viele Dezimalstellen-DIGITS aufweist wie der Quell-Typ und
ggf. das Vorzeichen oder den Exponent des Quell-Typs darstellen
kann.
---------------------------------------
VVVVVVVVVVVVV Grundtypen und String (Konvertierung) VVVVVVVVVVVV
VV --------------------------------------- VV
VV b o o l e a n b y t e VV
VV 1 bit 8 bit,2 DIGITS VV
VV : -2
7...27-1 VV
VV : VV
VV : VV
VV : c h a r s h o r t VV
VV : 16 bit,unsigned 16 bit,4 DIGITS VV
VV : 0...216-1 -215...215-1 VV
VV : VV
VV : VV
VV : ------------------------------- VV
VV : VV
VV : i n t - - - - f l o a t VV
VV : 32 bit,9 DIGITS 32 bit,7 DIGITS VV
VV : -231...231-1 -2122...2122° VV
VV : VV
VV : VV
VV : --------------- VV
VV : VV
VV : l o n g - - - d o u b l e VV
VV : 64 bit,18 DIGITS 64 bit,15 DIGITS VV
VV : -263...263-1 -2986...2986° VV
VV : : : VV
VV : v v VV
VV ························>················>··> S t r i n g VV
VV --- numerisch verlustfrei konvertierbar VV
VV - - zum nächsten Gleitpunktzahl-Wert erweiterbar VV
VV ···> mit Methode valueOf() verlustfrei konvertierbar VV
VV ° duale Bereichsabschätzung VV
VV VV
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
Die duale Darstellung der Grundtypen in Bit wird im Abschnitt
über Java-Maschinen-Arithmetik (4.3) behandelt. Die maximale Anzahl DIGITS von Dezimalziffern für numerische Typen entnimmt man
dem Output des obigen Programms MinMaxValue. Für jeden Grundtyp
gibt es in der Klasse String (2.6) eine Methode valueOf(...) zur
Konvertierung nach String und umgekehrt im Hüll-Klassentyp, der
zum Grundtyp korrespondiert, eine Methode parse...(String) oder
eine andere Methode zur Konvertierung von String,
z.B. out.print(String.valueOf ( 2.7 )); // 2.7
out.print(Double.parseDouble("2.7")); // 2.7
------------------------------------
VVVVVVVVVVVVVV Implizite Konvertierung (Prinzip) VVVVVVVVVVVVVV
VV ------------------------------------ VV
VV Bei korrespondierenden Grundtypen und Hüll-Klassentypen VV
VV 
wird der Grundtyp in den Hüll-Klassentyp durch Boxing VV
VV konvertiert, VV
VV VV
VV z.B. boolean b=true;Boolean B=b;//B.booleanValue()==true VV
VV VV
VV wird der Hüll-Klassentyp in den Grundtyp durch Unboxing VV
VV konvertiert, VV
VV VV
VV z.B. Boolean B=new Boolean(true);boolean b=B; // b==true VV
VV VV
VV Bei binären Operationen (4.2) VV
VV mit numerischen Operanden wird der speziellere Typ in VV
VV den allgemeineren Typ numerisch verlustfrei oder erwei- VV
VV ternd zum nächsten Gleitpunktzahl-Wert konvertiert, VV
VV VV
VV z.B. 'c'+1 // (int)'c'==99, 'c'+1==100 VV
VV VV
VV mit Operanden vom Typ char/byte/short wird verlustfrei VV
VV nach int konvertiert. Man kann explizit nach char/byte/ VV
VV short zurückkonvertieren, VV
VV VV
VV z.B. char c='#';c=(char)(c+c); // c+c==66, c=='B' VV
VV VV
VV Bei Zuweisungen (5.1) VV
VV mit numerischen Operanden wird falls möglich der rechte VV
VV Operand in den Typ des linken Operanden verlustfrei oder VV
VV erweiternd zum nächsten Gleitpunktzahl-Wert konvertiert, VV
VV VV
VV z.B. int i=123456789;float f;f=i; // f==1.23456792E8 VV
VV VV
VV mit konstantem Ausdruck (Synt.060) auf der rechten Seite VV
VV und einem linken Operanden vom Typ char/byte/short wird VV
VV der rechte Operand in den Typ des linken Operanden kon- VV
VV vertiert, wenn der konstante Ausdruck verlustfrei (ein- VV
VV engend) im Typ der linken Seite darstellbar ist, VV
VV VV
VV z.B. char c;c=33; // c=='#' VV
VV VV
VV Beim Überladen (7.3), VV
VV wenn mehrere Methoden bezüglich ihrer Parametertypen als VV
VV "numerisch verlustfrei konvertierbar oder zum nächsten VV
VV Gleitpunktzahl-Wert erweiterbar" in Frage kommen, wird VV
VV diejenige ausgewählt, die den geringsten Konvertierungs- VV
VV aufwand (siehe oben "Grundtypen und String") erfordert. VV
VV VV
VV z.B. int i=9;double d;d=Math.sqrt(i); // d=3.0 VV
VV VV
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
Explizit ist jeder numerische Typ in jeden anderen numerischen
Typ mit einem Grundtyp-Konvertierungsoperator (PrimitiveType Cast
-Operator, 4.2.2) ggf. mit Verlust konvertierbar,
z.B. out.print((int)2.7); // 2
Implizit konvertiert wird in Java nur numerisch verlustfrei
oder erweiternd zum nächsten Gleitpunktzahl-Wert. Implizit gerundet wird nicht, außer bei der formatierten Ausgabe (2.7).
Der Typ boolean, George Boole: "The laws of thought" (1847), d.h.
die Menge der logischen Werte false, true, ist der logische (boolean) Typ. Konvertierung von boolean in numerische Typen und umgekehrt ist nicht möglich. Für logische Operanden sind logische Operatoren ! (nicht), && (und), || (oder), Gleichheitsoperatoren == ,
!= und Zuweisung = zulässig. Wichtige Anwendungen sind Verzweigungen (5.2) und Schleifen (5.3).
Zum Grundtyp boolean gibt es im Paket java.lang den korrespondierenden Hüll-Klassentyp Boolean.
Der Typ char besteht nach den Syntaxdiagrammen für Eingabe-Zeichen (Synt.004) und Zeichen-Literalen (Synt.010) aus Unicode-Eingabezeichen (UnicodeInputCharacter), d.h. Zeichen aus einem 2-byte
Zeichensatz mit den Nummern 0...65535, der mit dem ASCII-Zeichensatz mit den Nummern 0...127 beginnt und fast alle Zeichen aus den
natürlichen Sprachen enthält.
004: InputCharacter EingabeZeichen
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H ---------------------------------------- H
H - UnicodeInputCharacter but not LF or CR - H
H ---------------------------------------- H
H H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
010: CharacterLiteral ZeichenLiteral
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H S i n g l e C h a r a c t e r H
H ------------------------------- H
H - ' -- InputCharacter but not ' or \ -- ' - H
H ------------------------------- H
H ---------------- H
H - EscapeSequence ---------------- H
H ---------------- H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
z.B. ' ','+','9','A','a','Ä','ä','\n' (newline, Syntax.008)
Zeichen-Literale sind durch Apostrophe begrenzt.
Im folgenden Programm CodePage850 wird die Code-Tabelle der Windows XP DOS-Emulation und des Editors edit ausgegeben.
//********************** CodePage850.java ************************
// Code Page 850 (DOS Latin-1, DOS Westeuropa) fuer edit *
//****************************************************************
// java.lang. Object
import static java.lang.System.out; // | `System
import static java.lang.String.format; // `String
class CodePage850
{public static void main(String[] args) // args ungenutzt
{String[]
for(int i=0;i<16;i++) // Zeile i
{ out.print(format("%3d ",16*i)); // Nummer links
for(int j=0;j<16;j++) // Spalte j
{ int k=16*i+j; // Nummer k
if ( i<= 1) // CTRL
{out.print(CTRL[i-0].substring(3*j,3*j+3));}
else if ( 8<=i && i<= 9) // CODE
{out.print(CODE[i-8].substring(3*j,3*j+3));}
else if ( 2<=i && i<= 7 // Ascii
|| 10<=i ) // CP850
{out.print(format("%-3c",(char)k));}
}
out.print(i<7?"\r\n" // 1 x Vorschub
:"\r\n\r\n"); // 2 x Vorschub
}
out.print("<+," // copy omission
+"u\",i`,A°,E',O/ " // javac warning
+"Ersatz fuer Windows-'unmappable'");
}
}
//****************************************************************
Der Leser kann das Programm zunächst übergehen und nur die im
Output aufgelistete Code-Tabelle betrachten:
Fig. 2.3a: CodePage850 Output
In der obigen Code-Tabelle wird zu jedem mit der deutschen
Tastatur im Code 850 direkt oder mit dem Editor edit darstellbaren
Zeichen die CP850-Nummer angegeben, z.B.
§ Ctr+p,Fn+NumLk,Alt+Ziffernblock(21) CP850: 21 (Unicode: 167)
A CP850: 65 (Unicode: 65)
Ä CP850:142 (Unicode: 196)
| Fn+NumLk,Alt+Ziffernblock(179) CP850:179 (Unicode:9474)
Nur im ASCII-Bereich 32...127 stimmen CP850- und Unicode-Nummer
und -Zeichen überein.
Textuell können nur die 256 CP850-Code-Zeichen in der Windows XP
DOS-Emulation dargestellt werden. Das DOS-Kommando chcp zeigt die
aktive Codepagenummer an.
Graphisch mit g.drawString(String,int,int) können alle 65536
Zeichen im Unicode des Java-Applets dargestellt werden.
Im folgenden Programm Unicode werden die 65536 Unicode-Zeichen
auf 64 Seiten mit je 1024 Zeichen dargestellt.
//************************ Unicode.java **************************
// Unicode-Tabelle, 64 Seiten mit je 1024 Zeichen *
//****************************************************************
// java.lang . Object
import java.awt.event.*; // ActionEvent'|||ActionListener
import static java.awt .Color.*;// Color'|| |
import java.awt .*; // Component'`FlowLayout |
//Container'`Button |
import java.applet .Applet; // `Applet----------------'
public class Unicode extends Applet implements ActionListener
{int size,off=0;
final Color B=BLACK,G=GREEN.darker(),R=RED,S=BLUE;
final int[] d={-10240,-1024,+1024,+10240};
final Button[] b={new Button("-10240"),new Button("-1024"),
new Button( "+1024"),new Button("+10240")
};
public void paint(Graphics g) // overrides Component
{for(int i=0;i<b.length;i++)
{b[i].setEnabled(0 <= off+d[i] && off+d[i]+1024-1 <= 65535);}
int x,y;
for(int j=off;j<off+1024;++j)
{ x=(1+j%32*2)*size/4;y=(4+(j-off)/32)*size;
if (j%32==0)
{g.setColor(B);g.drawString(""+j,x,y);
}g.setColor ((Character.isISOControl (j) ?R
:(Character.isJavaIdentifierStart(j) ?G
:(Character.isJavaIdentifierPart (j) ?S:B))));
g.drawString(""+(char)j,2*x+3*size,y);
} g.setColor(R);g.drawString("ISOControl", 7*size,37*size);
g.setColor(G);g.drawString("JavaLetter", 13*size,37*size);
g.setColor(S);g.drawString("JavaDigit" , 19*size,37*size);
g.setColor(B);g.drawString("Others" , 25*size,37*size);
}
public void actionPerformed(ActionEvent e) // ActionListener
{String s=e.getActionCommand();
s=(s.startsWith("+") ? s.substring(1) : s);
off+=Integer.parseInt(s);
repaint();
}
public void start() // overrides Applet, calles paint
{ size=getHeight()/38;
setFont (new Font("SansSerif",Font.BOLD,size));//Cont
for(Button each:b)
{add (each); // Container
each.addActionListener(this); // this Unicode
}
}
} // FlowLayout is default for Applet
//****************************************************************
Der Leser kann das Programm zunächst übergehen und nur die dargestellten Code-Seiten betrachten:
Fig. 2.3b: Unicode Darstellung
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" >
<!--***************** Unicode.html ****************************-->
<meta http-equiv="content-type"
content="text/html;charset=ISO-8859-15" >
<title> Unicode </title>
<applet code="Unicode.class" width="636" height="684" >
Unicode </applet>
<!--***************** width=Hochformat height=38*size *********-->
Zum Grundtyp char gibt es im Paket java.lang den korrespondierenden Hüll-Klassentyp Character.
2.4 byte/short/int/long Ganzzahlen
Ganzzahlen, d.h. nicht-gebrochene (ohne Dezimalpunkt) ggf. vorzeichenbehaftete Zahlen, sind gemäß ihrem Ganzzahltyp (IntegralType) byte/short/int/long und korrespondierendem Hüll-Klassentyp
Byte/Short/Integer/Long in Bereichen MIN_VALUE ... MAX_VALUE definiert, z.B. ist byte definiert im Bereich
-128==Byte.MIN_VALUE ... -3 -2 -1 0 1 2 3 ... Byte.MAX_VALUE==127
Die Bereichsgrenzen MIN_VALUE und MAX_VALUE entnimmt man dem
Output des Programms MinMaxValue (2.1).
Ein Ganzzahl-Literal (IntegerLiteral), d.h. eine explizit im
Programm vorkommende Ganzzahl, ohne führendes Vorzeichen, das als
unärer Operator (4.2) noch davor gesetzt werden darf, ist nach
Syntaxdiagramm 020 von der Form
020: IntegerLiteral GanzzahlLiteral
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H D e c i m a l IntegerLiteral H
H -------------- -------- H
H -- NonZeroDigit -- Digits ------ H
H -------------- -------- H
H H
H - 0 ------------------------------ H
H O c t a l IntegerLiteral H
H ------------- H
H -------------- OctalDigits - H
H ------------- H
H H e x IntegerLiteral default H
H - X ------- ----------- int H
H - x -------- HexDigits -------- H
H ----------- - L - H
H LongTypeSuffix - l -- H
H H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
z.B. 1234567890 dezimal int
0 dezimal int
08888888888 oktal int 810-1=1073741823
Für die typgenaue Kennzeichnung von long-Ganzzahlen gibt es das
Suffix L oder l,
z.B. 0xFFFFFFFFFFl hexadezimal long 1610-1=1099511627775L
2.5 float/double Gleitpunktzahlen
Gleitpunktzahlen, d.h. gebrochene (mit Dezimalpunkt) ggf. vorzeichenbehaftete Zahlen, sind gemäß ihrem Gleitpunktzahltyp (FloatingPointType) float/double und korrespondierendem Hüll-Klassentyp
Float/Double in Bereichen -MAX_VALUE ... MAX_VALUE definiert,
z.B. ist double definiert im Bereich
-1.7976931348623157E308 == -Double.MAX_VALUE ...
... Double.MAX_VALUE == 1.7976931348623157E308
Für Gleitpunktzahlen benötigt man, anders als für Ganzzahlen,
auch Angaben darüber, wie dicht man an 0.0 herankommt (SMALL=
Double.MIN_VALUE) und wie dicht man an 1.0 herankommt (EPSILON).
Die Bereichsgrenze Double.MAX_VALUE und die Differenzen SMALL=
Double.MIN_VALUE und EPSILON entnimmt man dem Output des Programms MinMaxValue (2.1).
Ein Gleitpunktzahl-Literal (FloatingPointLiteral), d.h. eine exlizit im Programm vorkommende Gleitpunktzahl, ohne führendes Vorzeichen, das als unärer Operator (4.2) noch davor gegesetzt werden
darf, ist nach Syntaxdiagramm 021 von der Form
021: FloatingPointLiteral GleitpunktzahlLiteral
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H H e x F l o a t i n g P o i n t L i t e r a l H
H -- 0 -- X - H
H - x - H
H ------------------ . -------- H
H --------- ----------- H
H -HexDigits----- . ------- HexDigits - H
H --------- ----------- H
H ---------------------- H
H ------------------------------ H
H BinaryExponent H
H -- P - -------- H
H - p -- - -- Digits ---- H
H - + - -------- H
H ----- H
H + default H
H D e c i m a l F l o a t i n g P o i n t Literal H
H --------------------- . -------- H
H -------- -------- H
H --- Digits ------ . ------- Digits - H
H -------- -------- H
H -------------------- H
H --------------------------- H
H ExponentPart default H
H -- E - -------- double H
H - e -- - -- Digits --------- H
H - + - -------- H
H ----- H
H + default H
H --------------------------------- D - H
H DoubleTypeSuffix - d - H
H - F - H
H FloatTypeSuffix - f -- H
H H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
z.B. .1 1. 1E1 1f 1D 3.14==314E-2==0.314E1==0.314E+1
Für die typgenaue Kennzeichnung von float-Gleitpunktzahlen gibt
es das Suffix F oder f, für die typgenaue Kennzeichnung von double
-Gleitpunktzahlen das Suffix D oder d. Gleitpunkzahlen werden
nicht wie Ganzzahlen dual im Prozessor, sondern i.a. dezimal im
Koprozessor berechnet.
Der Name Gleitpunktzahl rührt daher, dass bei Multiplikation mit
Zehnerpotenzen "10 hoch n" (n ist eine Dezimal-Ganzzahl), geschrieben als En, der Dezimalpunkt nach links (n negativ) oder
rechts (n nichtnegativ) "gleitet", z.B.
1.234567 entspricht 0.01234567E2 oder 123.4567E-2
2.6 String als Referenztyp, Zeichenketten-Literale
String ist eine Klasse des Pakets java.lang. Als Klassentyp ist
String ein Referenztyp (Synt.030), kein Reihungstyp (6), wie z.B.
char[], und kein Grundtyp (2), wie z.B. char. Insbesondere ist
eine String-Variable oder ein Zeichenketten-Literal (siehe unten)
nicht wie eine Reihung mit eckigen Klammern [] indizierbar, sondern mit Hilfe der in der Klasse String vereinbarten Methode
charAt(),
z.B. "StringLiteral".charAt(6) == 'L'
Ein Zeichenketten-Literal (StringLiteral) ist eine Konstante vom
Typ String, nach Syntaxdiagramm 011 von der Form
011: StringLiteral ZeichenkettenLiteral
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
H H
H ------------------------------------ H
H S t r i n g C h a r a c t e r H
H ------------------------------- H
H - " -- InputCharacter but not " or \ - - " - H
H ------------------------------- H
H ---------------- H
H - EscapeSequence ---------------- H
H ---------------- H
H -------------------------------------- H
H H
H EscapeSequence is only repla- FluchtzeichenFolge(n) sind H
H cement here for LF CR " \ hier die einzige Möglichkeit, H
H LF CR " \ darzustellen. H
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
z.B. " " , "9" , "A" , "Max und Moritz" , "Zeile1\nZeile2"
Die nicht direkt in Anführungsstrichen darstellbaren Zeichen
LF CR " \ lassen sich als Fluchtzeichenfolge (EscapeSequence,
Synt.008) darstellen:
"\n" (newline, linefeeed LF) "\r" (carriage return CR)
"\"" (double quote ") "\\" (backslash \)
Für String-Operanden sind der Katenationsoperator + und die
Gleichheitsoperatoren == , != zulässig.
Die String-Katenation s=s1+s2, d.h. die Aneinanderfügung von s1
und s2 zu einem neuen String s, ist definiert für mindestens einen
String-Operanden und höchstens einen Grundtyp-Operanden, wobei der
Grundtyp-Operand vor der Katenation implizit mit Hilfe der in der
Klasse String für jeden Grundtyp vereinbarten Methode valueOf() in
einen String umgewandelt wird,
z.B. "die "+(3+4)+" Zwerge" == "die 7 Zwerge"
"die "+ 3+4 +" Zwerge" == "die 34 Zwerge"
Die Gleichheit == gilt nur für Zeichenketten-Literale. Mit Hilfe
der in der Klasse String vereinbarten Methoden intern(), equals()
läßt sich jedoch auch die Gleichheit von String-Variablen (Referenzen) überprüfen,
z.B. String s="String";
out.print(s =="String" ); // false
out.print(s.intern()=="String" ); // true
out.print(s.equals( "String")); // true
Für String-Relationen "kleiner", "größer" gibt es keine Operatoren. Statt dessen gibt es die in der Klasse String vereinbarte
Methode compareTo() für lexikographischen Vergleich (Unicode 2.3),
z.B. out.print("String".compareTo("Literal")<0); // false
out.print("Literal".compareTo("String")<0); // true
Die Länge eines Strings ist bestimmbar mit der in der Klasse
String vereinbarten Methode length(),
z.B. "StringLiteral".length() == 13
Zeichenketten-Literale sind Konstanten, auch bezüglich ihrer char
Bestandteile, d.h. es gibt kein setCharAt(,) in der Klasse String.
Aber String-Variable (Referenzen) lassen sich auf andere Zeichenketten-Literale "umklinken",
z.B. String s="vorher";
s="nachher";
"Neue Bestandteile von String-Variablen" lassen sich mit Hilfe
der in der Klasse String vereinbarten Methoden substring(...) per
Katenation "einsetzen",
z.B. String s="Adam";
s=s.substring(0,1)+"mster"+s.substring(1);
out.print(s); // Amsterdam
Für jeden Grundtyp gibt es in der Klasse String (2.6) eine Methode valueOf(...) zur Konvertierung nach String und umgekehrt im
Hüll-Klassentyp, der zum Grundtyp korrespondiert, eine Methode
parse...(String) oder eine andere Methode zur Konvertierung von
String, vgl. Typ-Konvertierung (2.1),
z.B. out.print(String.valueOf ( 2.7 )); // 2.7
out.print(Double.parseDouble("2.7")); // 2.7
In der Dokumentation der Klasse Formatter des Pakets java.util
wird der format_string der Methode
String format(String format_string,Object... args)
der Klasse String des Pakets java.lang syntaktisch genau beschrieben. Damit läßt sich sowohl textuelle Ausgabe, z.B. (3 Varianten)
System.out.print(String.format(">%6.3f<",Math.PI) );//> 3,142<
System.out. format(">%6.3f<",Math.PI) ;//> 3,142<
System.out.printf (">%6.3f<",Math.PI) ;//> 3,142<
als auch graphische Ausgabe formatieren, z.B.
g.drawString (String.format(">%6.3f<",Math.PI),x,y);//> 3,142<
Der Format-String ">%6.3f<" zur Formatierung des Arguments
Math.PI enthält den eigentlichen Format-Spezifizierer %6.3f sowie
vorangehend auszugebenden Text ">" und nachfolgend auszugebenden
Text "<". Das allgemeine Fluchtsymbol % zeigt den Anfang des Format-Spezifizierers an. Das spezielle Format-Konvertierungs-Fluchtsymbol f (floating point ohne Zehnerpotenz) zeigt das Ende des
Format-Spezifizieres an. Die minimale Gesamtbreite (width) der
Gleitpunktzahl einschließlich Dezimalseparator und führender Zwischenraumzeichen ist 6. Die Präzision (precision) der Gleitpunktzahl, d.h. die Breite nach dem Dezimalseparator, ist 3. Die letzte
Ziffer nach dem Dezimalseparator wurde auf 2 gerundet.
Der Dezimalseparator ist in dem voreingestellten Gebiet
Locale.GERMAN ein Komma ','. Der Dezimalseparator kann mit
Locale.US auf Punkt '.' umgestellt werden, z.B.
System.out.printf(Locale.US,">%6.3f<",Math.PI); //> 3.142<
Der Format-String kann mehrere Format-Spezifizierer aufweisen,
die sich auf die verschiedenen Argumente in der Argumentliste beziehen. Der Bezug wird jeweils hergestellt durch Setzen eines Argument-Index (argument_index) mit abschließendem Dollar '$' an den
Anfang des betreffenden Format-Spezifizieres, z.B.
import static java.lang.System.*;
import static java.lang.Math.*; ...
out.printf("PI=%1$5.2f E=%2$4.2f",PI,E); //PI=3,142 E=2,72
Wir geben eine Übersicht über die wichtigsten der in Formatter
dokumentierten Bestandteile von Format-Strings:
----------------------------
VVVVVVVVVVVVVVVVVV Format-String ( Übersicht) VVVVVVVVVVVVVVVVVV
VV ---------------------------- VV
VV conversion ist das Konvertierungssymbol, u.a.: VV
VV b,B bedeutet boolean VV
VV c,C bedeutet char VV
VV d bedeutet decimal integer VV
VV f bedeutet floating point ohne Zehnerexponent VV
VV s,S bedeutet String VV
VV td bedeutet time day ,2-stellig,ggf.führende Null VV
VV tm bedeutet time month,2-stellig,ggf.führende Null VV
VV ty bedeutet time year ,2-stellig,ggf.führende Null, VV
VV z.B. import java.util.*; VV
VV import static java.util.Calendar; ... VV
VV Calendar c=new GregorianCalendar(2006,APRIL,16); VV
VV System.out.printf("Ostern:%1$td.%1$tm.%1$ty",c); VV
VV //Ostern:16.04.06 VV
VV width ist die minimale Gesamtbreite einschließlich Dezi- VV
VV malseparator und führender Zwischenraumzeichen, eine VV
VV Dezimal-Ganzzahl >0 . VV
VV Da es sich um eine Minimal-Angabe handelt, könnte die VV
VV Ausgabe darüber hinausgehen, VV
VV VV
VV z.B. System.out.printf(">%1.3f<",Math.PI ); //>3,142< VV
VV VV
VV flag (width-Vorzeichen, + default) ist die Bündigkeit: VV
VV VV
VV + bedeutet "rechtsbündig" innerhalb width, VV
VV - bedeutet "linksbündig" innerhalb width. VV
VV Nötigenfalls wird links (+) oder rechts (-) mit VV
VV Zwischenraum (Space) aufgefüllt, VV
VV VV
VV z.B. System.out.printf(">%-6d<","links"); //>links < VV
VV VV
VV precision ist die Anzahl (Präzision) der Stellen nach dem VV
VV Dezimalseparator, eine Dezimal-Ganzzahl >= 0 . VV
VV Nötigenfalls wird rechts mit Nullen aufgefüllt oder VV
VV gerundet. Für precision=0 entfällt der Dezimalsepara- VV
VV tor, VV
VV z.B. System.out.printf(">%6.3f<",3.14 ); //> 3,140< VV
VV System.out.printf(">%6.3f<",Math.PI); //> 3,142< VV
VV System.out.printf(">%6.0f<",Math.PI); //> 3< VV
VV VV
VV argument_index ist der Index (die Position) des Arguments VV
VV in der Argumentliste, eine Dezimal-Ganzzahl >=1, VV
VV z.B. import static java.lang.System.out; VV
VV import static java.lang.Math.PI; ... VV
VV out.printf("PI=%1$5.2f E=%2$4.2f",PI,E); VV
VV // 1$ 1-tes 2$ 2-tes Argument in Liste VV
VV // PI=3,142 E=2,72 VV
VV VV
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
zu Frage abdeckbare Antwort
-----------------------------------------------------------------
2.1 Mit wieviel Bits wird int dargestellt? 32 (-Bit Maschine)
2.2 Ergänze die Definitionsschemata:
== false true != false true != false true
---------------- ---------------- ----------------
falsetrue false false ? ? falsefalse true
true false true true ? ? true true false
&& false true || false true || false true
---------------- ---------------- ----------------
falsefalse false false ? ? falsefalse true
true false true true ? ? true true true
2.3 Welche der folgenden sind korrekte
2.6 CharacterLiteral oder StringLiteral?
'' inkorrekt
"in "DM" Preis" inkorrekt
'"' CharacterLiteral
"dreifach\"Hoch\"" StringLiteral
2.4 Gibt es verschiedene IntegerLiteral ja
mit gleichem Wert? z.B. 17 und 0x11
2.5 Was wird ausgedruckt? beachte: für double
ist DIGITS=15 (2.1)
out.print(1e25+1e5-1e25); (1e25+1e5)-1e25=
1e25 -1e25=0.0
gedruckt wird 0.0
out.print(1e25-1e25+1e5); (1e25-1e25)+1e5=
0.0 +1e5=1e5
gedr. wird 100000.0
2.4 Welche der folgenden sind korrekte
2.5 Zahlbezeichnungen (Literale)?
10X10 inkorrekt
E10 inkorrekt
0X0 HexIntegerLiteral
10.10E10 FloatingPointLit.
Was wird ausgedruckt?
import static java.lang.System.out; ...
2.6 out.print("es gilt: " +"2+2"+" ist "+4); es gilt: 2+2 ist 4
out.print("es gilt: "+ 2+2 +" ist 2"+2); es gilt: 22 ist 22
2.5 out.print(Math.PI); 3.141592653589793
2.7 out.printf("%5.2f",Math.PI); 3.14 (vorn 1 space)
