# Expliziter und impliziter Typecast



## Lestas89 (6. Apr 2016)

Guten Tag!

Folgende Aufgabe macht mir einwenig zu schaffen. (Siehe Bild)

Ich wäre dankbar, wenn einer kontrollieren würde ob ich a - d richtig beantwortet habe.

a) 0 lässt sich sowohl byte, char, short, int und double zuweisen implizit
b) 128 lässt sich implizit byte, char, short, int und double zuweisen
c) 16.5 lässt sich per explizitem Typecast verlustbehaftet in byte, char, short, int zuweisen.
d) für 0.125 gilt das selbe wie für c)

Ist das schonmal richtig?


----------



## kneitzel (6. Apr 2016)

Das ist doch etwas, das Du direkt in der IDE ausprobieren kannst.
Implizit bedeutet, dass Du nichts weiter dazu schreiben musst. Explizit bedeutet, dass du den Zieltyp in Klammern davor schreiben musst.
Also für a) müsstest Du in einem Programm schreiben:

```
byte byteTestA = 0;
char charTestA = 0;
// ...
```

Bei c) wäre es sowas wie

```
byte byteTestC = (byte) 16.5;
// ...
```

Compiliert es? Läuft es? Wenn beides mit ja zu beantworten ist, dann ist der Code schon einmal richtig.
Was Du bei expliziten Casts noch probieren solltest: Lass den expliziten cast weg um zu sehen ob es auch implizit funktioniert.


----------



## Lestas89 (6. Apr 2016)

Hallo Kneitzel,

das würde aber sehr lange dauern. Deswegen wollte ich die Aufgabe zusammen mit euch im Forum durchführen. Wenn es dir nichts ausmacht, wäre ich dankbar wenn du meine Ergebnisse überprüfen würdest.


----------



## kneitzel (6. Apr 2016)

Also das verstehe ich jetzt nicht. Du willst mir doch nicht erklären, dass es zu lange dauert, eben diesen Code einzutippen:

```
public class Main {
    public static void main(String[] args) {
        // Aufgabe a)
        byte byteTestA = 0;
        char charTestA = 0;
        short shortTestA = 0;
        int intTestA = 0;
        double doubleTestA = 0;

        // Aufgabe b)
        byte byteTestB = 128;
        char charTestB = 128;
        short shortTestB = 128;
        int intTestB = 128;
        double doubleTestB = 128;

        // Aufgabe c)
        byte byteTestC = (byte)16.5;
        char charTestC = (char)16.5;
        short shortTestC = (short)16.5;
        int intTestC = (int)16.5;

        // Aufgabe d)
        byte byteTestD = (byte)0.125;
        char charTestD = (char)0.125;
        short shortTestD = (short)0.125;
        int intTestD = (int)0.125;
    }
}
```

Nutzt Du eine IDE wir IntelliJ, die beim Eintippen bereits auf Fehler aufmerksam macht? Das ist sehr wichtig, denn so wird einiges direkt angezeigt. Es vereinfacht es direkt, denn den dann tippt man bei c) und d) erst ohne explizieten Cast und wenn das angemeckert wird, wird der explizite cast hinzugefügt.

Und 128 lässt dich nicht in ein byte eintragen, denn der Wertebereich eines bytes geht von -128 bis 127 - daher geht 128 nicht. 

Und zur Laufzeit (So man die Zuweisung von 128 in ein byte heraus nimmt) kommen keine Fehler, d.h. die expliziten casts sind in Ordnung.


----------



## Lestas89 (6. Apr 2016)

Alles klar. Ich werde das dann in einen Quellcode packen. Falls noch Fragen sind, melde ich mich


----------



## Lestas89 (6. Apr 2016)

Hab ich das richtig verstanden:

Eine explizite Typumwandlung ist immer dann erforderlich, wenn der Wertebereich nicht ausreicht oder wenn ein größerer Datentyp in einen kleineren umgewandelt werden muss.

Ist das richtig?


----------



## Joose (6. Apr 2016)

Lestas89 hat gesagt.:


> Eine explizite Typumwandlung ist immer dann erforderlich, wenn (...) ein größerer Datentyp in einen kleineren umgewandelt werden muss.



Das ist richtig!

Wenn der Wertebereich nicht ausreicht, dann ist dein Datentyp ungeeignet und es wird ein größeres benötigt. Hier wird aber kein expliziter caste benötigt.

```
long x = 0;
int y = 10;
x = y;  // möglich da von einem kleinen zu einem großen zugewiesen wird
y = x; // nicht möglich
```


----------



## Lestas89 (6. Apr 2016)

Aber wenn der Wertebereich nicht ausreicht, meldet der Compiler doch einen Fehler oder nicht? Also müsste man da das explizite Typecasting und Verluste beim Wert hinnehmen oder nicht?


----------



## Joose (6. Apr 2016)

Du hast natürlich recht wenn man konstante Werte im Code verwendet, dann müssen diese natürlich ebenfalls explizit gecastet werden wenn sie zu groß sind. (ich bin in dem Fall nur von Variablen ausgegangen)

Aber das hast du mit der gekürzten Antwort ebenfalls abgedeckt. Da der konstante Wert `3000000000` etwas größerem als int entspricht. Und etwas größeres dem kleinere zuweisen


----------



## Lestas89 (6. Apr 2016)

Danke dir!


----------

