Palavra-chave this Java

Neste artigo, vamos entender através de exemplos a palavra-chave this no Java, como e onde usá-la.

Palavra-chave this

A palavra-chave this no Java é usada para referenciar o objeto atual dentro de um método ou construtor. Por exemplo,

class Main {
　　　　int instVar;
　　　　Main(int instVar){
　　　　　　　　this.instVar = instVar;
　　　　　　　　System.out.println("Referência this= ",　+　this);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("Referência de objeto= ",　+　obj);
　　　　}
}

Saída:

Referência this = com.ThisAndThat.MyClass@74a14482
Referência de objeto = com.ThisAndThat.MyClass@74a14482

No exemplo acima, criamos um objeto chamado obj da classe Main. Em seguida, imprimimos a referência do objeto da classe obj e da palavra-chave this.

Aqui, podemos ver que a referência obj e this são as mesmas. Isso significa que isso é apenas uma referência para o objeto atual.

Usar a palavra-chave this

Em várias situações, o uso da palavra-chave this é comum.

Usar o método this para resolver a ambiguidade de nomes de variáveis

No Java, não é permitido declarar duas ou mais variáveis com o mesmo nome dentro de um escopo (escopo de classe ou método). No entanto, as variáveis de instância e os parâmetros podem ter o mesmo nome. Por exemplo,

class MyClass {
　　　　//　Variável de instância
　　　　int age;
　　　　//　Parâmetro
　　　　MyClass(int age){
　　　　　　　　age = age;
　　　　}
}

No programa acima, a variável de instância e o parâmetro têm o mesmo nome: age. Aqui, devido ao nome não claro, o compilador Java se confunde.

Neste caso, usamos a palavra-chave this. Por exemplo,

Primeiro, vamos ver um exemplo que não usa a palavra-chave this:

class Main {
　　　　int age;
　　　　Main(int age) {
　　　　　　　　age = age;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("obj.age = ",　+　obj.age);
　　　　}
}

Saída:

mc.age = 0

No exemplo acima, já atribuímos um valor8Foi passado para o construtor. No entanto, o 0 que obtemos é a saída. Isso ocorre porque o compilador Java se confunde devido ao nome não claro entre as variáveis de instância e os parâmetros.

现在，让我们使用this关键字重写上面的代码。

class Main {
　　　　int age;
　　　　Main(int age) {
　　　　　　　　this.age = age;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("obj.age = ",　+　obj.age);
　　　　}
}

Saída:

obj.age =　8

现在，我们得到了预期的输出。这是因为当构造函数被调用时，构造函数内部的内容被调用构造函数的对象obj所替换。因此，age变量被赋值为8。

另外，如果参数和实例变量的名称不同，则编译器会自动附加this关键字。例如代码：

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　age = i;
　　　　}
}

等同于：

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　this.age = i;
　　　　}
}

this 与Getters和Setters

this关键字的另一个常见用法是在类的setter和getter方法中。例如：

class Main {
　　　String name;
　　　//　setter 方法
　　　void setName(String name) {
　　　　　　　this.name = name;
　　　}
　　　//　getter 方法
　　　String getName() {
　　　　　　　return this.name;
　　　}
　　　public static void main(String[] args) {
　　　　　　　Main obj = new Main();
　　　　　　　//　调用setter和getter方法
　　　　　　　obj.setName("Seagull");
　　　　　　　System.out.println("obj.name: ",+obj.getName());
　　　}
}

Saída:

obj.name: Seagull

在这里，我们使用了this关键字：

• 在setter方法中分配值

• 在getter方法中访问值

在构造函数重载中使用this

在处理在构造函数重载时，我们可能必须从一个构造函数调用另一个构造函数。在这种情况下，我们不能显式调用构造函数。相反，我们必须使用this关键字。

在这里，我们使用this关键字的另一种形式。也就是this()。让我们举一个例子

