example - java static member

Java: Class.this

Question

Tengo un programa Java que se ve así.

public class LocalScreen {

   public void onMake() {
       aFuncCall(LocalScreen.this, oneString, twoString);
   }
}

¿Qué significa LocalScreen.this en aFuncCall ?

Answer 1

El compilador toma el código y hace algo como esto con él:

public class LocalScreen 
{
    public void method() 
    {
        new LocalScreen$1(this).run;
    }

    public String toString() 
    {
        return "A LocalScreen object"; 
    }

    public void onMake(LocalScreen ls) { /* ... */ }

    public static void main(String[] args) 
    {
        new LocalScreen().method();
    }
}

class LocalScreen$1
     extends Runnable
{
    final LocalScreen $this;

    LocalScreen$1(LocalScreen $this)
    {
        this.$this = $this;
    }

    public void run() 
    {
        // Prints "An anonymous Runnable"
        System.out.println(this.toString());

        // Prints "A LocalScreen object"
        System.out.println($this.toString());

        // Won''t compile! ''this'' is a Runnable!
        //onMake(this);

        // Compiles! Refers to enclosing object
        $this.onMake($this);
    }

    public String toString() 
    {
        return "An anonymous Runnable!";
    }
}

Como puede ver, cuando el compilador toma una clase interna, la convierte en una clase externa (esta fue una decisión de diseño hecha hace mucho tiempo, por lo que no era necesario cambiar las máquinas virtuales para comprender las clases internas).

Cuando se crea una clase interna no estática, necesita una referencia a la matriz para que pueda invocar métodos / variables de acceso de la clase externa.

Esto dentro de lo que era la clase interna no es del tipo apropiado, necesita obtener acceso a la clase externa para obtener el tipo correcto para llamar al método onMake.

Answer 2

Sé cuál es tu confusión. Ahora me encuentro con el problema, debería tener una escena especial para distinguirlos.

class THIS {
  def andthen = {
    new THIS {
      println(THIS.this.## + ":inner-THIS.this.##")
      println(this.## + ":inner-this.##")
      new THIS {
        println(THIS.this.## + ":inner-inner-THIS.this.##")
        println(this.## + ":inner-this.##")
      }
    }
  }
  def getInfo = {
    println(THIS.this.## + ":THIS.this.##")
    println(this.## + ":this.##")
  }
}

Puede ver la diferencia entre THIS.this y this en la nueva operación THIS por hashcode (. ##)

prueba en la consola scala:

scala> val x = new THIS
x: THIS = THIS@5ab9b447

scala> val y = x.andthen
1522119751:inner-THIS.this.##
404586280:inner-this.##
1522119751:inner-inner-THIS.this.##
2027227708:inner-this.##
y: THIS = THIS$$anon$1@181d7f28

scala> x.getInfo
1522119751:THIS.this.##
1522119751:this.##

THIS.this siempre apunta a la THIS.this ESTA clase que se refiere por val x, pero this está más allá de la operación nueva anónima.

Answer 3

Significa la instancia de la clase LocalScreen externa.

Escribir this sin un calificador devolverá la instancia de la clase interna en la que se encuentra la llamada.

Answer 4

Class.this permite el acceso a la instancia de la clase externa. Vea el siguiente ejemplo.

public class A
{
  final String name;
  final B      b;
  A(String name) {
    this.name = name;
    this.b = new B(name + "-b");
  }

  class B
  {
    final String name;
    final C      c;
    B(String name) {
      this.name = name;
      this.c = new C(name + "-c");
    }

    class C
    {
      final String name;
      final D      d;
      C(String name) {
        this.name = name;
        this.d = new D(name + "-d");
      }

      class D
      {
        final String name;
        D(String name) {
          this.name = name;
        }

        void printMe()
        {
          System.out.println("D: " + D.this.name); // `this` of class D
          System.out.println("C: " + C.this.name); // `this` of class C
          System.out.println("B: " + B.this.name); // `this` of class B
          System.out.println("A: " + A.this.name); // `this` of class A
        }
      }
    }
  }
  static public void main(String ... args)
  {
    final A a = new A("a");
    a.b.c.d.printMe();
  }
}

Entonces lo conseguirás.

D: a-b-c-d
C: a-b-c
B: a-b
A: a

Answer 5

LocalScreen.this refiere a this de la clase LocalScreen.this .

Este ejemplo debería explicarlo:

public class LocalScreen {

    public void method() {

        new Runnable() {
            public void run() {
                // Prints "An anonymous Runnable"
                System.out.println(this.toString());

                // Prints "A LocalScreen object"
                System.out.println(LocalScreen.this.toString());

                // Won''t compile! ''this'' is a Runnable!
                //onMake(this);

                // Compiles! Refers to enclosing object
                onMake(LocalScreen.this);
            }

            public String toString() {
                return "An anonymous Runnable!";
            }
        }.run();
    }

    public String toString() { return "A LocalScreen object";  }

    public void onMake(LocalScreen ls) { /* ... */ }

    public static void main(String[] args) {
        new LocalScreen().method();
    }
}

Salida:

An anonymous Runnable!
A LocalScreen object

Esta publicación ha sido reescrita como un artículo here .