blocks|key|1511880|text|Java使用按值传递，但如果参数是一个对象，则Java通过值传递对该对象的引用，因此被调用的方法可以更改对象的内容，而不是整个对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1511881|这并不意味着对象是通过引用传递的(+Joachim+Isaksson的注释是错误的)。|1511882|添加了来回应Arijeet+Saha的评论：|1511883|当我说“被调用的方法可以改变对象的内容，而不是整个对象”时，我的意思是，如果你作为一个整体改变了对象，调用者看不到改变。|1511884|考虑以下示例：|1511885|public+void+test(Person+p)+{
++++p.setName("Pino");
++++p+=+new+Person();
++++p.setName("John");
}|code-block|syntax|javascript|1511886|test()的第一行更改了该方法接收到的对象的内容，第二行更改了整个对象(它将一个新对象赋给了形参)，第三行更改了新对象的内容。在本例中，调用者看到的是名为"Pino“而不是"John”的Person对象，因为test()的第二行所做的更改对调用者是不可见的；它不可见是因为对象不是通过引用传递的。|CODE|1511887|entityMap^0|W|Y|0|0|17|0|0|M|0|0|1O|0|0|7|0|0|0|45|0|6|2M|6|2X|6|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|N|3|O|5|P|7|1C|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|U]|$9|1I|A|1J|B|U]|$9|1K|A|1L|B|U]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|W|$]]

Java uses pass-by-value but if the parameter is an object Java passes by value the reference to the object, so the called method can change the content of the object, not the object as a whole.

This does not mean that objects are passed by reference (the comment by Joachim Isaksson is wrong).

ADDED to answer to the comment by Arijeet Saha:

When I say "the called method can change the content of the object, not the object as a whole", I mean that if you change the object as a whole the caller doesn't see the change.

Consider the following example:

<pre><code>public void test(Person p) {
 p.setName("Pino");
 p = new Person();
 p.setName("John");
}
</code></pre>

The first line of <code>test()</code> changes the content of the object received by the method, the second line changes the object as a whole (it assigns a new object to the formal parameter), the third line changes the content of the new object. In this case the caller sees a <code>Person</code> object with name "Pino", not "John", because the change made by the second line of <code>test()</code> is not visible to the caller; it is not visible because objects are not passed by reference.

blocks|key|1517310|text|Java的参数传递相当棘手--当一个对象被传递给一个函数时，你可以操作该对象的字段，但不能操作对象本身。对象引用是通过值传递的。所以，你可以说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1517311|class+someClass{
++int+i+=+5;
}

class+Foo
{
++static+void+func(someClass+c)
++{
+++++c.i+=+3;
++}
}+

class+MainClass{
++public+static+void+main(){
++++someClass+c+=+new+someClass();
++++System.out.println(c.i);
++++Foo.func(c);
++++System.out.println(c.i);
++}
}|code-block|syntax|javascript|1517312|期望您的输出为：|1517313|5
3|1517314|对c字段的更改仍然存在。|1517315|但如果操作对象本身，这种操作将只在Foo.func()中持久存在，而不会在该函数之外存在：|offset|length|style|CODE|1517316|class+someClass{
++int+i+=+5;
}

class+Foo
{
++static+void+func(someClass+c)
++{
+++++c.i+=+new+someClass();
+++++c.i+=+3;
+++++System.out.println(c.i);
++}
}

class+MainClass{
++public+static+void+main(){
++++someClass+c+=+new+someClass();
++++System.out.println(c.i);
++++Foo.func(c);
++++System.out.println(c.i);
++}
}|1517317|1517318|5
3
5|1517319|发生了什么？c.i在Foo.func()中的MainClass.main()中值为5，c本身被修改为指向包含值3的someClass的另一个实例。但是，此更改不会反映到已传递的实际对象。Foo.func()和MainClass.main()中的c现在是不同的对象。这就是为什么对Foo.func()的c的更改不会影响MainClass.main()中的c。|1517320|entityMap^0|0|0|0|0|0|H|A|0|0|0|0|A|A|M|G|1L|9|2L|A|2W|G|3E|1|3V|A|46|1|4E|G|4W|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@$O|17|P|18|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|U|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|X|3|Y|5|6|7|1C|8|@$O|1D|P|1E|Q|R]|$O|1F|P|1G|Q|R]|$O|1H|P|1I|Q|R]|$O|1J|P|1K|Q|R]|$O|1L|P|1M|Q|R]|$O|1N|P|1O|Q|R]|$O|1P|P|1Q|Q|R]|$O|1R|P|1S|Q|R]|$O|1T|P|1U|Q|R]|$O|1V|P|1W|Q|R]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|10|$]]

