java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java是值传递还是引用传递

Java是值传递还是引用传递？看完这篇你就明白了

作者：jasmine_jokerluo

还在纠结Java的形参、实参和值传递、引用传递吗？本文用通俗易懂的例子和内存图解,帮你彻底搞懂Java参数传递机制,并详解JVM内存划分和数据类型存储原理,让你面试不再被问倒

形参和实参

举个例子：

public static void func(int a){
  a = 20;
  System.out.println(a);
}
public static void main(String[] args){
  int a =10;//变量
  func(a);
}

例子中int a=10;中的a在被调用之前就已经创建并初始化，在调用func方法时，他被当做参数传入，所以这个a是实参而func(int a)中的a只有在func被调用时它的生命周期才开始，而在func调用结束之后，它也随之被JVM释放掉，，所以这个a是形参

Java的数据类型

所谓数据类型，是编程语言中对内存的一种抽象表达方式，我们知道程序是由代码文件和静态资源组成，在程序被运行前，这些代码存在在硬盘里，程序开始运行，

这些代码会被转成计算机能识别的内容放到内存中被执行

因此

数据类型实质上是用来定义编程语言中相同类型的数据的存储形式，也就是决定了如何将代表这些值的位存储到计算机的内存中

所以，数据在内存中的存储，是根据数据类型来划定存储形式和存储位置的

基本类型

编程语言中内置的最小粒度的数据类型。它包括四大类八种类型：

引用类型

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

它主要包括：

JVM内存的划分及职能

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

Java程序的执行过程：

由图可以看出：

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

虚拟机栈

Java栈的模型以及栈帧的组成：

每个栈帧中包括：

堆

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

方法区

本地方法栈

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

程序计数器

数据如何在内存中储存

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

相应地，每个存储区域都有自己的内存分配策略：

数据储存策略

Java中的数据类型有基本数据类型和引用数据类型，这些数据的储存策略需分情况探究 

1.基本数据类型的存储：

2.引用数据类型的存储

1.基本数据类型的存储

A.基本数据类型的局部变量

定义基本数据类型的局部变量以及数据都是直接存储在内存中的栈上，也就是前面说到的“虚拟机栈”，数据本身的值就是存储在栈空间里面

如上图，在方法内定义的变量直接存储在栈中，如：

int age = 50;
int weigh = 50；
int grade = 6;

上述写的“int age = 50;"实际上分为两步：

int age;//定义变量
age = 50;//赋值

首先JVM创建一个名为age的变量，存于局部变量表中，然后去栈中查找是否存在有字面量值为50的内容，如果有就直接把age指向这个地址，如果没有，JVM会在栈中开辟一块空间来存储“50”这个内容，并且把age指向这个地址

由此可知：

我们声明并初始化基本数据类型的局部变量时，变量名以及字面量值都是存储在栈中，而且是真实的内容

按照刚才的思路："int weigh = 50;"即字面量为50的内容在栈中已经存在，因此weight是直接指向这个地址的

由此可知：

栈中的数据在当前线程下是共享的

如果此时再执行

int weigh = 40;

当代码中重新给weight变量进行赋值时，JVM会去栈中寻找字面量为40的内容，发现没有，就会开辟一块内存空间存储40这个内容，并且把weight指向这个地址

由此可知：

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

B. 基本数据类型的成员变量

成员变量：顾名思义，就是在类体中定义的变量

看下图：

per的地址指向的是堆内存中的一块区域，还原代码如下：

public class Person{
  private int age;
  private String name;
  private int grade;
//篇幅较长，省略setter getter方法
  static void run(){
    System.out.println(“run...");
    };
  }

//调用
Person per=new Person();

同样是局部变量的age、name、grade却被存储到了堆中为per对象开辟的一块空间中

由此可知：

基本数据类型的成员变量名和值都存储于堆中，其生命周期和对象的是一致的

C. 基本数据类型的静态变量

前面提到方法区用来存储一些共享数据，因此基本数据类型的静态变量名以及值存储于方法区的运行时常量池中，静态变量随类加载而加载，随类消失而消失

2. 引用数据类型的存储

上面提到：堆是用来存储对象本身和数组，而引用（句柄）存放的是实际内容的地址值，因此通过上面的程序运行图，也可以看出，当我们定义一个对象时

Person per=new Person();

实际上，它也是有两个过程：

Person per;//定义变量
per=new Person();//赋值

在执行Person per;时，JVM先在虚拟机栈中的变量表中开辟一块内存存放per变量，在执行per=new Person()时，

JVM会创建一个Person类的实例对象并在堆中开辟一块内存存储这个实例，同时把实例的地址值赋值给per变量

由此可知：

对于引用数据类型的对象/数组，变量名存在栈中，变量值存储的是对象的地址，并不是对象的实际内容

值传递和引用传递

值传递

值传递：

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

例：

