Java-值传递和值引用

1.形参和实参的区别？

形参:方法被调用时需要传递进来的参数,只有在被调用时才分配内存单元，在调用结束时，就会释放出所分配的内存单元。形参只能在函数内部才有效.

实参:在方法被调用前就已经被初始化并且在方法被调用时传入，是实际值。

如果不好理解,我们举个例子：

  @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parameter);        int a =10;
        parameter(a);//parameter()方法调用处为实参
    }    public void parameter(int a){//方法定义处为形参
        --a;
        Log.e(TAG, "parameter: "+a);
    }

我们的int a =10,在调用到parameter(a);之前已经初始化，作为参数传递给  parameter(a)，所以此处的a是实参。
方法 parameter(int a)中的a，只有parameter()被调用时它的生命周期才开始，而在func调用结束之后，它也随之被JVM释放掉，所以这个a是形参。
简单点就是:方法调用处是实参，方法定义处为实参。

2.Java的数据类型

我们知道程序是由代码文件和静态资源组成，在程序被运行前，这些代码存在在硬盘里，程序开始运行，这些代码会被转成计算机能识别的内容放到内存中被执行。因此:

数据类型实质上是用来定义编程语言中相同类型的数据的存储形式，也就是决定了如何将代表这些值的位(0或1)存储到计算机的内存中。所以，数据在内存中的存储，是根据数据类型来划定存储形式和存储位置的.

我们都知道数据类型分为基本数据类型和引用数据类型:
基本类型：编程语言中内置的最小粒度的数据类型。它包括四大类八种类型：

4种整数类型：byte、short、int、long
2种浮点数类型：float、double
1种字符类型：char
1种布尔类型：boolean

引用类型：引用也叫句柄，引用类型是编程语言中定义的在句柄中存放着实际内容所在地址的地址值的一种数据形式。它主要包括：

类
接口
数组

在来一张图，更好的说明一下:

image

有了数据类型，JVM对程序数据的管理就规范化了，不同的数据类型，它的存储形式和位置是不一样的，要想知道JVM是怎么存储各种类型的数据，就得先了解JVM的内存划分以及每部分的职能。

那我这里还有一个小问题，String属于什么数据类型呢？
答:Java中的字符串String属于引用数据类型。因为String是一个类.

3.JVM内存的划分及职能

Java语言通过JVM来控制和管理内存，因此Java内存区域的划分也就是JVM的区域划分，但在说JVM的内存划分之前，我们先来看一下Java程序的执行过程，如下图：

image.png

由图可以看出：Java代码被编译器编译成字节码之后，JVM开辟一片内存空间（也叫运行时数据区），通过类加载器加到到运行时数据区来存储程序执行期间需要用到的数据和相关信息，在这个数据区中，它由以下几部分组成:

1. 虚拟机栈

2. 堆

3. 程序计数器

4. 方法区

5. 本地方法栈
   我们接着来了解一下每部分的原理以及具体用来存储程序执行过程中的哪些数据:

1.虚拟机栈

虚拟机栈是Java方法执行的内存模型，栈中存放着栈帧，每个栈帧分别对应一个被调用的方法，方法的调用过程对应栈帧在虚拟机中入栈到出栈的过程。

栈是线程私有的，也就是线程之间的栈是隔离的；当程序中某个线程开始执行一个方法时就会相应的创建一个栈帧并且入栈（位于栈顶），在方法结束后，栈帧出栈。

下图表示了一个Java栈的模型以及栈帧的组成：

image.png

栈帧:是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区中的虚拟机栈的栈元素。

每个栈帧中包括：
局部变量表:用来存储方法中的局部变量（非静态变量、函数形参）。当变量为基本数据类型时，直接存储值，当变量为引用类型时，存储的是指向具体对象的引用。

操作数栈:Java虚拟机的解释执行引擎被称为"基于栈的执行引擎"，其中所指的栈就是指操作数栈。

指向运行时常量池的引用:存储程序执行时可能用到常量的引用。

方法返回地址:存储方法执行完成后的返回地址。

2.堆

堆是用来存储对象本身和数组的，在JVM中只有一个堆，因此，堆是被所有线程共享的。

3.方法区

方法区是一块所有线程共享的内存逻辑区域，在JVM中只有一个方法区，用来存储一些线程可共享的内容，它是线程安全的，多个线程同时访问方法区中同一个内容时，只能有一个线程装载该数据，其它线程只能等待。

方法区可存储的内容有：类的全路径名、类的直接超类的权全限定名、类的访问修饰符、类的类型（类或接口）、类的直接接口全限定名的有序列表、常量池（字段，方法信息，静态变量，类型引用（class））等。

