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

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

  bar = bar; 

ЛОЖНЫЙ! Он компилируется, но он не делает то, что вы думаете, что он делает!

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

В качестве ссылки вы можете проверить учебные пособия Oracle по Java this.subject 😉

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

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

Что касается повсюду, не используйте его, если это не требуется для удобства чтения. Если вы используете его везде, 20% вашего кода будет состоять из слова «это»!

На самом деле

 baz = baz 

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

Назначение переменной baz не влияет

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

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

я бы сказал

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

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

 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а и локальные переменные метода. например

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

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

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

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

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

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

это не то же самое, что

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Полезно для объекта, который наследует 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. } }