 public static void valueCrossTest(int age,float weight){
     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;
        valueCrossTest(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

从上面的打印结果可以看到：

a和w作为实参传入valueCrossTest之后，无论在方法内做了什么操作，最终a和w都没变化

原因：

首先程序运行时，调用mian()方法，此时JVM为main()方法往虚拟机栈中压入一个栈帧，即为当前栈帧，用来存放main()中的局部变量表(包括参数)、操作栈、方法出口等信息，如a和w都是mian()方法中的局部变量，因此可以断定，a和w是躺着mian方法所在的栈帧中

如图：

而当执行到valueCrossTest()方法时，JVM也为其往虚拟机栈中压入一个栈，即为当前栈帧，用来存放valueCrossTest()中的局部变量等信息，因此age和weight是躺着valueCrossTest方法所在的栈帧中，而他们的值是从a和w的值copy了一份副本而得

如图：

因而可以a和age、w和weight对应的内容是不一致的，所以当在方法内重新赋值时

实际流程如图：

也就是说，age和weight的改动，只是改变了当前栈帧（valueCrossTest方法所在栈帧）里的内容，当方法执行结束之后，这些局部变量都会被销毁，mian方法所在栈帧重新回到栈顶，成为当前栈帧，再次输出a和w时，依然是初始化时的内容

因此：

值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容

引用传递

引用传递：

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

例：

先定义一个对象：

 public class Person {
         private String name;
         private int 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;
        }
}

写个函数测试一下：

 public static void PersonCrossTest(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("我是马化腾");
        p.setAge(45);
        PersonCrossTest(p);
        System.out.println("方法执行后的name："+p.getName());
}

输出结果：

传入的person的name：我是马化腾
方法内重新赋值后的name：我是张小龙
方法执行后的name：我是张小龙

可以看出，person经过personCrossTest()方法的执行之后，内容发生了改变，这印证了上面所说的“引用传递”，对形参的操作，改变了实际对象的内容

下面我们对上面的例子稍作修改，加上一行代码：

public static void PersonCrossTest(Person person){
        System.out.println("传入的person的name："+person.getName());
        person=new Person();//加多此行代码
        person.setName("我是张小龙");
        System.out.println("方法内重新赋值后的name："+person.getName());
    }

输出结果：

传入的person的name：我是马化腾
方法内重新赋值后的name：我是张小龙
方法执行后的name：我是马化腾

输出结果不一样的原因：

按照上面讲到JVM内存模型可以知道，对象和数组是存储在Java堆区的，而且堆区是共享的，因此程序执行到main（）方法中的下列代码时

Person p=new Person();
        p.setName("我是马化腾");
        p.setAge(45);
        PersonCrossTest(p);

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

如图：

当执行到PersonCrossTest()方法时，因为方法内有这么一行代码：

person=new Person();

在第一个例子中，在方法内修改了形参的内容，会导致原始对象的内容发生改变的原因：

无论是基本类型和是引用类型，在实参传入形参时，都是值传递，也就是说传递的都是一个副本，而不是内容本身

由图可知，方法内的形参person和实参p并无实质关联，它只是由p处copy了一份指向对象的地址

此时：

p和person都是指向同一个对象

因此在第一个例子中，对形参p的操作，会影响到实参对应的对象内容。而在第二个例子中，当执行到new Person()之后，JVM在堆内开辟一块空间存储新对象，并且把person改成指向新对象的地址

此时：

p依旧是指向旧的对象，person指向新对象的地址

所以此时对person的操作，实际上是对新对象的操作，于实参p中对应的对象毫无关系

总结：

在Java中所有的参数传递，不管基本类型还是引用类型，都是值传递，或者说是副本传递

只是在传递过程中：

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

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

实例简证

核心概念

1. 基本数据类型（值传递）

void modify(int x) {
    x = 20;  // 修改的是副本，不影响原值
}

int a = 10;
modify(a);
System.out.println(a); // 输出 10，a 不变

2. 引用类型（传递引用的值）

class Person {
    String name;
}

void changeName(Person p) {
    p.name = "Bob";  // 可以修改对象内容
    p = new Person(); // 只是修改了局部变量p的指向，不影响原引用
}

Person person = new Person();
person.name = "Alice";
changeName(person);
System.out.println(person.name); // 输出 "Bob"

关键区分

值传递（Java的做法）

引用传递（Java不存在）

示例说明

public class ParameterPassing {
    public static void main(String[] args) {
        // 示例1：基本类型
        int num = 5;
        modifyPrimitive(num);
        System.out.println(num); // 5，未改变
        
        // 示例2：引用类型 - 修改对象内容
        StringBuilder sb = new StringBuilder("Hello");
        modifyObjectContent(sb);
        System.out.println(sb.toString()); // "Hello World"，内容被修改
        
        // 示例3：引用类型 - 改变引用指向
        StringBuilder sb2 = new StringBuilder("Test");
        changeReference(sb2);
        System.out.println(sb2.toString()); // "Test"，引用指向未改变
    }
    
    static void modifyPrimitive(int x) {
        x = 10;
    }
    
    static void modifyObjectContent(StringBuilder builder) {
        builder.append(" World");
    }
    
    static void changeReference(StringBuilder builder) {
        builder = new StringBuilder("New");  // 不影响原引用
    }
}

容易混淆的点

误区：“既然可以修改对象内容，那不就是引用传递吗？”

澄清：区别在于：

特殊案例：数组和集合

void modifyArray(int[] arr) {
    arr[0] = 100;  // 可以修改数组元素
    arr = new int[5];  // 不影响原数组引用
}

int[] array = {1, 2, 3};
modifyArray(array);
System.out.println(array[0]); // 100，元素被修改
// 但array仍然指向原来的数组对象

总结

特性基本类型引用类型
传递的内容值的副本引用的值（地址副本）
能否修改原值不能不能（不能改变引用指向）
能否修改对象内容-可以
类比复印一份文件给你修改给你保险箱钥匙的复印件

结论：

Java 严格采用值传递，只是对于引用类型，传递的是引用的值（你可以理解为"副本的钥匙"），这让很多人产生了"引用传递"的误解

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文