Qual é o significado de "this" em Java?

Normalmente eu uso this apenas em construtores.

Entendo que é usado para identificar a variável de parâmetro (usando this.something), se tiver o mesmo nome com uma variável global.

No entanto, não sei qual é o verdadeiro significado do thisJava e o que acontecerá se eu usar thissem o dot ( .).

this refere-se ao objeto atual.

Cada método não estático é executado no contexto de um objeto. Então, se você tem uma classe como esta:

public class MyThisTest {
  private int a;

  public MyThisTest() {
    this(42); // calls the other constructor
  }

  public MyThisTest(int a) {
    this.a = a; // assigns the value of the parameter a to the field of the same name
  }

  public void frobnicate() {
    int a = 1;

    System.out.println(a); // refers to the local variable a
    System.out.println(this.a); // refers to the field a
    System.out.println(this); // refers to this entire object
  }

  public String toString() {
    return "MyThisTest a=" + a; // refers to the field a
  }
}

Em seguida, chamando frobnicate()on new MyThisTest()imprimirá

1
42.
MyThisTest a = 42

Tão eficazmente você o usa para várias coisas:

• Esclareça que você está falando sobre um campo, quando também há algo mais com o mesmo nome que um campo
• consulte o objeto atual como um todo
• invoque outros construtores da classe atual em seu construtor

A seguir, copie e cole a partir daqui , mas explica muito bem todos os diferentes usos da thispalavra-chave:

Definição: A thispalavra-chave Java é usada para referenciar a instância atual do método no qual é usada.

A seguir estão as maneiras de usar isso:

1. Para indicar especificamente que a variável de instância é usada em vez da variável estática ou local. Isso é,

   private String javaFAQ;
   void methodName(String javaFAQ) {
       this.javaFAQ = javaFAQ;
   }

   Aqui, isso se refere à variável de instância. Aqui a precedência é alta para a variável local. Portanto, a ausência do thisdenota a variável local. Se a variável local que é o nome do parâmetro não for igual à variável de instância, independentemente de thisser usada ou não, isso indica a variável de instância.

2. This é usado para referir os construtores

    public JavaQuestions(String javapapers) {
        this(javapapers, true);
    }

   Isso chama o construtor da mesma classe java que possui dois parâmetros.

3. This é usado para passar a instância java atual como parâmetro

   obj.itIsMe(this);

4. Semelhante ao acima, isso também pode ser usado para retornar a instância atual

   CurrentClassName startMethod() {
        return this;
   }

   Nota: Isso pode levar a resultados indesejados enquanto usado em classes internas nos dois pontos acima. Como isso se refere à classe interna e não à instância externa.

5. This pode ser usado para obter o identificador da classe atual

   Class className = this.getClass(); // this methodology is preferable in java

   Embora isso possa ser feito por

   Class className = ABC.class; // here ABC refers to the class name and you need to know that!

Como sempre, thisestá associado à sua instância e isso não funcionará em métodos estáticos.

Para ser completo, thistambém pode ser usado para se referir ao objeto externo

class Outer {
    class Inner {
        void foo() {
            Outer o = Outer.this;
    }
  }
}

Refere-se à instância atual de um objeto específico, para que você possa escrever algo como

public Object getMe() {
    return this;
}

Um caso de uso comum de thisé evitar sombreamento. Veja o seguinte exemplo:

public class Person {
    private final String name;

    public Person(String name) {
        // how would we initialize the field using parameter?
        // we can't do: name = name;
    }
}

No exemplo acima, queremos atribuir o membro do campo usando o valor do parâmetro Como eles compartilham o mesmo nome, precisamos de uma maneira de distinguir entre o campo e o parâmetro. thispermite acessar membros dessa instância, incluindo o campo

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }
}

No Swing, é bastante comum escrever uma classe que implemente ActionListenere adicione a instância atual (ou seja, 'this') como um ActionListener para componentes.

public class MyDialog extends JDialog implements ActionListener
{
    public MyDialog()
    {
        JButton myButton = new JButton("Hello");
        myButton.addActionListener(this);
    }

