Datenfelder, Parameterübergabe, Casting [OOP04]

Transcription

4 Datenfelder, Parameterübergabe, Casting
Objektorientierte Programmierung OOP
– 4.1 Datenfelder
Programmieren mit Java
–4.1.1 Erstellen von Arrays
–4.1.2 Zugriff auf Array-Elemente
–4.1.3 Dreiecksmatrizen
–4.1.4 Referenztyp String
–4.1.5 Kopieren von Datenfeldern
– 4.2 Parameterübergabe
– 4.3 Casting
–4.3.1 Automatische Typenkonvertierung
–4.3.2 Type-Cast-Operator
© Prof. Dr. Rolf Dornberger
OOP: 4 Datenfelder, Parameterübergabe, Casting
22.09.2010
2
4.1 Datenfelder
Datenfelder heißen auf Englisch Arrays. Arrays sind eine Ansammlung von Elementen
eines bestimmten Typs, die über einen Index oder mehrere Indizes adressiert werden.
Im klassischen Array sind die Indizes Integerzahlen.
4.1 Datenfelder
In Java sind Arrays Objekte. (Was Objekte sind und was das bedeutet, wird in einem
späteren Kapitel erläutert.) Der Typ der Elemente eines Arrays muss in Java immer
derselbe sein, kann aber wieder aus einem Array bestehen (verschachtelte Arrays).
– 4.1 Datenfelder
–4.1.1 Erstellen von Arrays
–4.1.2 Zugriff auf Array-Elemente
Ein Arrays benötigt so viele Indizes zur Adressierung seiner Elemente wie es
Dimensionen aufweist. Die Zählung der Elemente beginnt in Java bei 0.
–4.1.3 Dreiecksmatrizen
–4.1.4 Referenztyp String
Beispiel: Das zweidimensionale
Array Regal
– 4.3 Casting
–4.3.1 Automatische Typenkonvertierung
–4.3.2 Type-Cast-Operator
[0][2]
[0][1]
[0][0]
–4.1.5 Kopieren von Datenfeldern
22.09.2010
3
[1][0]
[2][0]
.....
[3][0]
.....
22.09.2010
4
4.1 Datenfelder
4.1.1 Erstellen von Arrays
Der Index (bzw. die Indizes) eines Arrays muss (müssen) in Java vom Typ int
sein und beginnt (beginnen) immer mit 0.
Zum Erstellen eines Arrays in Java müssen folgende drei Schritte durchgeführt
werden:
Auf die einzelnen Elemente eines Arrays wird mittels der eckigen Klammer [ ]
zugegriffen.
– Deklarieren einer Array-Variablen
– Initialisieren des Arrays (Erzeugen eines Array-Objektes mit Zuweisen an die ArrayVariable)
Beispiele:
– Datenfeld[0]
1. Element des Arrays Datenfeld[]
– Datenfeld[1]
– Datenfeld[10]
– Füllen des Arrays mit Werten
– ...
– Matrix[0][0]
Element der 1.Zeile und 1.Spalte des Arrays Matrix[][]
– Matrix[2][4]
Element der 3.Zeile und 5.Spalte des Arrays Matrix[][]
Für eine kürze Schreibweise im Java-Quelltext gilt:
– Die Schritte 1. und 2. können mittels einer einzigen Anweisung ausgeführt werden.
– Die Schritte 1. bis 3. können auch mittels einer einzigen Anweisung ausgeführt
werden.
22.09.2010
5
Deklarieren einer Array-Variablen
Initialisieren des Arrays
22.09.2010
– Zuerst muss eine Variable deklariert werden, über die auf das Array zugegriffen
wird. (Die Variable zeigt quasi auf das Array.)
– Ein Array-Objekt wird erzeugt und der Array-Variablen zugewiesen.
– Die Kennzeichnung der Variable als Array-Variable erfolgt mittels eckiger Klammern
[ ], z.B.:
double[ ] Datenfeld;
– Dies geschieht mittels des new-Operators, z.B.:
Datenfeld = new double[4];
oder
Matrix = new int[2][2];
– Ein zweidimensionales Array wird mit 2 aufeinander folgenden eckigen Klammern [ ]
[ ] ([Zeile][Spalte]) gekennzeichnet, ein dreidimensionales Array mit [ ][ ][ ], und so
fort. 2D-Beispiel:
int[ ][ ] Matrix;
– Die mittels des new-Operators entstehenden Arrays sind dabei mit folgenden
Default-Werten (vordefinierten Werten) initialisiert:
– Dabei wird der Variablen auch mitgeteilt, wie groß das Array ist.
22.09.2010
– false für Boolesche Arrays,
– \0 für Zeichen-Arrays,
– 0 für Ganzzahl-Arrays und
– In Anlehnung an C/C++ sind auch folgende Positionen für die eckigen Klammern
erlaubt (worauf aber im Folgenden nicht weiter eingegangen wird):
double Datenfeld[ ];
oder
int Matrix[ ][ ];
6
– 0.0 für Gleitzahl-Arrays
– Beispielsweise ist jeder Wert in Datenfeld[] gleich 0.0 oder in Matrix[][] gleich 0.
7
22.09.2010
8
Soll nun das Arrays bei seiner Initialisierung sogleich auch mit vorgegebene
Werten belegt werden, können die beiden vorherigen Schritte auch mit einer
anderen Form eines Aufrufs kombiniert werden:
Diese beiden Schritte können auch in einem einzigen Aufruf kombiniert
werden:
1. / 2. / 3. Deklarieren, Initialisieren und Füllen des Arrays mit
vorgegebenen Werten
– Dies geschieht mittels direkter literaler Adressierung, z.B.:
double[] Datenfeld = {5.4, 3.7, 4.4, 4.8};
oder
double[] Datenfeld = new double[] {5.4, 3.7, 4.4, 4.8};
1. / 2. Deklarieren und Initialisieren eines Arrays
– Dies geschieht ebenfalls mittels des new-Operators, z.B.:
double[] Datenfeld = new double[4];
oder
int[][] Matrix = new int[2][2];
– Das Array Datenfeld[] mit diesen 4 Elementen vom Typ double wird
dabei automatisch erzeugt.
– Die mittels des new-Operators entstehenden Arrays sind auch hier mit
folgenden Default-Werten initialisiert: false für Boolesche, \0 für Zeichen-,
0 für Ganzzahl- und 0.0 für Gleitzahl-Arrays.
22.09.2010
– Ein mehrdimensionales Array kann so ebenfalls mittels geschachtelter
Adressierung der Elemente erzeugt werden, z.B.:
int[][] Matrix = {{1, 2}, {3, 4}};
oder
int[][] Matrix = new int[][] {{1, 2}, {3, 4}};
9
public class Array1{
public static void main (String[] args) {
Das Programm Array1
zeigt das nachträgliche
Zuweisen von Werten zu
Elementen eines Arrays.
// Deklaration
double[] Datenfeld1;
int[][] Matrix1;
// Initialisierung
Datenfeld1 = new double[4];
Matrix1
= new int[2][2];
// Deklaration und Initialisierung in einem Schritt
double[] Datenfeld2 = new double[4];
int[][] Matrix2
= new int[2][2];
// alles auf einmal
double[] Datenfeld3 = {5.4, 3.7, 4.4, 4.8};
int[][] Matrix3
= {{1, 2}, {3, 4}};
// ODER: alles auf einmal
//double[] Datenfeld3 = new double[] {5.4, 3.7, 4.4, 4.8};
//int[][] Matrix3
= new int[][] {{1, 2}, {3, 4}};
// Werte zuweisen
Datenfeld2[1] = 888;
Matrix2[1][1] = 999;
10
// Deklaration
double[] Datenfeld1;
int[][] Matrix1;
// Initialisierung
Datenfeld1 = new double[4];
Matrix1
= new int[2][2];
// Deklaration und Initialisierung in einem Schritt
double[] Datenfeld2 = new double[4];
int[][] Matrix2
= new int[2][2];
Dies erfolgt durch die
direkte Adressierung der
Array-Elemente über ihre
Indizes, z.B.:
Matrix[1][1]=999;
}}
22.09.2010
// alles auf einmal
double[] Datenfeld3 = {5.4, 3.7, 4.4, 4.8};
int[][] Matrix3
= {{1, 2}, {3, 4}};
// ODER: alles auf einmal
//double[] Datenfeld3 = new double[] {5.4, 3.7, 4.4, 4.8};
//int[][] Matrix3
= new int[][] {{1, 2}, {3, 4}};
// Werte zuweisen
Datenfeld2[1] = 888;
Matrix2[1][1] = 999;
In die 2. Zeile und 2. Spalte
des Arrays Matrix wird
der Wert 999 eingetragen.
System.out.println("Datenfeld1[0]="+Datenfeld1[0]);
System.out.println("Matrix1[0][0]="+Matrix1[0][0]);
4.1.2 Zugriff auf Array-Elemente
Das Programm Array1
zeigt nochmals die
unterschiedlichen
Möglichkeiten, Arrays zu
deklarieren, zu
initialisieren und mit
Werten zu belegen.
}}
22.09.2010
11
22.09.2010
12
Das Programm Array2 zeigt eine
Variante, bei der die Länge eines
Arrays abgefragt wird.
4.1.3 Dreiecksmatrizen
Wird ein Array mit Zahlen gefüllt, spricht man von einer Matrix. Meist sind
Matrizen viereckig, wie a, oftmals sogar quadratisch (Anzahl an Zeilen und
Spalten gleich):
1 2345
// Initialisierung
double[] a = {5.4, 3.7, 4.4, 4.8};
int[][] b = {{1, 2}, {3, 4}, {5, 6}};
Dazu dient die Operation
.length, die auf die
entsprechende Array-Variable
angewendet wird:
System.out.println("Laenge von a = " + a.length);
System.out.println("a[0]
– Anzahl Zeilen:
b.length
=
=
=
=
"
"
"
"
+
+
+
+
a[0]);
a[1]);
a[2]);
a[3]);
System.out.println("\nZeilen von b = " + b.length);
System.out.println("Spalten von b = " + b[0].length);
System.out.println("b[0] = "+b[0][0]+" "+b[0][1]);
– Anzahl Spalten:
b[0].length
}
Bei mehrdimensionalen Arrays,
kann damit die Länge der
einzelnen Dimensionen des
Arrays abgefragt werden.
In beiden Fällen ist es egal, ob man die Anzahl an Spalten mit a[0].length
oder a[1].length usw. abfragt.
Anders sieht es bei Dreiecksmatrizen wie c oder bei solchen Matrizen wie b
aus, bei denen die Anzahl der Einträge pro Zeile (also die Anzahl an
Spalten) variiert:
1
c = 2
3
}