class Complex {
　　　　private int a, b;
　　　　//构造函数带有两个参数
　　　　private Complex(int i, int j) {
　　　　　　　　this.a = i;
　　　　　　　　this.b = j;
　　　　}
　　　　//Construtor com um único parâmetro
　　　　private Complex(int i) {
　　　　　　　　//Chamada do construtor com dois parâmetros
　　　　　　　　this(i, i);　
　　　　}
　　　　//Construtor sem parâmetros
　　　　private Complex() {
　　　　　　　　//Chamada do construtor com um único parâmetro
　　　　　　　　this(0);
　　　　}
　　　　@Override
　　　　public String toString() {
　　　　　　　　return this.a　+　"　+　"　+　this.b　+　"i";
　　　　}
　　　　public static void main(String[] args) {
　　
　　　　　　　　　　　　　　　　//Criar objeto da classe Complex
　　　　　　　　　　　　　　　　//Usar2parâmetros chamada do construtor　
　　　　　　　　Complex c1　= new Complex(2,　3);　
　　　　
　　　　　　　　//Chamada do construtor com um único parâmetro
　　　　　　　　Complex c2　= new Complex(3);
　　　　　　　　//Chamada do construtor sem parâmetros
　　　　　　　　Complex c3　= new Complex();
　　　　　　　　//Imprimir objeto
　　　　　　　　System.out.println(c1);
　　　　　　　　System.out.println(c2);
　　　　　　　　System.out.println(c3);
　　　　}
}

Saída:

2　+　3i
3　+　3i
0　+　0i

No exemplo acima, usamos a palavra-chave this,

• Chama o construtor Complex(int i) a partir do construtor Complex(int i, int j)

• Chama o construtor Complex() a partir do construtor Complex(int i)

Atenção a esta linha,

System.out.println(c1);

Aqui, quando imprimimos o objeto c1Quando o objeto é convertido em uma string. Durante esse processo, será chamado toString(). Como reescrevemos o método toString() na classe, obtemos a saída com base nisso.

　Uma das maiores vantagens do this() é reduzir a quantidade de código repetido. Mas, ao usar this(), devemos ser especialmente cuidadosos.

　Isso porque chamar um construtor a partir de outro aumenta o overhead e é um processo lento. Outra grande vantagem de usar this() é reduzir a quantidade de código repetido.

Atenção：Chamar um construtor a partir de outro construtor é chamado de chamada de construtor explícita.

this como parâmetro

Podemos usar a palavra-chave this para passar o objeto atual como parâmetro para um método. Por exemplo,

class ThisExample {
　　　　//　declarar variáveis
　　　　int x;
　　　　int y;
　　　　ThisExample(int x, int y) {
　　　　　　　　　　//Atribuição de valores para variáveis dentro do construtor
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　　　　　//Os valores de x e y antes da chamada de add()
　　　　　　　　System.out.println("Antes de passar this para o método addTwo():");
　　　　　　　　System.out.println("x = ")}　+　this.x　+　", y = ",　+　this.y);
　　　　　　　　//Chama o método add() passando this como parâmetro
　　　　　　　　add(this);
　　　　　　　　//Os valores de x e y após a chamada de add()
　　　　　　　　System.out.println("Depois de passar this para o método addTwo():");
　　　　　　　　System.out.println("x = ")}　+　this.x　+　", y = ",　+　this.y);
　　　　}
　　　　void add(ThisExample o){
　　　　　　　　o.x　+=　2;
　　　　　　　　o.y　+=　2;
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ThisExample obj = new ThisExample(1,　-2);
　　　　}
}

Saída:

Antes de passar this para o método addTwo():
x =　1, y =　-2
Depois de passar this para o método addTwo():
x =　3, y = 0

No exemplo acima, na função construtora ThisExample(), note a linha a seguir:

add(this);

Aqui, chamamos o método add() passando this como parâmetro. Porque o operador this contém uma referência ao objeto da classe obj, podemos alterar os valores de x e y no método add().