java中的参数传递

---

两个基本概念

参数类型

形参：方法被调用时需要传递进来的参数。
例如：function(int a)中的a,他只有func被调用期间a才有意义，也就是被分配内存空间，在方法function方法被执行完后，a就会被销毁释放内存空间，也就不存在了。
实参：方法被调用时传递进来的实际值，他在方法被调用前就已经被初始化，并且在方法被调用时传入。例如：有个方法叫add（int a,int b）。主函数中有add（3，4）这里面的3和4就是实参。同理a,b就是形参。

参数传递方式

参数传递方式主要有以下两种

---

值传递：在方法被调用时，实参通过把他的内容副本传入方法内部，此时形参接收的内容是实参的一个拷贝，因此在方法内对实参的任何操作，都仅仅是对这个内容的副本进行操作，不影响原初始值的内容。值传递传递的是一个真实内容的副本，对副本的操作不影响原内容，也就是形参怎么变化，不影响实参对应的内容。
引用类型传递："引用”也就是指向真实内容的地址值。在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向同一块内存地址，对形参的操作会影响原来的内容。

案例分析

案例1

public static void main(String[] args) {
		
		String nameString = "张三";
		
		name(nameString);
		
		System.out.println("main--->"+nameString);
	}
	
	public static void name(String name) {
		name = "李四";
		System.out.println("name--->"+name);	
	}

代码如下（示例）：结果是先输出李四，再输出张三。
总结一下结果就是：
如果两次输出都是李四，说明是引用传递。
如果第一次是李四，第二次是张三，说明是值传递。
所以重点来了：通过实验证明java采用的是值传递。

案例2

public class Person {
	
	private String nameString;
	
	private int age;

	public Person(String nameString,int age) {
		this.age = age;
		this.nameString = nameString;
	}
	
	@Override
	public String toString() {
		return "Person [nameString=" + nameString + ", age=" + age + "]";
	}

	public static void name(Person person) {	
		person.nameString="李四";
		person.age =20;
	}
	
	public static void main(String[] args) {
		Person person = new Person("张三",18);
		System.out.println(person.toString()); //参数改变前
		name(person);
		System.out.println(person.toString()); // 参数改变后
	}
}

结果是
Person [nameString=张三, age=18]
Person [nameString=李四, age=20]
原因：
传的是对象的地址，所以赋值会变.

案例3

public class Student {
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	public static Student change(Student s1, Student s2){
		Student temp = new Student("王五",20);
		temp = s1;
		s1 = s2;
		s2 = temp;
		return temp;
	}
	public static void main(String[] args) {
		Student zhangsan = new Student("张三", 18);
		Student lisi = new Student("李四", 20);
		Student tStudent = Student.change(zhangsan, lisi);
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
	}
	

}

结果：
Student [name=张三, age=18]
Student [name=李四, age=20]
原因：
不会 是因为仅在方法内s1,s2进行地址交换

案例4

public class Student {
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	public static void change(Student s1, Student s2){
		Student temp = new Student("王五",20);
		temp.name = s1.name;
		s1.name = s2.name;
		s2.name = temp.name;
		
	}
	public static void main(String[] args) {
		Student zhangsan = new Student("张三", 18);
		Student lisi = new Student("李四", 20);
		Student.change(zhangsan, lisi);
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
	}
	

}

结果：
Student [name=李四, age=18]
Student [name=张三, age=20]
原因：
会因为，在方法执行时，s1.name和s2.name值进行了交换。

总结

对于第一个来说，直接赋值，仅能在方法内改变，出了方法，就没了。
对于第二个引用类型数据，数据无法进栈，在堆内，值传递的是地址，所以修改会改变。
对于第三个来说，方法入栈，地址传入，但仅在栈内的临时变量中交换了地址，方法结束后，就结束了。
对于第四个而言，也是将地址传入，不同的是，交换了地址指向的值，所以交换会成功。
String类型能入栈，new的对象类型在堆内不能入栈。