В Java, почему люди добавляют поля к `this`?

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

Пример:

public class Person {        
    private String name;

    public String toString() {
        return this.name;
    }
}

В toString, почему бы просто не указать name как name?

return name;

Что покупает this.name?

Вот вопрос с вопросом о стеке, чей код имеет this предварительно ожидающий.

Ответ 1

По той же причине, почему некоторые люди предпочитают добавлять личные данные с помощью "m_" или именных интерфейсов "IFoo". Они считают, что это повышает читаемость и ясность. Независимо от того, согласны ли вы с такими конвенциями, это вопрос вкуса.

Ответ 2

Оборонительное программирование (в случае, если кто-то редактирует код позже, добавляет параметр или локальный с конфликтующим именем
Сделайте код "самодокументирующимся", более очевидным

Ответ 3

Иногда необходимо устранить неоднозначность:

public void setFoo(Bar foo) {
    this.foo = foo;
}

В других случаях это просто стилистическая вещь. В целом я стараюсь избегать this.blah, когда это возможно, поскольку это более подробно. Если вам интересно, результирующий байт-код будет точно таким же.

Ответ 4

Он ничего не делает на уровне языка. Но это дает немедленное указание на то, что кто-то читает код об объеме переменной, что улучшает понимание кода.

Ответ 5

Я чаще всего вижу, как люди это делают, потому что он вызывает intellisense. Я лично предпочитаю оставить "это". потому что он создает больше кода без каких-либо значений.

Ответ 6

В .NET мире средство Microsoft StyleCop также имеет правило "Префикс локальных вызовов с этим":

Нарушение этого правила происходит, когда код содержит вызов члена экземпляра локального класса или базового класса, который не имеет префикса с этим. Исключение из этого правила возникает, когда существует локальное переопределение член базового класса, и код намеревается непосредственно вызвать элемента базового класса, минуя локальное переопределение. В этом случае вызов может иметь префикс "база". а не "это".

По умолчанию StyleCop запрещает использование символов подчеркивания или m_ для маркировки полей локального класса, в пользу "this". префикс. Преимущество использования этого. заключается в том, что он одинаково применим ко всем типам элементов, включая методы, свойства и т.д., а не только поля, делая все вызовы членам класса мгновенно узнаваемыми, независимо от того, какой редактор используется для просмотра кода. Другим преимуществом является то, что он создает быструю, узнаваемую дифференциацию между членами экземпляра и статическими элементами, которые не имеют префикса.

Последнее преимущество использования этого. префикс заключается в том, что набрав это. приведет к тому, что Visual Studio отобразит всплывающее окно IntelliSense, чтобы разработчик мог быстро и просто выбрать участника класса.

Мое предложение - выбрать соглашение (используйте это или нет) и придерживаться этого.

Ответ 7

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

Ответ 8

Немного в стороне, но может быть стоит отметить, что инструмент "Очистить" в Eclipse можно настроить на автоматическое добавление/удаление этого. доступ к элементам в соответствии с предпочтением.

"Стиль Java/код/очистка" в диалоговом окне настроек.

Ответ 9

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

Ответ 10

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

Это не влияет на производительность, это не создает проблем для чтения (если вообще облегчает чтение).

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

Ответ 11

Единственное место, которое я использую это, - это конструкторы в классах, где некоторый/большинство полей класса может быть предоставлен конструктором. Я использую это вместо использования коротких имен для подписи метода, это просто кажется более последовательным, чем аббревиатура.

Например, в классе "Rational"

Вместо того, чтобы делать

class Rational
{
    int denominator;
    int numerator;

    public Rational(int d, int n)
    {
        denominator = d;
        numerator = n;
    }
}

Я делаю это.

class Rational
{
    int denominator;
    int numerator;

    public Rational(int denominator, int numerator)
    {
        this.denominator = denominator;
        this.numerator = numerator;
    }
}

Таким образом, абоненты знают больше о параметрах конструкторов.

Ответ 12

Они, возможно, программист на Python и подвергаются пыткам/потерям/запутываются без явного этого.

Ответ 13

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

Если вы используете PHP, использование $this обычно требуется при ссылке на переменные класса. С разными правилами между языками часто проще всего придерживаться шаблона, который является общим между ними, шаблона, который так и бывает, является очень строгим стилем кодирования. Мне легче просто добавить this ко всему, чем попытаться вспомнить, какой язык ему нужен, и какой язык просто "предпочитает" его.

Ответ 14

"this" предотвращает путаницу с переменными экземпляра с тем же именем в родительском классе /es.

Это в значительной степени дополнение к добавлению с помощью "супер".

Ответ 15

Я пытаюсь использовать "this.whatever" при написании больших кусков кода, потому что было легче выяснить, на что ссылаются. При чтении больших фрагментов кода, написанных другими людьми, я в некоторых случаях часто путался, ссылались ли они на переменные экземпляра или локальные переменные.

Ответ 16

Код более простой. Другая хорошая практика, на мой взгляд, вызывает getXXX() в toString() тоже (вместо этого this.XXX), becuse getXXX() может иметь важную логику.

Я думаю, что использовать имя атрибута без этого is'nt хорошая идея для поддержания приложения.