blocks|key|1306026|text|这是个人喜好--选择一种风格并坚持下去。我个人使用this，但其他人认为它是多余的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1306027|entityMap^0|P|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

It is a personal preference - choose a style and stick to it. I personally use <code>this</code> but others think it is redundant.

blocks|key|1306068|text|根据约定，您可以将其用于可读性。它强调了它是一个对象变量的事实。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1306069|我也喜欢setter参数与变量同名(在方法签名中看起来更好)。在这种情况下，您需要this。|offset|length|style|CODE|1306070|entityMap^0|0|15|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Depending on convention, you can use it for readability. It stresses the fact that it's an object variable.

I also like to have setter arguments with the same name as the variable (looks better in method signature). You need <code>this</code> in this case.

blocks|key|1090883|text|当你有一个与字段同名的参数时，你应该使用它，否则你会遇到问题。它可以编译，但不一定会做你想要的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1090884|至于其他任何地方，除非为了可读性而需要，否则不要使用它。如果你到处使用它，你20%25的代码将包含'this‘这个单词！|1090885|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You should use it when you have a parameter with the same name as a field otherwise you will run into issues. It will compile, but won't necessarily do what you want it to.

As for everywhere else, don't use it unless it's needed for readability's sake. If you use it everywhere, 20% of your code will consist of the word 'this'!

blocks|key|1306187|text|public+Foo(Bar+bar)+{
+++++this.bar+=+bar;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1306188|不同于|unstyled|1306189|public+Foo(Bar+bar)+{
+++++bar+=+bar;
}|1306190|在第二种情况下，作用域中的bar是参数，因此您将其分配给自己。this.bar仍然是null。|offset|length|style|CODE|1306191|entityMap^0|0|0|0|V|8|16|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>public Foo(Bar bar) {
 this.bar = bar;
}
</code></pre>

is not the same as

<pre><code>public Foo(Bar bar) {
 bar = bar;
}
</code></pre>

In the second case the bar in scope is the parameter, so you assign it to itself. <code>this.bar</code> remains <code>null</code>.

blocks|key|1306272|text|个人偏好，但我只使用它来解决歧义，我认为在非常罕见的情况下，我认为很明显，分配的变量是一个字段。在一些项目中，人们在每个字段引用上都使用"this.field“。我发现这种做法在视觉上让人分心，以至于令人讨厌，但您应该准备好偶尔看到这样的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1306273|我暗自认为，对于那些写了500行包含275个“this”关键字的类的人来说，在地狱里有一个特殊的地方，但这种风格在一些开源项目中是可以找到的，所以我猜每个人都有自己的风格。|1306274|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Personal preference, but I use it to solve ambiguities only, and I suppose in the very rare case to make it obvious that the assigned variable is a field. There are some projects where people use "this.field" on every single field reference. I find this practice visually distracting to the point of being obnoxious, but you should be prepared to see such code once in a while.

I secretly think there's a special place in hell for people who write 500 line classes that have 275 'this' keywords in them, but this style is found in some open source projects, so to each his own I guess.

blocks|key|1306363|text|我总是尝试在本地类对象上使用this关键字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1306364|我用它来直观地提醒我一个对象是静态对象还是类对象。|1306365|它帮助我和编译器区分方法args和本地类对象。|1306366|public+void+setValue(int+value){
++this.value+=+value;
}|code-block|syntax|javascript|1306367|它帮助我在视觉上提醒我在内部/嵌套/匿名类中是否有这样的本地对象，以将其与封装类对象区分开来。因为如果没有this前缀，我的约定将提醒我它是封装类的对象|1306368|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;
++++}
++}
}|1306369|entityMap^0|E|4|0|0|0|0|1H|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

I always try to use <code>this</code> keyword on local class objects.

I use it to visually remind me if an object is static object or class object.

It helps me and the compiler differentiate between method args and local class object.

<pre><code>public void setValue(int value){
 this.value = value;
}
</code></pre>

It helps me to visually remind me if there is such a local object in an inner/nested/anonymous class to differentiate it from encapsulating class objects. Because if there is not <code>this</code> prefixed, my convention will remind me that it is an object of the encapsulating class 

<pre><code>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;
 }
 }
}
</code></pre>

