Pelebaran dan Penyempitan jenis primitif

Hai! Semasa anda telah maju melalui CodeGym, anda telah menemui jenis primitif berkali-kali. 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
   • Nombor bulat: bait , pendek , int , panjang
   • Nombor titik terapung (pecahan): terapung dan berganda
   • Nilai logik: boolean
   • Nilai simbolik (untuk mewakili huruf dan angka): char

3. Setiap jenis mempunyai julat nilainya sendiri:

Tetapi selain mempunyai nilai yang berbeza, mereka juga berbeza dalam berapa banyak ruang yang mereka duduki dalam ingatan. Int memerlukan lebih daripada satu bait . Dan yang panjang lebih besar daripada yang pendek. Jumlah memori yang diduduki oleh primitif boleh dibandingkan dengan anak patung bersarang Rusia: Setiap anak patung bersarang mempunyai ruang yang tersedia di dalamnya. Lebih besar anak patung bersarang, lebih banyak ruang yang ada. Anak patung bersarang yang besar ( panjang ) akan mudah menampung int yang lebih kecil . Ia mudah sesuai dan anda tidak perlu melakukan apa-apa lagi. Di Jawa, apabila bekerja dengan primitif, ini dipanggil penukaran tersirat. Atau dengan kata lain, ia dipanggil pelebaran.

Meluas di Jawa

Berikut ialah contoh mudah penukaran yang semakin meluas:

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       byte littleNumber = 16;

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

Di sini kami memberikan nilai bait kepada pembolehubah int . Tugasan berjaya tanpa sebarang masalah: nilai yang disimpan dalam bait mengambil kurang memori daripada apa yang int boleh menampung. Anak patung bersarang kecil (nilai bait) mudah dimuatkan di dalam anak patung bersarang besar ( pembolehubah int ). Ini adalah perkara yang berbeza jika anda cuba melakukan sebaliknya, iaitu untuk meletakkan nilai yang besar ke dalam pembolehubah yang julatnya tidak dapat menampung jenis data yang begitu besar. Dengan anak patung bersarang sebenar, jumlahnya tidak sesuai. Dengan Java, ia boleh, tetapi dengan nuansa. Mari cuba masukkan int ke dalam pembolehubah pendek :

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 normal dengan memasukkan anak patung bersarang besar ( int ) ke dalam anak patung yang kecil ( pendek ). Dalam kes ini, ralat kompilasi ialah amaran daripada pengkompil: "Hei, adakah anda pasti benar-benar mahu melakukan ini?" Jika anda pasti, maka anda memberitahu pengkompil: "Semuanya baik-baik saja. Saya tahu apa yang saya lakukan!" Proses ini dipanggil penukaran jenis eksplisit, atau penyempitan.

Penyempitan di Jawa

Untuk melakukan penukaran yang mengecil, anda perlu menyatakan secara eksplisit jenis yang anda ingin tukarkan nilai anda. Dalam erti kata lain, anda perlu menjawab soalan pengkompil: "Nah, yang manakah antara anak patung bersarang kecil ini yang anda mahu letakkan anak patung bersarang besar ini?" Dalam kes kami, ia 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 int ke dalam pembolehubah pendek dan kami akan bertanggungjawab. Melihat bahawa jenis yang lebih sempit telah ditunjukkan secara jelas, pengkompil melakukan penukaran. Apakah keputusannya? Output konsol: -27008 Itu agak tidak dijangka. Kenapa sebenarnya kita mendapat itu? Sebenarnya, semuanya sangat mudah. Pada asalnya, nilainya ialah 10000000 Ia disimpan dalam pembolehubah int , yang menduduki 32 bit. Ini adalah perwakilan binarinya: Kami menulis nilai ini ke dalam pembolehubah pendek , yang hanya boleh menyimpan 16 bit! Oleh itu, hanya 16 bit pertama nombor kami akan dipindahkan ke sana. Selebihnya akan dibuang. Akibatnya, pembolehubah pendek menerima nilai berikut yang dalam bentuk perpuluhan adalah sama dengan -27008 Itulah sebabnya pengkompil meminta anda untuk "mengesahkan" dengan menunjukkan penukaran penyempitan yang jelas kepada jenis tertentu. Pertama, ini menunjukkan bahawa anda bertanggungjawab untuk hasilnya. Dan kedua, ia memberitahu pengkompil berapa banyak ruang untuk diperuntukkan apabila penukaran berlaku. Lagipun, dalam contoh terakhir, jika kita memberikan nilai int kepada pembolehubah bait dan bukannya short , maka kita hanya akan mempunyai 8 bit yang kita gunakan, bukan 16, dan hasilnya akan berbeza. Jenis pecahan ( float dan double ) mempunyai proses tersendiri untuk menyempitkan penukaran. Jika anda cuba menghantar nombor puak kepada jenis integer, bahagian pecahan akan dibuang.

