Primitívne konverzie Java

1. Úvod

Java je písaný jazyk, čo znamená, že využíva koncept typov. Existujú dve odlišné skupiny typov:

  1. primitívne dátové typy
  2. abstraktné dátové typy.

V tomto článku sa zameriame na konverzie primitívnych typov.

2. Prehľad primitívov

Prvá vec, ktorú musíme vedieť, je, aký druh hodnôt sa môže použiť s primitívnymi typmi. Existuje osem primitívnych typov, ktoré sú:

  • bajt - 8 bitov a podpísané

  • krátky - 16 bitov a podpísané

  • char - 16 bitov a bez znamienka, takže môže predstavovať znaky Unicode

  • int - 32 bitov a podpísané

  • dlho - 64 bitov a podpísané

  • plavák - 32 bitov a podpísané

  • dvojitý - 64 bitov a podpísané

  • boolovský - nie je číselný, môže mať iba pravda alebo nepravdivé hodnoty

Nie je to myslené ako rozsiahla diskusia o primitívoch a v priebehu konverzácií si podľa potreby povieme niečo viac o ich podrobnostiach.

3. Rozširovanie primitívnych konverzií

Keď potrebujeme prevádzať z primitívu, ktorý je jednoduchší alebo menší ako cieľový typ, nemusíme na to používať nijakú špeciálnu notáciu:

int myInt = 127; long myLong = myInt;

Počas rozšírenia prevodu je menšia primitívna hodnota umiestnená nad väčší kontajner, čo znamená, že všetok ďalší priestor naľavo od hodnoty je vyplnený nulami. To možno tiež použiť na prechod zo skupiny celých čísel na plávajúcu desatinnú čiarku:

float myFloat = myLong; double myDouble = myLong;

Je to možné, pretože prechod na širší primitív nestratí žiadne informácie.

4. Zúženie primitívnej konverzie

Niekedy musíme prispôsobiť hodnotu, ktorá je väčšia ako typ použitý v deklarácii premennej. To môže mať za následok stratu informácií, pretože niektoré bajty budú musieť byť vyradené.

V takom prípade musíme výslovne povedať, že sme si vedomí situácie, a súhlasíme s tým, že použijeme obsadenie:

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

5. Rozšírenie a zúženie primitívnej konverzie

Táto situácia sa deje v a veľmi konkrétny prípad, keď chceme previesť z a bajt do a char. Prvou konverziou je rozšírenie bajt do int a potom z int je zúžený na char.

Tento bod objasní príklad:

byte myLargeValueByte = (byte) 130; // 0b10000010 -126

Binárna reprezentácia 130 je rovnaká pre -126, rozdiel je v interpretácii signálneho bitu. Poďme teraz konvertovať z bajt do char:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 hodnota bez znamienka int myLargeValueInt = myLargeValueChar; // 0b11111111 10000010 65410

The char reprezentácia je hodnota Unicode, ale prevedená na int nám ukázal veľmi veľkú hodnotu, ktorá má spodných 8 bitov úplne rovnakých ako -126.

Ak to znova prevedieme na bajt dostaneme:

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

Pôvodná hodnota, ktorú sme použili. Ak celý kód začínal znakom char hodnoty sa budú líšiť:

char myLargeValueChar2 = 130; // Toto nie je int, ale bajt! // 0b 00000000 10000010 hodnota bez znamienka int myLargeValueInt2 = myLargeValueChar2; // 0b00000000 10000010 130 bajtov myOtherByte2 = (bajt) myLargeValueInt2; // 0b10000010 -126

Napriek tomu bajt zastúpenie je rovnaké, čo je -126, char reprezentácia nám dáva dva rôzne znaky.

6. Konverzia boxu / unboxingu

V Jave máme pre každý primitívny typ triedu Wrapper, toto je šikovný spôsob, ako programátorom poskytnúť užitočné metódy spracovania, bez toho, aby sme museli mať všetko ako referenciu na ťažký objekt. Od verzie Java 1.5 bola zahrnutá schopnosť automaticky prevádzať na / z primitívu na objekt a späť a dosiahla sa jednoduchým uvedením zdroja:

Celé číslo myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. Konverzie reťazcov

Všetky primitívne typy je možné previesť na String prostredníctvom svojich tried obaľovačov, ktoré majú prednosť pred natiahnuť() metóda:

Reťazec myString = myIntegerReference.toString ();

Ak sa potrebujeme vrátiť k primitívnemu typu, musíme použiť metódu analýzy definovanú zodpovedajúcou triedou obálky:

byte myNewByte = Byte.parseByte (myString); short myNewShort = Short.parseShort (myString); int myNewInt = Integer.parseInt (myString); long myNewLong = Long.parseLong (myString); float myNewFloat = Float.parseFloat (myString); double myNewDouble = Double.parseDouble (myString); 
boolean myNewBoolean = Boolean.parseBoolean (myString);

Jedinou výnimkou je tu Postava Trieda, pretože a String je vyrobený z chars tak ako tak, vzhľadom na to, že pravdepodobne String je vyrobený z jediného char, môžeme použiť charAt () metóda String trieda:

char myNewChar = myString.charAt (0);

8. Číselné propagácie

Na vykonanie binárnej operácie je potrebné, aby boli oba operandy z hľadiska veľkosti kompatibilné.

Platí súbor jednoduchých pravidiel:

  1. Ak je jedným z operandov a dvojitý, druhý je povýšený na dvojitý
  2. V opačnom prípade, ak je jedným z operandov a plavák, druhý je povýšený na plavák
  3. V opačnom prípade, ak je jedným z operandov a dlho, druhý je povýšený na dlho
  4. V opačnom prípade sa uvažuje o oboch int

Pozrime sa na príklad:

bajt op1 = 4; bajt op2 = 5; byte myResultingByte = (byte) (op1 + op2);

Obaja operanti boli povýšení na int a výsledok musí byť skleslý k bajt ešte raz.

9. Záver

Konverzia medzi typmi je veľmi častou úlohou pri každodenných programovacích činnostiach. Existuje súbor pravidiel, ktoré určujú spôsoby, ako staticky písané jazyky prevádzajú tieto konverzie. Poznanie týchto pravidiel môže ušetriť veľa času pri hľadaní dôvodu, prečo sa určitý kód kompiluje alebo nie.

Kód použitý v tomto článku nájdete na GitHub.


$config[zx-auto] not found$config[zx-overlay] not found