Exemple d'équivalence Code d'instance et de classe en Java

Cet article étudie principalement l'équivalence de l'instance et de la classe en Java, comme suit.

L'opérateur d'instance OFF en Java est utilisé pour indiquer si un objet est une instance d'une classe spécifique lors de l'exécution. L'instanceof indique si l'objet est une instance de cette classe particulière ou d'une sous-classe en renvoyant une valeur booléenne.

Exemple 1 (instanceof)

Interface

 Personne d'interface publique {public void Eat ();}

Implémenter la classe des personnes

 classe publique Les gens implémentent la personne {private int a = 0; @Override public void Eat () {System.out.println ("=======" + a); }}

Sous-classe XiaoMing:

 La classe publique XiaoMing étend les gens {Nom de la chaîne privée; @OverridePublic void Eat () {System.out.println ("++++++++++");}}

Fonction principale

 public static void main (String [] args) {People p = new People (); xiaoMing x = new xiaoMing (); System.out.println (p instanceof personne); System.out.println (p instanceof xiaoMing); ----- 2 System.out.println (x instanceof personne); System.out.println (x instance de personnes); }

Remarque: le code dans les 2 ci-dessus ne rapportera pas les erreurs pendant la compilation.

Résultats en cours:

 truefalsettrue

Exemple 2

 package com.test.class_obj; classe de classe {} classe dérivée étend base {} public class FamilyVSExactType {static void test (objet x) {System.out.println ("Tester x de type" + x.getClass (). getImpLename ()); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Base)); System.out.println ("x instanceof dérivé" + (x instanceof Derived));System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Derived.class.isInstance(x));System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (x.getClass (). equals (base.class))); System.out.println ("x.getClass (). Equals (Derive.Class))" + (x.getClass (). Equals (Derive.class))); System.out.println ("**************************************************"); System.out.println ("*********************************************************** ") {test (new base ()); test (new dérivé ());}}

Le contenu de sortie est le suivant:

 Tester x de type Base---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Faux *******************************************************************************************************************************************************. Dérivé ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Base.class falsex.getClass () == Derive.class trueEx.getClass (). Equals (base.class)) falsex.getClass (). true********************************************************************************************************************************************************************************************************************************* Process finished with Code de sortie 0

Grâce aux tests ci-dessus, les conclusions suivantes peuvent être tirées:

• Le résultat généré par l'instance () et iSInstance () sont les mêmes
• Le même résultat généré par equals () et ==
• La classe parent peut être une instance d'une classe d'enfants, mais la classe d'enfants ne peut pas être une instance d'une classe parent.
• L'héritage n'est pas pris en compte lors de la comparaison des objets de classe

Résumer

Ce qui précède est l'intégralité du contenu de cet article sur l'exemple de code d'équivalence de l'instance de la classe et de la classe en Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!