blocks|key|1307382|text|从构造函数内部将this传递给另一个方法/对象可能是相当危险的。当从构造函数内部查看时，对象通常满足的许多保证并不一定是真的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1307383|例如，如果您的类有一个final+(非static)字段，那么您通常可以依赖于它被设置为一个值，并且永远不会改变。|1307384|当您查看的对象当前正在执行其构造函数时，则该保证不再成立。|1307385|另一种方法是，您可以延迟ClassAHandler对象的构造，直到第一次需要它(例如，通过在该属性的getter中执行延迟初始化)。|1307386|entityMap^0|8|4|0|B|5|J|6|0|0|C|D|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|M|$]]

Passing <code>this</code> to another method/object from inside the constructor can be rather dangerous. Many guarantees that objects usually fulfill are not necessarily true, when they are looked at from inside the constructor.

For example if your class has a <code>final</code> (non-<code>static</code>) field, then you can usually depend on it being set to a value and never changing.

When the object you look at is currently executing its constructor, then that guarantee no longer holds true.

As an alternative you could delay the construction of the <code>ClassAHandler</code> object until it is first needed (for example by doing lazy initialization in the getter of that property).

blocks|key|1092210|text|创建一个registerHandler(ClassA处理程序)方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1092211|没有办法为处理程序不知道的事情创建处理程序。|1092212|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|$]]

Create a registerHandler(ClassA handler) method.

There is no way to create a handler for something the handler doesn't know about.

blocks|key|1092239|text|为ClassAattr编写一个getter方法，如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1092240|++++++++++++public+boolean+isClassAattr(){
+++++++++++++++++return+this.ClassAattr;
++++++++++++}|code-block|syntax|javascript|1092241|这样你就可以像ca.isClassAattr()一样访问它；|1092242|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Write a getter method for ClassAattr, as 

<pre><code> public boolean isClassAattr(){
 return this.ClassAattr;
 }
</code></pre>

So that you can get access it as ca.isClassAattr();

blocks|key|1307508|text|您可以使ClassAHandler成为ClassA的内部类。它将有权访问ClassA的成员。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1307509|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You may make ClassAHandler an inner class of ClassA. It would have access to the members of ClassA.

blocks|key|1307557|text|你可以使用内部类，然后在两个实例之间有一个隐式的父子关系。(但我不知道它是否真的更好)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1307558|public+class+ClassA+{
++++private+boolean+ClassAattr+=+false;

++++public+class+ClassAHandler+extends+GeneralHandler+{

+++++++public+ClassAHandler()+{
+++++++++++//+can+access+ClassAattr
+++++++}
++++}

++++public+ClassA()+{++++
++++++++ClassAHandler+handler+=+new+ClassAHandler();
++++}
}|code-block|syntax|javascript|1307559|如果您传递this，子类将需要使用parent.classAattr访问父值。根据law+of+demeter的说法，我们可以怀疑它是否正确。|offset|length|style|CODE|1307560|另一种选择是ClassA在构造函数中传递ClassAHandler所需的所有信息。如果处理程序需要ClassAttr的值，则将其传递到构造函数中。|1307561|++++public+ClassA()+{++++
++++++++ClassAHandler+handler+=+new+ClassAHandler(+classAattr+);
++++}|1307562|但是参数是通过值传递的，所以我不知道它是否适用于您。|1307563|第三种选择是稍微更改一下设计，并将boolean放在处理程序中。然后，ClassA使用handler.handlerAttr访问子对象的值。孩子对父母一无所知，但父母可以访问孩子中他想要的任何信息。这对于law+of+demeter来说是更好的。|1307564|public+class+ClassAHandler+extends+GeneralHandler+{+++++
+++boolean+handlerAttr;

+++public+ClassAHandler()+{+++++++
+++}
}|1307565|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Law_of_Demeter|1^0|0|0|5|4|H|H|15|E|0|0|6|6|K|D|1D|9|0|0|0|H|7|Z|6|17|J|2U|E|1|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@$I|18|J|19|K|L]|$I|1A|J|1B|K|L]]|9|@$I|1C|J|1D|1|1E]]|A|$]]|$1|M|3|N|5|6|7|1F|8|@$I|1G|J|1H|K|L]|$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1N|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1O|8|@$I|1P|J|1Q|K|L]|$I|1R|J|1S|K|L]|$I|1T|J|1U|K|L]]|9|@$I|1V|J|1W|1|1X]]|A|$]]|$1|U|3|V|5|D|7|1Y|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|13]]]]

You could use inner classes, there is then a implicit parent-child relationship between the two instances. (But I don't know if it's really better).

<pre><code>public class ClassA {
 private boolean ClassAattr = false;

 public class ClassAHandler extends GeneralHandler {

 public ClassAHandler() {
 // can access ClassAattr
 }
 }

 public ClassA() { 
 ClassAHandler handler = new ClassAHandler();
 }
}
</code></pre>

