精华内容
下载资源
问答
  • 值传递和引用传递
    千次阅读
    2022-03-31 19:47:03
    值传递:在调用函数的时候,将实际参数复制一份传递到函数中,这样在函数中对参数进行修改的
           时候,就不会影响到原来的实际参数
    引用传递:在调用函数的时候,将实际参数的地址直接传递函数中,这样在函数中对参数进行修改
           的时候,就会影响到实际参数
    
                  值传递                    引用传递
    根本区别    会创建一个副本(copy)        不创建副本
    结果        函数中无法改变原来的对象    函数可以改变原来的对象
    
    将对象创建好了之后将信息传给了函数
    在函数中对原来传入的值进行了改变,
    主函数中的对象的值也改变了.
    那么这里就是引用传递,并且所有的对象的地址都是相同
    只要有一个函数对其进行了改变,那么对象的值就变了
    java中的基本年数据类型都是值传递,引用数据类型中的String也是值传递
    引用数据类型除了String之外都是引用传递

    值传递

    package cn.java.Demo;
    
    /**
     * 通过运行结果我们知道,str的值发生了改变,但是s的值没有发生改变还是原来的值
     * 所有
     * String类型是一个值传递
     * 调用函数对String类型进行赋值的时候,   str = "哈哈哈哈"; 相当于做了一个创建
     * 对象的操作   str = new String("哈哈哈哈");
     * 这里我们可以理解为变量str重新创建了一个新的对象指向新的地址
     */
    public class Demo_02 {
        public void pass(String str){
            System.out.println("str === " + str.hashCode());
            str = "哈哈哈哈";
            System.out.println("str = " + str);
            System.out.println("str === " + str.hashCode());
        }
    
        public static void main(String[] args) {
            Demo_02 demo_02 = new Demo_02();
            String s = "呵呵呵";
            System.out.println("s === " + s.hashCode());
    
            demo_02.pass(s);
            System.out.println("s = " + s);
            System.out.println("s === " + s.hashCode());
        }
    }

    运行结果:

     引用传递

    先创建一个实体类:

    package cn.java.Demo;
    
    public class User {
        private String name;
        private Integer age;
    
        public User() {
        }
    
        public User(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;
        }
    
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    /**
     * 将对象创建好了之后将信息传给了函数
     * 在函数中对原来传入的值进行了改变,
     * 主函数中的对象的值也改变了.
     * 那么这里就是引用传递,并且所有的对象的地址都是相同
     * 只要有一个函数对其进行了改变,那么对象的值就变了
     * java中的基本年数据类型都是值传递,引用数据类型中的String也是值传递
     * 引用数据类型除了String之外都是引用传递
     */
    public class Demo_03 {
        public void pass(User user){
            System.out.println("2     " + user.hashCode());
            user.setName("李四");
            user.setAge(20);
            System.out.println(user.toString());
            System.out.println("3     " + user.hashCode());
        }
    
        public static void main(String[] args) {
            Demo_03 demo_03 = new Demo_03();
            User user = new User("张三",18);
            System.out.println("1     " + user.hashCode());
            System.out.println(user.toString());
            demo_03.pass(user);
            System.out.println(user.toString());
            System.out.println("4     " + user.hashCode());
        }
    }

    运行结果:

     

    更多相关内容
  • java 中没有引用传递,都是值传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • 当一个变量为一个参数传入方法内部的时候,会有两种不同的传递方式:值传递和引用传递。  值传递的特点:不管方法内部对传进去的参数作任何改变,也不会影响方法外部的变量的值  引用传递的特点:方法内部对传...
  • 值传递和引用传递

    2020-12-23 01:08:15
    1.值传递:只要是基本数据类型传递就是值传递,传递的就是值 package arrayDemo; public class Demo1 { public static void main(String[] args) { int b =20; change(b);// 实参 实际上的参数 System.out.println...
  • 主要介绍了java通过实例了解值传递和引用传递,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java中的值传递和引用传递

    千次阅读 2021-12-07 20:07:09
    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。一般java中的基础类型数据传递都是值传递引用传递(Pass By Reference或者Call By Reference)...

    个人理解,可能会有错误之处,请仔细甄别,谨慎参考!如有错误或不同见解请指出!

    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。一般java中的基础类型数据传递都是值传递。
    引用传递(Pass By Reference或者Call By Reference)一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。一般java中实例(包装)对象的传递是引用传递。

    一、基本类型和引用类型在内存中的不同之处

    int num = 10;
    String str = "hello";


    如图所示,num是基本类型,值就直接保存在变量中。而str是引用类型,变量中保存的只是实际对象的地址。一般称这种变量为"引用",引用指向实际对象,实际对象中保存着内容。

    二、赋值时内存的变化

    int num = 24;
    String str = "world";

    对于基本类型num,赋值运算符会直接改变变量的值,原来的值被覆盖掉。对于引用类型str,赋值运算符会改变引用中所保存的地址,原来的地址被覆盖掉。但是原来的对象(“hello” 字符串对象)不会被改变。(没有被任何引用所指向的对象是垃圾,会被垃圾回收器回收)

    三、调用方法时发生了什么,参数传递基本上就是赋值操作

    第一个例子:基本类型

    void change(int value) {
        value = 100;
    }
    change(num); // num 没有被改变

    第二个例子:引用类型没有使用改变自身方法的方法

    void change(String a) {
        a = "唐";
    }
    change(str); // str没有被改变

    或:

    StringBuilder stri = new StringBuilder("唐");
    void change(StringBuilder builder) {
        builder = new StringBuilder("宋");
    }
    change(stri); // stri没有被改变,还是 "唐"。

     第三个例子:引用类型使用了改变自身方法的方法

    StringBuilder stri = new StringBuilder("明");
    void change(StringBuilder builder) {
        builder.append("清");
    }
    change(stri); // stri被改变了,变成了"清"。

    第三个例子的图解:


    builder.append("清")之后

    参考:

    java基本数据类型传递与引用传递区别详解_zejian的博客-CSDN博客_java值传递和引用传递java的值传递和引用传递在面试中一般都会都被涉及到,今天我们就来聊聊这个问题,首先我们必须认识到这个问题一般是相对函数而言的,也就是java中的方法参数,那么我们先来回顾一下在程序设计语言中有关参数传递给方法(或函数)的两个专业术语:按值调用(call by value)按引用调用(call by reference)所谓的按值调用表示方法接收的是调用着提https://blog.csdn.net/javazejian/article/details/51192130

     

    展开全文
  • 快速区分值传递和引用传递

    引言

    为了搞清楚值传递和引用传递的区别,查阅了许多资料,加以自身理解,做出本篇博客用于记录。

    概念

    • 值传递:指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
    • 引用传递:指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    误区

    • 错误理解一:通过传递的内容区分,如果是个值,就是值传递。如果是个引用,就是引用传递。
    • 错误理解二:Java是引用传递。
    • 错误理解三:传递的参数如果是普通类型,那就是值传递,如果是对象,那就是引用传递。

    举例

    实例1

    public class TestOne {
        public static void main(String[] args) {
            int num1 = 10;
            int num2 = 20;
            swap(num1, num2);
            System.out.println("num1 = " + num1);
            System.out.println("num2 = " + num2);
        }
        public static void swap(int a, int b) {
            int temp = a;
            a = b;
            b = temp;
            System.out.println("a = " + a);
            System.out.println("b = " + b);
        }
    }
    

    输出:
    在这里插入图片描述
    为什么swap输出的值进行了交换,而main输出的却没交换?

    1、首先,我们都知道,对于基本数据类型来说,使用的是值传递。即
    t=a;a=b;b=t; 这种情况。
    2、但在函数方法中,即实参传递给形参这种情况下,首先把实参复制了一份,并复制给形参。也就是得到的形参是实参的备份
    3、通过对复制出来的备份进行值的交换,并不会影响原来的数值。这也就说明了为什么swap输出的值进行了交换,而main输出的却没交换。

    实例2

    public class TestTwo {
        public static void main(String[] args) {
            Student t1 = new Student("张三", 18);
            Student t2 = new Student("李四", 19);
            swap(t1, t2);
            System.out.println(t1);
            System.out.println(t2);
        }
    
        private static void swap(Student t1, Student t2) {
            Student t = t1;
            t1=t2;
            t2=t;
            System.out.println("t1:"+t1);
            System.out.println("t2:"+t2);
        }
    }
    class Student {
        String name;
        int age;
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Test{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    输出:
    在这里插入图片描述

    原因同实例1,只不过本实例是将实参的地址复制了一份,并赋值给形参,然后进行交换,使其改变指向。
    但是,注意: 这并不是引用传递,在Java里只能叫传递了对象的引用,本质上是传递了对象的引用(地址)的副本,这也算值传递。

    若将交换函数改成如下代码,则成功进行交换

        private static void swap(Student t1, Student t2) {
            Student t = new Student("流星",20);
            t.name=t1.name;
            t.age = t1.age;
            t1.name= t2.name;
            t1.age= t2.age;
            t2.name= t.name;
            t2.age = t.age;
        }
    

    总结

    1、Java 没有引用传递
    2、Java 传递对象 确实是传递对象的引用。更确切的说是传递的对象引用的副本。
    3、Java传递的是引用的副本,而不是引用本身,所以引用没有传递,所以这个不叫引用传递。

    附:参考资料

    1、为什么说Java中只有值传递
    2、Java只有值传递

    展开全文
  • 通过引用传递参数允许函数成员(方法、属性、索引器、运算符构造函数)更改参数的,并保持该更改。 二、传递类型参数类型变量直接包含其数据,这与引用类型变量不同,后者包含对其数据的引用。因此,向方法...
  • Java中是值传递和引用传递

    千次阅读 2022-01-15 12:22:33
    值传递 / 引用传递 值传递:就是在方法调用的时候,实参是将自己的一份拷贝赋给形参,在方法内,对该参数值的修改不影响原来的实参。 引用传递:是在方法调用的时候,实参将自己的地址传递给形参,此时方法内对该...

    值传递 / 引用传递
    值传递:就是在方法调用的时候,实参是将自己的一份拷贝赋给形参,在方法内,对该参数值的修改不影响原来的实参。

    引用传递:是在方法调用的时候,实参将自己的地址传递给形参,此时方法内对该参数值的改变,就是对该实参的实际操作。

    Java中只有值传递
    首先回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。

    按值调用(call by value):表示方法接收的是调用者提供的值。

    按引用调用(call by reference):表示方法接收的是调用者提供的变量地址。

    它用来描述各种程序设计语言(不只是 Java)中方法参数传递方式。

    Java 程序设计语言总是采用按值调用。也就是说,方法得到的是所有参数值的一个拷贝,即,方法不能修改传递给它的任何参数变量的内容。

    swap( ) 场景
    要求写一个函数交换int类型的a和b的值

    在 swap() 方法中,a、b 的值进行交换,并不会影响到 A、B。因为,a、b 中的值,只是从 A、B 复制过来的。也就是说,a、b 相当于 A、B 的副本,副本的内容无论怎么修改,都不会影响到原件本身。

    如果我们这么写:

    public class test{
      
        public static void main(String[] args) {
              int A = 2;
              int B = 3;
              swap(A, B);
            System.out.println(A);
            System.out.println(B);
        }
        
          public static void swap(int a, int b){
            int tmp = a;
            a = b;
            b = tmp;
            }
    }


    运行结果为:

    2
    3


    发现A和B的值并没有交换,为什么呢?

    因为Java中采用的是值传递,也就是说执行swap(int a, int b)时,这里的参数a和b,只是A和B的副本,函数的运行结果并没有改变原来A和B的值。

    那么采用Integer呢?

    如果将上面的int类型转变为Integer,swap(Integer a, Integer b)会不会实现交换功能呢?

    public class test{
      
        public static void main(String[] args) {
              Integer A = 2;
              Integer B = 3;
              swap(A, B);
            System.out.println(A);
            System.out.println(B);
        }
        
          public static void swap(Integer a, Integer b){
            Integer tmp = a;
            a = b;
            b = tmp;
            }
    }


    运行结果为:

    2
    3


    可见还是没有完成交换!

    去查看Integer的源码:

    public final class Integer extends Number implements Comparable<Integer> {}

    可以看到Integer使用final修饰的int进行存储。final修饰的变量不能被重新赋值,所以操作参数传递变量时,实际上是操作变量对象的副本(Java中的包装类型都是默认使用这种方式实现的,使用拷贝副本的方式提升效率和减少内存消耗)。

    如果换作是数组呢?

    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        System.out.println(arr[0]);
        change(arr);
        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        // 将数组的第一个元素变为0
        array[0] = 0;
    }


    运行结果为:

    1

    0


    这里方法array是对象的引用arr的拷贝,而不是对象本身的拷贝,因此, array 和 arr 指向的是同一个数组对象。

    如果换做是一般对象呢?

    很多程序设计语言(特别是 C++ 和 Pascal)提供了两种参数传递的方式:值调用和引用调用。

    有些程序员(甚至本书的作者)认为 Java 程序设计语言对对象采用的是引用调用,实际上,这种理解是不对的。由于这种误解具有一定的普遍性,所以下面给出一个反例来详细地阐述一下这个问题。

    class User {
        private String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return name;
        }
    }


    测试:

    public class test{
            public static void main(String[] args) {
            User A = new User("ali");
            User B = new User("bd");
            System.out.println("交换前name:" + A + "-->" + B);
            swap(a,b);
            System.out.println("交换后name:" + A + "-->" + B);
        }

        private static void swap(User a, User b) {
            User tmp = a;
            a = b;
            b = tmp;
        }
    }


    运行结果为:

    交换前name:ali-->bd
    交换后name:ali-->bd


    发现还是没有交换!

    所以到底有没有交换,主要是看它修改的是变量(引用)还是修改的堆里面的对象。

    交换前:


    交换后:

     

     


    通过上面两张图可以很清晰的看出: 方法并没有改变存储在变量 A 和 B 中的对象引用。swap() 方法的参数 a 和 b 被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝。

    那么到底该如何实现交换两个变量的值呢?

    用容器(或者数组)
    例如:

    public class test{

        public static void main(String[] args) {
            int[] arr = {2, 3};
            int A = arr[0];
            int B = arr[1];
            swap(arr, 0, 1);
            A = arr[0];
            B = arr[1];
            System.out.println(A);
            System.out.println(B);
        }

        public static void swap(int[] arr, int a, int b){
            int tmp = arr[a];
            arr[a] = arr[b];
            arr[b] = tmp;
        }
    }


    运行结果为:

    3
    2


    用反射


    public static void swap(Integer a, Integer b) throws Exception {
        Field field = Integer.class.getDeclaredField("value");
        field.setAccessible(true);   //设置可以访问成员的私有不可变的变量
        Integer tmp =new Integer(a.intValue());
        field.set(a, b.intValue());
        field.set(b, tmp);
    }

    展开全文
  • Java的值传递和引用传递

    千次阅读 2022-04-20 16:12:38
    Java的值传递和引用传递 值传递:对形参的修改不会影响到实参 。引用传递:对实参的修改能够影响到实参 Java是值传递:如果是基本数据类型,就是复制一份值传递给形参;如果是引用类型,那就将引用复制一份,传递给...
  • java的值传递和引用传递

    千次阅读 2021-02-26 08:26:02
    昨天博主在对于值传递和引用传递这里栽了一个大坑啊,导致一下午时间都浪费在这里,我们先说下值传递和引用传递java官方解释:值传递:(形式参数类型是基本数据类型):方法调用时,实际参数把它的值传递给对应的形式...
  • C#中的值传递和引用传递

    千次阅读 2021-09-28 08:02:49
    在C#语言中,传递参数的方式有两种:值传递和引用传递。 在介绍这两种参数传递方式我们先简单理解一下类型和引用类型。 在C#语言中的char,int,short,long,byte,float,double,boolean类型都是类型,另外enum...
  • Python 函数的值传递和引用传递详解

    千次阅读 2022-02-02 22:22:30
    Python 值传递和引用传递是根据实际参数的类型不同进行区分的,如下所示: 值传递:指的是实参类型为不可变类型(数字、字符串、元组); 引用传递(或叫地址传递):指的是实参类型为可变类型(列表,字典,set ...
  • 一个实例让你明白什么是值传递和引用传递的!
  • 这一次,让你彻底明白Java的值传递和引用传递

    万次阅读 多人点赞 2018-10-29 08:39:00
    本文旨在用最通俗的语言讲述最枯燥的基本知识学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运...
  • java中的值传递和引用传递的区别?

    千次阅读 多人点赞 2018-11-29 21:04:51
    1.值传递概念:值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。 实例: public class Main { public static void main(String[] args) { int ...
  • 值传递和引用传递的区别

    千次阅读 2018-07-19 21:13:00
    值传递是指基本数据类型在方法中的传递,引用传递是指引用数据类型在方法中的传递,举例来说,如下图程序代码运行所示: 注:int属于基本数据类型,因此在方法中进行传递和引用时,并不会改变该变量的数值 而arr...
  • 值传递 -- 例1 a = 1 b = a b = 2 print("a ==",a) -- 输出:a == 1 -- 例2 a = "this is str" b = a b = "this is not str" print("a ==",a) -- 输出:a == this is str -- 例3 function fun1(a) a = 2 end b = ...
  • C++值传递和引用传递的区别

    千次阅读 2020-05-27 17:16:02
    c++中参数传递的区别: 1.值传递: 可以想象改变的只是实参的“替身”的值,而实参本身不会被改变。...2.引用传递 可以想象成是“同一个人”,只不过把名字换了换,但本质上还是同样的。 因此,引用并不分配独
  • 函数参数传递的两种方式——值传递和引用传递

    万次阅读 多人点赞 2018-10-23 15:50:05
    值传递包括实实在在的值传递以及指针传递(指针传递参数本质上是值传递的方式,它所传递的是一个地址值),传递的都是实参的一个拷贝。 1、实实在在的“值”传递 #include &lt;iostream&gt; #include &...
  • Java:按值传递还是按引用传递详细解说
  • 学过java基础的人都知道,在java中参数的传递过程中有值传递和应用传递,那么这两个到底有什么区别呢,下面我通过例子为大家详细的介绍下。 我们都知道Java中有八种数据类型,基础数据类型分别是:byte,short,int...
  • 值传递和引用传递(地址传递)的区别

    千次阅读 2019-08-07 10:38:05
    也许大家对于被值传递和引用传递(看了些别人的博客也有人说只有值传递)弄得傻傻分不清楚,我个人之前也是这样过来的,自己也思考了一番,后来才弄清楚了,结合大多数人的想法总结: 八大基本数据类型:(byte, ...
  • 【JAVA】 什么是值传递和引用传递

    万次阅读 多人点赞 2019-06-04 11:10:05
    值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 一般认为,java内的基础类型数据传递都是...
  • 什么是值传递和引用传递

    千次阅读 2017-09-19 15:17:47
    一、什么是值传递和引用传递值传递,是对于基本数据类型的变量而言的。传递的是该变量的一个副本,改变副本并不影响原变量 引用传递,是对于对象型变量而言的。传递的是该变量地址的一个副本,并不是该对象本身...
  • 什么是值传递和引用传递

    千次阅读 2019-07-08 21:42:24
    1.值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参 数的值。 2.引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 729,900
精华内容 291,960
关键字:

值传递和引用传递