"Hai, Amigo! Topik pelajaran hari ini adalah meluaskan dan menyempitkan penukaran jenis. Anda telah lama belajar tentang meluaskan dan menyempitkan jenis primitif. Pada Tahap 10. Hari ini kita akan bercakap tentang cara ia berfungsi untuk jenis rujukan, iaitu contoh kelas."

Sebenarnya, semuanya agak mudah. Bayangkan rantaian warisan kelas: kelas, induknya, induk induk, dsb., sepanjang perjalanan kembali ke kelas Objek. Oleh kerana kelas mengandungi semua kaedah ahli kelas yang diwarisinya , contoh kelas boleh disimpan dalam pembolehubah yang jenisnya adalah mana-mana ibu bapanya.

Berikut ialah contoh:

Kod Penerangan 
class Animal
{
public void doAnimalActions();
}class Cat extends Animal
{
public void doCatActions();
}class Tiger extends Cat
{
public void doTigerActions();
}
 Di sini kita mempunyai tiga pengisytiharan kelas: Haiwan, Kucing dan Harimau. Kucing mewarisi Haiwan. Dan Harimau mewarisi Kucing. 
public static void main(String[] args)
{
Tiger tiger = new Tiger();
Cat cat = new Tiger();
Animal animal = new Tiger();
Object obj = new Tiger();
}
 Objek Harimau sentiasa boleh diberikan kepada pembolehubah yang jenisnya adalah salah satu daripada nenek moyangnya. Untuk kelas Harimau, ini ialah Kucing, Haiwan dan Objek.
Java university

Sekarang mari kita lihat pada melebarkan dan mengecilkan penukaran.

Jika operasi penugasan menyebabkan kami bergerak ke atas rantaian warisan (ke arah kelas Objek), maka kami sedang berhadapan dengan penukaran yang semakin meluas (juga dikenali sebagai upcasting). Jika kita bergerak ke bawah rantai ke arah jenis objek, maka ia adalah penukaran yang mengecil (juga dikenali sebagai downcasting).

Bergerak ke atas rantaian warisan dipanggil pelebaran, kerana ia membawa kepada jenis yang lebih umum. Walau bagaimanapun, dengan berbuat demikian kita kehilangan keupayaan untuk menggunakan kaedah yang ditambahkan pada kelas melalui pewarisan.

Kod Penerangan 
public static void main(String[] args)
{
Object obj = new Tiger();
Animal animal = (Animal) obj;
Cat cat = (Cat) obj;
Tiger tiger = (Tiger) animal;
Tiger tiger2 = (Tiger) cat;
}
 Apabila menyempitkan jenis, anda perlu menggunakan operator penukaran jenis, iaitu kami melakukan penukaran eksplisit.

Ini menyebabkan mesin Java menyemak sama ada objek itu benar-benar mewarisi jenis yang ingin kita tukarkan.

Inovasi kecil ini menghasilkan pengurangan berlipat ganda dalam bilangan ralat pemutus jenis, dan meningkatkan kestabilan program Java dengan ketara.
Kod Penerangan 
public static void main(String[] args)
{
Object obj = new Tiger();
if (obj instanceof Cat)
{
Cat cat = (Cat) obj;
cat.doCatActions();
}}
 Lebih baik lagi, gunakan  instanceof check 
public static void main(String[] args)
{
Animal animal = new Tiger();
doAllAction(animal);

Animal animal2 = new Cat();
doAllAction(animal2);

Animal animal3 = new Animal();
doAllAction(animal3);
}

public static void doAllAction(Animal animal)
{
if (animal instanceof Tiger)
{
Tiger tiger = (Tiger) animal;
tiger.doTigerActions();
}

if (animal instanceof Cat)
{
Cat cat = (Cat) animal;
cat.doCatActions();
}

animal.doAnimalActions();
}
 Dan inilah sebabnya. Lihat contoh di sebelah kiri.

Kami (kod kami) tidak selalu tahu jenis objek yang kami gunakan. Ia boleh menjadi objek jenis yang sama dengan pembolehubah (Haiwan), atau mana-mana jenis keturunan (Kucing, Harimau).

Pertimbangkan kaedah doAllAction. Ia berfungsi dengan betul, tanpa mengira jenis objek yang dilalui.

Dalam erti kata lain, ia berfungsi dengan betul untuk ketiga-tiga jenis: Haiwan, Kucing dan Harimau.

 
public static void main(String[] args)
{
Cat cat = new Tiger();
Animal animal = cat;
Object obj = cat;
}
 Di sini kita mempunyai tiga operasi tugasan. Kesemuanya adalah contoh penukaran yang meluas.

Operator jenis cast tidak diperlukan di sini, kerana tiada semakan diperlukan. Rujukan objek sentiasa boleh disimpan dalam pembolehubah yang jenisnya adalah salah satu nenek moyangnya.

"Oh, contoh kedua hingga terakhir menjelaskan segala-galanya: mengapa semakan diperlukan dan mengapa penghantaran jenis diperlukan."

"Saya harap begitu. Saya ingin menarik perhatian anda kepada fakta ini:"

Tiada satu pun daripada ini menyebabkan objek berubah dalam apa cara sekalipun! Satu-satunya perkara yang berubah ialah bilangan kaedah yang tersedia untuk dipanggil pada pembolehubah rujukan tertentu.

Contohnya, pembolehubah Cat membolehkan anda memanggil kaedah doAnimalActions dan doCatActions. Ia tidak tahu apa-apa tentang kaedah doTigerActions, walaupun ia menunjuk kepada objek Tiger.

"Ya, saya faham. Ia lebih mudah daripada yang saya sangkakan."