If you pass <code>this</code>, the subclass will need to access the parent value with <code>parent.classAattr</code>. We can wonder whether it's correct according to the <a href="http://en.wikipedia.org/wiki/Law_of_Demeter" rel="nofollow noreferrer">law of demeter</a>. 

Another option then would be that <code>ClassA</code> pass all the information that <code>ClassAHandler</code> requires in the constructor. If the handler requires the value of <code>ClassAttr</code>, pass it in the constructor.

<pre><code> public ClassA() { 
 ClassAHandler handler = new ClassAHandler( classAattr );
 }
</code></pre>

But the parameter is passed by value so I don't know if it works for you.

A third option would be to change the design a bit and have the <code>boolean</code> be in the handler. Then <code>ClassA</code> accesses the value of the child with <code>handler.handlerAttr</code>. The child knows nothing about the parent, but the parent can access as much information in the child has he wants. This is better regarding the <a href="http://en.wikipedia.org/wiki/Law_of_Demeter" rel="nofollow noreferrer">law of demeter</a>. 

<pre><code>public class ClassAHandler extends GeneralHandler { 
 boolean handlerAttr;

 public ClassAHandler() { 
 }
}
</code></pre>

blocks|key|1307594|text|您粘贴的代码没有任何错误，但是您可以使用非静态内部类来使内容(可以说)更清晰：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1307595|public+class+ClassA+{
++++private+boolean+ClassAattr+=+false;

++++public+ClassA()+{++++
++++++++ClassAHandler+handler+=+new+ClassAHandler();
++++}

++++class+ClassAHandler+extends+GeneralHandler+{

++++++++//+magically+sees+the+instantiating+ClassA+members+and+methods
++++}
}|code-block|syntax|javascript|1307596|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

there is nothing wrong with the code you pasted, however you can use a non static inner class to make things (arguably) cleaner:

<pre><code>public class ClassA {
 private boolean ClassAattr = false;

 public ClassA() { 
 ClassAHandler handler = new ClassAHandler();
 }

 class ClassAHandler extends GeneralHandler {

 // magically sees the instantiating ClassA members and methods
 }
}
</code></pre>

blocks|key|1307661|text|如果我理解正确的话，您需要处理程序有一个对ClassA的引用，但是您不想从ClassA的构造函数中设置它？如果是这种情况，那么您可以使用工厂模式将构造与“连接”分开，这将避免您的ClassA需要了解ClassAHandler类。有点像这样：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1307662|public+class+ClassA+{

++++private+boolean+ClassAattr+=+false;

++++public+ClassA()+{
++++}

}


public+class+ClassAHandler+{

++++private+ClassA+ca+=+null;

++++public+ClassAHandler(ClassA+classa)+{
++++++++this.ca+=+classa;
++++}

}


public+HandlerFactory+{

++++public+ClassAHandler+createClassAHandler(ClassA+classa)+{
++++++++ClassAHandler+handler+=+new+ClassAHandler(classa);
++++++++return+handler;
++++}

}|code-block|syntax|javascript|1307663|entityMap^0|L|6|11|6|2H|6|2R|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

If I understand correctly, you need the handler to have a reference to <code>ClassA</code>, but you don't want to set this up from within the constructor of <code>ClassA</code>? 
If that is the case, then you could separate construction from "wiring up" using a factory pattern, which will prevent your <code>ClassA</code> from needing to know about the <code>ClassAHandler</code> class. Kind of like this: 

<pre><code>public class ClassA {

 private boolean ClassAattr = false;

 public ClassA() {
 }

}


public class ClassAHandler {

 private ClassA ca = null;

 public ClassAHandler(ClassA classa) {
 this.ca = classa;
 }

}


public HandlerFactory {

 public ClassAHandler createClassAHandler(ClassA classa) {
 ClassAHandler handler = new ClassAHandler(classa);
 return handler;
 }

}
</code></pre>

Look into the following code:

<pre><code>public class ClassA {
 private boolean ClassAattr = false;

 public ClassA() { 
 ClassAHandler handler = new ClassAHandler(this);
 }
}

public class ClassAHandler extends GeneralHandler {
 ClassA ca = null;

 public ClassAHandler(ClassA classa) {
 this.ca = classa;
 }
}
</code></pre>

I need to access <code>ClassAattr</code> on some <code>ClassAHandler</code> methods, among other attributes. Is there a way to do so without passing the origin class in the handler constructor. I don't really like how this solution "looks".

Passing "this" in java constructor

查看以下代码：public class ClassA {    private boolean ClassAattr = false;    public ClassA() {            ClassAHandler handler = new ClassAHandler(this);    }}public...

问在java构造函数中传递"this“
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java构造函数中传递"this“EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java构造函数中传递"this“
EN