a = 6 7 8 9 0
3 4 5 3 2
22.09.2010
13
3
4



5
1 2 3


b = 2 3 4 5 
3 4 5 6 7
22.09.2010
14
4.1.3 Dreiecksmatrizen
In diesem Fall ist es ein Unterschied, ob man die Anzahl an Spalten mit b[0].length
oder b[1].length usw. abfragt, da die Zeilen eine verschiedene Anzahl an
Einträgen respektive Spalten haben.
Dies zeigt auch das Programm Dreiecksmatrix1:
int[][] b = {{1,2,3}, {2,3,4,5}, {3,4,5,6,7}};
System.out.println("b[0] = "+b[0][0]+" "+b[0][1]+" "+b[0][2]);
System.out.println("b[1] = "+b[1][0]+" "+b[1][1]+" "+b[1][2]+" "+b[1][3]);
System.out.println("b[2] = "+b[2][0]+" "+b[2][1]+" "+b[2][2]+" "+b[2][3]+" "+b[2][4]);
z = b.length;
s0 = b[0].length;
s1 = b[1].length;
s2 = b[2].length;
(In späteren Kapiteln wird die Klasse String und deren Methoden ausführlicher
behandelt.)
}
}
In Anlehnung an die Definition eines Datenfeldes (bzw. einer Klasse) mit dem
new-Operator wird entsprechend einer String-Variablen eine Zeichenkette
zugewiesen. Allerdings steht hier der Inhalt der Zeichenkette in
Anführungszeichen:
– String a = new String("Hello World");
Ebenso ist die Initialisierung einer String-Variablen über die literale Adressierung
möglich (Kurzform):
– String b = "Hello Switzerland";
System.out.println("Zeilen = " + z);
System.out.println("Eintraege (=Spalten) in Zeile 0 = " + s0);
Eine besondere Form eines Datenfeldes ist eine Zeichenkette, auch als String
bezeichnet.
Zeichenketten werden in Java über den Referenztyp String (über die Klasse
String) quasi als erweiterter Datentyp ähnlich einem Array mit Elementen vom
Typ char definiert.
public class Dreiecksmatrix1 {
int
int
int
int
4.1.4 Referenztyp String
22.09.2010
15
22.09.2010
16
Das Programm Array3 zeigt, wie die Länge einer Zeichenkette abgefragt wird.
Dazu dient die Operation (bzw. Methode) .length(), die auf die
entsprechende String-Variable angewendet wird, z.B.:
a.length()
oder
Mehrmals wurde schon gezeigt, dass mit dem Operator + zwei Strings
miteinander verbunden werden können. Allerdings muss man die OperatorenPriorität, wie in einem der letzten Kapitel angegeben, für die einzelnen
Operatoren beachten.
b.length()
(Warum für Strings .length() und für Arrays .length verwendet werden
muss, wird in einem späteren Kapitel erklärt.)
Das Beispiel String1 zeigt, dass + einerseits Verknüpfung zweier Strings,
andererseits Addition zweier Zahlen bedeuten kann.
public class String1 {
public static void main(String[] args) {
System.out.println("3 + 4 = " + 3 + 4);
System.out.println("3 + 4 = " + (3 + 4));
}
}
// Initialisierung
String a = new String("Hello World");
String b = "Hello Switzerland";
System.out.println(a);
System.out.println("Laenge = " + a.length());
Im ersten Fall lautet die Ausgabe 3 + 4 = 34 (ausschließlich Verknüpfung von
Strings).
System.out.println(b);
System.out.println("Laenge = " + b.length());
}
Im Zweiten Fall 3 + 4 = 7 (Addition von 3+4 und dann Verknüpfung von Strings).
}
22.09.2010
17
22.09.2010
18
4.1.5 Kopieren von Datenfeldern
Während die Werte von Variablen sehr einfach kopiert werden können
(variable2 = variable1), muss man beim Kopieren von Datenfeldern
unterscheiden, ob man die Referenz auf ein Datenfeld kopieren oder die
Inhalte eines Datenfeldes kopieren will.
Referenz auf Datenfeld kopieren
feld1[][]
Inhalte eines Datenfeldes kopieren
feld1[][]
feld2[][]
Referenz auf Datenfeld kopieren
feld1[][]
Inhalte eines Datenfeldes kopieren
feld1[][]
feld2[][]
feld2[][]
feld2[][]
22.09.2010
19
22.09.2010
20
Referenz kopieren heißt, dass nicht nur die Variable feld1 auf das gesamte
Datenfeld zeigt, sondern danach auch die Variable feld2 auf dasselbe gesamte
Datenfeld.
Datenfeld kopieren bzw. Inhalte eines Datenfeldes kopieren heißt, dass vom
gesamten Inhalt des Datenfeldes feld1 eine Kopie feld2 angelegt wird.
Wird ein Eintrag in einem Datenfeld geändert, ist er natürlich nur in der dazugehörigen
Variablen geändert, wie Programm Feldkopie2 verdeutlicht.
feld1[][]
Wird ein Eintrag in diesem Datenfeld geändert, ist er natürlich in beiden Variablen
geändert, wie Programm Feldkopie1 verdeutlicht.
public class Feldkopie1 {
feld2[][]
feld1[][]
int[] feld1 = {1,2,3};
int[] feld2 = new int[3];
int[] feld1 = {1,2,3};
feld2[][]
System.out.println("feld1 = ["+feld1[0]+" "+feld1[1]+" "+feld1[2]+"]");
int[] feld2 = feld1;
// Referenz wird kopiert.
// D.h. feld1 und feld2 zeigen auf denselben Speicherbereich.
// Inhalte
feld2[0] =
feld2[1] =
feld2[2] =
des Datenfelds werden kopiert.
feld1[0];
feld1[1];
feld1[2];
feld2[1] = 8;
feld2[1] = 8;
}
}
}
}
22.09.2010
21
22.09.2010
22
Eine elegantere Art, komplette Datenfelder bzw. komplette Inhalte von Datenfeldern zu kopieren,
ermöglicht die Methode .clone().
Der Ausdruck feld2 = (int[]) feld1.clone(); kopiert den gesamten Inhalt der Variable
feld1 auf ein Mal in die Variable feld2, wie Programm Feldkopie3 verdeutlicht.
Der Ausdruck (int[]) ist ein explizites Casting zu einem Array des Datentyps int. Es muss von
dem Datentyp sein, in dem auch die Felder definiert sind, also hier int[]. (Wird später noch
ausführlicher erklärt.)
feld1[][]
feld2[][]
int[] feld1 = {1,2,3};
int[] feld2 = new int[3];
Das Kopieren von Strings verhält sich dahingegen wieder so, wie bei normalen
Variablen.
D.h. es wird eine neue Variable angelegt (keine neue Referenz) und nur diese wird
geändert, wie Programm Feldkopie4 verdeutlicht.
(Die Methode .clone() kann hier nicht angewendet werden, da sie nur für Objekte,
die Referenzen verwenden, definiert ist und daher nicht für Zeichenketten.)
String feld1 = "Hallo Welt";
String feld2 = feld1;
// Inhalte des Datenfelds werden auf elegante Art kopiert.
feld2 = (int[]) feld1.clone();
System.out.println("feld1 = "+feld1);
feld2 = "Hallo Oma";
feld2[1] = 8;
}
}
}
}
22.09.2010
23
22.09.2010
24
4.2 Parameterübergabe
Beim Aufruf von Java-Programmen mittels
– 4.1 Datenfelder
java JavaProgramm
können auch Parameter an das Programm bei Programmaufruf
übergeben werden, z.B.:
– 4.3 Casting
java JavaProgramm Parameter1 Parameter2
Intern werden diese Parameter in dem Array args[] von String-Variablen
innerhalb der Befehlszeile
public static void main (String[] args)
abgelegt.
22.09.2010
25
22.09.2010
26
Betrachten Sie folgendes Programm:
Damit handelt es sich bei args um ein Array von String-Variablen, dessen
Länge erst beim Aufruf des Java-Programms festgelegt wird.
Auf die einzelnen Einträge (die einzelnen Strings) dieses Arrays wird mittels
args[] zugegriffen.
public class Parameterinput1 {
System.out.println(args[0]);
}
}
Werden nun beim Aufruf des Programms Parameter eingegeben,
java Parameterinput1 Parameter1 Parameter2
so werden diese in der angegebenen Reihenfolge in der Array-Variablen args[]
als String abgelegt:
– args[0] beinhaltet Parameter1
– args[1] beinhaltet Parameter2 usw.
Die Zeile System.out.println(args[0]) gibt nun den Parameter in args[0]
wieder aus.
Achtung: Wird auf mehr Parameter zugegriffen, als eingegeben wurden, erzeugt der
Java-Interpreter eine Fehlermeldung!
22.09.2010
27
22.09.2010
28
4.3 Casting
4.3 Casting
4.1 Datenfelder
Casting ist die Typenkonvertierung, die es erlaubt, den Wert einer Variablen von
einem bestimmten Typ einer anderen Variablen mit einem anderen Datentyp
zuzuweisen. Dies entspricht quasi dem Ändern eines Datentyps einer Variablen.
Nicht alle Konvertierungen von einem Typ in einen anderen sind aber zulässig.
Manche Typenkonvertierungen sind zulässig, führen aber zu einem Verlust an
Genauigkeit der Werte.
4.3 Casting
– 4.3.1 Automatische Typenkonvertierung
– 4.3.2 Type-Cast-Operator
Manche Konvertierungen werden vom Compiler automatisch vorgenommen,
ohne dass der Programmierer explizit etwas programmieren muss, z.B.:
– Bei einer Zuweisung, wenn Typ der Variablen und Typ des zugewiesenen
Ausdrucks nicht identisch sind.
– Bei der Auswertung eines arithmetischen Ausdrucks, wenn Operanden von
unterschiedlichem Datentyp sind.
– Wenn der Wertebereich über- oder unterschritten wird.
4.3.1 Automatische Typenkonvertierung
29
public class Casting1{
Variablen vom Typ byte haben
einen Wertebereich von –128 bis
127. Wird nun a+b=125+7 mit
byte-Variablen gerechnet, so wird
das Ergebnis automatisch in einen
grösseren Typ transformiert (in Java
ist das für Ganzzahlen immer int).
Zwei Variablen vom Typ int liefern
bei der Division (c/d) nur einen
Ganzzahlwert, selbst wenn das
Ergebnis einer float-Variablen (f)
zugewiesen wird.
22.09.2010
22.09.2010
30
4.3.2 Type-Cast-Operator
byte a = 125;
byte b = 7;
System.out.println("a+b = " + (a+b));
System.out.println("a+b = " + a + b);
In Java gibt es einen Type-Cast-Operator, mit dem explizite Typenumwandlungen
vorgenommen werden können.
int c = 7;
int d = 2;
float e, f, g;
Der Ausdruck (Datentyp)a wandelt bzw. konvertiert die Variable a in eine
Variable vom Typ Datentyp um.
f = c / d;
e = c;
g = e / d;
System.out.println("e =
System.out.println("c/d
System.out.println("f =
System.out.println("g =
"
=
"
"
+
"
+
+
e);
+ (c/d));
f);
g);
22.09.2010
31
}
}
Wird allerdings eine int-Variable
einer float-Variablen zu gewiesen
(e=c), wird der Ganzzahlwert
in
einen Gleitzahlwert konvertiert. Die
Typenumwandlungen mit dem Type-Cast-Operator sind für alle primitiven
Datentypen ausser boolean möglich.
Daraus ergeben sich folgende Type-Cast-Operatoren:
– (byte) a
konvertiert a in den Typ byte
– (short) a
konvertiert a in den Typ short
– (int) a
konvertiert a in den Typ int
– (long) a
konvertiert a in den Typ long
– (float) a
konvertiert a in den Typ float
– (double) a
konvertiert a in den Typ double
– (char) a
konvertiert a in den Typ char
22.09.2010
32
4.3 Casting
4.3.2 Type-Cast-Operator
public class Casting2{
byte a = 125;
byte b = 7;
byte z;
Da die byte-Variablen einen Wertebereich von 128 bis 127 haben, die Berechnung von
a+b=125+7 aber ein grösseres Ergebnis liefert,
ist dieses Ergebnis vom Typ int. Wird der Wert
dann mittels Casting wieder in eine byte-Variable
transformiert (z=(byte)(a+b)), läuft diese
Variable über ihren gültigen Wertebereich hinaus,
beginnt wieder bei –128 und erhält dann den
byte-Wert –124.
Zwei Variablen vom Typ int liefern bei der
Division (c/d) einen Ganzzahlwert. Wird jedoch
eine der int-Variablen vorher in eine floatVariable konvertiert, (float)c, wird auch eine
Gleitzahldivision durchgeführt.
ja)
z = (byte)(a+b);
System.out.println("a+b = " + (a+b));
System.out.println("a+b = " + z);
cast) Typ2 = (Casting-Typ) Typ1; (Casting-Operator notwendig)
Typ1
byte
short
int
long
float
double
boolean
char
Typ2
f = (float)c / d;
System.out.println("f = " + f);
byte
ja
cast
cast
cast
cast
cast
nein
cast
short
ja
ja
cast
cast
cast
cast
nein
cast
int
ja
ja
ja
cast
cast
cast
nein
ja
long
ja
ja
ja
ja
cast
cast
nein
ja
float
ja
ja
ja
ja
ja
cast
nein
ja
double
ja
ja
ja
ja
ja
ja
nein
ja
boolean
nein
nein
nein
nein
nein
nein
ja
nein
char
cast
cast
cast
cast
cast
cast
nein
ja
System.out.println((char) 65);
}
}
22.09.2010
33
Lernziele
Wissen, wie man in Java Datenfelder anlegt und auf die einzelnen Einträge in den
Datenfeldern zugreift.
Arrays mit den primitiven Variablen und Strings anlegen und kopieren können.
Den Unterschied zwischen Referenz kopieren und Daten kopieren verstanden
haben.
Matrizen (normale, Dreiecksmatrizen, unterschiedliche Spaltenzahl) anlegen
können und auf Zeilen und Spalten zugreifen können.
Parameterübergabe anwenden können.
Das Prinzip des Casting (explizit und automatisch) verstanden haben und richtig
einsetzen können.
(automatische Typenkonvertierung)
Typ2 = Typ1;
nein) Casting von Typ1 in Typ2 nicht möglich
int c = 7;
int d = 2;
float f;
Der Wert 65 wird in das Zeichen 'A'
umgewandelt. diese Umwandlung geht darauf
zurück, dass der Unicode von 'A' der
Integerwert 65 ist. D.h. (char) 65 ergibt 'A',
also A auf dem Bildschirm ohne
Anführungszeichen.
Die Tabelle zeigt, welche Typenkonvertierungen von Typ1 in Typ2 in Java
möglich sind:
22.09.2010
35
22.09.2010
34

Datenfelder, Parameterübergabe, Casting [OOP04]

Transcription

Similar documents

2. Klausur im Wintersemester

Folie 1 - Weblearn

Migrationspfade für OWB-Projekte

Übungsblatt 4 – Musterlösung

single vs - Weblearn

single vs. dual core - Weblearn

4.4.3 Givens

Aufgabenblatt 4 - Fachbereich Wirtschaftswissenschaften

4.6 Berechnung von Eigenwerten