Домашнее задание: сравнение даты [дубликат]

Второе важное использование this (помимо скрытия с локальной переменной, о чем уже говорят многие ответы) - это обращение к внешнему экземпляру из вложенного нестатического класса:

public class Outer {
  protected int a;

  public class Inner {
    protected int a;

    public int foo(){
      return Outer.this.a;
    }

    public Outer getOuter(){
      return Outer.this;
    }
  }
}

this не влияет на итоговый код - это оператор времени компиляции, и код, сгенерированный с ним или без него, будет таким же. Когда вы должны использовать его, зависит от контекста. Например, вы должны использовать его, как вы сказали, когда у вас есть локальная переменная, которая изменяет переменную класса, и вы хотите ссылаться на переменную класса, а не на локальную.

изменить: по «результирующий код будет тот же «Я имею в виду, конечно, когда какая-то переменная в локальной области не скрывает того, что принадлежит классу. Таким образом,

class POJO {
   protected int i;

   public void modify() {
      i = 9;
   }

   public void thisModify() {
      this.i = 9;
   }
}

полученный код обоих методов будет таким же. Разница будет в том, что если какой-либо метод объявляет локальную переменную с тем же именем

  public void m() {
      int i;
      i = 9;  // i refers to variable in method's scope
      this.i = 9; // i refers to class variable
  }

Вам нужно использовать this - и большинство людей используют его только при наличии локальной локальной переменной с таким же именем. (Например, методы сеттера.)

Конечно, еще одна веская причина использовать this в том, что она вызывает всплытие intellisense в IDE:)

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

Есть много хороших ответов, но есть еще одна очень небольшая причина, чтобы поместить this всюду. Если вы попытались открыть исходные коды из обычного текстового редактора (например, блокнот и т. Д.), Использование this сделает его более понятным для чтения.

Представьте это:

public class Hello {
    private String foo;

    // Some 10k lines of codes

    private String getStringFromSomewhere() {
        // ....
    }

    // More codes

    public class World {
        private String bar;

        // Another 10k lines of codes

        public void doSomething() {
            // More codes
            foo = "FOO";
            // More codes
            String s = getStringFromSomewhere();
            // More codes
            bar = s;
        }
    }
}

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

Вам будет трудно узнать, где находится foo, пока вы не используйте функцию «Найти» редактора. Тогда вы будете кричать на getStringFromSomewhere() по той же причине. Наконец, после того, как вы забыли, что s есть, bar = s даст вам последний удар.

Сравните это с этим:

public void doSomething() {
    // More codes
    Hello.this.foo = "FOO";
    // More codes
    String s = Hello.this.getStringFromSomewhere();
    // More codes
    this.bar = s;
}

1. Вы знаете, что foo - переменная, объявленная во внешнем классе Hello.
2. Вы знаете, что getStringFromSomewhere() - это метод, объявленный также в внешнем классе.
3. Вы знаете, что bar принадлежит классу World, а s - локальная переменная, объявленная в этом методе.

Конечно, всякий раз, когда вы что-то создаете, вы создаете правила. Поэтому при разработке вашего API или проекта, если ваши правила включают «если кто-то открывает все эти исходники с помощью блокнота, он или она должен стрелять в себя в голову», тогда вы совершенно не хотите делать это .

Ключевое слово this используется в основном в трех ситуациях. Первый и наиболее распространенный в методах setter для устранения неоднозначности ссылок на переменные. Во-вторых, когда необходимо передать текущий экземпляр класса в качестве аргумента методу другого объекта. Третий - это способ вызова альтернативных конструкторов из конструктора.

Случай 1: Использование this для устранения неоднозначности ссылок на переменные. В методах настройки Java мы обычно передаем аргумент с тем же именем, что и переменная частного члена, которую мы пытаемся установить. Затем мы назначим аргумент x на this.x. Это дает понять, что вы присваиваете значение параметра «name» переменной экземпляра «name».

public class Foo
{
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

Случай 2: Использование this в качестве аргумента, переданного другому объекту.

public class Foo
{
    public String useBarMethod() {
        Bar theBar = new Bar();
        return theBar.barMethod(this);
    }

    public String getName() {
        return "Foo";
    }
}

public class Bar
{
    public void barMethod(Foo obj) {
        obj.getName();
    }
}

Случай 3: Использование this для вызова альтернативных конструкторов. В комментариях trinithis правильно указал еще одно общее использование this. Когда у вас есть несколько конструкторов для одного класса, вы можете использовать this(arg0, arg1, ...) для вызова другого конструктора по вашему выбору, если вы делаете это в первой строке своего конструктора.

class Foo
{
    public Foo() {
        this("Some default value for bar");

        //optional other lines
    }

    public Foo(String bar) {
        // Do something with bar
    }
}

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