wiki.smarken.dk

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
^ Linux - Friheden til at programmere i Java: Version 0.7.20040516 - 2020-12-31 ^|
| [[java:java-basal-prg-loekke|forrige]] | Kapitel 3. Basal programmering | [[java:java-basal-prg-fejl|næste]] |

----

==== 3.6. Værditypekonvertering ====

 Java er det, man kalder et stærkt typet sprog. Det betyder, at alle variabler og værdier har en bestemt type gennem hele deres levetid, og at der er visse begrænsninger for, hvilke værdier man kan tildele en variabel. Når man først har vænnet sig til det, er det en stor hjælp, fordi oversætteren på denne måde ofte fanger fejl i programmerne. Desuden gør det, at computeren hurtigere kan udføre beregninger.

 I Java kan man f.eks. ikke lægge en double-værdi ind i en int-variabel:

<code>int x; 
x=2.7;  // Fejl.</code>

 Forsøger man på dette, vil man få oversætter-fejlen: //Possible loss of precision: double, required: int// .

 Årsagen til, at vi i Java ikke kan gemme 2.7 i x, kan forstås på to måder:

  - x har kun plads i lageret til at gemme hele tal (fra -2 mia. til +2 mia).
  - x er erklæret som en int, og skal derfor blive ved med at være en int. I de efterfølgende beregninger kan det have stor betydning, om x har en kommadel. Programmøren skal derfor kunne se på, hvordan x er erklæret, og derefter være helt sikker på, hvilke værdier x kan indeholde.

 Begge måder at forstå årsagen på er rigtige og gyldige.

 For at kunne gemme 2.7 i x bliver man derfor nødt til at lave 2.7 om til en int-værdi. Det kaldes at typekonvertere værdien. Dette er ikke helt uden problemer. Der er åbenlyst et informationstab, da kommadelen af værdien må fjernes. Derudover kunne double-værdien være 5 mia. i stedet for 2.7, og det er der ikke plads til i en int. Et tredje problem er, at man skal vælge, hvordan man vil udføre konverteringen. Skal man afrunde korrekt til 3, eller nedrunde til 2? Det første tager lidt mere tid end det sidste.

 Af disse årsager bliver man i nogle tilfælde nødt til eksplicit at fortælle oversætteren, at den skal foretage en værdi-typekonvertering.

=== 3.6.1. Eksplicit værdi-typekonvertering ===

 Man konverterer en værdi til en anden type ved at skrive det eksplicit (eng.: cast) med:

<code>int x; 
x = (int) 2.7;</code>

 Inde i parentesen skriver man typen, som værdien lige til højre skal konverteres til. Denne form for typekonvertering runder altid ned til nærmeste hele tal.

=== 3.6.2. Implicit værdi-typekonvertering ===

 Implicit typekonvertering betyder, at oversætteren selv laver konverteringen, uden at programmøren behøver at skrive noget særligt om, at den skal gøre det.

<code>double y; 
y=4;   // OK: Implicit værdi-typekonvertering.</code>

 Selvom 4 er en int-værdi, kan y godt indeholde den, da den svarer til double-værdien 4.0. Denne form for typekonvertering er således ikke nær så problematisk som i det tidligere eksempel.

 En tommelfingerregel i Java er, at når modtagertypen kan indeholde hele intervallet af mulige værdier for afsendertypen, kan den være implicit. I appendikset sidst i dette kapitel findes en tabel over typerne.

=== 3.6.3. Misforståelser af værdi-typekonvertering ===

 Bemærk, at det kun er //værdien// , der bliver konverteret. Variablen bliver ikke ændret.

<code>int x; 
double y; 
y=2.7; //x=(int)y// ;              // punkt A 
System.out.println(x); 
System.out.println(y); // y er upåvirket af typekonverteringen</code>

 Resultatet bliver

<code>2 
2.7</code>

 Man kunne måske fristes til at tro, at i punkt A konverteres variablen y til en variabel af typen int, men det ville så betyde, at den sidste linje i uddata skulle være 2. Men husk at:


> En variabels type er altid som den er erklæret - den kan ikke ændre type

 Det der sker i ovenstående er, at y's værdi (2.7) læses, en konverteret værdi (2) beregnes og denne værdi lægges ind i x.

 En anden misforståelse er at tro, at oversætteren kan se at noget er lovligt ud fra de øvrige programlinjer, f.eks.:

<code>int x; 
double y; 
y=4.0; 
x=y;    // Fejl - her stopper oversætteren med "Possible loss of precision"</code>

 I ovenstående tilfælde kunne man tro, at man kan bruge implicit typekonvertering, fordi oversætteren kan se at y altid er 4.0, og at der derfor ikke går information tabt. Men så klog er oversætteren ikke. Når den skal afgøre, om den kan lave implicit typekonvertering, kigger den //kun// på typerne af variabler og værdier. Den skeler ikke til resten af programmet.

----

| [[java:java-basal-prg-loekke|forrige]] | [[java:index|hjem]] | [[java:java-basal-prg-fejl|næste]] |
| Løkker | [[java:java-basal-prg|op]] | Fejl |