1. 本地方法栈

本地方法栈的功能和虚拟机栈是基本一致的，并且也是线程私有的，它们的区别在于虚拟机栈是为执行Java方法服务的，而本地方法栈是为执行本地方法服务的。

什么是本地方法？为什么Java还要调用本地方法？

简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。

1. 程序计数器：

线程私有的。
记录着当前线程所执行的字节码的行号指示器，在程序运行过程中，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、异常处理、线程恢复等基础功能都需要依赖计数器完成。

4. 数据如何在内存中存储？

从上面程序运行图我们可以看到，JVM在程序运行时的内存分配有三个地方：

• 堆,对应的内存分配策略为堆式

• 栈，对应的内存分配策略为栈式

• 静态方法区，对应的内存分配策略为静态

那我们来讨论一下，Java的数据类型即基本数据类型和引用数据类型采取的分配方式，这里要分情况讨论：
基本数据类型在内存中的存储

• 基本数据类型的局部变量

• 基本数据类型的成员变量

• 基本数据类型的静态变量

引用数据类型在内存中的存储

那我们先来讨论

4.1基本数据类型的局部变量如何在内存中存储

局部变量可以理解为：在方法中定义的变量
你比如我们在代码中写了一个局部变量number并赋值
public void method(){ int number=8; }

那么这个局部变量会被分两步存储在栈中，

int number;//第一步定义变量number=50;//第二步赋值

首先JVM创建一个名为number的变量，存于局部变量表中，然后去栈中查找是否存在有字面量值为50的内容，如果有就直接把number指向这个地址，如果没有，JVM会在栈中开辟一块空间来存储“50”这个内容，并且把number指向这个地址。
这里的栈就是我们上面提到的“虚拟机栈”，数据本身的值就是存储在栈空间里面。

如果此时我在写一个局部变量 int numberTwo =50,jvm将不会再次开辟一块空间来存储50，而是将直接引用int number=50的那个地址，由此可见栈中的数据在当前线程下是共享的。

那如果我将int number=40呢？JVM会在栈中查找是否有一块空间的值为40，没有就开辟新的内存空间，并将number指向该地址。

总结：基本数据类型的数据本身是不会改变的，当局部变量重新赋值时，并不是在内存中改变字面量内容，而是重新在栈中寻找已存在的相同的数据，若栈中不存在，则重新开辟内存存新数据，并且把要重新赋值的局部变量的引用指向新数据所在地址。

4.2基本数据类型的成员变量如何在内存中存储

成员变量可以理解为类中定义的变量。
你比如我在Person类中定义了name,age等属性代码如下：

public class Person{String name;int age;public void setName(String name){this.name =name;
}public String getName(){
retrun name
}//部分get,set方法省略........
}

然后我进行Persion的实例化
Person mPerson =new Person();
实际上是分为了两步：

第一步:Person mPerson;
第二步:mPerson =new Person;

那么name、age会被存储到了堆中为Personr对象开辟的一块空间中。因此可知：基本数据类型的成员变量名和值都存储于堆中，其生命周期和对象的是一致的，在JVM中只有一个堆，因此，堆是被所有线程共享的。

4.3基本数据类型的静态变量如何在内存中的存储

基本数据类型的静态变量名以及值存储于方法区的运行时常量池中，静态变量随类加载而加载(不依赖对象而加载，只要加载了.class文件 就加载了静态变量 这时还没有对象产生)，随类消失而消失(相当于程序结束)，非静态变量(包括类实例和成员变量): 随着对象的创建而创建(依赖对象)，随着对象的销毁而销毁， 存储于堆内存中(表述不是很准确，下面说)。

这里需要抛一个问题：我们在Android开发中，当一个Activity被onDestory()那么其类中的基本类型的静态变量的成员会不会被销毁？
答：不会，原因是，Activity中的基本类型的静态变量在类加载的时候变量名和值都存在于方法区中，而onDestory()只是销毁了该Activity类实例即销毁的是该Activity存在于堆内存和栈中的数据(非静态的成员变量)。

4.4引用数据类型如何在内存中的存储

上面提到：堆是用来存储对象本身和数组，而引用（句柄）存放的是实际内容的地址值，因此当我们定义一个对象时，如我们上面提到的：
Person mPerson =new Person();
实际上是分为了两步：

第一步:Person mPerson;
第二步:mPerson =new Person;

