Ключевое слово this {в примерах}

На JavaRush студентов буквально с первых лекций знакомят с ключевым словом this. И со временем становится понятно, что все же оно означает. Но многие, обернувшись назад, наверное, честно себе скажут, что долго не могли осознать дзен этого ключевого слова. В статье приоткрываем завесу тайн применения ключевика this для тех, кто до сих пор в него не может… Welcome! Если вы возьмете справочник Шилдта по Java, то на 171 странице вы прочитаете о том, что ключевое слово this требуется для того, чтобы метод мог сослаться на вызвавший его объект. На этом, собственно можно было бы и закончить. Но нам нужна конкретика. Как правило, применять this нужно в двух случаях:

1. Когда у переменной экземпляра класса и переменной метода/конструктора одинаковые имена;
2. Когда нужно вызвать конструктор одного типа (например, конструктор по умолчанию или параметризированный) из другого. Это еще называется явным вызовом конструктора.

Вот и все, на самом деле не так много, — всего два случая, когда применяется это страшное ключевое слово. Теперь давайте рассмотрим эти две ситуации на примерах.

Пример первый — у переменной экземпляра и метода одинаковые имена

Допустим, у нас есть класс Human, для которого определено поле «имя»: Давайте для переменной name создадим сеттер (setter вполне рабочий и никакого подвоха здесь нет): Обратите внимание, что в метод (сеттер) setName мы передаем переменную String newName. Мы ввели новую переменную и (в общем-то) могли назвать ее как угодно ведь она будет видна только в пределах {фигурных скобок} метода setName. Обратите внимание, что в сеттере есть одна строка:

name = newName;

То есть по факту мы ввели новую переменную newName и присвоили ее уже существующей в классе переменной name. Многим программистом казалось это странным, — вводить переменную с новым именем, если в итоге речь идет об одном и том же. Об имени в классе Human. Поэтому, разработчики языка задумались о том, чтобы удобно сделать использование одного имени переменной. Другими словами, зачем иметь два имени для переменной, обозначающей одно и то же. То есть хотелось бы сделать как-то так: Но в этом случае возникает проблема. У нас теперь две переменные, которые называются одинаково. Один String name принадлежит классу Human, а другой String name его методу setName. Поэтому Java – машина не знает, какую переменную вы имеете ввиду, когда пишете строку в сеттере:

name = name;

Java берет самую близкую – name из метода setName: и получается, что вы просто присваиваете значение переменной name из этого метода, ей же. Что конечно не имеет никакого смысла. Поэтому нужен был какой-то способ, чтобы отличить переменную name из класса Human, от переменной name из метода setName.Для решения этой проблемы и было введено ключевое слово this, которое в данном случае укажет, что нужно вызывать переменную не метода, а класса Human: То есть this сошлется на вызвавший объект, как было сказано в начале статьи. В результате чего имя человека через сеттер setName будет установлено создаваемому объекту. Ниже приведен программный код без использования ключевого слова this. В коде создается объект класса Human и присваивается ему имя: А ниже программный код с ключевым словом this:

public class Solution{
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Volodya");
        human1.print();
    }
}
class Human{
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print(){
        System.out.println(name);
    }
}

Таким образом, здесь this позволяет не вводить новые переменные для обозначения одного и того же, что позволяет сделать код менее «перегруженным» дополнительными переменными.

Пример второй — Применение this для явного вызова конструктора

Вызов одного конструктора из другого может пригодиться тогда, когда у вас (как ни странно) несколько конструкторов и вам не хочется в новом конструкторе переписывать код инициализации, приведенный в конструкторе ранее. Запутал? Все не так страшно как кажется. Посмотрите на код ниже, в нем два конструктора класса Human:

class Human{
    int age;
    int weight;
    int height;

    Human(int age, int weight){
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height){
        //вы вызываете конструктор с двумя параметрами
        this(age, weight);
        //и добавляете недостающую переменную
        this.height = height;
    }
}

Здесь у нас сначала приводится конструктор с двумя параметрами, который принимает int age и int weight. Допустим, мы написали в нем две строчки кода:

this.age = age;
this.weight = weight;

а потом решили добавить еще один конструктор, с тремя параметрами, который помимо возраста и веса принимает еще и рост. В новом конструкторе вы бы могли написать так:

this.age = age;
this.weight = weight;
this.height = height;

Но вместо того, чтобы повторять уже написанный ранее код в этом конструкторе, вы можете с помощью ключевого слова this явно вызвать конструктор с двумя параметрами:

this(age, weight);
// и дописываете недостающую переменную:
this.height = height;

Таким образом, вы как-бы говорите конструктору с тремя параметрами:

• вызови this (этот) конструктор, который имеет два параметра.
• и добавить недостающую переменную.

Вот и все =). Напоследок отметим, что ключевое слово this в Java используется только в составе методов либо конструкторов экземпляра класса. Но неявно ключевое слово this передается во все методы, кроме статических (поэтому this часто называют неявным параметром) и может быть использовано для обращения к объекту, вызвавшему метод. Бояться этого ключевого слова не нужно, потому что This не страшно.