Menghantar (menukar) jenis primitif di Jawa

hello! Semasa melalui JavaRush, anda menjumpai jenis primitif lebih daripada sekali. Berikut ialah senarai pendek perkara yang kami ketahui tentang mereka:

1. Ia bukan objek dan mewakili nilai yang disimpan dalam ingatan
2. Terdapat beberapa jenis jenis primitif:
   • Nombor bulat - byte, short, int,long
   • Nombor titik terapung (pecahan) - floatdandouble
   • Boolean -boolean
   • Simbolik (untuk menunjukkan huruf dan nombor) -char
3. Setiap daripada mereka mempunyai julat nilainya sendiri:

Tetapi, sebagai tambahan kepada nilai, jenis juga berbeza dalam saiz memori. intmengambil masa lebih daripada byte. A long- lebih daripada short. Jumlah memori yang diduduki oleh primitif boleh dibandingkan dengan anak patung bersarang: Terdapat ruang kosong di dalam anak patung bersarang. Lebih besar anak patung bersarang, lebih banyak ruang. longKita boleh dengan mudah meletakkan yang lebih kecil di dalam anak patung bersarang yang besar int. Ia sesuai dengan mudah dan anda tidak perlu melakukan apa-apa tambahan. Di Jawa, apabila bekerja dengan primitif, ini dipanggil penukaran automatik. Dengan cara lain ia dipanggil lanjutan. Berikut ialah contoh sambungan mudah:

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       byte littleNumber = 16;

       bigNumber = littleNumber;
       System.out.println(bigNumber);
   }
}

Di sini kita memberikan nilai bytekepada pembolehubah int. Tugasan itu berjaya dan tanpa sebarang masalah: nilai yang disimpan dalam bytemenempati ruang memori yang kurang daripada yang "sesuai" dalam int. "Anak patung bersarang kecil" (nilai byte) mudah sesuai dengan "matryoshka besar" (pembolehubah int). Perkara lain apabila anda cuba melakukan sebaliknya - letakkan nilai yang besar ke dalam pembolehubah yang tidak direka bentuk untuk saiz sedemikian. Pada dasarnya, helah ini tidak akan berfungsi dengan anak patung bersarang sebenar, tetapi di Jawa ia akan berfungsi, tetapi dengan nuansa. Mari cuba letakkan nilai intke dalam pembolehubah short:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = bigNumber;//error!
   System.out.println(bigNumber);
}

Ralat! Pengkompil memahami bahawa anda cuba melakukan sesuatu yang tidak standard, dan meletakkan anak patung matryoshka yang besar ( int) di dalam yang kecil ( short). Ralat kompilasi dalam kes ini ialah amaran daripada pengkompil: “ Hei, adakah anda pasti mahu melakukan ini? "Jika anda pasti, beritahu pengkompil mengenainya: " Semuanya ok, saya tahu apa yang saya lakukan!" ” Proses ini dipanggil penukaran jenis eksplisit, atau penyempitan . Untuk membuat penyempitan, anda perlu menyatakan secara eksplisit jenis yang anda ingin hantarkan nilai anda. Dalam erti kata lain, jawab soalan penyusun: " Nah, mana antara anak patung kecil ini yang anda mahu letakkan anak patung besar ini?" ” Dalam kes kami, ia akan kelihatan seperti ini:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = (short) bigNumber;
   System.out.println(littleNumber);
}

Kami secara eksplisit menyatakan bahawa kami ingin memasukkan nilai intke dalam pembolehubah shortdan bertanggungjawab untuknya. Pengkompil, melihat petunjuk eksplisit jenis yang lebih sempit, melakukan penukaran. Apakah hasilnya? Output konsol: -27008 Sedikit tidak dijangka. Kenapa betul-betul begini? Ia sebenarnya mudah. Kami mempunyai nilai asal - 10000000 Ia disimpan dalam pembolehubah intyang mengambil 32 bit, dan dalam bentuk binari ia kelihatan seperti ini: Kami menulis nilai ini kepada pembolehubah short, tetapi ia hanya boleh menyimpan 16 bit! Oleh itu, hanya 16 bit pertama nombor kami akan dipindahkan ke sana, selebihnya akan dibuang. Akibatnya, pembolehubah shortakan mengandungi nilai , yang dalam bentuk perpuluhan adalah betul-betul sama dengan -27008 Itulah sebabnya pengkompil "meminta pengesahan" dalam bentuk hantaran eksplisit kepada jenis tertentu. Pertama, ia menunjukkan bahawa anda bertanggungjawab untuk hasilnya, dan kedua, ia memberitahu pengkompil berapa banyak ruang yang perlu diperuntukkan semasa menghantar jenis. Lagipun, jika dalam contoh terakhir kita telah menghantar intke taip byte, dan bukan kepada short, kita akan mempunyai hanya 8 bit di pelupusan kita, bukan 16, dan hasilnya akan berbeza. Untuk jenis pecahan ( floatdan double), penyempitan berlaku secara berbeza. Jika anda cuba menukar nombor sedemikian kepada jenis integer, bahagian pecahannya akan dibuang.

