【java】值传递和引用传递理解 博客分类： java知识总结 java

一、理解

★ 当一个变量最为一个参数传入方法内部的时候，会有两种不同的传递方式：值传递和引用传递。

　　☆ 值传递的特点：不管方法内部对传进去的参数作任何改变，也不会影响方法外部的变量的值

　　☆ 引用传递的特点：方法内部对传进去的参数作的改变也会影响方法外部的变量的值

二、记忆

★ 1、基本类型（8种）的传递都是值传递

★ 2、引用类型（除String外）都是引用传递（传递引用的副本）

★ 3、Strng比较特殊，它虽然是引用类型，但是却是值传递

三 示例

3.1 基本类型：如 int

 

public class StudyInt {
	public static void main(String[] args) {
		new StudyInt().printFirst();
	}
	private void printFirst() {
		int i = 2;
		testChange(i);
		System.out.println("printFirst：i = "+i);
	}
	private void testChange(int i) {
		i = 4;
		System.out.println("testChange: i = "+i);
	}
}

打印结果：

testChange: i = 4
printFirst：i = 2

理解：

i 作为参数将值传递给testChange方法，不论值在testChange 中怎么变，都不影响 i 在printFirst中的值

3.2 引用类型：如 新建Appoint类

 

public class StudyAppoint {

	public static void main(String[] args) {
		new StudyAppoint().printFirst();
	}
	private void printFirst() {
		Appoint iAppoint = new Appoint();
		sysoutAppoint("1 初始值：printFirst", iAppoint);

		testChange(iAppoint);
		sysoutAppoint("2 传参更改值：printFirst", iAppoint);
		// 重点testNew方法传递的是引用的副本，当改变副本的指向地址时，原属性本身的值不改变
		testNew(iAppoint);
		sysoutAppoint("3 传参new对象：printFirst", iAppoint);
		// 重点理解testChangeAndNew
		testChangeAndNew(iAppoint);
		sysoutAppoint("4 传参改值并new对象：printFirst", iAppoint);
	}
	private void testChange(Appoint iAppoint) {
		iAppoint.iInt = 2;
		iAppoint.iStr = "testChange";
		sysoutAppoint("testChange", iAppoint);
	}
	private void testNew(Appoint iAppoint) {
		Appoint i = new Appoint();
		i.iInt = 3;
		i.iStr = "testChangeNew";
		iAppoint = i;
		sysoutAppoint("testNew", iAppoint);
	}
	private void testChangeAndNew(Appoint iAppoint) {
		iAppoint.iInt = 4;
		iAppoint.iStr = "testChangeAndNew 1";
		Appoint i = new Appoint();
		i.iInt = 5;
		i.iStr = "testChangeNew 2";
		iAppoint = i;
		sysoutAppoint("testChangeAndNew", iAppoint);
	}
	/**
	 * 打印出执行的方法中指定的属性的值
	 */
	private void sysoutAppoint(String methodName, Appoint iAppoint) {
		System.out.println(methodName + "：iAppoint.iInt = " + iAppoint.iInt);
		System.out.println(methodName + "：iAppoint.iStr = " + iAppoint.iStr);
	}
}

class Appoint {
	int iInt = 1;
	String iStr = "aaa";
}

打印结果：

理解：

1、testChange ：iAppoint作为参数在testChange方法中传递的是iAppoint 引用的副本，指向同一地址，对副本值进行改变改变的也就是地址的中的值，iAppoint 指向的是相同地址所以也是改变的

2、testNew:iAppoint作为参数在testChange方法中传递的是iAppoint 引用的副本，指向同一地址， 当引用的副本指向的地址更改后，无论对引用副本值做什么改变，对iAppoint本身指向的地址没有影响

3.3 String 和 StringBuffer

 

public class StudyString {

    void printFirst(){
    	String i="i -- string ";
    	String i2= new String("i2 -- new string");
    	StringBuffer ibuf = new StringBuffer("ibuf -- strbuf");
    	sysout("1 printFirst",i,i2,ibuf);  	
    	testChange(i,i2,ibuf);  	
    	sysout("3 printFirst",i, i2, ibuf);
    	testChange2(i, i2, ibuf);
    	sysout("5 printFirst",i, i2, ibuf);
    }
    /**
     * 分别更改值，查看打印内容
     */
    private void testChange(String i, String i2, StringBuffer ibufferBuffer) {
    	i+=" ; 改变值";
    	i2 += " ; 改变值";
    	ibufferBuffer.append(" ; 改变值");
    	sysout("2 testChange",i, i2, ibufferBuffer);  	
    	
	}
	private void testChange2(String i, String i2, StringBuffer ibufferBuffer) {
		String inew = "inew --  new";
    	i=inew;
    	String i2new = new String("i2new -- new");
    	i2=i2new;
    	StringBuffer iBuffernew = new StringBuffer("iBuf -- new");
    	ibufferBuffer = iBuffernew;
    	sysout("4 testChange2",i, i2, ibufferBuffer);
	}
	/**
     * 打印结果
     */
	private void sysout(String methodStr,String i,String i2,StringBuffer ibufferBuffer) {
		System.out.println(methodStr+": i = "+i);
    	System.out.println(methodStr+": i2 = "+i2);
    	System.out.println(methodStr+": ibuf = "+ibufferBuffer);
	}
	public static void main(String[] args) {
		new StudyString().printFirst();
	}
}

打印结果：

 

理解：

1、Strng是引用类型，但是却是值传递，不论值在testChange中怎么变，或者改变地址都不影响在printFirst中的值

2、StringBuffer方法中传递的是引用的副本

四、String的扩展知识（equal和==）

public class StringEqual {
 public static void main(String[] args) {
  new StringEqual().printFirst();
 }
 private void printFirst() {
  String iStr = "aaa";
  String iStr2 = "aaa";
  String iNewStr = new String("aaa");
  String iNewStr2 = new String("aaa");
  System.out.println("iStr == iStr2: "+(iStr==iStr2));
  System.out.println("iStr.equals(iStr2): "+(iStr.equals(iStr2)));
  System.out.println("iStr == iNewStr: "+(iStr==iNewStr));
  System.out.println("iStr.equals(iNewStr): "+(iStr.equals(iNewStr)));
  System.out.println("iNewStr2 == iNewStr: "+(iNewStr2==iNewStr));
  System.out.println("iNewStr2.equals(iNewStr): "+(iNewStr2.equals(iNewStr)));
 }
}

打印结果：
iStr == iStr2: true
iStr.equals(iStr2): true
iStr == iNewStr: false
iStr.equals(iNewStr): true
iNewStr2 == iNewStr: false

iNewStr2.equals(iNewStr): true

理解：

==在java中是比较引用的，即在内存中的地址。而String的equals()是比较字符串的内容。

学习地址☞ ：http://www.51testing.com/html/68/n-816868.html