Java's parameter passing is quite tricky - When an object is passed to a function, you can manipulate the object's fields but you cannot manipulate object itself. The object reference is passed by value. So, you can say:

<pre><code>class someClass{
 int i = 5;
}

class Foo
{
 static void func(someClass c)
 {
 c.i = 3;
 }
} 

class MainClass{
 public static void main(){
 someClass c = new someClass();
 System.out.println(c.i);
 Foo.func(c);
 System.out.println(c.i);
 }
}
</code></pre>

Expect your output to be:

<pre><code>5
3
</code></pre>

Changes to the fields of c persist.

but if manipulate the object itself, this manipulation will only persist in <code>Foo.func()</code> and not outside that function:

<pre><code>class someClass{
 int i = 5;
}

class Foo
{
 static void func(someClass c)
 {
 c.i = new someClass();
 c.i = 3;
 System.out.println(c.i);
 }
}

class MainClass{
 public static void main(){
 someClass c = new someClass();
 System.out.println(c.i);
 Foo.func(c);
 System.out.println(c.i);
 }
}
</code></pre>

Expect your output to be:

<pre><code>5
3
5
</code></pre>

What has happened? c.i has the value 5 in <code>MainClass.main()</code> in <code>Foo.func()</code>, c itself is modified to point to another instance of <code>someClass</code>, containing the value 3. However, this change is not reflected to the actual object that has been passed. The <code>c</code> in <code>Foo.func()</code> and <code>MainClass.main()</code> are different objects now. That's why changes to the <code>c</code> of <code>Foo.func()</code> do not affect the <code>c</code> in <code>MainClass.main()</code>.

blocks|key|1831118|text|让我先弄清楚按值传递是什么意思？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1831119|这意味着无论你向一个方法传递什么，它都会收到它的副本，而不是实际的地址。|1831120|因此，在本例中，您也是在传递变量a的值，并且它的值(引用对象或对对象的地址)被复制到方法(AB)。|1831121|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Let me first clear what does pass-by-value mean?

It means what ever you are passing to a method, it will recieve its copy not the actual adress.

So in your case you too are passing the value the variable a, and its value (which is referance to an object or adress to an object) is copied to the method(AB a).

blocks|key|1831144|text|Java总是通过值传递参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1831145|重要的是要理解值是什么(变量保存的是什么)。|1831146|对于原语，它是值本身。|1831147|对于对象，它是一个引用。|1831148|当您将对象作为参数传递时-对该对象的引用将被复制，但它仍然指向原始对象。|1831149|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Java always passes parameters as by value.

It's important to understand what is the value (what a variable holds).

For primitives it's the value itself.

For objects it's a reference.

When you pass an object as a parameter - the reference to the object is copied but it still points to the original object.

Code:

<pre><code>class AB{
 int i=5;
}

class BC{
 public void test(AB a){
 a.i=10;
 }

}

public class ATest{

public static void main(String aa[]){
 AB a = new AB();
 //Base class variable value
 System.out.println(a.i);

 BC b = new BC();
 //Modifying the object "a"
 b.test(a);
 //Printing the base class object
 System.out.println(a.i);
}
}

// Output : 5
// 10
</code></pre>

If it is pass-by-value, the output should have been 5 and 5

Java supports pass-by-value. But can't make out the reason of the below code

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

代码：class AB{    int i=5;}class BC{    public void test(AB a){        a.i=10;    }}public class ATest{public static void main(String aa[]){    AB a = new AB();  ...

问Java支持按值传递。但是我不能理解下面代码的原因
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java支持按值传递。但是我不能理解下面代码的原因EN