En Java, ¿cuál es la diferencia entre this.method () y method ()?

¿Hay alguna diferencia entre llamar this.method() y method() (incluida la diferencia de rendimiento)?

El único momento en que importa es si está usando OuterClass.this.method() por ejemplo

 class OuterClass { void method() { } class InnerClass { void method() { OuterClass.this.method(); // not the same as method(). } } } 

No hay absolutamente ninguna diferencia entre estos constructos y el bytecode generado será exactamente el mismo, por lo tanto, no tendrá impacto en el rendimiento. this se resuelve durante la comstackción si no se define explícitamente.

La única razón para usar explícitamente this es la legibilidad: para algunas personas es más fácil de leer porque this sugiere que este es un método de instancia de objeto actual.

También tenga en cuenta que si el method() es estático, se desaconseja usarlo y es engañoso.

 private static void method() { } private void foo() { this.method(); //generates warning in my IDE for a reason } 

Y en este caso, tampoco tendrá ningún efecto en el rendimiento.

No se puede ver nada llamando a javap -c ClassName en la línea de comandos. Por ejemplo:

 public class This { private void method() { } public void noThis() { method(); } public void useThis() { this.method(); } } 

Produce el siguiente resultado desmontado:

 Compiled from "This.java" public class This extends java.lang.Object{ public This(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."":()V 4: return public void noThis(); Code: 0: aload_0 1: invokespecial #2; //Method method:()V 4: return public void useThis(); Code: 0: aload_0 1: invokespecial #2; //Method method:()V 4: return } 

Para los métodos no hay diferencia, pero puede marcar la diferencia con los campos. Considera este código:

 private String someObject = "some value"; public String someMethod(String someObject) { //this.someObject refers to the field while //someObject refers to the parameter } 

No hay diferencia real: al menos no hay impacto en el rendimiento. Prefiero no escribir “esto” – El IDE generalmente puede resaltar llamadas a esto de todos modos, y creo que es menos legible cuando cada acceso a métodos / campos / … comienza con “esto”. Pero realmente es una cuestión de preferencia personal.

No hay diferencia en absoluto más que la legibilidad. Lo hace más claro para el lector.

Utilice this.method() y / o this.myVar o no – en los métodos no hay diferencia, en vars puede haber – pero sea consistente al respecto. Lo veo salpicado en todo el código, a veces incluso veo this.m_myClassVar .

Personalmente, prefiero ponerle un prefijo a mis vars de clase con un guion bajo simple y poner un guion bajo en mi args de método:

 public MyClass { private int _myInt; public void myMethod(final int myInt_, final int fooFactor_) { _myInt = myInt_ * fooFactor_; } } 

Aunque la mayoría de los IDEs dejarán en claro cuál es cuál, me parece que esto tiende a evitar una mala asignación y hace que las intenciones del código sean más claras y que la OMI sea más fácil de leer.

Utilizo _thisInstance.myMethod() (donde _thisInstance es una referencia a la clase externa) o _thisInstance._myVar , en inner classes / listeners / threads / etc. donde necesito tener claro qué método en qué clase estoy llamando y / o dónde necesito tener una referencia a una instancia de clase.

El uso de this.method () deja en claro que se está invocando una función asociada con la instancia de la clase, en oposición a una función estática o perteneciente a otro objeto.

Está en el espíritu de los desarrolladores de C ++ a quienes les gusta anteponer “m_” en todas las variables miembro en una clase. Hace que la propiedad sea inequívoca. Tiendo a gustarme, pero no es tan importante cuando estás usando un IDE que aclara tales cosas usando colores y fonts.

¿Has intentado hacer esto. Variable en el constructor?

En teoría, en C ++, dado que el objeto aún no se ha creado, no existe esto. No estoy seguro del caso en Java.