引言

本想使用Java来说明值传递和引用传递，这里有两个弊端：

Java无法获取值或对象的地址，不能很好地阐述值传递和引用传递
如果使用JVM的内存模型来讲解，很多人不是真正知道JVM 内存模型，自然是看不懂的。

综上两个问题，故而使用golang来阐述问题，因为go语言可以直接展示值的内存地址😹🤣😹🤣😹🤣😹🤣

概念

值传递：方法的形参获取到实参的一份副本，它的生命周期随方法的结束而结束。

引用传递：方法的形参获取到实参的地址，操作形参也就是操作地址，即操作实参。

这里有些拗口，下面以数据交换为例，来说明这个问题。

备注， go语言中有指针的概念：

*表示指针，指向内存地址

&获取值的内存地址

值传递

package main

func swapValue( a ,b int)  {
    a,b = b,a
    println("inner func output : a = %d,b= %d",a,b)
    println("inner address a =%T,address b =%T",&a,&b)
}

func main()  {
    a := 10
    b := 20
    println("outer address a =%T,address b =%T",&a,&b)
    swapValue(a,b)
    println("after address a =%T,address b =%T",&a,&b)
    println("after func output : a = %d,b= %d",a,b)
}

输出结果为：

你会清楚的看到，在main中执行方法swapValue之前的a的内存地址为0xc000032748，b的内存地址为0xc000032738，在方法swapValue中的 a的内存地址为0xc000030740，b的内存地址为0xc000030730，方法swapValue结束之后， a和 b的内存地址不变，仍为0xc000032748和0xc000032738。

这就很好的说明了，在值传递的过程中，方法swapValue只是拿到了实参【a和b】的副本，并在方法swapValue内部创建该副本的内存地址，形参【a和b】指向该副本的内存地址，等到方法体结束之后，这部分【方法体内】的内存即被回收掉。

同时，你还会发现，在方法体内部，a和 b的值确实交换了，值分别为 20 和 10 ，说明它们指向的是副本的内存地址，因为方法swapValue执行之前，a和 b的值分别为10 和 20。

同时，也能看到即便在方法体内的值交换了，但输出的值还是没有交换，因为在当方法结束之后，副本所占的内存即被回收。

引用传递

package main

func swapRef(a *int,b *int)  {
     *a,*b = *b,*a
    println("inner func output : a = %d,b= %d",*a,*b)
    println("inner address a =%T,address b =%T",a,b)
}

func main()  {
    a := 10
    b := 20
    println("outer address a =%T,address b =%T",&a,&b)
    swapRef(&a,&b)
    println("after address a =%T,address b =%T",&a,&b)
    println("after func output : a = %d,b= %d",a,b)
}

你会清楚的看到，在main中执行方法swapRef之前的a的内存地址为0xc000030738，b的内存地址为0xc000030730，当程序执行到 swapRef(&a,&b) 方法时，即传递 a和 b的内存地址，因而，在方法swapRef中的 a的内存地址为0xc000030738，b的内存地址为0xc000030730，方法swapRef结束之后， a和 b的内存地址不变，仍为0xc000030738和0xc000030730，但存储的值发生了改变。

这就很好的说明了，在引用传递的过程中，方法swapRef拿到了实参【a和b】的内存地址， a和 b在进行数值交换时，即交换了a和 b内存所存储的数值。

因而，不仅在方法体内部，a和 b的值交换了，值分别为 20 和 10 ，在方法体结束之后，main方法中的数值也已交换了。

补充例子

代码

package main

import (
	"fmt"
)

type Book struct {
	title string
	author string
	name string
	bookId int
}

func output(book Book,msg string)  {
	fmt.Println(msg,"title=",book.title,",subject=",book.name)
}

func changeBookNameWithoutPtr(book Book)  {
	book.title="测试book title"
	book.name = " 测试 book name"
	output(book,"执行方法体内的输出结果：")
}

func changeBookNameWithPtr(book *Book)  {
	book.title="测试 book title"
	book.name = " 测试 book name"
	output(book,"执行方法体内的输出结果：")
}

当执行这个方法 changeBookNameWithoutPtr时，如下面的main函数：

func main()  {
	book :=Book{title: "go language",name: "go language study"}
	output(book,"执行方法前的输出结果：")
	changeBookNameWithoutPtr(book)
	output(book,"执行方法后的输出结果：")
}

其输出结果，如图所示：

当执行这个方法 changeBookNameWithPtr，如下面的main函数：

func main()  {
	book :=Book{title: "go language",name: "go language study"}
	output(book,"执行方法前的输出结果：")
	changeBookNameWithPtr(&book)
	output(book,"执行方法后的输出结果：")
}