public static void main(String[] args) {

   double d = 2.7;

   long x = (int) d;
   System.out.println(x);
}

Output konsol: 2

Jenis data char

Anda sudah tahu bahawa jenis char digunakan untuk memaparkan aksara individu.

public static void main(String[] args) {

   char c = '!';
   char z = 'z';
   char i = '8';

}

Tetapi ia mempunyai beberapa ciri yang penting untuk difahami. Mari kita lihat semula jadual dengan julat nilai: Jenis ini charmempunyai julat angka dari 0 hingga 65536. Tetapi apakah maksudnya? Lagipun, charini bukan sahaja nombor, tetapi juga huruf, tanda baca... Hakikatnya ialah nilai chardisimpan dalam Java dalam format Unicode. Kami telah pun menemui Unicode dalam salah satu kuliah sebelumnya. Anda mungkin masih ingat bahawa Unicode ialah standard pengekodan aksara yang merangkumi aksara daripada hampir semua bahasa bertulis di dunia. Dalam erti kata lain, ini ialah senarai kod khas di mana terdapat kod untuk hampir mana-mana aksara daripada mana-mana bahasa. Jadual Unicode am adalah sangat besar dan, sudah tentu, tidak perlu dipelajari dengan hati. Di sini, sebagai contoh, adalah sebahagian daripadanya: Perkara utama ialah memahami prinsip menyimpan nilai char, dan ingat bahawa mengetahui kod simbol tertentu, anda sentiasa boleh mendapatkannya dalam program. Mari cuba ini dengan beberapa nombor rawak:

public static void main(String[] args) {

   int x = 32816;

   char c = (char) x ;
   System.out.println(c);
}

Output konsol: 耰 Ini ialah format di mana aksara disimpan dalam Java char. Setiap aksara sepadan dengan nombor - kod angka 16 bit, atau dua bait. Unicode 32816 sepadan dengan aksara 耰. Perhatikan detik ini. Dalam contoh ini kami menggunakan pembolehubah int. Ia menduduki 32 bit memori , manakala char16 . Di sini kami memilih kerana nombor yang kami perlukan, 32816, berada di luar julat . Walaupun saiz , seperti pendek, ialah 16 bit, tiada nombor negatif dalam julat, jadi julat "positif" adalah dua kali lebih besar (65536 bukannya 32767 ). Kita boleh menggunakan , selagi kod kita berada dalam julat 65536. Tetapi jika kita mencipta nombor , ia akan mengambil masa lebih daripada 16 bit. Dan apabila menyempitkan jenis: intshortcharcharcharshortintint >65536

char c = (char) x;

bit tambahan akan dibuang, dan hasilnya akan agak tidak dijangka.

Ciri penambahan char dan integer

Mari lihat contoh luar biasa ini:

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

       System.out.println(i+c);
   }
}

Output konsol: 50 O_O Di manakah logiknya? 1+1, dari mana datangnya 50?! Anda sudah tahu bahawa nilai chardisimpan dalam ingatan sebagai nombor dalam julat dari 0 hingga 65536, mewakili Unicode watak kami. Jadi begini. Apabila kita melakukan penambahan chardan beberapa jenis integer charditukar kepada nombor yang sepadan dengannya dalam Unicode. Apabila dalam kod kami kami menambah 1 dan '1', simbol '1' telah ditukar kepada kodnya, iaitu 49 (anda boleh menyemaknya dalam jadual di atas). Oleh itu, hasilnya menjadi sama dengan 50. Mari kita ambil sekali lagi rakan lama kita -耰sebagai contoh , dan cuba tambahkannya dengan beberapa nombor.

public static void main(String[] args) {

   char c = '耰';
   int x = 200;

   System.out.println(c + x);
}

Output konsol: 33016 Kami telah mengetahui bahawa耰sepadan dengan kod 32816. Dan apabila kami menambah nombor ini dan 200, kami mendapat hasil yang tepat - 33016 :) Mekanisme operasi, seperti yang anda lihat, agak mudah.