    public void actionPerformed(ActionEvent evt)
    {
        System.out.println("Hurdy Gurdy!");
    }

}

É "uma referência ao objeto no contexto atual" efetivamente. Por exemplo, para imprimir "este objeto", você pode escrever:

System.out.println(this);

Observe que o uso de "variável global" está um pouco desabilitado ... se você estiver usando this.variableName, por definição, não é uma variável global - é uma variável específica para essa instância específica.

Citando um artigo em programming.guide:

thispossui dois usos em um programa Java.

1. Como referência ao objeto atual

A sintaxe nesse caso geralmente se parece com

this.someVariable = someVariable;

Este tipo de uso é descrito aqui: A referência 'this' (com exemplos)

2. Para chamar um construtor diferente

A sintaxe nesse caso normalmente se parece com

MyClass() {
    this(DEFAULT_VALUE); // delegate to other constructor
}

MyClass(int value) {
    // ...
}

Este tipo de uso é descrito aqui: esta (…) chamada do construtor (com exemplos)

Refere-se à instância na qual o método é chamado

class A {

  public boolean is(Object o) {
    return o == this;
  }

}

A someA = new A();
A anotherA = new A();
someA.is(someA); // returns true
someA.is(anotherA); // returns false

A palavra-chave this é usada para referenciar a variável atual de um bloco, por exemplo, considere o código abaixo (apenas um exemplo, então não espere o código JAVA padrão):

Public class test{

test(int a) {
this.a=a;
}

Void print(){
System.out.println(a);
}

   Public static void main(String args[]){
    test s=new test(2);
    s.print();
 }
}

É isso aí. a saída será "2". Se não usamos a palavra - chave this , a saída será: 0

Os objetos têm métodos e atributos (variáveis) derivados de classes, para especificar quais métodos e variáveis ​​pertencem a um objeto específico que a thispalavra reservada é usada. no caso de variáveis ​​de instância, é importante entender a diferença entre parâmetros implícitos e explícitos. Dê uma olhada na fillTankchamada para o audiobjeto.

Car audi= new Car();

audi.fillTank(5); // 5 is the explicit parameter and the car object is the implicit parameter 

O valor entre parênteses é o parâmetro implícito e o objeto em si é o parâmetro explícito, métodos que não possuem parâmetros explícitos, usam parâmetros implícitos, o fillTankmétodo possui um parâmetro explícito e implícito.

Vamos dar uma olhada no fillTankmétodo na Carclasse

public class Car()
{
   private double tank;

   public Car()
   {
      tank = 0;
   }

   public void fillTank(double gallons)
   {
      tank = tank + gallons;
   }

}

Nesta classe, temos uma variável de instância "tank". Pode haver muitos objetos que usam a variável de instância tank, para especificar que a variável de instância "tank" seja usada para um objeto em particular; no nosso caso, o objeto "audi" que construímos anteriormente, usamos a thispalavra-chave reservada. por exemplo, variáveis, o uso de 'this' em um método indica que a variável de instância, no nosso caso "tank", é variável de instância do parâmetro implícito.

O compilador java adiciona automaticamente a thispalavra reservada para que você não precise adicioná-la, é uma questão de preferência. Você não pode usar thissem um ponto (.) Porque essas são as regras do java (a sintaxe).

Em suma.

• Objetos são definidos por classes e têm métodos e variáveis
• O uso de thisuma variável de instância em um método indica que a variável de instância pertence ao parâmetro implícito ou que é uma variável de instância do parâmetro implícito.
• O parâmetro implícito é o objeto do qual o método é chamado, neste caso "audi".
• O compilador java adiciona automaticamente a palavra reservada, acrescentando que é uma questão de preferência
• this não pode ser usado sem um ponto (.), isso é sintaticamente inválido
• this também pode ser usado para distinguir entre variáveis ​​locais e variáveis ​​globais que têm o mesmo nome
• a thispalavra reserva também se aplica aos métodos, para indicar que um método pertence a um objeto específico.

