instanceOf dalam Java

InstanceOf dalam Java digunakan untuk menentukan hubungan objek dengan kelasnya apabila konsep pewarisan dilaksanakan dalam coretan kod Java. Kelas instanceOf, secara amnya, boleh digunakan untuk bahasa pengaturcaraan berorientasikan objek yang membenarkan pewarisan, dan ia mengembalikan nilai output dalam bentuk hasil boolean, iaitu, sama ada benar atau palsu. Jika pembolehubah kelas instanceOf mempunyai nilai NULL, maka kelas mengembalikan output sebagai 'palsu'. Memandangkan kelas ini digunakan untuk tujuan perbandingan, ia juga dipanggil sebagai 'pengendali perbandingan jenis'.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks:

Kelas instanceOf digunakan untuk menyemak sama ada objek itu daripada mana-mana kelas atau tidak.

obj instanceOf object

Di atas ialah sintaks standard untuk kelas instanceOf. Di sini, obj ialah nama objek yang mesti dibuat lebih awal (rujukan). instanceOf ialah kata kunci, dan objek ialah kelas atau antara muka yang kita sepadan dengan objek obj.

Dalam pelbagai kes, instanceOf boleh dibuktikan sebagai kegunaan utama, seperti di mana kami mempunyai koleksi objek, dan anda tidak pasti objek mana yang dirujuk. Contoh kes sedemikian boleh menjadi bentuk mudah dengan banyak kawalan.

Selain itu, jika sekiranya kita menggunakan instanceOf dengan pembolehubah yang mempunyai nilai NULL, ia pasti akan mengembalikan palsu.

Bagaimana instanceOf berfungsi?

Operator instanceOf dalam java berfungsi pada hubungan is-a mudah. Secara ringkasnya, is-a relationship ialah konsep berorientasikan objek, di mana kita membandingkan atau, katakan, bekerja pada hubungan antara abstraksi, di mana kelas A ialah subkelas kelas B. Ini adalah hubungan yang sepenuhnya berdasarkan warisan. Dalam erti kata lain, ia seperti mengatakan, “X ialah jenis Y”.

Sekarang, mari kita fahami cara kerja instanceOf, bersama-sama dengan kod masing-masing.

Mula-mula, kami akan membuat kelas bernama Ibu Bapa.

Kod:

class Parent{
}
//Then let’s add a simple main class.
public static void main(String args[]) {
}

Kami kemudian akan membuat tika kelas Induk kami.

Parent child = new Parent();

Akhir sekali, kami akan menggunakan operator instanceOf untuk menyemak hubungan antara anak dan Ibu Bapa. Yang berbunyi seperti ini: child instanceOf Parent

Sekarang, seperti yang dinyatakan sebelum ini, sintaks untuk instanceOf pergi daripada objek yang perlu diperiksa, kemudian kata kunci instanceOf dan kemudian kelas/antara muka yang mana objek yang diberikan akan diuji.

Pada bila-bila masa di mana kita temui dengan kata kunci "lanjutkan" atau "melaksanakan" dalam perisytiharan kelas, ini adalah tanda yang jelas bahawa perhubungan sedang digunakan.

Contoh instanceOf dalam Java

Contoh berikut menunjukkan penggunaan satu baris instanceOf.

class instanceof_java{
public static void main(String args[]) {
instanceof_java s = new instanceof_java();
System.out.println(s instanceOf instanceof_java);
}
}

Tafsiran Kod: Bermula dengan mencipta instanceof_java kelas mudah. Dalam instanceof_java kelas, kami mempunyai kelas utama kami, dan dalam kelas utama kami, kami mempunyai objek yang dicipta. Objek s ini adalah jenis instanceof_java. Kemudian untuk melaksanakan kerja instanceOf, kami menyediakan pernyataan output dengan objek s. Dalam baris terakhir, kami lulus s bersama-sama dengan instanceof kata kunci dan kelas induk. Selepas pelaksanaan, kod akan kembali 'true' kerana objek s adalah jenis instanceof.

Bergerak lebih jauh, jika kami mempunyai objek kelas atau antara muka kami yang diketahui tetapi tidak memberikan sebarang nilai kepada objek yang sama, ia pasti akan mengembalikan palsu, walaupun kami daripada kelas yang sama.

class instanceof_sample{
public static void main(String args[]) {
instanceof_sample new = null;
System.out.println(new instanceOf instanceof_sample);
}
}

Di sini kita mempunyai kod yang sama seperti yang kita ada untuk contoh terdahulu, tetapi dengan objek nilai nol. Apabila dilaksanakan, kod ini akan kembali palsu. Seperti yang dapat kita lihat, object new ialah instance of_sample, tetapi new sedang diberikan dengan nilai nol, yang kembali dalam false.

Peraturan contohnyaOf Operator

Berdasarkan sama ada objek ref bukan batal dan contoh jenis yang dirujuk. Apabila X ialah kelas mudah bagi objek yang dirujuk dan Y ialah kelas yang diselesaikan atau tatasusunan jenis antara muka.

• When X is a simple class, then:
• If Y is a class type, then the X must be a subclass of Y, or X must the same class as Y.
• If Y is an interface type, then the X class must implement interface T.
• When X is type interface, then:
• If Y is a class type, then the Y must be an Object.
• Y can be the same as the interface as X or super interface of X if Y is an interface type.
• If X is a class, which is representing the array type SC[], which is an array of type SC components, then:
• If Y is a class type, then Y must be an object.
• If Y is an interface type, then Y must be of interface type implemented by arrays.

Finally, we will demonstrate an instanceOf program to understand that the parent object cannot be an instance of the child class.

Program

class Subject {  }
class Topic extends Subject { }
class instanceof_java
{
public static void main(String[] args)
{
Subject history = new Subject ();
if (history instanceof Topic)
System.out.println("history is instance of Topic");
else
System.out.println("history is NOT instance of Topic");
}
}

Code Interpretation: For the purpose of understanding the instanceOf operator in different scenarios, we wrote the above code. We created a simple class Subject and then another class Topic, which extends class Subject, making the class Topic as child and class Subject as Parent here. Then another class with the main method. Within the main method, we created a new instance of parent class Subject. In the IF ELSE loop, we checked the instance object’s condition with the parent class Subject. If the condition was fulfilled, it would return “history is an instance of Topic” and “history is NOT an instance of Topic” if the condition fails.

Upon executing the above code, the output will be “history is NOT an instance of Topic”, meaning the condition passed in IF fails. It happened because we tried to check the parent of the object “history” with the class Topic. We know that the class Topic extends the class Subject, meaning Topic is a subclass to Subject. And when we tried to check the type of history with class Topic, it returns false (NOT). This means the Parent Object cannot be an instance of a class.

 Output:

Conclusion

We have learned about instanceOf class in Java, which simply decides if the object is of the given type. We understood how is-a relationship impacts on instanceOf operator. Also known as a comparison operator, instanceOf is based on inheritance.

Atas ialah kandungan terperinci instanceOf dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!