这不会影响结果代码——它是编译时操作符，有或没有它生成的代码都是一样的。当你必须使用它时，取决于上下文。例如，你必须使用它，当你有一个局部变量，它掩盖了类变量你想引用类变量而不是局部变量。

edit:“生成的代码将是相同的”，我的意思当然是，当局部作用域中的某个变量没有隐藏属于类的变量时。因此

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的第二个重要用途(除了用局部变量隐藏之外，很多人已经说过了)是在从嵌套的非静态类访问外部实例时:

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

这是对当前对象的引用。它在构造函数中用于区分具有相同名称的局部类变量和当前类变量。例如:

public class circle {
    int x;
    circle(int x){
        this.x =x;
        //class variable =local variable 
    }
} 

这也可以用于从另一个构造函数调用一个构造函数。例如:

public class circle {
    int x;

    circle() { 
        this(1);
    }

    circle(int x) {
        this.x = x; 
    }
}

this关键字主要用于三种情况。第一种也是最常见的方法是在setter方法中消除变量引用的歧义。第二种情况是需要将当前类实例作为参数传递给另一个对象的方法。第三种方法是从构造函数内部调用备用构造函数。

案例1:使用this来消除变量引用的歧义。在Java setter方法中，我们通常传递一个与我们试图设置的私有成员变量同名的参数。然后我们将参数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
    }
}

我还见过这种情况，用来强调实例变量被引用(不需要消除歧义)，但在我看来，这种情况很少见。

除非你有重叠的变量名，这只是为了在你阅读代码时清晰。

这在构建器模式中很有用。

public class User {

    private String firstName;
    private String surname;

    public User(Builder builder){
        firstName = builder.firstName;
        surname = builder.surname;
    }

    public String getFirstName(){
        return firstName;
    }

    public String getSurname(){
        return surname;
    }

    public static class Builder {
        private String firstName;
        private String surname;

        public Builder setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder setSurname(String surname) {
            this.surname = surname;
            return this;
        }

        public User build(){
            return new User(this);
        }

    }

    public static void main(String[] args) {
        User.Builder builder = new User.Builder();
        User user = builder.setFirstName("John").setSurname("Doe").build();
    }

}