Variáveis ​​de instância são comuns a todos os objetos que você está criando. digamos, existem duas variáveis ​​de instância

class ExpThisKeyWord{
int x;
int y;

public void setMyInstanceValues(int a, int b) {
    x= a;
    y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

}




class Demo{
public static void main(String[] args){

ExpThisKeyWord obj1 = new ExpThisKeyWord();
ExpThisKeyWord obj2 = new ExpThisKeyWord();
ExpThisKeyWord obj3 = new ExpThisKeyWord();

obj1.setMyInstanceValues(1, 2);
obj2.setMyInstanceValues(11, 22);
obj3.setMyInstanceValues(111, 222);



}
}

se você notou o código acima, iniciamos três objetos e três estão chamando o método SetMyInstanceValues. Como você acha que a JVM atribui corretamente os valores para cada objeto? existe o truque, a JVM não verá esse código como é mostrado acima. em vez disso, verá o código abaixo;

public void setMyInstanceValues(int a, int b) {
    this.x= a; //Answer: this keyword denotes the current object that is handled by JVM.
    this.y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

(Eu sei que estou atrasado, mas ela está sendo a boi sorrateira que você nunca me viu)

O presente palavra chave na maioria das linguagens de programação orientada a objetos, se não todas, significa que é uma referência à instância atual do objeto dessa classe. É essencialmente a mesma coisa que chamar esse objeto de fora do método pelo nome. Provavelmente isso não fazia sentido, tão pouco elaborado:

Fora da classe, para chamar algo nessa instância do objeto, por exemplo, digamos que você tenha um objeto chamado object e que deseje obter um campo que precisaria usar

object.field

Digamos, por exemplo, que você esteja tentando acessar object.field de dentro da sua classe, digamos, seu construtor, por exemplo, você poderia usar

this.field

A palavra - chave this substitui essencialmente a palavra - chave do nome do objeto ao ser chamada dentro da classe. Geralmente, não há muito motivo para fazer isso fora de se você tiver duas variáveis ​​com o mesmo nome, uma das quais sendo um campo da classe e a outra apenas sendo uma variável dentro de um método, isso ajuda a decifrar entre as duas . Por exemplo, se você tem o seguinte: (Hah, entendeu? Isso ? Hehe .... só eu? Ok :( vou embora agora)

public String Name;
//Constructor for {object} class
public object(String Name){
    Name = Name;
}

Isso causaria alguns problemas, o compilador não seria capaz de saber a diferença entre a variável Name definida nos parâmetros para o construtor e a variável Name dentro das declarações de campo da sua classe ', para que, em vez disso, atribuísse o parâmetro Name a .. .. o valor do parâmetro Name que não faz nada benéfico e literalmente não tem propósito. Esse é um problema comum que a maioria dos programas mais recentes faz e eu também fui vítima. De qualquer forma, a maneira correta de definir esse parâmetro seria usar:

public String Name;
//Constructor for {object} class
public object(String Name){
    this.Name = Name;
}

Dessa forma, o compilador sabe que a variável Name que você está tentando atribuir faz parte da classe e não parte do método e a atribui corretamente, o que significa que atribui o campo Name ao que você colocar no construtor.

Para resumir, ele essencialmente faz referência a um campo da instância de objeto da classe em que você está trabalhando, portanto, é a palavra-chave "this", significando que é esse objeto ou essa instância. É uma boa prática usar isso ao chamar um campo da sua classe, em vez de apenas usar o nome para evitar possíveis erros difíceis de encontrar, pois o compilador passa por cima deles.

Uma rápida pesquisa no Google trouxe esse resultado: http://xahlee.org/java-a-day/this.html

Praticamente a palavra-chave "this" é uma referência ao objeto atual (ele mesmo).

thisé uma referência ao objeto atual: http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

isso pode ser usado dentro de algum método ou construtor.

Retorna a referência ao objeto atual.

Isso se refere ao objeto em que você está "no momento". Em outras palavras, isso se refere ao objeto receptor. Você usa isso para esclarecer a qual variável você está se referindo. Página Java_whitepaper: 37

class Point extends Object
{
    public double x;
    public double y;

    Point()
    {
        x = 0.0;
        y = 0.0;
    }

    Point(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

No código de exemplo acima, this.x / this.y refere-se à classe atual que é a variável Point xey, onde (double x, double y) são valores duplos passados ​​de uma classe diferente para atribuir valores à classe atual.

Eu também estava procurando a mesma resposta e, de alguma forma, não conseguia entender o conceito claramente. Mas finalmente entendi a partir deste link

Esta é uma palavra-chave em Java. Que pode ser usado dentro do método ou construtor da classe. Funciona como uma referência a um objeto atual cujo método ou construtor está sendo chamado. essa palavra-chave pode ser usada para referenciar qualquer membro do objeto atual de dentro de um método de instância ou de um construtor.

Verifique os exemplos no link para um entendimento claro

Se as variáveis ​​de instância são iguais às variáveis ​​declaradas no construtor, usamos "this" para atribuir dados.

class Example{
     int assign;// instance variable

     Example(int assign){ // variable inside constructor
          this.assign=assign;
     }
}

Espero que isto ajude.

Em Java "isto" é uma variável predefinida. Se usarmos "this" no método, significa que estamos obtendo a referência (endereço) do objeto em execução no momento. Por exemplo.

this.age ---> age do objeto em execução no momento.

Gostaria de compartilhar o que entendi dessa palavra-chave. Esta palavra-chave tem 6 usos em java da seguinte maneira: -

1. Pode ser usado para se referir à variável de classe atual. Vamos entender com um código. *

Vamos entender o problema se não usarmos essa palavra-chave pelo exemplo abaixo:

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
id_no = id_no;  
name=name;  
salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}}  

Resultado:-

0 null 0.0
0 null 0.0

No exemplo acima, parâmetros (argumentos formais) e variáveis ​​de instância são os mesmos. Portanto, estamos usando essa palavra-chave para distinguir variável local e variável de instância.

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
this.id_no = id_no;  
this.name=name;  
this.salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}} 

resultado:

111 ankit 5000
112 sumit 6000

2. Para chamar o método de classe atual.

class A{  
void m(){System.out.println("hello Mandy");}  
void n(){  
System.out.println("hello Natasha");  
//m();//same as this.m()  
this.m();  
}  
}  
class TestThis4{  
public static void main(String args[]){  
A a=new A();  
a.n();  
}}  

Resultado:

hello Natasha
hello Mandy

3. para chamar o construtor de classe atual. É usado para encadeamento de construtores.

class A{  
A(){System.out.println("hello ABCD");}  
A(int x){  
this();  
System.out.println(x);  
}  
}  
class TestThis5{  
public static void main(String args[]){  
A a=new A(10);  
}}

Resultado:

hello ABCD
10

4. passar como argumento no método.

class S2{  
  void m(S2 obj){  
  System.out.println("The method is invoked");  
  }  
  void p(){  
  m(this);  
  }  
  public static void main(String args[]){  
  S2 s1 = new S2();  
  s1.p();  
  }  
}  

Resultado:

The method is invoked

5. passar como argumento na chamada do construtor

class B{  
  A4 obj;  
  B(A4 obj){  
    this.obj=obj;  
  }  
  void display(){  
    System.out.println(obj.data);//using data member of A4 class  
  }  
}  

class A4{  
  int data=10;  
  A4(){  
   B b=new B(this);  
   b.display();  
  }  
  public static void main(String args[]){  
   A4 a=new A4();  
  }  
} 

Resultado:-

10

6. para retornar a instância da classe atual

class A{  
A getA(){  
return this;  
}  
void msg(){System.out.println("Hello");}  
}  
class Test1{  
public static void main(String args[]){  
new A().getA().msg();  
}  
}  

Resultado:-

Hello

Além disso, essa palavra-chave não pode ser usada sem. (Ponto), pois sua sintaxe é inválida.