| In Java heb je geen expliciete conversie nodig om een `float` in een `double` te veranderen. Java promoveert `float` automatisch naar `double` indien nodig. Dit wordt *verbredende conversie* genoemd omdat `double` een groter bereik en grotere nauwkeurigheid heeft dan `float`.
Hier is hoe het werkt:
```java
openbare klasse FloatToDouble {
public static void main(String[] args) {
float myFloat =3,14f; // Merk op dat het achtervoegsel 'f' cruciaal is voor letterlijke floats.
dubbel mijnDouble =mijnFloat; // Impliciete conversie
System.out.println("Float:" + mijnFloat);
System.out.println("Double:" + mijnDouble);
}
}
```
De regel `double myDouble =myFloat;` converteert impliciet de `float`-waarde naar een `double`. Gieten is niet nodig. Java verwerkt de conversie naadloos.
Als u rekenkundige bewerkingen zou uitvoeren met `float` en `double`, zou `float` vóór de berekening automatisch worden gepromoveerd tot `double`.
Hoewel je het expliciet *kan* casten met `(double)myFloat`, is het overbodig omdat de impliciete conversie al correct en efficiënt wordt afgehandeld door de Java-compiler:
```java
dubbel myDoubleExplicit =(dubbel) myFloat; // Expliciet, maar onnodig
```
In bijna alle gevallen verdient de impliciete conversie de voorkeur vanwege een betere leesbaarheid en beknoptheid. De expliciete cast kan alleen nuttig zijn in situaties waarin u de conversie zeer expliciet wilt maken voor de leesbaarheid in complexe code of om te benadrukken dat u zich bewust bent van potentieel precisieverlies (hoewel dit in dit geval van float naar double minimaal is in vergelijking met andere conversies). |
