InstanzOf in Java

InstanceOf wird in Java zum Bestimmen der Beziehung eines Objekts zu seiner Klasse verwendet, wenn das Vererbungskonzept im Java-Code-Snippet implementiert ist. Die Klasse „instanceOf“ gilt im Allgemeinen für die objektorientierten Programmiersprachen, die die Vererbung ermöglichen, und gibt die Ausgabewerte in Form boolescher Ergebnisse zurück, also entweder „true“ oder „false“. Wenn die Klassenvariable „instanceOf“ einen NULL-Wert hat, gibt die Klasse die Ausgabe als „false“ zurück. Da diese Klasse zu Vergleichszwecken verwendet wird, wird sie auch als „Typvergleichsoperator“ bezeichnet.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

Die Klasse „instanceOf“ wird verwendet, um zu überprüfen, ob das Objekt einer Klasse angehört oder nicht.

obj instanceOf object

Oben ist die Standardsyntax für die Instanz der Klasse aufgeführt. Dabei ist obj der Name des Objekts, das zuvor erstellt worden sein muss (Referenz). „instanceOf“ ist das Schlüsselwort und „obj“ ist die Klasse oder Schnittstelle, mit der wir das obj-Objekt abgleichen.

InstanceOf kann in verschiedenen Fällen nachweislich von großem Nutzen sein, beispielsweise wenn wir eine Sammlung von Objekten haben und Sie nicht sicher sind, auf welches Objekt es sich bezieht. Ein Beispiel für einen solchen Fall kann ein einfaches Formular mit vielen Steuerelementen sein.

Außerdem wird, falls wir „instanceOf“ mit einer Variablen verwenden, die einen NULL-Wert hat, mit Sicherheit „false“ zurückgegeben.

Wie funktioniert das?

Der InstanceOf-Operator in Java arbeitet mit einer einfachen Ist-A-Beziehung. Vereinfacht ausgedrückt ist eine Ist-eine-Beziehung ein objektorientiertes Konzept, bei dem wir eine Beziehung zwischen Abstraktionen vergleichen oder beispielsweise daran arbeiten, wobei Klasse A eine Unterklasse von Klasse B ist. Dies ist eine Beziehung, die vollständig auf Vererbung basiert. Mit anderen Worten, es ist, als würde man sagen: „X ist vom Typ Y“.

Lassen Sie uns nun die Funktionsweise von „instanceOf“ zusammen mit dem entsprechenden Code verstehen.

Zuerst erstellen wir eine Klasse mit dem Namen Parent.

Code:

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

Wir erstellen dann eine Instanz unserer übergeordneten Klasse.

Parent child = new Parent();

Zuletzt verwenden wir den Operator „instanceOf“, um die Beziehung zwischen „Kind“ und „Eltern“ zu überprüfen. Das geht so: Child-InstanceOf Parent

Wie bereits erwähnt, geht die Syntax für „instanceOf“ nun von einem Objekt aus, das überprüft werden muss, dann vom Schlüsselwort „instanceOf“ und dann von der Klasse/Schnittstelle, mit der das gegebene Objekt getestet werden soll.

An jedem Punkt, an dem wir in einer Klassendeklaration auf das Schlüsselwort „extends“ oder „implements“ stoßen, ist dies ein klares Zeichen dafür, dass eine is-a-Beziehung verwendet wird.

Beispiele für „instanceOf“ in Java

Das folgende Beispiel zeigt die Verwendung von „instanceOf.

“ in einer einzelnen Zeile

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

Codeinterpretation: Begonnen mit der Erstellung einer einfachen Klasse „instanceof_java“. In der Klasse „instanceof_java“ haben wir unsere Hauptklasse und innerhalb unserer Hauptklasse haben wir ein Objekt erstellt. Dieses Objekt ist vom Typ „instanceof_java“. Um dann die Funktionsweise von „instanceOf“ zu implementieren, haben wir eine Ausgabeanweisung mit Objekt s bereitgestellt. In der letzten Zeile haben wir s zusammen mit dem Schlüsselwort „instanceof“ und der übergeordneten Klasse übergeben. Bei der Ausführung gibt der Code „true“ zurück, da das Objekt s vom Typ „instanceof“ ist.

Wenn wir weitergehen, wenn wir ein Objekt unserer bekannten Klasse oder Schnittstelle haben, aber demselben Objekt keinen Wert zugewiesen haben, wird es zwangsläufig false zurückgeben, auch wenn wir derselben Klasse angehören.

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

Hier haben wir einen ähnlichen Code wie im vorherigen Beispiel, jedoch mit einem Nullwertobjekt. Bei der Ausführung gibt dieser Code „false“ zurück. Wie wir sehen können, ist das Objekt „new“ die Instanz von „instanceof_sample“, aber „new“ wird mit einem Nullwert zugewiesen, der „false“ zurückgibt.

Regeln für „instanceOf Operator“

Basierend darauf, ob die Objektreferenz nicht null und eine Instanz des referenzierten Typs ist. Wenn X die einfache Klasse des Objekts ist, auf das verwiesen wird, und Y die aufgelöste Klasse oder ein Array eines Schnittstellentyps ist.

• 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.

Das obige ist der detaillierte Inhalt vonInstanzOf in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!