streamalism.org

1. Bemutatkozás

A Java egy tipizált nyelv, ami azt jelenti, hogy használja a típusok fogalmát. Két különböző típusú csoport létezik:

1. primitív adattípusok
2. absztrakt adattípusok.

Ebben a cikkben a primitív típusok átalakítására fogunk összpontosítani.

2. A primitívek áttekintése

Az első dolog, amit tudnunk kell, hogy milyen értékeket lehet használni a primitív típusoknál. Nyolc primitív típus létezik:

• byte - 8 bit és aláírt

• rövid - 16 bit és aláírt

• char - 16 bit és aláíratlan, hogy az Unicode karaktereket reprezentálhassa

• int - 32 bit és aláírt

• hosszú - 64 bit és aláírt

• úszó - 32 bit és aláírt

• kettős - 64 bit és aláírt

• logikai - ez nem numerikus, csak lehet igaz vagy hamis értékek

Ez nem célja a primitívekről folytatott átfogó megbeszélés, és szükség esetén a konverziók során még egy kicsit bővebben beszélünk részleteiről.

3. A primitív konverziók kiszélesítése

Amikor egy primitívről kell átalakulnunk, amely egyszerűbb vagy kisebb, mint a céltípus, akkor ehhez nem kell külön jelölést használnunk:

int myInt = 127; hosszú myLong = myInt;

A szélesebb körű átalakítás során a kisebb primitív értéket egy nagyobb konténer fölé helyezzük, ami azt jelenti, hogy az érték bal oldalán található összes extra hely nullákkal van kitöltve. Ez arra is használható, hogy az egész csoportból a lebegőponthoz lépjünk:

float myFloat = myLong; double myDouble = myLong;

Ez azért lehetséges, mert a szélesebb primitív irányba való elmozdulás nem veszít semmilyen információt.

4. A primitív megtérés szűkülése

Néha be kell illesztenünk egy értéket, amely nagyobb, mint a változó deklarációjában használt típus. Ez információvesztést okozhat, mivel néhány bájtot el kell dobni.

Ebben az esetben kifejezetten ki kell fejeznünk, hogy tudatában vagyunk a helyzetnek, és ezzel egyetértünk egy szereplőgárda használatával:

int myInt = (int) myDouble; byte myByte = (byte) myInt;

5. A primitív megtérés kiszélesítése és szűkülése

Ez a helyzet a nagyon konkrét eset, amikor át akarunk térni a byte a char. Az első konverzió a byte nak nek int majd a int leszűkült char.

Egy példa tisztázza ezt a kérdést:

byte myLargeValueByte = (bájt) 130; 0b10000010 -126

A 130 bináris ábrázolása megegyezik -126 esetében, a különbség a jelbit értelmezése. Most térjünk át a byte nak nek char:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 előjel nélküli érték int myLargeValueInt = myLargeValueChar; 0b11111111 10000010 65410

A char ábrázolás Unicode érték, de konvertálás int nagyon nagy értéket mutatott, amelynek az alsó 8 bitje pontosan megegyezik -126 értékével.

Ha újra átalakítjuk byte kapunk:

byte myOtherByte = (byte) myLargeValueInt; 0b10000010 -126

Az eredeti érték, amelyet használtunk. Ha az egész kód a-val kezdődött char az értékek eltérőek lesznek:

char myLargeValueChar2 = 130; // Ez egy int nem bájt! // 0b 00000000 10000010 aláíratlan érték int myLargeValueInt2 = myLargeValueChar2; // 0b00000000 10000010 130 bájt myOtherByte2 = (byte) myLargeValueInt2; 0b10000010 -126

Habár a byte ábrázolás megegyezik, ami -126, a char ábrázolás két különböző karaktert ad nekünk.

6. Boxing / Unboxing Conversion

A Java-ban van egy Wrapper osztályunk minden primitív típushoz, ez egy okos módja annak, hogy a programozók számára hasznos feldolgozási módszereket nyújtsunk anélkül, hogy minden nehéz feladat objektum referenciaként szolgálna. A Java 1.5 óta benne van az a lehetőség, hogy automatikusan átalakuljon egy primitívből objektummá és vissza, és ezt egyszerű hozzárendeléssel érjék el:

Egész szám myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. Vonós konverziók

Az összes primitív típus átalakítható Húr a Wrapper osztályokon keresztül, amelyek felülírják a toString () módszer:

Karakterlánc myString = myIntegerReference.toString ();

Ha vissza kell térnünk egy primitív típushoz, akkor a megfelelő Wrapper osztály által meghatározott elemzési módszert kell használnunk:

byte myNewByte = Byte.parseByte (myString); rövid myNewShort = Rövid.parseShort (myString); int myNewInt = Integer.parseInt (myString); hosszú myNewLong = Long.parseLong (myString); float myNewFloat = Úszó.parseFloat (myString); double myNewDouble = Double.parseDouble (myString); 

logikai myNewBoolean = logikai.parseBoolean (myString);

Az egyetlen kivétel itt a karakter Osztály, mert a Húr készült chars különben is, így, tekintve, hogy valószínűleg a Húr kislemezből készül char, használhatjuk a charAt () módszere Húr osztály:

char myNewChar = myString.charAt (0);

8. Numerikus promóciók

A bináris művelet végrehajtásához mindkét operandusnak kompatibilisnek kell lennie méretét tekintve.

Van egy sor egyszerű szabály, amely alkalmazható:

1. Ha az egyik operandus a kettős, a másikat előléptetik kettős
2. Egyébként, ha az egyik operandus a úszó, a másikat előléptetik úszó
3. Egyébként, ha az egyik operandus a hosszú, a másikat előléptetik hosszú
4. Ellenkező esetben mindkettőt figyelembe vesszük int

Lássunk egy példát:

bájt op1 = 4; bájt op2 = 5; bájt myResultingByte = (bájt) (op1 + op2);

Mindkét operandust előléptették int és az eredménynek le kell süllyednie byte újra.

9. Következtetés

A típusok közötti átalakítás nagyon gyakori feladat a napi programozási tevékenységek során. Van egy olyan szabályrendszer, amely szabályozza, hogy a statikusan tipizált nyelvek hogyan működtetik ezeket a konverziókat. E szabályok ismerete sok időt takaríthat meg, amikor megpróbáljuk kideríteni, miért fordít egy bizonyos kódot vagy sem.

A cikkben használt kód megtalálható a GitHub oldalon.