# primitives Objekt mit Primitiv addieren



## sousou (4. Feb 2010)

Hallo zusammen,

Ich hatte folgende Aufgabe:

1. Legen Sie zu dem int-Wert -1 ein entsprechendes Integer-Objekt an.
2. Wie kann man zwei Integer-Objekte addieren?
3. Wie kann man ein Integer-Objekt und einen int-Wert addieren?
4. Wie kann man ein Integer-Objekt und einen double-Wert addieren?


Die Frage die Ich mir gerade stelle ist, wenn man eine addition vornimmt müssen ja soweit ich bis heute weiß die Typen die man addiert den selben Typ haben. Ist dies nicht der Fall so muss man den typ casten sodass beide Typen gleich sind. Bei Nummer 4 tu ich jedoch ein Double Wert mit einen Objekt aus einer Integer Wrapper Klasse addieren und der Compiler gibt keine Fehlermeldung aus...

Ich habs ganz intuitiv versucht, hab ich dabei kein so gutes Gewissen weil ich nicht weiß warums geht... Hoffe jemand kann mir helfen


Diese habe ich so gelöst:



```
class Aufgabe1Am22Monat9{
   
   // Nr.1
      int i = -1;
   
      Integer a = new Integer(i);
   
   // Nr.2
   
      Integer b = new Integer(2);
      Integer c = new Integer(3);
   
       int summeInteger(){
      
      
         int ergebnis = 0;
      
         ergebnis = b + c;
         return ergebnis;
      
      
      }
   
   // Nr.3
   
      Integer d = new Integer (5);
      int e = 5;
   
       int summeIntegerObjektundInteger(){
      
         int ergebnis = d + e;
         return ergebnis;
      
      }
   
   
   // Nr.4
      Integer f = new Integer (5);
      double g = 5.45;
   
   
       double summeIntegerObjektundDouble(){
      
         double ergebnis = 0;
         ergebnis = f + g;
      
         return ergebnis;
      
      }
   
   
   }
```


----------



## xerberuz (4. Feb 2010)

Das Stichwort heißt autoboxing. Die Wrapper Klassen werden in primitive Typen umgewandelt wenn man Rechenoperationen verwendet.

Autoboxing

Also aus int + Double wird int + double


```
public static void main(final String[] args)
	{
		// 1
		final Integer i = Integer.valueOf(1);

		// 2
		final Integer j = Integer.valueOf(2);

		System.out.println(i + j); // 1+2 = 3

		// 3
		final int k = 3;
		System.out.println(i + k); // 1+3 = 4

		// 4
		final double d = 1.5;
		System.out.println(i + d); // 1+1.5 = 2.5

	}
```


----------



## Ziegenpeter (4. Feb 2010)

Ok, ich hoffe ich hab' deine Frage richtig verstanden und dir geht es eigentlich nur um Nr. 4

Dann mal hier ein Erklärungsversuch:
In Java gibt es das sogenannte Boxing und Unboxing, das bedeutet wenn ich z.b. zwei Integer addieren möchte passiert intern folgendes:
Die int-Werte hinter den Objekten wird "ausgelesen", dies ist das Unboxing.
Diese werden dann addiert, wie du das kennst.
Dann wird das Zwischenergebnis wieder in ein Integer-Objekt verwandelt, dies ist das Boxing.

Wie du siehst lässt sich die Addition solcher Klassen auf die primitiven Datentypen zurückführen.Möchtest du jetzt zwei primitive Typen addieren, die nicht den gleichen Typ haben sucht Java den kleinstmöglichen Typ, der eine solche Addition erlaubt ohne Informationen zu verlieren. Dadurch wird ein int in ein double gecastet (alles intern, ohne deinen Einfluss). Den double-Wert können wir nicht z.B. in int casten, da wir sonst Informationen verlieren würden. Wenn gewünscht kann ich dir mal eine Auflistung der Typen als eine Art Baum aufmalen.


----------



## sousou (4. Feb 2010)

danke euch beiden,

ich glaub ist nicht nötig das du das extra noch malst. Also bei Autoboxing werden die Wrapperklassen bei der Rechenoperation zum primitiven Typ und dadurch ist eine Addition möglich...

Sprich:


Integer b = new Integer(5); ->> das ist die Wrapper Klasse

int i = 5;

int ergebnis = b + i; // und hier wird also Wrapperklasse zum primitiven Typ geboxt

Sprich:  b ist nun ein int und i war und ist ein primitiver Typ.


----------



## Ziegenpeter (4. Feb 2010)

> int ergebnis = b + i; // und hier wird also Wrapperklasse zum primitiven Typ geboxt



Boxing ist wenn ein primitiver Typ zum Objekt gemacht wird. Der Effekt hier ist das Unboxing.



> Sprich:  b ist nun ein int und i war und ist ein primitiver Typ.



b ist *KEIN* int!! b ist immer noch Integer-Objekt. Lediglich ergebnis ist ein int, nämlich das geunboxete (klingt strange, mir fällt aber grad kein gutes deutsches Wort ein) b + i.

Kleiner Nachtrag: Dadurch dass b immer noch ein Integer-Objekt ist, ist es Laufzeittechnisch auch keine gute Idee ein Integer-Objekt zu verwenden wenn man nur die primitiven Typen braucht. Es wird nämlich immer wieder wenn du das Objekt als primitiven Typ verwenden willst das Unboxing betrieben.
Ich gebe zu, dass ist in so einem einfachen Beispiel kein Problem aber wenn du äußerst viele Integer-Objekte hast, die du so verwendest wird es sich Laufzeittechnisch bemerkbar machen.


