这个问题最近又看了一次,温故而知新
我认为该方法论为:
1:java中方法参数传递方式是按值传递。
2:如果参数是基本类型,传递的是基本类型的字面量值的拷贝。
3:如果参数是引用类型,传递的是该参量所引用的对象在堆中地址值的拷贝。
这是知乎上的例子,前面两个没啥问题,写几年代码的基本都知道,后面三和四就要慢慢思考了
作者:Intopass
链接:https://www.zhihu.com/question/31203609/answer/50992895
来源:知乎
第一个例子:基本类型
void foo(int value) {
value = 100;
}
foo(num); // num 没有被改变
第二个例子:没有提供改变自身方法的引用类型
void foo(String text) {
text = "windows";
}
foo(str); // str 也没有被改变
第三个例子:提供了改变自身方法的引用类型
StringBuilder sb = new StringBuilder("iphone");
void foo(StringBuilder builder) {
builder.append("4");
}
foo(sb); // sb 被改变了,变成了"iphone4"。
第四个例子:提供了改变自身方法的引用类型,但是不使用,而是使用赋值运算符。
StringBuilder sb = new StringBuilder("iphone");
void foo(StringBuilder builder) {
builder = new StringBuilder("ipad");
}
foo(sb); // sb 没有被改变,还是 "iphone"。
重点解释第四个例子,图解,也是从里面捞的,懒的画了
在闭包里面如果new了对象等于开辟了新的空间并且把复制的引用连接到新空间里面,这时候和原对象已经没关系了.
这是https://www.journaldev.com/上的一个例子,非常有趣,差点又栽了.
public class Balloon {
private String color;
public Balloon(){}
public Balloon(String c){
this.color=c;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class Test {
public static void main(String[] args) {
Balloon red = new Balloon("Red"); //memory reference 50
Balloon blue = new Balloon("Blue"); //memory reference 100
swap(red, blue);
System.out.println("red color="+red.getColor());
System.out.println("blue color="+blue.getColor());
foo(blue);
System.out.println("blue color="+blue.getColor());
}
private static void foo(Balloon balloon) { //baloon=100
balloon.setColor("Red"); //baloon=100
balloon = new Balloon("Green"); //baloon=200
balloon.setColor("Blue"); //baloon = 200
}
//Generic swap method
public static void swap(Object o1, Object o2){
Object temp = o1;
o1=o2;
o2=temp;
}
}
red color=Red
blue color=Blue
blue color=Red
这个有意思的点在swap方法,大家细细品一品.