Ini adalah konten baru yang diperkenalkan setelah jdk1.5 Karena saya bersikeras bahwa penerbitan adalah memori terbaik, saya memutuskan untuk mengganti memori saya dengan blog:
Spesifikasi Bahasa Java mengatakan: Dalam banyak kasus, pengemasan dan pembongkaran dilakukan oleh kompiler itu sendiri (dalam hal ini pengemasan disebut boxing, dan pembongkaran disebut unboxing);
Faktanya, menurut pemahaman saya sendiri, tinju otomatis dapat secara sederhana dipahami sebagai merangkum tipe data dasar menjadi tipe objek agar sesuai dengan orientasi objek Java misalnya, gunakan int sebagai contoh:
Copy kode kodenya sebagai berikut:
//Deklarasikan objek Integer
Bilangan bulat = 10;
//Pernyataan di atas menggunakan tinju otomatis: diuraikan sebagai
Integer num = new Integer(10); Di atas adalah contoh yang bagus, karena 10 termasuk dalam tipe data dasar, pada prinsipnya tidak dapat langsung ditugaskan ke suatu objek Integer, tetapi setelah jdk1.5 Anda dapat melakukan Pernyataan ini, ini adalah pesona autoboxing untuk secara otomatis mengubah tipe data dasar menjadi tipe enkapsulasi yang sesuai. Setelah menjadi sebuah objek, Anda dapat memanggil semua metode yang dideklarasikan oleh objek untuk secara otomatis membuka kotaknya: sesuai dengan namanya, ini berarti mengubah ulang objek menjadi tipe data dasar:
//tinju
Bilangan bulat = 10;
//membuka kemasan
int num1 = num; Penggunaan unboxing otomatis yang paling umum adalah ketika melakukan operasi: karena objek tidak dioperasikan secara langsung, tetapi harus diubah menjadi tipe data dasar sebelum penjumlahan, pengurangan, perkalian dan pembagian dapat dilakukan.
Bilangan bulat = 10;
// Pembuka kotak otomatis tersirat saat melakukan penghitungan
System.out.print(num--); Haha, seharusnya terasa sangat sederhana. Sekarang saya akan membicarakan sesuatu yang sedikit lebih sulit.
//Angka di luar -128~127
Bilangan bulat1 = 297; Bilangan bulat2 = 297;
System.out.println("angka1==angka2: "+(angka1==angka2));
// Angka dalam -128~127
Bilangan bulat3 = 97; Bilangan bulat4 = 97;
System.out.println("num3==num4: "+(num3==num4)); Hasil cetakannya adalah: num1==num2: false num3==num4: true
Aneh: ini karena desain tinju otomatis dan unboxing Java dari Integer dan int. Ini adalah mode: disebut mode kelas terbang (kelas terbang)
Untuk meningkatkan penggunaan kembali bilangan sederhana, Java mendefinisikan: Selama pentinjuan otomatis, untuk nilai antara 128 dan 127, setelah dimasukkan ke dalam objek Integer, nilai tersebut akan disimpan dalam memori untuk digunakan kembali, dan hanya akan selalu ada satu objek. Dan jika melebihi nilai antara 128 dan 127, kotak Inte Objek ger tidak akan digunakan kembali, yang setara dengan membuat objek Integer baru setiap kali dikotak paham, fenomena di atas disebabkan oleh penggunaan tinju otomatis, tetapi ikuti Seperti kelas umum , jika Anda menggunakan new untuk membuat instance, objek baru akan dibuat setiap kali new digunakan;
Boxing dan unboxing otomatis ini tidak hanya digunakan pada tipe data dasar saja, tetapi juga pada kelas String. Misalnya saja ketika kita sering mendeklarasikan objek String:
Copy kode kodenya sebagai berikut:
String str = "sl";
//Ganti metode deklarasi berikut
String str = String baru("sl");
Autoboxing dan unboxing tipe data dasar (Primitif) adalah fungsi yang disediakan sejak J2SE 5.0. Meskipun memberikan kemudahan bagi Anda untuk mengemas tipe data dasar, ini juga menyembunyikan detailnya. Disarankan untuk menggunakannya hanya ketika Anda dapat membedakan perbedaan antara tipe data dasar dan objek.
autoboxing dan unboxing
Di Java, hampir semua yang akan diproses adalah objek (Object). Misalnya Scanner yang digunakan sebelumnya adalah objek, dan String (String) juga merupakan objek. Namun, tipe data dasar bukanlah objek, yaitu variabel yang Anda definisikan menggunakan int, double, boolean, dll., dan konstanta literal yang Anda tulis langsung di dalamnya.
Di bagian sebelumnya, kita telah melihat secara kasar kenyamanan mengoperasikan objek, dan siapa pun yang telah menggunakan Java selama beberapa waktu mengetahui bahwa terkadang tipe data dasar menjadi objek perlu diubah. Misalnya, saat menggunakan metode put() pada objek Map, parameter yang perlu diteruskan adalah objek, bukan tipe data dasar.
Anda perlu menggunakan tipe pembungkus (Wrapper Types) untuk membungkus tipe data dasar menjadi objek. Pada bagian sebelumnya, Anda sudah mengetahui bahwa sebelum J2SE 5.0, Anda perlu menggunakan pernyataan berikut untuk membungkus int menjadi objek Integer: Integer integer = new Bilangan Bulat(10) ;
Fungsi auto-boxing disediakan setelah J2SE 5.0 Anda dapat langsung menggunakan pernyataan berikut untuk mengemas tipe data dasar: Integer integer = 10;
Saat kompilasi, kompiler akan secara otomatis menentukan apakah akan melakukan tinju otomatis berdasarkan pernyataan yang Anda tulis. Dalam contoh di atas, integer mengacu pada turunan kelas Integer. Tindakan yang sama dapat diterapkan pada tipe data dasar seperti boolean, byte, short, char, long, float, double, dll. Tipe wrapper yang sesuai (Wrapper Type) Boolean, Byte, Short, Character, Long, Float atau Double akan digunakan masing-masing. Mari langsung gunakan fungsi autoboxing untuk menulis ulang Contoh 4.4.
Contoh 4.5 AutoBoxDemo.java
Copy kode kodenya sebagai berikut:
kelas publik AutoBoxDemo {
public static void main(String[] args) {
Data bilangan bulat1 = 10;
Data bilangan bulat2 = 20;
//Konversikan ke nilai ganda dan bagi dengan 3
Sistem.keluar.println(data1.doubleValue() / 3);
//Bandingkan dua nilai
Sistem.keluar.println(data1.compareTo(data2));
}
}
Program ini tampak lebih sederhana. data1 dan data2 adalah contoh Integer saat runtime dan dapat langsung melakukan operasi objek. Hasilnya adalah sebagai berikut:
3.3333333333333335
1
Cara penggunaan tinju otomatis juga bisa sebagai berikut:
Copy kode kodenya sebagai berikut:
ke dalam saya = 10;
Bilangan bulat = i;
Anda juga dapat menggunakan kelas java.lang.Number yang lebih umum untuk autoboxing. Misalnya:
Nomor angka = 3.14f;
3.14f akan secara otomatis dimasukkan ke dalam kotak sebagai Float dan kemudian ditetapkan ke nomor.
Mulai dari J2SE 5.0, tersedia automatic boxing dan automatic unboxing, yaitu informasi berupa data dasar pada objek secara otomatis dikeluarkan dari objek. Misalnya saja dapat dituliskan sebagai berikut:
Copy kode kodenya sebagai berikut:
Bilangan bulat fooInteger = 10;
int fooPrimitive = fooInteger;
Setelah fooInteger direferensikan ke sebuah instance yang secara otomatis dikotakkan sebagai Integer, jika ditugaskan ke variabel fooPrimitive bertipe int, maka secara otomatis akan diubah menjadi bertipe int dan kemudian ditetapkan ke fooPrimitive. Selama pengoperasian, box dan unboxing otomatis juga dapat dilakukan. Misalnya:
Copy kode kodenya sebagai berikut:
Bilangan bulat saya = 10;
Sistem.keluar.println(i + 10);
Sistem.keluar.println(i++);
Pada contoh di atas akan ditampilkan 20 dan 10. Kompiler akan secara otomatis melakukan tinju dan unboxing otomatis, yaitu 10 akan dikotakkan terlebih dahulu, kemudian dibuka kotaknya terlebih dahulu ketika i + 10, dan operasi penambahan akan dilakukan; baris juga akan dimasukkan ke dalam kotak terlebih dahulu dan kemudian melakukan operasi penambahan. Mari kita lihat contoh lainnya:
Copy kode kodenya sebagai berikut:
Boolean boo = benar;
Sistem.keluar.println(boo && false);
Boo yang sama awalnya merupakan turunan dari Boolean. Saat melakukan operasi AND, boo akan dibuka kotaknya terlebih dahulu, lalu di-AND dengan false, dan hasilnya akan menampilkan false.
//////////////////////////////////////////////////// /// /////////////////
Boxing: Konversi dari tipe dasar ke tipe Object disebut boxing; ***Unboxing: Operasi konversi dari Object ke tipe dasar disebut unboxing. Operasi ini biasa digunakan dalam proses refleksi.
Pengepakan: Buat instance Objek di heap dan salin nilai yang Anda tentukan; ***Unboxing: Tentukan apakah informasi di heap yang ditunjuk oleh referensi adalah tipe yang akan dipisahkan, dan ambil nilai dari heap dan kirim ke variabel tumpukan, jika tidak, pengecualian akan dilaporkan
//////////////////////////////////////////////////// /// //////////////////
Boxing adalah konversi pertapa dari tipe nilai ke tipe objek atau ke tipe antarmuka apa pun yang diimplementasikan oleh tipe nilai.
Meninju tipe nilai mengalokasikan instance objek dan menyalin nilai ke objek baru.
Copy kode kodenya sebagai berikut:
ke dalam saya=123;
objek o=i;
Hasil dari kalimat ini adalah membuat objek o di tumpukan, yang mereferensikan nilai bertipe int di tumpukan. Nilai ini ditugaskan ke variabel i
Salinan nilai tipe nilai.
Di bawah ini adalah tampilan yang melakukan konversi tinju
Copy kode kodenya sebagai berikut:
ke dalam saya=123;
objek o=(objek)i;
Contoh ini mengubah variabel integer i menjadi objek o melalui tinju. Dengan cara ini, nilai yang disimpan dalam variabel i berubah dari 123 menjadi 456. Contoh ini menunjukkan bahwa objek menyimpan salinan asli kontennya. Itu adalah 123.
Unboxing adalah konversi eksplisit dari tipe objek ke tipe nilai atau dari tipe antarmuka ke tipe nilai yang mengimplementasikan antarmuka. Operasi membuka kotak meliputi:
Memeriksa instance objek untuk memastikan itu adalah nilai kotak dari tipe nilai yang diberikan.
Menyalin nilai dari instance ke dalam variabel tipe nilai.
contoh:
Copy kode kodenya sebagai berikut:
ke dalam saya=123;
kotak objek=i;
int j=(int)kotak;