----------



## eRaaaa (4. Feb 2010)

sousou hat gesagt.:


> Sprich:  b ist nun ein int und i war und ist ein primitiver Typ.



Nein, b ist weiterhin ein Integer worauf einfach nur die Methode intValue() aufgerufen wird...Daher solltest du auch aufpassen dass das Integer-Objekt auch nicht null ist....


----------



## sousou (4. Feb 2010)

hmmm,... also ich hab mich an der Antwort von xerberuz festgehalten gehabt. 

Das Stichwort heißt autoboxing. Die Wrapper Klassen werden in primitive Typen umgewandelt wenn man Rechenoperationen verwendet.

Autoboxing

Also aus int + Double wird int + double



Da wird ja aus dem Double(Objekt) ein -> primitiver Typ

Hier wird aus ein Objekt ein primitiver Typ erstellt und das soll sich Autoboxing nennen.

Andere Aussage eben war Boxing ist wenn aus ein einen primitiver Typ zum objekt gemacht wird


Das Ergebnis von ein Objekt und einen primitiven Typ ist ein Wert von einen primitiver Typ

So stimmts aber?...


----------



## Ziegenpeter (4. Feb 2010)

> Das Ergebnis von ein Objekt und einen primitiven Typ ist ein Wert von einen primitiver Typ



Ja. (Jedenfalls wenn die Casts möglich sind)

Um die Verwirrung über Autoboxing, Boxing und Unboxing mal etwas zu nehmen:
Autoboxing bezeichnet schlicht und ergreifend das von Java automatisch übernommene Boxing und Unboxing. Was Boxing und Unboxing ist, hab' ich in meinem ersten Beitrag beschrieben.


----------



## sousou (4. Feb 2010)

ja aber der Beitrag von xerberuz wiederspricht find ich total den Beitrag von allen anderen.

Da wird ja gesagt :

Das Stichwort heißt autoboxing. Die Wrapper Klassen werden in primitive Typen umgewandelt wenn man Rechenoperationen verwendet.

Autoboxing

Also aus int + Double wird int + double



Und du sagst das man kein Objekt in ein Primitiven Typ umwandeln kann


----------



## sousou (4. Feb 2010)

bin jetzt noch mehr verwirrt als vor ne stunde


Autoboxing: Objekt wird zum Primitiven Typ umgewandelt.
-> Also werden Wrapper klassen in primitve Typen umgewnadelt.


Boxing: Primitve Typen werden in OObjekte umgewandelt
-> int b;

Integer a = new Integer (b);


----------



## Ziegenpeter (4. Feb 2010)

Ich würd' gern wissen woraus du das liest?

Was ich sage ist, dass b (um bei deinem Beispiel zu bleiben) kein int wird sondern immer noch ein Integer-Objekt bleibt. Hierbei meine ich ausschließlich die Variable b. Schreibst du nun:

```
Integer b = new Integer(5);
System.out.println(b + 1.5)
```
passiert im intern folgendes:

```
Integer b = new Integer(5);
System.out.println((double)b.valueOf() + 1.5)
```

die valueOf()-Methode liefert dir den gekapselten (geboxten) int-Wert. Danach wird jener Wert in ein double gecastet und die Addition ausgeführt. An der Variablen b ändert sich allerdings genau *NICHTS*.

Edit:
Zum Thema Boxing nochmal:
Ich schrieb doch oben, dass Autoboxing lediglich das *automatische* Boxing und Unboxing beschreibt.

Edit2: 
Hier mal ein Satz aus einem Wiki über Autoboxing:


> Mit der Version 5 von Java haben die Entwickler ein neues, langersehntes Feature bekommen - das Autoboxing. Das bedeutet, dass primitive Datentypen und Wrapper-Objekte bei Bedarf automatisch ineinander umgewandelt werden.


Dies ist im Grunde das was ich sagte.

Ich muss allerdings zugeben, dass das in dem Link etwas anderst steht.


----------



## eRaaaa (4. Feb 2010)

Ziegenpeter hat gesagt.:


> passiert im intern folgendes:
> 
> ```
> Integer b = new Integer(5);
> ...



hö? meinst du nicht eher b.doubleValue() ? 

Noch ein kleiner Zusatz: Wrapper sind alle immutable!
D.h.

```
Integer b = new Integer(5);
    	b = 6; // b referenziert nun ein ganz anderes Objekt als vorher !
```


----------



## sousou (4. Feb 2010)

naja lasst mal. Mir reicht wenn ich weis das autoboxing bedeutet aus einen wrapper Klasse einen primitiven zu machen und boxing aus einen primitiven einen objekt.


----------



## Ziegenpeter (4. Feb 2010)

eRaaaa hat gesagt.:


> hö? meinst du nicht eher b.doubleValue() ?


Das könnte natürlich sein. Ich weiß nicht wie Java das intern regelt, ich wollte es nur straightforward darstellen. 


> Noch ein kleiner Zusatz: Wrapper sind alle immutable!
> D.h.
> 
> ```
> ...


Das ist richtig, wir sollten nur den armen Kerl nicht noch mehr verwirren als bis jetzt schon geschehen


----------

