前言
群友魂淡之前讨论过的问题，后续又有人还是没有明白，所以写一篇博客作为简书的开端。
学过java基础的人都知道，java的内存模型，java的值传递和引用传递一直都是一个难点，有些人一直死命的背书，最后仅仅应付了面试，实际引用的时候缺没办法应用，有时候会的了运用却解释不出原理。有时候觉得百度一下发现，这个东西我会，但是具体怎么使用的时候，却没办法解释，这篇文章的计划是，从内存模型开始，一步一步的深入到值传递和引用传递的本质，鉴于所有人的基础不一定一致，因此从基础的开始讲起，篇幅可能偏长（我的很长，你忍耐一下）。
基础：形参和实参
我们先来回顾一下，我们学习java的时候，所谓的形参和实参的定义吧
形参：方法被调用时需要传递进来的参数，如：function(int a)中的a，它只有在function被调用期间a才有意义，也就是会被分配内存空间，在方法function执行完成后，a就会被销毁释放空间，也就是不存在了
实参：方法被调用时是传入的实际值，它在方法被调用前就已经被初始化并且在方法被调用时传入。
举个简单的栗子
public static void function(int a){
a = 20;
System.out.println(a);
}
public static void main(String[] args) {
int a=10;//变量
function(a);
}
这里吐槽一下，写伪代码是真麻烦啊。
例子中int a=10;中的a在被调用之前就已经创建并初始化，在调用function方法时，他被当做参数传入，所以这个a是实参。
而function(int a)中的a只有在function被调用时它的生命周期才开始，而在function调用结束之后，它也随之被JVM释放掉，所以这个a是形参，此时可以猜猜打印出来的结果，再猜一猜如果地下在sout一下a的值，等于多少。
基础：java的数据类型
所谓数据类型，是编程语言中对内存的一种抽象表达方式，我们知道程序是由代码文件和静态资源组成，在程序被运行前，这些代码存在在硬盘里，程序开始运行，这些代码会被转成计算机能识别的内容放到内存中被执行。
因此：
数据类型实质上是用来定义编程语言中相同类型的数据的存储形式，也就是决定了如何将代表这些值的位存储到计算机的内存中。
所以，数据在内存中的存储，是根据数据类型来划定存储形式和存储位置的。
那么
Java的数据类型有哪些？
基本类型：编程语言中内置的最小粒度的数据类型。它包括四大类八种类型：4种整数类型：byte、short、int、long2种浮点数类型：float、double1种字符类型：char1种布尔类型：boolean
引用类型：引用也叫句柄，引用类型，是编程语言中定义的在句柄中存放着实际内容所在地址的地址值的一种数据形式。它主要包括：类、接口、数组
当然了，上面这些定义，是我抄的，但是，有了这些数据类型JVM对程序数据的管理就规范化了，不同的数据类型，它的存储形式和位置是不一样的，我们知道了类型，也就知道jvm的管理方式。
基础：jvm的内存模型及功能
Java语言本身是不能操作内存的，它的一切都是交给JVM来管理和控制的。换句话说，Java内存区域的划分也就是JVM的区域划分，在说JVM的内存划分之前，我们先来看一下Java程序的执行过程，如下图：
好了，从网上抄来了一个图片，java内存和字节码的内容可以参照《深入了解jvm虚拟机》这个书里去看，我这些也是书上或者网上抄的。Java代码被编译器编译成字节码之后，JVM开辟一片内存空间（也叫运行时数据区），通过类加载器加到到运行时数据区来存储程序执行期间需要用到的数据和相关信息，在这个数据区中，它由以下几部分组成：
1. 虚拟机栈
2. 堆
3. 程序计数器
4. 方法区
5. 本地方法栈
我们接着来了解一下每部分的原理以及具体用来存储程序执行过程中的哪些数据。
虚拟机栈
虚拟机栈是Java方法执行的内存模型，栈中存放着栈帧，每个栈帧分别对应一个被调用的方法，方法的调用过程对应栈帧在虚拟机中入栈到出栈的过程。
栈是线程私有的，也就是线程之间的栈是隔离的；当程序中某个线程开始执行一个方法时就会相应的创建一个栈帧并且入栈（位于栈顶），在方法结束后，栈帧出栈。
下图表示了一个Java栈的模型以及栈帧的组成：
栈帧:是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区中的虚拟机栈的栈元素。
每个栈帧中包括：
局部变量表:用来存储方法中的局部变量（非静态变量、函数形参）。当变量为基本数据类型时，直接存储值，当变量为引用类型时，存储的是指向具体对象的引用。
操作数栈:Java虚拟机的解释执行引擎被称为"基于栈的执行引擎"，其中所指的栈就是指操作数栈。
指向运行时常量池的引用:存储程序执行时可能用到常量的引用。
方法返回地址:存储方法执行完成后的返回地址。
堆
堆是用来存储对象本身和数组的，在JVM中只有一个堆，因此，堆是被所有线程共享的。
方法区
方法区是一块所有线程共享的内存逻辑区域，在JVM中只有一个方法区，用来存储一些线程可共享的内容，它是线程安全的，多个线程同时访问方法区中同一个内容时，只能有一个线程装载该数据，其它线程只能等待。
方法区可存储的内容有：类的全路径名、类的直接超类的权全限定名、类的访问修饰符、类的类型（类或接口）、类的直接接口全限定名的有序列表、常量池（字段，方法信息，静态变量，类型引用（class））等。
本地方法栈
本地方法栈（Native Method Stack）与虚拟机栈所发挥的作用是非常相似的，它们之间的区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚 拟机使用到的Native方法服务。在虚拟机规范中对本地方法栈中方法使用的语言、使用方式 与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如 Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法 栈区域也会抛出StackOverflowError和OutOfMemoryError异常。
其实，这部分是最难理解的。
程序计数器
程序计数器（Program Counter Register）是一块较小的内存空间，它可以看作是当前线 程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能 会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选 取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需 要依赖这个计数器来完成。
数据存储
从上面程序运行图我们可以看到，JVM在程序运行时的内存分配有三个地方：
堆、栈、静态方法区、常量区
相应地，每个存储区域都有自己的内存分配策略：
堆式、栈式、静态
我们已经知道：Java中的数据类型有基本数据类型和引用数据类型，那么这些数据的存储都使用哪一种策略呢？
这里要分以下的情况进行探究：
1. 基本数据类型的存储：
1.1. 基本数据类型的局部变量
1.2. 基本数据类型的成员变量
1.3. 基本数据类型的静态变量
2. 引用数据类型的存储
基本类型的存储
基本数据类型的局部变量
定义基本数据类型的局部变量以及数据都是直接存储在内存中的栈上，也就是前面说到的“虚拟机栈”，数据本身的值就是存储在栈空间里面。
所以很容易理解的是，这些数据会直接被存在栈中：
int age = 50;
int weight=50;
int grade=6;
同理，我们很容易理解，当我们int age 这句话的时候，其实分了2个操作，先创建一个名为age的变量，然后，存在局部变量表里，然后查找对应值为50的内容，如果有，直接把age指向对应的内存地址，如果没有，则开辟内存，然后存入50这个数据，然后在把age指向50的内存地址
我们声明并初始化基本数据类型的局部变量时，变量名以及字面量值都是存储在栈中，而且是真实的内容。
我们再来看“int weight=50；”，按照刚才的思路：字面量为50的内容在栈中已经存在，因此weight是直接指向这个地址的。由此可见：栈中的数据在当前线程下是共享的。
那么如果再执行下面的代码呢？
weight=40；
修改weight的值，那么会如何操作呢？首先第一步在栈中，查找是否有40的内容，现在目前没有，那么，开辟内存，赋值40，将weight的指向内容为40的内存地址。
由此，我们得出很重要的一个结论：基本数据类型的数据本身是不会改变的，当局部变量重新赋值时，并不是在内存中改变字面量内容，而是重新在栈中寻找已存在的相同的数据，若栈中不存在，则重新开辟内存存新数据，并且把要重新赋值的局部变量的引用指向新数据所在地址。
基本类型的成员变量
成员变量，很显然，就是一个类的基本属性的成员，也就是定义在类的全局变量（如果这个都不知道，我建议你还是电子厂找个班上上）。
图中，per这个变量，指向了一个内存地址，然后，内存地址指向了堆中的一块区域，这就是于Person per = new Person();这句话在内存中的结构，per存在jvm栈中，然后内容是一个内存地址，从图上分析，Person类一共3个属性：age name grade，还有一个静态无返回值方法run，
@Data //假装是lombox的注解，省略get和set方法，这代码格式化是真特么的难
public class Person{
private int age;
private String name;
private int grade;
static void run(){
System.out.println("run....");
}
｝
同样是局部变量的age、name、grade却被存储到了堆中为per对象开辟的一块空间中。因此可知：基本数据类型的成员变量名和值都存储于堆中，其生命周期和对象的是一致的。
上面这句很重要，也就是说，类的这些成员变量，其实是存在堆内存里，需要理解的就是，把他当做一个实体吧，有这个一个实在的人的属性就是包括在一个整体里。
基本数据类型的静态变量
基本类型的静态变量，是存在于方法区的，基本数据类型的静态变量名以及值存储于方法区的运行时常量池中，静态变量随类加载而加载，随类消失而消失。
引用类型的存储
从定义我们知道，堆是存储对象本身和数组的，虚拟机栈中只存储了内容的地址。所以Person per = new Person();这句话出现的时候，虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一 个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过（这是类加载的过程）。如果没有，那必须先执行相应的类加载过程，在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务等同于把 一块确定大小的内存从Java堆中划分出来。假设Java堆中内存是绝对规整的，所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅是把那个指针向空闲空间那边挪动一段与对象大小相等的距离，这种分配方式称 为“指针碰撞”（Bump the Pointer）。如果Java堆中的内存并不是规整的，已使用的内存和空 闲的内存相互交错，那就没有办法简单地进行指针碰撞了，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例， 并更新列表上的记录，这种分配方式称为“空闲列表”（Free List）。选择哪种分配方式由 Java堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。因此，在使用Serial、ParNew等带Compact过程的收集器时，系统采用的分配算法是指针碰撞，而使用CMS这种基于Mark-Sweep算法的收集器时，通常采用空闲列表。
一句话解释就是：现在栈中创建per这个变量，然后在堆中创建对象实体，在讲堆中内存实体的内存地址给到per中，让per指向这部分的内存地址。引用数据类型的对象/数组，变量名存在栈中，变量值存储的是对象的地址，并不是对象的实际内容，对象的实际内容是在堆中。
java传递的本质
刚才，介绍的都是一些基础，大量的抄袭了jvm的书籍和博客。其实理解起来，也还是很容易的，如果理解了这部分，就能够理解很多很多的现象了。
我们看看值传递的定义
在方法被调用时，实参通过形参把它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。
同样的，我们看看引用传递的定义
”引用”也就是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向通愉快内存地址，对形参的操作会影响的真实内容。
首先程序运行时，调用main()方法，此时JVM为main()方法往虚拟机栈中压入一个栈帧，即为当前栈帧，用来存放main()中的局部变量表(包括参数)、操作栈、方法出口等信息。
而当main方法中调用其他方法的时候，JVM也为其往虚拟机栈中压入一个栈帧（被调用的方法的栈帧），即为当前栈帧，用来存放被调用的方法中的局部变量等信息，而main方法中的数据作为形参传入被调用的方法中，其实是给予了当前栈帧（被调用方法栈帧）的一份拷贝，当被调用的方法返回的时候，当前栈帧从虚拟机栈中出栈，因此，无论你在当前栈帧中怎么改变值，都不会影响main方法中的值，毕竟，你修改了一个复制品，是不影响被复制的那个的。怎么说呢，dota很多人玩过吧，出个分身斧，你开分身， 然后上去辉耀烫人，分身被打死了以后，你本人是不掉血的。这样说可能会好理解一些，我们继续举个栗子：
public static void test(int age,float weight){
// 这个age和weight 都是形参，也就是调用的方法传递进来的一个数据的拷贝，无论你怎么改变这个值，都不影响main方法，也就是调用方法的实际值的
System.out.println("传入的age："+age);
System.out.println("传入的weight："+weight);
age=33;
weight=89.5f;
System.out.println("方法内重新赋值后的age："+age);
System.out.println("方法内重新赋值后的weight："+weight);
}
public static void main(String[] args) {
int a=25;
float w=77.5f;
test(a,w);
System.out.println("方法执行后的age："+a);
System.out.println("方法执行后的weight："+w);
}
结论也很明显了：
传入的age：25
传入的weight：77.5
方法内重新赋值后的age：33
方法内重新赋值后的weight：89.5
方法执行后的age：25
方法执行后的weight：77.5
有想法的小伙伴可以试试。我们通过一组图片来解释具体花生了什么
main方法在调用test方法前，先初始化了2个变量，a和w，并且赋值。
然后main方法调用test方法，也就是吧a和w复制了一份，传给test方法，在test
当我们程序运行到test方法中的age=33; weight=89.5f;2句时，发生了test方法栈帧中的局部变量值修改，查找是否存在内容为50和89.5，不存在的话，开辟内存，并且将内存地址赋值给age和weight。
但是，这里始终应该理解的是，main方法中的栈帧的局部变量表的数据，还是没有改变的，修改的只是test方法压如虚拟机的栈帧。所以我们可以理解，在test方法中，所有的age和weight的数值，都被修改了，但是main方法中的所有数值，都没有被修改。
值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容。
好了，这部分说完了，相信已经颠覆了很多人的程序观，我平时写代码，不是给对象赋值，修改对象，然后就起作用了么？
好，我要开始装逼了
假设，我们还是使用已开始说内存结构的Person类。我们创建一个对象，然后赋值，然后在修改属性，比如：
public static void test(Person person){
System.out.println("传入的person的name："+person.getName());
person.setName("我是张大逼");
System.out.println("方法内重新赋值后的name："+person.getName());
}
public static void main(String[] args) {
Person p=new Person();
p.setName("我是sage");
p.setAge(30);
test(p);
System.out.println("方法执行后的name："+p.getName());
}
这段代码运行的结果是什么呢？
传入的person的name：我是sage
方法内重新赋值后的name：我是张大逼
方法执行后的name：我是张大逼
卧槽，你刚才这么改的时候，为啥出来main方法就被改了，现在为啥，出来的还是张大逼？？？
显然，我们日常使用的，其实就是这种调用形式，所以刚才的结论才会摧毁了我们的码砖概念。理解这个就需要我们会看刚才讲的，对象，也就是引用类型在内存模型中的存储了。
main方法创建了一个对象p，然后调用test方法，这个时候，压入虚拟机栈的，是对象p在堆内存中内存地址的复制，这个还是和刚才说的一样。然后也解释的通，毕竟是一样的，调用方法，就是把新调用的方法作为当前栈帧压入虚拟机栈中，然后将作为形参的数据复制一份。
不同之处在于，我们从p中拿到的，不在是实际的内容，而是堆中的对象实体所在的内存地址，我们顺着这个地址找过去，我们修改的是什么呢？
看到了么，我们，这个时候修改的是堆内存中的数据，那么，main方法中，p存储的，也是这个地址，相当于什么呢？
相当于我给你的是门牌号和钥匙，你去我家去装修，然后装修好了以后，我再按照门牌号和钥匙来找我家，我家是不是就被装修过了？
理解了这部分以后，我们来把刚才代码改动一下，也就是把我们要讲的内容的结论推出来。
public static void test(Person person){
person = new Person(); //增加了这句代码
System.out.println("传入的person的name："+person.getName());
person.setName("我是张大逼");
System.out.println("方法内重新赋值后的name："+person.getName());
}
public static void main(String[] args) {
Person p=new Person();
p.setName("我是sage");
p.setAge(30);
test(p);
System.out.println("方法执行后的name："+p.getName());
}
我们将刚才试验的代码中，加入一句person = new Person(); 其余代码不变，那么结论是什么呢？
传入的person的name：我是sage
方法内重新赋值后的name：我是张大逼
方法执行后的name：我是sage
怎么样，又和我们刚才得出来的结论一致了，修改了test方法中的p的值，main方法中的值保持不变。
这个过程是怎么样的呢？当我们main方法调用test方法的时候，还是将test方法的栈帧作为当前栈帧压入了虚拟机，并且将p复制了一份，给到test栈帧。而我们修改了p的值，也就是形参的值，根据我们之前的结论，复制的值被修改，不影响原先的值，所以，main方法中的值还是旧的。test方法中创建了新的对象，也就是，test方法中的person指向了新的地址。就如前文讲的：JVM会在堆内开辟一块内存，用来存储p对象的所有内容，同时在main（）方法所在线程的栈区中创建一个引用p存储堆区中p对象的真实地址。
具体来说就是，我把我家地址给装修公司，装修公司自作主张的改变了我家地址（就是在test方法中创建对象），然后说，给我装修了房子。这时候的这是情况，就是装修了隔壁老王家，然后非要说是装修给我的。
可以推出：实参也应该指向了新创建的person对象的地址，所以在执行test()结束之后，最终输出的应该是后面创建的对象内容。
然而实际上，最终的输出结果却跟我们推测的不一样，最终输出的仍然是一开始创建的对象的内容。
由此可见：引用传递，在Java中并不存在。
但是有人会疑问：为什么第一个例子中，在方法内修改了形参的内容，会导致原始对象的内容发生改变呢？
这是因为：无论是基本类型和是引用类型，在实参传入形参时，都是值传递，也就是说传递的都是一个副本，而不是内容本身。
结论
终于到结论了，为了说明一个简答的问题，码了这么多的字，也是真的不容易啊。
在Java中所有的参数传递，不管基本类型还是引用类型，都是值传递，或者说是副本传递。
只是在传递过程中：
如果是对基本数据类型的数据进行操作，由于原始内容和副本都是存储实际值，并且是在不同的栈区，因此形参的操作，不影响原始内容。
如果是对引用类型的数据进行操作，分两种情况，一种是形参和实参保持指向同一个对象地址，则形参的操作，会影响实参指向的对象的内容。一种是形参被改动指向新的对象地址（如重新赋值引用），则形参的操作，不会影响实参指向的对象的内容。
