Taip dalam Java

1. Typecasting

Pembolehubah jenis primitif (dengan pengecualian jenis boolean) digunakan untuk menyimpan pelbagai jenis nombor. Walaupun jenis pembolehubah tidak pernah berubah, terdapat tempat di mana anda boleh menukar dari satu jenis ke yang lain. Dan tempat itu adalah tugasan .

Pembolehubah pelbagai jenis boleh ditugaskan antara satu sama lain. Apabila anda melakukan ini, nilai pembolehubah satu jenis ditukar kepada nilai jenis lain dan diberikan kepada pembolehubah kedua. Dalam hal ini, kita boleh mengenal pasti dua jenis penukaran jenis: pelebaran dan penyempitan.

Pelebaran adalah seperti memindahkan nilai dari bakul kecil kepada bakul besar: operasi ini lancar dan tidak menyakitkan. Penyempitan berlaku apabila anda mengalihkan nilai dari bakul besar ke bakul kecil: mungkin tidak ada ruang yang mencukupi, dan anda perlu membuang sesuatu.

Berikut ialah jenis, diisih mengikut saiz bakul:

2. Meluaskan penukaran jenis

Selalunya perlu untuk menetapkan pembolehubah satu jenis angka kepada pembolehubah jenis angka yang lain. Bagaimana anda melakukannya?

Java mempunyai 4 jenis integer:

Pembolehubah yang disimpan dalam bakul yang lebih kecil sentiasa boleh diberikan kepada pembolehubah yang disimpan dalam bakul yang lebih besar.

int, shortdan bytepembolehubah boleh diberikan dengan mudah kepada longpembolehubah. shortdan bytepembolehubah boleh diberikan kepada intpembolehubah. Dan bytepembolehubah boleh diberikan kepada shortpembolehubah.

Contoh:

byte a = 5;
short b = a;
int c = a + b;
long d = c * c;

Penukaran sedemikian, daripada jenis yang lebih kecil kepada yang lebih besar, dipanggil penukaran jenis pelebaran .

Bagaimana dengan nombor nyata?

Dengan mereka, semuanya adalah sama — saiz penting:

floatpembolehubah boleh diberikan kepada doublepembolehubah tanpa sebarang masalah. Tetapi perkara lebih menarik dengan jenis integer.

Anda boleh menetapkan sebarang pembolehubah integer kepada floatpembolehubah. Malah longjenis, yang panjangnya 8 bait. Dan anda boleh menetapkan apa sahaja yang anda mahu - mana-mana pembolehubah integer atau floatpembolehubah - kepada doublepembolehubah:

long a = 1234567890;
float b = a;
double c = a;

b == 1.23456794E9
c == 1.23456789E9

Ambil perhatian bahawa menukar kepada jenis sebenar boleh mengakibatkan kehilangan ketepatan kerana kekurangan digit bererti yang mencukupi.

Apabila menukar daripada integer kepada nombor titik terapung, bahagian nombor tertib bawah mungkin dibuang. Tetapi oleh kerana nombor pecahan difahami untuk menyimpan nilai anggaran, operasi tugasan tersebut dibenarkan.

3. Menyempitkan penukaran jenis

Bagaimana pula dengan kemungkinan lain? Bagaimana jika anda perlu memberikan longnilai kepada intpembolehubah?

Bayangkan pembolehubah sebagai bakul. Kami mempunyai bakul pelbagai saiz: 1, 2, 4 dan 8 bait. Tidak menjadi masalah untuk memindahkan epal dari bakul yang lebih kecil kepada yang lebih besar. Tetapi apabila beralih dari bakul yang lebih besar kepada yang lebih kecil, beberapa epal mungkin hilang.

Transformasi ini — daripada jenis yang lebih besar kepada jenis yang lebih kecil — dipanggil penukaran jenis penyempitan . Apabila melakukan operasi tugasan seperti ini, sebahagian daripada nombor mungkin tidak sesuai dengan pembolehubah baharu dan oleh itu boleh dibuang.

Apabila menyempitkan jenis, kita mesti secara jelas memberitahu pengkompil bahawa kita tidak membuat kesilapan, bahawa kita sengaja membuang sebahagian daripada nombor itu. Operator typecast digunakan untuk ini. Ia adalah nama jenis dalam kurungan .

