# Upcast / downcast



## sousou (6. Feb 2010)

Hallo zusammen,



Zu folgender Zeichnung Directupload.net - Dkn6lpyyv.jpg hab ich folgenden CODE.
Dabei geht es um UPCAST und DOWNCAST oder? Upcast ist Generalisierung und Downcast ist die Spezialisierung. 


Bei der Methode MessungY also der dritten geposteten Methode steht:
     double x = super.wert; // greif ich nicht hiermit auf den Wert des Attribut der Oberklasse auf?
     // ist das down cast?

Handelt es sich hierbei um downcast? Da man der Variablen x den Wert der Oberklasse zuweise ?





```
class Messung extends Object {
   
      double wert = 3.1415;
   
       Messung(double wert){
         super();
         this.wert = wert;
      }
   
   // lesen von wert
       double getWert() {
         return wert;
      }
   
   // setzen von wert
       void setWert(double wert) {
         this.wert = wert;
      }
   
       boolean istGleich(Messung ander) {
         if( wert == ander.getWert() )  {
            return true;
         } 
         else {
            return false;
         }
      }
   
   
   }

 /*
	Klasse ändern?
	- Klasse ist stabil => besser nicht
	- Klasse ist im Einsatz => besser nicht
	- Klasse gehört mir nicht => geht gar nicht
	
	Lösung: Spezialisierung, Vererbung
	*/
```



```
class MessungX extends Messung {
   
      String ort;
   
       MessungX(double wert, String ort) {
         super(wert);
         this.ort = ort;
      }
   }
   
/*	Jeder Konstruktor ruft in der ersten Zeile
	einen Konstruktor der Oberklasse auf
	= Initialisierung der Oberklasse
	
	Wenn nicht, dann fügt der Compiler den
	Aufruf super()  ein.
	*/
```



```
/* Überdecken von Attributen */
    class MessungY extends Messung {
      String wert = "Köln";
      
   	// wert-Attribut der Oberklasse
   	// super wechselt auf den Typ der Oberklasse
      double x = super.wert; // greif ich nicht hiermit auf den Wert des Attribut der Oberklasse auf?
     // ist das down cast?
	  
   }
   
/*	bei Zugriff auf Attribute gilt der
	aktuelle Typ */
```


Danke...


----------



## nrg (6. Feb 2010)

Upcast und Downcast sind die englischen Begriffe für implizite und explizite casts.

Upcast/impliziter Cast: wird von der VM automatisch durchgeführt. "Guter Stil" ist aber es trotzmit mitzucasten, weil man dadurch deutlich mach, was passiert.
Downcast/expliziter Cast: muss *immer* manuell gemacht werden

Ich werde erstmal ein Beispiel bei primitiven Datentypen nehmen: 

short ist ja bekanntlich kleiner als ein int. Wenn man jetzt einen short in einen int packt, hat dies keine Konsequenzen auf den Inhalt, weil ein short in *jeden fall* in einen int "passt": 

```
short s = Short.MAX_VALUE;
    	int i;
    	i = s;
    	System.out.println(i);
    	System.out.println(Short.MAX_VALUE);
```
Ausgabe:

```
32767
32767
```

andersrum kann es allerdings sein, dass der int nicht in den short passt und somit ein Teil "abgeschnitten" wird. Das muss man der VM *explizit* klarmachen:
[Java]
    	int i = Integer.MAX_VALUE;
    	short s;
    	s = (short)i;  // DAS IST DER CAST !!
    	System.out.println(s);
    	System.out.println(Integer.MAX_VALUE);
[/code]
Ausgabe:

```
-1
2147483647
```

Nicht anders ist es bei Objekten. Die muss man auch casten. Dabei bezeichnet man eben einen Upcast, einen cast in eine Klassenhierarchisch übergeordnete Klasse, einen Downcast, einen cast in eine untergeordnete. 

Les das hier mal durch: Java Upcasting, downcasting - CodeCall Programming Forum


> First, you must understand, that by casting you are not actually changing the object itself, you are just labeling it differently.
> For example, if you create a Cat and upcast it to Animal, then the object doesn't stop from being a Cat. It's still a Cat, but it's just treated as any other Animal and it's Cat properties are hidden until it's downcasted to a Cat again.



edit: ein cast bei Objekten sieht genauso aus, wie ein cast bei pimitiven Datentypen:

```
public class Tester {
    public static void main(String[] args)  {
    	//Upcasting!!!!
    	TestKlasse test = new TestKlasse();
    	Object o = test;
    	
    	//Downcasting!!!!
    	Object o2 = new Object();
    	TestKlasse test2 = (TestKlasse)o2;
    }
}
class TestKlasse extends Object {}
```


----------



## sousou (6. Feb 2010)

endlich mal verstanden... super erklärt! Danke...


übrigens eine Anmerkung:

Das casten ist ja dann nur bei Downcasting notwendig da man da ja unterklasse = Oberklasse zuordnet und dabei die Oberklasse runtercastet.


Jedoch bei Upcast könnte man da auch die Oberklasse runterkasten, wenn dies auch nicht notwendig ist?

        short s = Short.MAX_VALUE;
        int i;
        i(short) = s;


lg


----------



## nrg (6. Feb 2010)

nrg hat gesagt.:


> Upcast/impliziter Cast: wird von der VM automatisch durchgeführt. "Guter Stil" ist aber es trotzmit mitzucasten, weil man dadurch deutlich mach, was passiert.





			
				sousou hat gesagt.:
			
		

> Jedoch bei Upcast könnte man da auch die Oberklasse runterkasten, wenn dies auch nicht notwendig ist?



Erstmal nur als Anmerkung, redest du hier von Klassen und in deinem Beispiel geht es um primitive Datentypen. Beim Casten macht das keinen großen Unterschied, ob Objekte oder primitve Datentypen allerdings solltest du die Begrifflichkeiten strickt differenzieren!

Hätte dir vielleicht einen impliziten Cast auch zeigen sollen, den habe ich in meinen Beispiele (weil man ihn eben nicht *zwingend* machen muss) weggelassen.

*Man castet immer "die Zuweißung ins Ziel"*

```
ziel = (cast)zuweißung;
```
edit: dabei gilt:

```
A = (TypVon[B]A[/B]) B;
```
d.h. die Zuweißung (hier B) wird immer in den Typ vom Ziel (hier A) gecastet.

Also anhand von deinem/meinem Beispiel bei einem impliziten Cast/Upcast bei pimitiven Datentypen:

```
short s = Short.MAX_VALUE;
int i;
i = (int)s;
```

Bei Objekten:

```
//Upcasting!!!!
        TestKlasse test = new TestKlasse();
        Object o = (Object)test;
```

edit: hatte in meinem letzten edit einen dreher


----------

