Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo, erstmal ich habe hier eine Aufgabe in der ich auf Hüllklassen verzichten soll. Wenn ich es richtig verstanden habe sind in meinem code:
Java:
double a = Math.random();
Random ran = new Random();
int e = ran.nextInt(100);
double x = a * Math.pow(10,e);
System.out.println(x);
if (Double.isInfinite(x)) {
System.out.println(1 / x + " ist nicht endlich!");
}else {
System.out.println(1 / x + " ist endlich!");
}
double d = Double.MIN_VALUE;
Hüllklassen vorhanden, oder (z.B double d = Double.MIN_VALUE) ? Wie umgehe ich diese?
Gruß
Das Bild mit der Aufgabe widerspricht auch der Aussage, auf "Hüllklassen" zu verzichten. Es wird ja teilweise explizit diese gefordert:
"Ein Double-Objekt d" soll da verwendet werden um dann den Inhalt dieses Objektes auszugeben.
Hehe, ich muss das unbedingt mal anders aufschreiben damit ich nur noch dagegen linken muss in den Themen...
Also es gibt zwei unterschiedliche Typen von "Werten" in Java, naemlich Primitive und Klassen. Vier der wichtigsten Unterschiede sind:
1. Primitive sind unveraenderbar und sind keine Klassen (haben keine Methoden und so weiter).
2. Primitive werden immer als Wert uebergeben, nicht als Instanz. Primitive koennen nie null sein.
3. Primitive und Klassen sind nicht austauschbar (sie wirken nur so durch den Compiler).
4. Operatoren koennen nur mit Primitiven verwendet werden (auszer halt + in Kombination mit Strings).
Primitive sind immer die kleingeschriebenen Typen, wie int oder char. Dazu gibt es dann die Klassen-Varianten wie Integer und Character.
Java:
// Primitiver Type
int wert = 5;
// Klasse
Integer wert = new Integer(5);
Da Java auf Klassen basiert, und fortgesetzt damit auf Object, ist die Konvertierung an vielen Stellen notwendig weil Methoden einfach keine primitiven Typen uebernehmen koennen ohne diese explizit zu deklarieren. In Reflection ist dies zum Beispiel der Fall. Spielt jetzt gerade aber keine Rolle.
Ich habe gesagt dass diese nicht austauschbar sind, wieso kompiliert dann folgender Code und funktioniert?
Java:
int wert = new Integer(5);
Integer wert = 5;
Die Antwort ist: Autoboxing. In dem Fall handelt es sich um "Hilfsfunktion" des Compilers welcher die Konvertierung automatisch vornimmt. Also der Code von oben wird in Wahrheit zu folgendem kompiliert:
Java:
int wert = new Integer(5).intValue();
Integer wert = Integer.valueOf(5);
Ohne das wir etwas dazu machen muessen. Die Umwandlung von Primitiv in Klasse und zurueck (Boxing) uebernimmt fuer uns der Compiler (Autoboxing).
Aber, solche Umwandlung haben immer das Potenzial eine Klasseninstanz zu erzeugen, nehmen wir zum Beispiel folgenden Code:
Java:
int result = 0;
for (int counter = 0; counter < 500; counter++) {
result = result + counter;
}
Diese Schleife addiert ganz simpel 500 ints. Das gleiche nochmal aber mit Klassen:
Java:
Integer result = 0;
for (int counter = 0; counter < 500; counter++) {
result = result + counter;
}
Das erzeugt zusaetzlich 501 Instanzen der Klasse Integer, was wir so nicht bemerken weil der Compiler die Umwandlung uebernimmt:
Java:
Integer result = Integer.valueOf(0);
for (int counter = 0; counter < 500; counter++) {
result = Integer.valueOf(result.intValue() + counter);
}
Wir haben in der zweiten Variante also viel mehr Klassenabfall erzeugt als mit den primitiven Typen. Das ist etwas auf das man immer achten sollte.
In alten Java Versionen war es sogar schlimmer, valueOf verwendet einen Cache von Instanzen, also es gibt die Möglichkeit dass keine neue Instanz erzeugt wird wenn diese bereits im Cache existiert. Das ist aber ein Implementierungsdetail auf welches man sich nicht verlassen sollte. In alten Java Versionen wurde vom Compiler immer eine Instanz erzeugt:
Java:
Integer result = new Integer(0);
for (int counter = 0; counter < 500; counter++) {
result = new Integer(result.intValue() + counter);
}
Aber das wurde korrigiert irgendwo vor 1.5, glaube ich.
Ich persoehnlich mache immer gerne die Umwandlung haendisch (man kann in den IDEs eine Warnung dafuer einschalten), einfach damit ich nie den Ueberblick verliere wo Instanzen und Objekte erzeugt und verwendet werden und wo nicht.
Hehe, ich muss das unbedingt mal anders aufschreiben damit ich nur noch dagegen linken muss in den Themen...
Also es gibt zwei unterschiedliche Typen von "Werten" in Java, naemlich Primitive und Klassen. Vier der wichtigsten Unterschiede sind:
1. Primitive sind unveraenderbar und sind keine Klassen (haben keine Methoden und so weiter).
2. Primitive werden immer als Wert uebergeben, nicht als Instanz. Primitive koennen nie null sein.
3. Primitive und Klassen sind nicht austauschbar (sie wirken nur so durch den Compiler).
4. Operatoren koennen nur mit Primitiven verwendet werden (auszer halt + in Kombination mit Strings).
Primitive sind immer die kleingeschriebenen Typen, wie int oder char. Dazu gibt es dann die Klassen-Varianten wie Integer und Character.
Java:
// Primitiver Type
int wert = 5;
// Klasse
Integer wert = new Integer(5);
Da Java auf Klassen basiert, und fortgesetzt damit auf Object, ist die Konvertierung an vielen Stellen notwendig weil Methoden einfach keine primitiven Typen uebernehmen koennen ohne diese explizit zu deklarieren. In Reflection ist dies zum Beispiel der Fall. Spielt jetzt gerade aber keine Rolle.
Ich habe gesagt dass diese nicht austauschbar sind, wieso kompiliert dann folgender Code und funktioniert?
Java:
int wert = new Integer(5);
Integer wert = 5;
Die Antwort ist: Autoboxing. In dem Fall handelt es sich um "Hilfsfunktion" des Compilers welcher die Konvertierung automatisch vornimmt. Also der Code von oben wird in Wahrheit zu folgendem kompiliert:
Java:
int wert = new Integer(5).intValue();
Integer wert = Integer.valueOf(5);
Ohne das wir etwas dazu machen muessen. Die Umwandlung von Primitiv in Klasse und zurueck (Boxing) uebernimmt fuer uns der Compiler (Autoboxing).
Aber, solche Umwandlung haben immer das Potenzial eine Klasseninstanz zu erzeugen, nehmen wir zum Beispiel folgenden Code:
Java:
int result = 0;
for (int counter = 0; counter < 500; counter++) {
result = result + counter;
}
Diese Schleife addiert ganz simpel 500 ints. Das gleiche nochmal aber mit Klassen:
Java:
Integer result = 0;
for (int counter = 0; counter < 500; counter++) {
result = result + counter;
}
Das erzeugt zusaetzlich 501 Instanzen der Klasse Integer, was wir so nicht bemerken weil der Compiler die Umwandlung uebernimmt:
Java:
Integer result = Integer.valueOf(0);
for (int counter = 0; counter < 500; counter++) {
result = Integer.valueOf(result.intValue() + counter);
}
Wir haben in der zweiten Variante also viel mehr Klassenabfall erzeugt als mit den primitiven Typen. Das ist etwas auf das man immer achten sollte.
In alten Java Versionen war es sogar schlimmer, valueOf verwendet einen Cache von Instanzen, also es gibt die Möglichkeit dass keine neue Instanz erzeugt wird wenn diese bereits im Cache existiert. Das ist aber ein Implementierungsdetail auf welches man sich nicht verlassen sollte. In alten Java Versionen wurde vom Compiler immer eine Instanz erzeugt:
Java:
Integer result = new Integer(0);
for (int counter = 0; counter < 500; counter++) {
result = new Integer(result.intValue() + counter);
}
Aber das wurde korrigiert irgendwo vor 1.5, glaube ich.
Ich persoehnlich mache immer gerne die Umwandlung haendisch (man kann in den IDEs eine Warnung dafuer einschalten), einfach damit ich nie den Ueberblick verliere wo Instanzen und Objekte erzeugt und verwendet werden und wo nicht.
Das und das Bild...ich finde es immer schade wenn dass der beste Weg ist Text zu speichern oder zu verteilen, naemlich als Bild...aber das Thema hatten wir schon andernorts hier im Forum zur Genuege.
