Utiliser “this” avec le nom de la classe

Je fais de la programmation sous Android et je me suis renseigné sur les intentions, lorsque j’ai vu un constructeur qui, à mon avis, semblait funky. L’appel était:

Intent myIntent = new Intent(CurrentActivity.this, NextActivity.class); 

Les deux parameters sont nouveaux pour moi. Comment existe-t-il un “.this” statique d’un nom de classe? Est-ce une chose Java ou Android? Je suppose que c’est la même chose que de dire “ceci”, puisque je suis dans le contexte de CurrentActivity , mais je ne comprends pas comment le “this” peut être appelé à partir du nom de classe lui-même. Aussi. La classe “.class” semble être utilisée pour la reflection, que je connais bien en C #, mais toute idée à ce sujet serait également la bienvenue.

Merci.

    Habituellement, vous ne pouvez utiliser que this . Mais, parfois, this fait référence à une classe interne … donc, par exemple:

     Button button = (Button)findViewById(R.id.ticket_details_sell_ticket); button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // it will be wrong to use only "this", because it would // reference the just created OnClickListener object Intent login = new Intent(ClassName.this, Login.class); startActivityForResult(login, LOGIN_REQUEST); } }); 

    Un à la fois:

    Le premier construit s’appelle un qualifié . Le but de la syntaxe est dans le cas où vous êtes dans une classe interne (généralement une classe interne anonyme) et que vous souhaitez référencer le this de la classe externe plutôt que this de la classe interne (anonyme). Le “qualifié” ne peut être utilisé que dans un contexte où this serait ambigu. La citation JLS “C’est une erreur de compilation si l’expression se produit dans une classe ou une interface qui n’est pas une classe interne de la classe T ou T elle-même”.

    La seconde construction est appelée un class literal permet de référencer l’object Class qui représente ce type. Il peut être utilisé dans n’importe quel contexte.

    La syntaxe “Classname.this” est pour les classes internes. Si vous voulez vous référer à l’instance englobante de type “Outerclass”, vous le faites comme “Outerclass.this”.

    NextActivity.class est simplement l’object Class qui décrit la classe “NextActivity”.

    NextActivity.class dans java signifie typeof(NextActivity) en C #

    ClassName.this est utilisé pour référencer l’instance actuelle d’une classe externe d’une classe interne.

     .this 

    est utilisé dans les classes nestedes pour faire référence à l’instance actuelle de la classe englobante, puisque le mot-clé `this ‘fait référence à l’instance de la classe d’imbrication.

     classe publique Siht {
         classe NestedSiht {
             annuler la démoThis () {
                 System.err.println (" this' is an instance of: " + this.getClass().getName()); System.err.println(" this' is an instance of: " + this.getClass().getName()); System.err.println("  this' is an instance of: " + this.getClass().getName()); System.err.println(" Siht.this" est une instance de: "+
                                 Siht.this.getClass (). GetName ());
             }
         } 

     void demoThis() { new java.lang.Object() { void demoThis() { System.err.println("`this' is an instance of: " + this.getClass().getName()); System.err.println("`Siht.this' is an instance of: " + Siht.this.getClass().getName()); } }.demoThis(); new NestedSiht().demoThis(); } public static void main(Ssortingng [] args) { new Siht().demoThis(); } 

    }

    C’est déroutant seulement parce que lorsque vous utilisez ” MainActivity.this “, il semble que vous faites référence à la classe et non à l’object. En réalité, lorsque vous utilisez “this”, vous faites toujours référence à l’object actuel, comme l’indique la documentation de Java:

    https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

    Dans une méthode d’instance ou un constructeur, il s’agit d’une référence à l’object en cours – l’object dont la méthode ou le constructeur est appelé. Vous pouvez faire référence à n’importe quel membre de l’object actuel depuis une méthode d’instance ou un constructeur en utilisant ceci.

    C’est juste syntaxiquement particulier.