在执行Person mPerson;时，JVM先在虚拟机栈中的变量表中开辟一块内存存放mPerson变量，在执行mPerson=new Person()时，JVM会创建一个Person类的实例对象并在堆中开辟一块内存存储这个实例，同时把实例的地址值赋值给mPerson变量。因此可见：
对于引用数据类型的对象/数组，变量名存在栈中，变量值存储的是对象的地址，并不是对象的实际内容。

5. 值传递和引用传递

5.1 终于说到重点了，开不开心。先来看一下值传递的定义

值传递：
在方法被调用时，实参通过形参把它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。

我们根据这段话的描述，写一下相关的代码：

public static void main(String [] args){         int A=10;
        testParameters(A);
        System.out.println("方法执行完毕的参数值"+A);
    }    public static void testParameters(int a){
        System.out.println( "方法传入的参数值"+a);
        a =11;
        System.out.println("方法内重新赋值的参数值"+a);

    }

结果:

image.png

从结果可以看到，无论在方法内对形参做了什么操作，实参a始终没有变化。
我们运用上面学习的内容来分析一下：
首先程序执行main()，因为我们之前说过：栈帧是用于支持虚拟机进行方法调用和方法执行的数据结构，此时JVM为main()方法往虚拟机栈中压入一个栈帧，即为当前栈帧，用来存放main()中的局部变量表，也就是我们代码中的A变量及其值。
然后当执行到testParameters()方法时，JVM也为其往虚拟机栈中压入一个栈，即为当前栈帧，用来存放testParameters()中的局部变量等信息，也就是我们代码中的形参小a，而a的值是从A的值copy了一份副本而得。
所以a和At对应的内容是不一致的，a对应的是A的副本。当testParameters()执行结束之后，这些局部变量都会被销毁，mian()所在栈帧重新回到栈顶，成为当前栈帧，再次输出A的值时依然是初始化时的内容。
因此：
值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容。

5.2.看一眼引用传递

引用传递：
”引用”也就是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向同一个内存地址，对形参的操作会影响的真实内容。

相关代码如下:

    public static void main(String [] args){
        Person p=new Person("xzt",18);
        testArguement(p);
        System.out.println("方法执行完毕后的年龄为"+p.getAge());
    }    public static void testArguement(Person person){
       System.out.println("传递的年龄为"+person.getAge());
       person.setAge(20);
        System.out.println("重新赋值后的年龄为"+person.getAge());
    }  public class person{
        String name;        int age;        public Person() {
        }        public person(String name, int age) {            this.name = name;            this.age = age;
        }        public String getName() {            return name;
        }        public void setName(String name) {            this.name = name;
        }        public int getAge() {            return age;
        }        public void setAge(int age) {            this.age = age;
        }
    }

结果:

：

这是不是和我们上面说的引用传递的的定义一致:在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向同一个内存地址，对形参的操作会影响的真实内容。

那我们在对上面的代码稍作变动执行一下:
代码:

image.png

结果:

image.png

分析:
我们知道对象和数组是存储在Java堆区的，而且堆区是共享的，因此程序执行到main（）方法中的下列代码时

  Person p=new Person("xzt",18);

JVM会在堆内开辟一块内存，用来存储p对象的所有内容，同时在main（）方法所在线程的栈区中创建一个引用p存储堆区中p对象的真实地址，如图：

image.png

当执行到testArguement()方法时，因为方法内有我们新增的一行代码:

image.png

JVM需要在堆内另外开辟一块内存来存储new Person()，假如地址为“0x222”，那此时形参person指向了0x222这个地址而不是之前的那个地址，所以我们对0x222这个地址的值的操作不能影响到地址值为0x111的。
那么这里有一个问题，我们上面说：引用传递中形参实参指向同一个对象，形参的操作会改变实参对象的改变。为什么这次没有改变呢?
答:引用传递，在Java中并不存在。无论是基本类型和是引用类型，在实参传入形参时，都是值传递，也就是说传递的都是一个副本，而不是内容本身。

上面的代码可以用下图表示:

image.png

总结:
因此可见：在Java中所有的参数传递，不管基本类型还是引用类型，都是值传递，或者说是副本传递。
只是在传递过程中：

如果是对基本数据类型的数据进行操作，由于原始内容和副本都是存储实际值，并且是在不同的栈区，因此形参的操作，不影响原始内容。

如果是对引用类型的数据进行操作，分两种情况，一种是形参和实参保持指向同一个对象地址，则形参的操作，会影响实参指向的对象的内容。一种是形参被改动指向新的对象地址（如重新赋值引用），则形参的操作，不会影响实参指向的对象的内容。

作者：薛之涛
链接：https://www.jianshu.com/p/bb68f74c3471