Wie ist der Output des folgenden Codes?
ArrayList Mitarbeiter = new ArrayList();
Mitarbeiter.add(5);
Integer mitarbeiter= Mitarbeiter.get(0);
System.out.println(mitarbeiter);
| Antwort/ answer | |
|---|---|
Sep 20
Aug 20
Wie ist der Output des folgenden Codes?
Number[]a = new Integer[3];
System.out.println(a[2]);
| Antwort/ answer | |
|---|---|
Aug 20
Was ist der Output des folgenden Codes?
Boolean a = new Boolean(“TRUE”);
Boolean b = new Boolean(“FAlse”);
Boolean c = new Boolean(“PersNr”);
System.out.println(a+” “+b+” “+c);
| Antwort/ answer | |
|---|---|
Nov 10
die Methode get() möchte ich aufgrund der Fehlerproblematik zur Laufzeit nochmal genauer erklären:
der Rückgabwert von get() ist bei non-generics eine Referenz von java.lang.Objekt, ansonsten eine Referenz vom jeweils bestimmten Objekt-Typ.
Dies bedeutet, dass bei non-generics eine Umwandlung in einen primitiven Wert nicht statt finden kann, da unboxing sich nur auf einen Wrapper (bzw dessen Klassenreferenz ) bezieht. Ein Cast kann hier Abhilfe schaffen:
List <Integer> a= new ArrayList<Integer>(); // generic
a.add(3);
int b = a.get(0); // problemlose Zuweisung des int-Wertes durch Wrapper
List c = new ArrayList (); // non-generic
c.add(3);
int d = (Integer)c.get(0); // Zuweisung nur durch expliziten Cast möglich, da Referenz von java.lang.Object zurückgegeben wurde.
Sep 18
Was ist der Output folgenden Codes:
class Angestellter{
public static void getValue(Long a) {
System.out.print(“LONG “);
}
public static void main (String … args){
int i = 1;
getValue(i);
}
}
| Antwort/ answer | |
|---|---|
Jun 30
Wie ist der Output des folgenden Codes:
public class Angestellter {
static void PrintPersNr(int … PersNr){
for (int i:PersNr)
System.out.println(i);
}
public static void main(String args[]) {
Integer PersNr [] = {1,2,3,4};
PrintPersNr(PersNr);
}
}
| Antwort/ answer | |
|---|---|
Mai 09
Eine der frühreren Nachteile von Wrappern war, dass für die üblichen Operationen bei primitiven Datentypen immer wieder das Objekt in einen primitiven Datentyp zurückgewandelt und nach der Operation wieder in eine Referenzvariable umgewandelt werden musste:
Integer a = new Integer(10); // Wrappen eines primitiven Datentyps in eine Referenzvariable
int b = a.intValue(); // Un-wrappen der Referenzvariable in einen primitiven Datentyp
b++; // Ausführung der Operation auf den primitiven Datentyp
a=new Integer(b); // Re-Wrappen des primitiven Datentyps in eine Referenzvariable
Mit Java5 wird die Sache erheblich vereinfacht:
Integer a = new Integer(10);
a++;
Die Operation kann also direkt auf der Referenzvariable durchgeführt werden, das Un- und Re-Wrappen passiert im Hintergrund von alleine.
Mai 07
Da ja ein SBabCJP nicht so wirklich einfach ist, wird gerne auf die verwirrenden Unterschiede und besonders auf die (Nicht-)Möglichkeiten der einzelnen Funktionen eingegangen. Um hier noch etwas mehr Licht in die Dunkelheit zu bringen habe ich hier eine Tabelle zur besseren Übersicht:
| Boolean | Byte | Character | Double | Float | Integer | Long | Short | |
| XxxValue() | x | x | x | x | x | x | ||
| parseXxx() | x | x | x | x | x | x | ||
| parseXxx() – mit Basiswert, z.B. 16 für hex |
x | x | x | x | ||||
| ValueOf() | x | x | x | x | x | x | x | |
| ValueOf() – mit Basiswert, z.B. 16 für hex |
x | x | x | x | ||||
| toString() | x | x | x | x | x | x | x | x |
| toString(primitiver Datentyp) |
x | x | x | x | x | x | x | x |
| toString(primitiver Datentyp, Basiswert ) |
x | x | ||||||
| toXxxString() | x | x |
Mai 05
Es gibt noch 4 weitere Varianten für die Darstellung einer beliebigen Basis:
- binär
- hexadezimal
- oktal
- String
Diese sind statische Methoden der Klassen Integer und Long. Es wird also ein int oder long-Wert genommen und als String ausgegeben. Die Ausgabe/Übergabe erfolgt nicht int Byte.
Eine Ausführung dieser Methode sähe z.B. so aus:
String a = Integer.toBinaryString(20); // a=10100
String b = Integer.toHexString(20); // b=14
String c = Integer.toOctalString(20); // c=24
String d = Integer.toString(20,2) // d=10100; 2 als Hinweis auf Binärumrechnung
Mai 03
Aus einer Wrapper-Klasse heraus kann man auch in einen String (zurück-)wandeln.
Dies geschieht mit der toString() – Methode.
Hier ein paar Beispiele:
String a = Double.toString(1.23);
Integer b = new Integer(1);
String c = Integer.toString(b);
Es funktionieren aber auch komplizierte Umwandlungen, wie z.B. die Umwandlung von Long in Binär und von Binär zu String
String d = Long.toString(15,2); // d bekommt den Binärwert von 15 zugewiesen: 1111