public static void main(String[] args) {

   double d = 2.7;

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

Output konsol: 2

char

Anda sudah tahu bahawa char digunakan untuk memaparkan aksara individu.

public static void main(String[] args) {

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

}

Tetapi jenis data ini mempunyai beberapa ciri yang penting untuk difahami. Mari kita lihat semula jadual julat nilai: Julat 0 hingga 65536 ditunjukkan untuk jenis aksara . Tetapi apakah maksudnya? Lagipun, char bukan sahaja mewakili nombor, tetapi juga huruf, tanda baca... Perkaranya ialah dalam Java nilai char disimpan dalam format Unicode. Kami telah menemui Unicode dalam salah satu pelajaran sebelumnya. Anda mungkin masih ingat bahawa Unicode ialah standard pengekodan aksara yang merangkumi simbol hampir semua bahasa bertulis di dunia. Dalam erti kata lain, ia adalah senarai kod khas yang mewakili hampir setiap aksara dalam mana-mana bahasa. Keseluruhan jadual Unicode adalah sangat besar, dan, sudah tentu, tidak perlu mempelajarinya dengan teliti. Berikut adalah sebahagian kecil daripadanya: Perkara utama ialah memahami cara aksara disimpan, dan ingat bahawa jika anda mengetahui kod untuk aksara tertentu, anda sentiasa boleh menghasilkan aksara itu dalam program anda. Mari cuba 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 yang digunakan untuk menyimpan aksara dalam Java. Setiap simbol sepadan dengan nombor: kod angka 16-bit (dua bait). Dalam Unicode, 32816 sepadan dengan aksara Cina 耰. Perhatikan perkara berikut. Dalam contoh ini, kami menggunakan pembolehubah int . Ia menduduki 32 bit dalam ingatan, manakala char menduduki 16. Di sini kami memilih int , kerana nombor kami (32816) tidak muat dalam short . Walaupun saiz char (sama seperti short ) ialah 16 bit, tiada nombor negatif dalam julat char , jadi bahagian "positif" charjulat adalah dua kali lebih besar (65536 dan bukannya 32767 untuk jenis pendek ). Kami boleh menggunakan int selagi kod kami kekal di bawah 65536. Tetapi jika anda mencipta nilai int lebih besar daripada 65536, maka ia akan menduduki lebih daripada 16 bit. Dan ini akan mengakibatkan penukaran yang mengecil

char c = (char) x;

bit tambahan akan dibuang (seperti yang dibincangkan di atas) dan hasilnya akan agak tidak dijangka.

Ciri khas menambah aksara dan integer

Mari lihat contoh yang luar biasa:

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

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

Output konsol: 50 O_О Bagaimanakah ia masuk akal? 1+1. Dari mana datangnya 50?! Anda sudah tahu bahawa charnilai disimpan dalam ingatan sebagai nombor dalam julat dari 0 hingga 65536, dan nombor ini ialah perwakilan Unikod bagi aksara. Apabila kita menambah aksara dan beberapa jenis nombor bulat, aksara ditukar kepada nombor Unikod yang sepadan. Dalam kod kami, apabila kami menambah 1 dan '1', simbol '1' telah ditukar kepada kodnya sendiri, iaitu 49 (anda boleh mengesahkan ini dalam jadual di atas). Oleh itu, hasilnya ialah 50. Mari kita ambil sekali lagi rakan lama kita 耰 sebagai contoh, dan cuba tambahkannya pada beberapa nombor.

public static void main(String[] args) {

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

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

Output konsol: 33016 Kami telah mendapati bahawa 耰 sepadan dengan 32816. Dan apabila kami menambah nombor ini dan 200, kami mendapat hasil kami: 33016. :) Seperti yang anda lihat, algoritma di sini agak mudah, tetapi anda tidak sepatutnya melupakannya .