Neste artigo, aprenderemos sobre essa palavra-chave em Java, como e onde usá-la com a ajuda de exemplos.
esta palavra-chave
Em Java, esta palavra-chave é usada para se referir ao objeto atual dentro de um método ou construtor. Por exemplo,
class Main ( int instVar; Main(int instVar)( this.instVar = instVar; System.out.println("this reference = " + this); ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("object reference = " + obj); ) )
Produto :
esta referência = Principal @ 23fc625e referência de objeto = Principal @ 23fc625e
No exemplo acima, criamos um objeto denominado obj da classe Main. Em seguida, imprimimos a referência ao objeto obj e thispalavra - chave da classe.
Aqui, podemos ver que a referência de obj e thisé a mesma. Isso significa que nada mais é do que a referência ao objeto atual.
Uso desta palavra-chave
Existem várias situações em que a thispalavra-chave é comumente usada.
Usando isso para nomes de variáveis de ambiguidade
Em Java, não é permitido declarar duas ou mais variáveis com o mesmo nome dentro de um escopo (escopo de classe ou escopo de método). No entanto, variáveis e parâmetros de instância podem ter o mesmo nome. Por exemplo,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
No programa acima, a variável de instância e o parâmetro têm o mesmo nome: idade. Aqui, o compilador Java fica confuso devido à ambigüidade do nome.
Em tal situação, usamos esta palavra-chave. Por exemplo,
Primeiro, vamos ver um exemplo sem usar thispalavras-chave:
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); ) )
Produto :
mc.age = 0
No exemplo acima, passamos 8como um valor para o construtor. No entanto, estamos obtendo 0uma saída. Isso ocorre porque o compilador Java fica confuso por causa da ambigüidade nos nomes entre a instância da variável e o parâmetro.
Agora, vamos reescrever o código acima usando a thispalavra-chave.
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); ) )
Produto :
obj.age = 8
Agora, estamos obtendo a saída esperada. É porque quando o construtor é chamado, thisdentro do construtor é substituído pelo objeto obj que chamou o construtor. Portanto, a variável de idade recebe o valor 8.
Além disso, se o nome do parâmetro e da variável de instância forem diferentes, o compilador anexará automaticamente esta palavra-chave. Por exemplo, o código:
class Main ( int age; Main(int i) ( age = i; ) )
é equivalente a:
class Main ( int age; Main(int i) ( this.age = i; ) )
isso com Getters e Setters
Outro uso comum de thispalavra-chave é nos métodos setters e getters de uma classe. Por exemplo:
class Main ( String name; // setter method void setName( String name ) ( this.name = name; ) // getter method String getName()( return this.name; ) public static void main( String() args ) ( Main obj = new Main(); // calling the setter and the getter method obj.setName("Toshiba"); System.out.println("obj.name: "+obj.getName()); ) )
Produto :
obj.name: Toshiba
Aqui, usamos a thispalavra-chave:
- atribuir valor dentro do método setter
- para acessar o valor dentro do método getter
Usando isso na sobrecarga do construtor
Ao trabalhar com a sobrecarga do construtor, podemos ter que invocar um construtor de outro construtor. Nesse caso, não podemos chamar o construtor explicitamente. Em vez disso, temos que usar thispalavras-chave.
Aqui, usamos uma forma diferente desta palavra-chave. Ou seja this(),. Vamos dar um exemplo,
class Complex ( private int a, b; // constructor with 2 parameters private Complex( int i, int j )( this.a = i; this.b = j; ) // constructor with single parameter private Complex(int i)( // invokes the constructor with 2 parameters this(i, i); ) // constructor with no parameter private Complex()( // invokes the constructor with single parameter this(0); ) @Override public String toString()( return this.a + " + " + this.b + "i"; ) public static void main( String() args ) ( // creating object of Complex class // calls the constructor with 2 parameters Complex c1 = new Complex(2, 3); // calls the constructor with a single parameter Complex c2 = new Complex(3); // calls the constructor with no parameters Complex c3 = new Complex(); // print objects System.out.println(c1); System.out.println(c2); System.out.println(c3); ) )
Produto :
2 + 3i 3 + 3i 0 + 0i
No exemplo acima, usamos a thispalavra-chave,
- para chamar o construtor
Complex(int i, int j)do construtorComplex(int i) - para chamar o construtor
Complex(int i)do construtorComplex()
Observe a linha,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
class ThisExample ( // declare variables int x; int y; ThisExample(int x, int y) ( // assign values of variables inside constructor this.x = x; this.y = y; // value of x and y before calling add() System.out.println("Before passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); // call the add() method passing this as argument add(this); // value of x and y after calling add() System.out.println("After passing this to addTwo() method:"); 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); ) )
Produto :
Antes de passar para o método addTwo (): x = 1, y = -2 Depois de passar para o método addTwo (): x = 3, y = 0
No exemplo acima, dentro do construtor ThisExample(), observe a linha,
add(this);
Aqui, estamos chamando o add()método passando isso como um argumento. Como essa palavra-chave contém a referência ao objeto obj da classe, podemos alterar o valor de xey dentro do add()método.
