Java - когда использовать ключевое слово 'this'

Какова наилучшая практика использования ключевого слова this в Java? Например, у меня есть следующий класс:

class Foo {
    Bar bar;

    public Foo(Bar bar) {
         this.bar = bar;
    }
}

Это прекрасно и все, но Java достаточно умен, чтобы знать, что происходит, если я изменил оператор в конструкторе на

 bar = bar;

Итак, зачем использовать ключевое слово this? (Я понимаю, что в некоторых ситуациях совершенно необходимо использовать его, я просто прошу о таких ситуациях). На самом деле, я обычно использую ключевое слово исключительно для удобства чтения, но что такое обычная практика? Используя его во всем магазине, мой код выглядит немного грязным, например

boolean baz;
int someIndex = 5;
this.baz = this.bar.getSomeNumber() == this.someBarArray[this.someIndex].getSomeNumber();

Очевидно, что это плохой код, но он иллюстрирует мой пример. В этих случаях это зависит от личных предпочтений?

ОТВЕТЫ

Ответ 1

но Java достаточно умна, чтобы знать, что происходит, если я изменил оператор в конструкторе на

  bar = bar;

ЛОЖЬ! Он компилируется, но он не делает то, что, по вашему мнению, делает!

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

В качестве справочной информации вы можете проверить учебные материалы Oracle Java Tutorials об этом .subject; -)

http://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

Ответ 2

На самом деле

baz = baz

поднимет это предупреждение

Назначение переменной baz не имеет Эффект

Итак, что вы считаете неправильным, локальная область переопределяет атрибут класса, поэтому вы ДОЛЖНЫ использовать ключевое слово this для назначения переменной атрибуту класса.

В противном случае переменная, учтенная в присваивании, является только той, которая передается как параметр, а класс один игнорируется. Вот почему this полезен, это не факт удобочитаемости, это факт явного решения, о котором baz вы говорите.

Я бы сказал

используйте this везде, где это не используется, вызовет неоднозначность (или предупреждение компилятора, что более важно), иначе просто оставьте его. Поскольку его цель заключается в том, чтобы разрешить неоднозначность, когда предположения по умолчанию (первая проверка локальных жителей, а затем проверка атрибутов класса) недостаточно.

Ответ 3

Вы должны использовать его, когда у вас есть параметр с тем же именем, что и поле, иначе вы столкнетесь с проблемами. Он будет компилироваться, но не обязательно сделает то, что вы хотите.

Как и везде, не используйте его, если это необходимо для удобства чтения. Если вы используете его везде, 20% вашего кода будет состоять из слова 'this'!

Ответ 4

Ключевое слово

this относится к объекту класса, на котором вызывается какой-либо метод.
Например:

public class Xyz {  
    public Xyz(Abc ob)
    {
        ob.show();
    }
}

public class Abc {
    int a = 10;

    public Abc()
    {
        new Xyz(this);
    }

    public void show()
    {
        System.out.println("Value of a " + a);
    }

    public static void main(String s[])
    {
        new Abc();
    }
}

Здесь в Abc() мы вызываем Xyz(), которому нужен Object of Abc Class. Поэтому мы можем передать this вместо нового Abc(), потому что если мы передадим новый Abc() здесь, он снова вызовет себя и опять.

Также мы используем это, чтобы различать переменные класса и локальные переменные метода. например

class Abc {
    int a;

    void setValue(int a)
    {
        this.a = a;
    }
}

Здесь this.a относится к переменной a класса Abc. Следовательно, тот же эффект, что и вы используете новый Abc().a;.

Итак, вы можете сказать, что this относится к объекту текущего класса.

Ответ 5

Обычно используется это ключевое слово в вызове явного конструктора. Вы можете увидеть пример из документации.

public class Rectangle {
    private int x, y;
    private int width, height;

    public Rectangle() {
        this(0, 0, 1, 1);
    }
    public Rectangle(int width, int height) {
        this(0, 0, width, height);
    }
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
    ...
}

Ответ 6

public Foo(Bar bar) {
     this.bar = bar;
}

не совпадает с

public Foo(Bar bar) {
     bar = bar;
}

Во втором случае бар в области видимости является параметром, поэтому вы назначаете его самому себе. this.bar остается null.

Ответ 7

Это личное предпочтение - выберите стиль и придерживайтесь его. Я лично использую this, но другие считают, что он лишний.

Ответ 8

В зависимости от соглашения вы можете использовать его для удобства чтения. Он подчеркивает тот факт, что это переменная объекта.

Мне также нравятся аргументы setter с тем же именем, что и переменная (лучше выглядит в сигнатуре метода). Вам нужно this в этом случае.

Ответ 9

Я всегда стараюсь использовать ключевое слово this для локальных объектов класса.

Я использую его, чтобы визуально напомнить мне, является ли объект статическим объектом или объектом класса.

Это помогает мне и компилятору различать методы args и локальный объект класса.

public void setValue(int value){
  this.value = value;
}

Это помогает мне визуально напомнить мне, есть ли такой локальный объект во внутреннем/вложенном/анонимном классе, чтобы отличать его от инкапсуляции объектов класса. Поскольку, если нет префикса this, мое соглашение будет напоминать мне, что это объект класса инкапсуляции

public class Hello{
  public int value = 0;
  public boolean modal = false;

  public class Hellee{
    public int value = 1;
    public getValue(){
      if (modal)
        return 0;
      return this.value;
    }
  }
}

Ответ 10

void set(int real)
{
    this.real = real;
}

здесь this - это ключевое слово, используемое, когда переменная экземпляра такая же, как и локальная. другое использование this - это перегрузка конструктора. он может вызвать конструктор в перегруженном конструкторе.

Ответ 11

Личные предпочтения, но я использую его только для устранения двусмысленностей, и я предполагаю, что в очень редком случае сделать очевидным, что назначенная переменная является полем. Есть несколько проектов, в которых люди используют "this.field" для каждой ссылки на поле. Я нахожу эту практику визуально отвлекающей до такой степени неприятной, но вы должны быть готовы видеть такой код время от времени.

Я тайно считаю там особое место в аду для людей, которые пишут 500 линейных классов, в которых есть 275 'this' ключевых слов в них, но этот стиль встречается в некоторых проектах с открытым исходным кодом, поэтому каждому из них я думаю.

Ответ 12

Используйте его для клонирования объектов (путем передачи ссылки на себя через конструктор копирования).

Полезно для объекта, который наследует Cloneable.

public Foo implements Cloneable {
  private String bar;

  public Foo(Foo who) {
    bar = who.bar;
  }

  public Object getClone() {
    return new Foo(this);  //Return new copy of self.
  }
}