Dalam situasi sedemikian, pengkompil Java memerlukan pengaturcara untuk menentukan pengendali taip. Secara umum, ia kelihatan seperti ini:

(type) expression

Contoh:

long a = 1;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

Di sini aadalah sama dengan 1, dan mungkin pengendali taip kelihatan seperti berlebihan. Tetapi bagaimana jika alebih besar?

long a = 1000000;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

a == 1000000
b == 1000000
c == 16960
d == 64

Satu juta sesuai dengan sempurna ke dalam longdan ke dalam int. Tetapi apabila memperuntukkan satu juta kepada shortpembolehubah, dua bait pertama akan dibuang, dan hanya dua bait terakhir dikekalkan. Dan apabila menetapkan kepada byte, satu-satunya perkara yang tinggal ialah bait terakhir.

Bagaimana nombor disusun dalam ingatan:

chartaip

A char, seperti a short, menduduki dua bait, tetapi untuk menukar satu kepada yang lain, anda sentiasa perlu menggunakan operator taip. Isu di sini ialah shortjenis ditandatangani dan boleh mengandungi nilai dari -32,768kepada +32,767, tetapi charjenis itu tidak ditandatangani dan boleh mengandungi nilai dari 0kepada 65,535.

Nombor negatif tidak boleh disimpan dalam char, tetapi ia boleh disimpan dalam short. Dan a shorttidak boleh menyimpan nombor yang lebih besar daripada 32,767, tetapi nombor tersebut boleh disimpan dalam char.

4. Jenis ungkapan

Bagaimana jika pembolehubah jenis yang berbeza digunakan dalam ungkapan yang sama? Secara logiknya, kami faham bahawa mereka perlu ditukar kepada jenis biasa dahulu. Tetapi yang mana satu?

Kepada yang lebih besar, sudah tentu.

Java sentiasa menukar kepada jenis yang lebih besar. Secara kasarnya, salah satu jenis mula-mula diluaskan dan barulah operasi dilakukan menggunakan nilai-nilai jenis yang sama.

Jika an intdan a longterlibat dalam ungkapan, nilai intakan ditukar kepada a longdan hanya selepas itu operasi akan diteruskan:

int a = 1;
long b = 2;
long c = a + b;

Nombor titik terapung

Jika integer dan nombor titik terapung ( floatatau double) terlibat dalam ungkapan, integer akan ditukar kepada nombor titik terapung ( floatatau double), dan selepas itu barulah operasi dijalankan.

Jika operasi melibatkan a floatdan a double, maka floatakan ditukar kepada a double. Yang sebenarnya dijangka.

Jika anda mendarab a bytedengan a short, anda mendapat int. Jika anda mendarab a bytedengan a byte, anda mendapat int. Walaupun anda menambah a bytedan a byte, anda mendapat int.

Terdapat beberapa sebab untuk ini. Contoh:

byte a = 110;
byte b = 120;
byte c = a * b;  // Error

byte a = 110;
byte b = 120;
byte c = a + b; // Error

Secara umum, apabila mendarabkan nombor 8-bit (1 bait) dengan nombor 8-bit (1 bait), kita mendapat nombor yang menduduki 16-bit bit (2 bait)

Akibatnya, semua operasi dengan jenis integer yang lebih kecil daripada intsentiasa ditukar dengan serta-merta kepada ints. Dan ini bermakna jika anda ingin menyimpan hasil pengiraan dalam pembolehubah jenis yang lebih kecil daripada int, maka anda akan sentiasa perlu menyatakan secara eksplisit pengendali taip.

Contoh:

byte a = 110;
byte b = 120;
byte c = (byte) (a * b);

byte a = 110;
byte b = 120;
byte c = (byte) (a + b);

byte a = 1;
byte b = (byte) (a + 1);

5. Nuansa penting

Pengendali taip mempunyai keutamaan yang agak tinggi.

Ini bermakna jika ungkapan mengandungi, contohnya, penambahan dan pengendali taip, siaran taip akan dilakukan sebelum penambahan.

Contoh:

byte a = 1;
byte b = 2;
byte c = (byte) a * b;

byte a = 1;
byte b = 2;
byte c = (byte) (a * b);

Jika anda ingin menukar keseluruhan ungkapan kepada jenis tertentu, dan bukan hanya satu komponen ungkapan, kemudian bungkus keseluruhan ungkapan dalam kurungan dan letakkan operator taip di hadapan.