细微处见功夫，请大家分析一下：

xiachedan(瞎扯蛋) 能否说的详细点？没看明白。

xiachedan(瞎扯蛋)的名字起得很贴切，一开口就瞎扯蛋。Object result = v;
this.value = v;
这里的对象有几个？答案是：只有一个。这两句赋值语句过后，v、result、value（请注意，这三个都是reference）都指向同一个对象，它们三者是完全等价的。这么玩一趟，平白增加一个local variable有什么用？我看不出来。另外，setXxx方法的返回值是毫无意义的——唯一的意义就是使这个方法不符合Java Bean规范。一个糟糕的设计。不过这是题外话了。

这要看你用在哪方面了
法一返回v 的值
法二返回return this.value的值，有可能因为线程问题不是v的值

1. 这是一个奇怪的方法,有些畸形,不过也说的过去.
第一种生成两个对象,一个由this.value保存,而返回一个和this.value相同但分离的对象,这样对返回的对象进行任何操作可以不会破坏this.value的值,而第二个方法就不行了.看 java高效编程,最好用clone方法,返回一个副本

to sisn()：请问哪条语句会“生成两个对象”？哪条语句会生成“和this.value相同但分离的对象”？你自己写段代码试试，是不是真的“对返回的对象进行任何操作可以不会破坏this.value的值”？一个Java基础问答：
Object result = v;
this.value = v;
这两条语句执行以后，v、result、this.value三者的object identity是否相等？
看看有多少人答错的。

以下代码据称是某超级牛人写的这个方法实现：
private Object value;
public Object setValue(Object v)
{
Object o = v;
Object b = o;
Object j = b;
Object e = j;
Object c = e;
Object t = c;
Object e = t;
this.value = v;
return e;
}怎么样，高明多了吧？

不太明白有什么区别
有可能就是象 jinbuquan(金不全) 说的线程同步问题

线程同步问题？这是那位“瞎扯蛋”的兄弟吧？Java代码在什么情况下是线程不安全的？今天的第二道基础问答，看看又有多少人答错。

to eyeieye(魔之眼) :
这段代码怎么高明.在下不才.搞不明白,胡涂啦!
给个解释一下.ok?^_^

to tiger_wkh52741(走走.跑跑.瞧瞧!) ：
他逗你玩呢。这个家伙就爱乱开玩笑。不过这玩笑开得也有点道理：如果加上一个不必要的变量就让这个方法变得“高明”的话，加上一大堆不必要的变量不就是“极其高明”了？

方法一是Think in java 中的代码片断

在 java 中，一般情况下需要直接或间接地调用 new 方法产生新类。而且上诉方法中业没有使用更特殊的方法产生新类，也就是说上诉2方法一直都是在操作同个类，没有本质意义上的区别只是用不同的引用返回了它， Object result 与 this.value如果有区别的话也只是在代码的逻辑性、可读性稍有差别（代码长的话）======================
以上拙论，见笑！

都别吵了，就是把bill gates找来他也不会

最会开玩笑的两个人出现。一个说，“调用 new 方法产生新类”——“类”和“对象”分得清楚吗？另一个说，“就是把bill gates找来他也不会”——盖茨是微软的老板，不是Sun的。
CSDN的后辈们虽然技术不见长，搞笑的功夫倒是青出于蓝，后生可畏呀。

private Object value;
public Object setValue(Object v)
{
Object o = v;
Object b = o;
Object j = b;
Object e = j;
Object c = e;
Object t = c;
Object e = t;
this.value = v;
return e;
}
eyeieye(魔之眼)朋友的这段代码最高明了，整个方法的N多个reference同时指向同一个对象，不多占一丝空间，同时多产生N-1行代码，老板对你的工作量也会另眼相看，还有一个好处就是去面试的时候考官问你写了多少行代码，你可以理直气壮地多说N-1行，成功机率将会大增，一举多得。高、高、实在高！同时也建议楼上N多的朋友真正去理解一下面向对象的基本理论。

严重支持 Schlemiel(维特根斯坦的扇子) ：Object result = v;
this.value = v;
这里的对象有几个？答案是：只有一个。这两句赋值语句过后，v、result、value（请注意，这三个都是reference）都指向同一个对象（内存），它们三者是完全等价的。这么玩一趟，平白增加一个local variable有什么用？我看不出来。另外，setXxx方法的返回值是毫无意义的——唯一的意义就是使这个方法不符合Java Bean规范。一个糟糕的设计。不过这是题外话了。

to Schlemiel(维特根斯坦的扇子) :
   你也满会开玩笑的!不过倒是很新颖啊!
   要你这么说,他那段所谓高明的程序果然"高明"
   而且是极其"高明"
   哈哈哈!

请看虚拟机指令(javap产生的)：方法一：
Method java.lang.Object setValue(java.lang.Object)
   0 aload_1
   1 astore_2
   2 aload_0
   3 aload_1
   4 putfield #19 <Field java.lang.Object value>
   7 aload_2
   8 areturn方法二：
Method java.lang.Object setValue(java.lang.Object)
   0 aload_0
   1 aload_1
   2 putfield #19 <Field java.lang.Object value>
   5 aload_0
   6 getfield #19 <Field java.lang.Object value>
   9 areturn方法一和方法二中不同的指令：
方法一：
   0 aload_1
   1 astore_2
   7 aload_2
方法二：
   5 aload_0
   6 getfield #19 <Field java.lang.Object value>我的结论：
1.方法一编译出来的代码短。2.方法一的速度快。方法一中两条aload加一条astore指令比方法二中一条aload指令加调用函数getfield快。

to cbhyk()：
如果把方法二改成 return v; 呢？
再说了，这样生成vm指令的方式是spec允许的多种方式之一呢，还是必须的做法？既然this.value和v指向同一个对象，getfield完全可能被编译器优化掉。

Schlemiel(维特根斯坦的扇子):
我认为是线程的问题理由？
具体解释我说不来那么多了，说实话我也说不透。
这种概念也是照搬书上的。请翻阅Concurrent Programming in Java™: Design Principles and Patterns, Second Edition
2.4节中的一个例子：
class SynchronizedInt {
private int value; public SynchronizedInt(int v) { value = v; } public synchronized int get() { return value; } public synchronized int set(int v) { // returns previous value
  int oldValue = value;
  value = v;
  return oldValue;
} public synchronized int increment() { return ++value; } // and so on}

to jigsaw(jigsaw)：
呵呵，既然自己都看出问题了，我就不说什么了。

仔细想了一下，是线程问题的可能性要大些，但又为什么不这样写：
this.value = v;
return v;

调试易

细微处见功夫，请大家分析一下：

解决方案 »