blocks|key|1306435|text|this关键字是指调用某个方法的类的对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1306436|例如：|1306437|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+"+%2B+a);
++++}

++++public+static+void+main(String+s[])
++++{
++++++++new+Abc();
++++}
}|code-block|syntax|javascript|1306438|在Abc()中，我们调用Xyz()，它需要Abc类的对象。所以我们可以传递this而不是新的Abc()，因为如果我们在这里传递新的Abc()，它会一次又一次地调用它自己。|1306439|我们还用它来区分类的变量和方法的局部变量。e.g|1306440|class+Abc+{
++++int+a;

++++void+setValue(int+a)
++++{
++++++++this.a+=+a;
++++}
}|1306441|这里this.a是指Abc类的变量a。因此与使用新的Abc().a;具有相同的效果。|1306442|所以你可以说this指的是当前类的对象。|1306443|entityMap^0|0|4|0|0|0|1|5|C|5|11|4|1A|5|1T|5|0|0|0|2|6|Q|8|0|6|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|X|$]]

<code>this</code> keyword refers to the Object of class on which some method is invoked. 
For example:

<pre><code>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();
 }
}
</code></pre>

Here in <code>Abc()</code> we are calling <code>Xyz()</code> which needs Object of Abc Class.. So we can pass <code>this</code> instead of new <code>Abc()</code>, because if we pass new <code>Abc()</code> here it will call itself again and again. 

Also we use this to differentiate variables of class and local variables of method. e.g

<pre><code>class Abc {
 int a;

 void setValue(int a)
 {
 this.a = a;
 }
}
</code></pre>

Here <code>this.a</code> is refers to variable a of class Abc. Hence having same effect as you use new <code>Abc().a;</code>.

So you can say <code>this</code> refers to object of current class.

blocks|key|1306463|text|使用它来克隆对象(通过复制构造函数传递自身的引用)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1306464|对于继承Cloneable的对象非常有用。|offset|length|style|CODE|1306465|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.
++}
}|code-block|syntax|javascript|1306466|entityMap^0|0|4|9|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Use it for Cloning objects (by passing reference of itself through a copy constructor).

Useful for object that inherits <code>Cloneable</code>.

<pre><code>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.
 }
}
</code></pre>

blocks|key|1091358|text|void+set(int+real)
{
++++this.real+=+real;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1091359|在这里，this是当实例变量与局部变量相同时使用的关键字。|unstyled|offset|length|style|CODE|1091360|this的另一个用途是构造函数重载。它可以在重载的构造函数中调用构造函数。|1091361|entityMap^0|0|4|4|0|0|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@$G|T|H|U|I|J]]|9|@]|A|$]]|$1|M|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>void set(int real)
{
 this.real = real;
}
</code></pre>

here <code>this</code> is a keyword used when there is instance variable is same as the local variable. 
another use of <code>this</code> is constructor overloading. it can call the constructor in a overloaded constructor.

What is the best practise for using the <code>this</code> keyword in Java? For example, I have the following class:

<pre><code>class Foo {
 Bar bar;

 public Foo(Bar bar) {
 this.bar = bar;
 }
}
</code></pre>

That's fine and all, but Java is clever enough to know what is happening if I change the statement in the constructor to

<pre><code> bar = bar;
</code></pre>

So why use the <code>this</code> keyword? (I realise in some situations, it's totally necessary to use it, I'm just asking for situations like this). Actually, I tend to use the keyword purely for readability sake but what's the common practise? Using it all over the shop makes my code look a bit messy, for example

<pre><code>boolean baz;
int someIndex = 5;
this.baz = this.bar.getSomeNumber() == this.someBarArray[this.someIndex].getSomeNumber();
</code></pre>

Obviously a poor bit of code but it illustrates my example. Is it just down to personal preference in these cases?

Java - when to use 'this' keyword

编译器

Java

在Java中使用this关键字的最佳实践是什么？例如，我有以下类：class Foo {    Bar bar;    public Foo(Bar bar) {         this.bar = bar;    }}这很好，但是Java足够聪明，如果我将构造函数中的语句改为 bar = bar;那么为什么要使用t...

问Java -何时使用'this‘关键字
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java -何时使用'this‘关键字EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java -何时使用'this‘关键字
EN