Java esta palavra-chave

Java esta palavra-chave

Neste artigo, aprenderemos sobre essa palavra-chave em Java, como e onde usá-la com a ajuda de exemplos.

esta palavra-chave

Em Java, essa 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);
    }
}

Saída :

this reference = Main@23fc625e
object reference = Main@23fc625e

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

Aqui, podemos ver que a referência de ambos obj e this é o mesmo. Isso significa que isso nada mais é do que a referência ao objeto atual.

---

Uso desta palavra-chave

Existem várias situações em que this palavra-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 ​​de instância e parâmetros 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 está confuso devido à ambiguidade do nome.

Em tal situação, usamos esta palavra-chave. Por exemplo,

Primeiro, vamos ver um exemplo sem usar this palavra-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);
    }
}

Saída :

obj.age = 0

No exemplo acima, passamos 8 como um valor para o construtor. No entanto, estamos recebendo 0 como saída. Isso ocorre porque o compilador Java fica confuso devido à ambiguidade nos nomes entre a instância da variável e o parâmetro.

Agora, vamos reescrever o código acima usando this palavra-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);
    }
}

Saída :

obj.age = 8

Agora, estamos obtendo a saída esperada. É porque quando o construtor é chamado, this dentro do construtor é substituído pelo objeto obj que chamou o construtor. Daí a idade à variável é atribuído o valor 8 .

Além disso, se o nome do parâmetro e da variável de instância for diferente, o compilador anexará automaticamente essa 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 this palavra-chave está em 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());
   }
}

Saída :

obj.name: Toshiba

Aqui, usamos this palavra-chave:

• para 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 sobrecarga de 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 this palavra-chave.

Aqui, usamos uma forma diferente dessa 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);
    }
}

Saída :

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

No exemplo acima, usamos this palavra-chave,

• chamar o construtor Complex(int i, int j) do construtor Complex(int i)
• chamar o construtor Complex(int i) do construtor Complex()

Observe a linha,

System.out.println(c1);

Aqui, quando imprimimos o objeto c1 , o objeto é convertido em uma string. Nesse processo, o toString() é chamado. Como substituímos o toString() dentro de nossa classe, obtemos a saída de acordo com esse método.

Uma das grandes vantagens do this() é reduzir a quantidade de código duplicado. No entanto, devemos sempre ter cuidado ao usar this() .

Isso ocorre porque chamar o construtor de outro construtor adiciona sobrecarga e é um processo lento. Outra grande vantagem de usar this() é reduzir a quantidade de código duplicado.

Observação :Chamar um construtor de outro construtor é chamado de invocação explícita do construtor.

---

Passando isso como um argumento

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

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);
    }
}

Saída :

Before passing this to addTwo() method:
x = 1, y = -2
After passing this to addTwo() method:
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 esta palavra-chave contém a referência ao objeto obj da classe, podemos alterar o valor de x e s dentro do add() método.