Question

我想知道对象何时以及为什么会引用自己。我正在使用＆＃39;这个＆＃39;来阅读内部课程。关键字，这有点令人困惑。一个简单的例子和解释会很棒。

Answer 1

当您想在同一对象中引用实例方法或变量时（例如在构造函数中），以便将参数与实例变量区分开来

class MyClass {

     private int valueA;
     private int valueB;

     public MyClass(int valueA, int valueB) {
         this.valueA = valueA;
         this.valueB = valueB;
     }

}

Answer 2

考虑以下代码：

class MyClass {
    private int myvar = 1;

    public int returnMyVar() {
        int myvar = 2;
        // return myvar;
        // or
        // return this.myvar;
    }
}

在returnMyVar方法中声明的myvar局部变量会掩盖MyClass.myvar，因此如果我要取消注释第一个返回，则返回2。如果我取消注释第二个返回，则返回1，因为我们指的是此类的myvar字段。

这在构造函数和setter中经常出现，其中参数通常与它们填充的字段具有相同的名称。

public void setMyVar(int myvar) {
    this.myvar = myvar;
}

Answer 3

this的一个用途是防止被称为变量阴影的东西。＆＃34;基本上，当变量在不同的范围内声明时，无法确定您所引用的变量。

例如：

public class Person{
  private String name = "Defaulty McDefaultinstein";

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

在这种情况下，我们如何知道（第5行）应该将哪个名称设置为哪个名称？

如果我们改为：

public class Person{
  private String name = "Defaulty McDefaultinstein";

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

我们明确地说，属于类的名称应该设置为传递给方法的名称，现在它都是肉汁。< / p>

Answer 4

此关键字的典型用途是two：

- 因为某个字段被方法或构造函数参数遮蔽。

public class Point {
  public int x = 0;
  public int y = 0;

  //constructor
  public Point(int x, int y) {
      this.x = x;
      this.y = y; 
  }
}

- 在同一个类中调用另一个构造函数。

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

另外一个原因是可读性。

但是，实现builder pattern时非常方便，因为您可能需要返回对象本身。

public class PersonBuilder
{
   private String newLastName;
   private String newFirstName;
   private String newMiddleName;

   public PersonBuilder()
   {
   }

   public PersonBuilder setNewLastName(String newLastName) {
      this.newLastName = newLastName;
      return this;
   }

   public PersonBuilder setNewFirstName(String newFirstName) {
      this.newFirstName = newFirstName;
      return this;
   }

   public PersonBuilder setNewMiddleName(String newMiddleName) {
      this.newMiddleName = newMiddleName;
      return this;
   }


   public Person createPerson() {
      return new Person(newLastName, newFirstName, newMiddleName);
   }
}

希望这有帮助。

Answer 5

我没有想到的另一个重要原因已经被覆盖（好的，我在评论中看到Jeroen暗示了这一点）：

有时，对象只需要在另一个类中告诉自己的方法。我的头脑中的一个例子：假设你有一个Message抽象类，其中action()方法对消息执行适当的操作。假设有一个MessageQueue类跟踪可以立即执行操作的消息，并且有其他方法可以在以后通过队列执行现在可能执行的操作：< / p>

public class MessageQueue {
    public void queue(Message m) { ... }
    // other methods
}

某种类型的Message可能有action()方法，在某些情况下，可能希望将自己排队以便稍后调用：

public class MessageTypeA extends Message {

    @Override
    public void action() {
         if (webConnection.completed()) {
             // do the action
         } else {
             MessageQueue q = // find out what queue to put myself on
             q.queue(this);   // ********* HERE *********
         }
    }
}

你为什么要传递一个引用呢？

5 个答案: