精华内容
下载资源
问答
  • java按值传递
    千次阅读
    2017-02-09 14:17:27

    看这篇也可以看一下最新整理的文:

    Java内存管理-Stackoverflow问答-Java是传值还是传引用?(十一)

    先复制一个面试/笔试的题:

    当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递?

    答案:

    是值传递。Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值,但是在Java中却做不到。

    java中的按值传递和按址传递(按引用传递),要明白这两个概念,要理解按值和按址。
    下面举个简单的例子来说明:
    比如你去国外旅行,拍了一张特别好的照片,你想分享给你的朋友,那么有两种方式,第一种是你直接将这个照片发送给你的朋友,也就是给你朋友这个照片的副本;第二种是假如你将这张及其好的照片上传到一个QQ(微博)等,你将会得到一个访问这个照片的地址(Url),此时在将这个url分享给你的朋友。
    如上例子,第一种可以认为是按值传递,第二种可以认为是按址传递(按引用传递)。知道了这个概念。在进行下面的简单分析。

    • 按值传递:只有当参数为基本类型变量的时候,java按这种策略的方式传递。
      上面的分享照片,你的朋友拿到的照片是你的副本,那么朋友对照片的修改不会影响你的照片,你对照片的修改也不会影响到你给朋友分享的照片。

    • 按址传递:只有当参数为引用类型变量,java按这种策略方式进行传递。
      上面的Url地址给朋友,那么如果朋友也有修改的权限,朋友对照片进行操作,自己访问的照片就是朋友操作结果后的结果。

    下面通过代码来解释这个例子:

    package com.dufy.reforvalue;
    
    import java.util.Arrays;
    
    /**
     * java中 按值传递和按址传递
     * 按值传递:基本类型变量-按值传递,按值传递通过复制获取参数的副本
     * 按址传递:引用类型变量-按址传递,按址传递通过传递对象的引用地址
     * 
     * @author dufy
     * @creation 2017年2月9日
     */
    public class ReferenceOrValue {
    
    	/**
    	 * 基本类型,按值传递
    	 * 举例:给朋友分享你的照片,对方接收的是你的照片的一个实际的副本,
    	 * 你和朋友分别对各自的照片进行操作,不会影响彼此的照片!
    	 */
    	public static void testVal(int photo){
    		photo++;//朋友对照片进行修改
    		System.out.println("My friend see photo = " + photo);
    	}
    	
    	/**
    	 * 引用类型:按址传递
    	 * 举例:给朋友分享你的照片,分享的是你上传网上的一个照片的Url(地址),
    	 * 你和朋友都可以通过这个地址访问照片,并对照片进行一个操作!
    	 */
    	public static void testRef(Photo photo){
    		photo.setPhoto("java Photo,Great!");//朋友对你的照片进行修改
    		System.out.println("My friend see photo = " + photo.getPhoto());
    	}
    	
    	/**
    	 * 引用类型:按址传递
    	 * 因为数组是一个引用类型。所以传递进去的是它们的引用,故在方法中互换了它们的值,也必然影响到它们原来的值.
    	 */
    	public static void testArrayRef(int[] array){
    		for (int i = 0; i < array.length; i++) {
    			array[i] = 0;
    		}
    		System.out.println("testArrayRef array is = "+Arrays.toString(array));
    	}
    	public static void main(String[] args) {
    		//一:按值传递
    		int photo = 10;//定义要发送的照片
    		testVal(photo);//将照片发发送你朋友,朋友得到的是一个副本
    		System.out.println("My see photo = " + photo);
    		
    		
    		//二:按址传递
    		Photo p = new Photo();//定义一个照片的对象,我自己拍摄的java photo
    		p.setPhoto("java photo");
    		
    		testRef(p);//将照片对象(即 Url地址) 发送你朋友,朋友得打的是一个Url(地址),Url打开才是照片
    		System.out.println("My friend see photo = " + p.getPhoto());
    		
    		//三:数组也是对象,数组在堆内存。引用是在栈。
    		int array[] = {1,2,3,4,5};
    		testArrayRef(array);
    		System.out.println("array is = "+Arrays.toString(array));
    		
    	}
    	
    	/**
    	 * 照片类
    	 */
    	static class Photo{
    		String photo;
    
    		public String getPhoto() {
    			return photo;
    		}
    
    		public void setPhoto(String photo) {
    			this.photo = photo;
    		}
    		
    	}
    }
    
    

    输出的结果如下:

    My friend see photo = 11
    My see photo = 10
    My friend see photo = java Photo,Great!
    My friend see photo = java Photo,Great!
    testArrayRef array is = [0, 0, 0, 0, 0]
    array is = [0, 0, 0, 0, 0]
    

    小插曲:有下下面这一道题:这个method应该怎么写呢?

    public static void main(String[] args) {
    		int a = 10;
    		int b = 20;
    		method(a,b);//需要在method被调用后,仅打印出a=100,b=200,请写出method(a,b)方法!
    		System.out.println("a = " + a);
    		System.out.println("b = " + b);
    	}
    

    肯定有很多人和我之前一样,想都没想就写出下面的代码:

    private static void method(int a, int b) {
    		a*=10;
    		b*=10;
    	}
    

    但是运行结果后你会发现,没有打印出理想的结果!

    这时候如果你仔细看来了上面的介绍就不难理解为什么会出现这样的结果了!

    给出这道题可能正确的结果:

    private static void method(int a, int b) {
    		System.out.println("a=100,b=200");
    		System.exit(0);
    	}
    

    附:

    public static void main(String[] args) {
    		int a = 10;
    		int b = 20;
    		method(a,b);//需要在method被调用后,仅打印出a=100,b=200,请写出method(a,b)方法!
    		System.out.println("a = " + a);
    		System.out.println("b = " + b);
    		System.out.println("a = " + Integer.valueOf(a));
    		System.out.println("b = " + Integer.valueOf(b));
    	}
    
    	private static void method(Integer a, Integer b)  {
    		try {
    			Field filea = a.getClass().getDeclaredField("value");
    			filea.setAccessible(true);
    			filea.setInt(a, 100);
    			Field fileb = b.getClass().getDeclaredField("value");
    			fileb.setAccessible(true);
    			fileb.setInt(b, 200);
    			
    		} catch (NoSuchFieldException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalArgumentException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	private static void method1(int a, int b) {
    		System.out.println("a=100,b=200");
    		System.exit(0);
    	}
    

    输出结果:

    a = 10
    b = 20
    a = 100
    b = 200
    
    

    你觉得正确的答案是什么,可以给我留言和评论,欢迎讨论!

    java到底是值传递还是引用传递? 知乎:https://www.zhihu.com/question/31203609
    你会swap吗,按值传递还是按引用?:http://www.cnblogs.com/foreach-break/p/call-by-reference-OR-call-by-value.html

    更多相关内容
  • 深入理解--Java按值传递引用传递

    万次阅读 多人点赞 2017-07-20 15:48:49
    引言最近刷牛客网上的题目时碰到不少有关Java按值传递引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?Java按...

    引言

    最近刷牛客网上的题目时碰到不少有关Java按值传递和按引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?

    Java按值传递和按引用传递

    首先问一句:Is Java “pass-by-reference” or “pass-by-value”? Java到底是按值传递还是按引用传递的呢?国外的网站上关于这个问题的讨论非常之多。官方答案:The Java Spec says that everything in Java is pass-by-value. There is no such thing as “pass-by-reference” in Java. 官方的说法是在java中只有按值传递,并没有所谓的按引用传递。

    基本数据类型的按值传递

    java数据类型可以分为两大类:基本类型(primitive types)和引用类型(reference types)。primitive types 包括boolean类型以及数值类型(numeric types)。numeric types又分为整型(integer types)和浮点型(floating-point type)。整型有5种:byte short int long char(char本质上是一种特殊的int)。浮点类型有float和double。关系整理一下如下图:

    这里写图片描述
    例1

    public class Swap {
    
        public static void main(String[] args) {
            int x = 10;
            int y = 20;
            swap(x, y);
            System.out.println("x(2) = " + x);
            System.out.println("y(2) = " + y);
        }
         public static void swap(int x, int y) {
            int temp = x;
            x = y;
            y = temp;
            System.out.println("x(1) = " + x);
            System.out.println("y(1) = " + y);
        }
    }
    
        /*输出
        x(1) = 20
        y(1) = 10
        x(2) = 10
        y(2) = 20
        */

    上面程序main函数调用swap函数来交换 x,y的值,然而调用函数之后发现main中x,y的值并未交换。包括在Java api中找不到一个可以交换两个变量的方法。这与Java语言的特性有关。通过一个图就可以知道上面程序的运行结果了。

    这里写图片描述
    由上图可知,main函数中的x,y和swap函数中的x,y分别存放在不同的区域,在main中调用swap函数的时候,会将main中的x,y的值赋给swap中的x,y。当swap函数中对x,y交换时只是对swap帧中的x,y做交换,并不会改变main中的x,y。所以当函数返回时main中的x,y并不会改变。swap执行过程图如下:
    这里写图片描述

    对于基本数据类型 short int long float double char byte boolean这八种按值传递调用函数并不会改变在原函数中的值。

    引用数据类型的按值传递

    引用数据数据类型分为三种:①接口 ②类 ③数组对于引用数据类型的按值传递先给出一个实例对比实例进行分析。

    例2

    public static void main(String[] args) {    
            int []a={10,20};
            System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=10,a[1]=20;      
            swap(a, 0, 1);
            System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=20,a[1]=10;  
    
        }
    public static void swap(int []a,int i,int j){
            int temp=a[i];
            a[i]=a[j];
            a[j]=temp;
            System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=20,a[1]=10;
        }
    //输出
    /*a[0]=10 a[1]=20
    
      a[0]=20 a[1]=10
    
      a[0]=20 a[1]=10   
    */

    运行程序后发现,swap函数对a[0] ,a[1]的操作竟然影响到了main函数中的a[0] ,a[1]的值,真是不可思议。为什么会产生如此之结果。原来引用类型的按值传递,传递的是对象的地址。还是用图来解释一下。

    这里写图片描述
    由图可以看出在swap中仅仅是得到了数组的地址,并没有对数组的元素进行复制,在swap中对数组的操作是直接对main函数中数组的操作,因此swap函数返回后main函数中的a[0] ,a[1]的值发生交换。

    数组、类、接口按值传递的时候都是传递对象的地址。再来看一个比较复杂的实例。

    例3

    public class Main{
         public static void main(String[] args){
              Foo f = new Foo("f");
              changeReference(f); // It won't change the reference!
              modifyReference(f); // It will modify the object that the reference variable "f" refers to!
         }
         public static void changeReference(Foo a){
              Foo b = new Foo("b");
              a = b;
         }
         public static void modifyReference(Foo c){
              c.setAttribute("c");
         }
    }

    ①Foo f = new Foo(“f”);
    这里写图片描述

    ②public static void changeReference(Foo a)
    这里写图片描述

    ③changeReference(f);
    这里写图片描述

    ④Foo b = new Foo(“b”);
    enter image description here
    ⑤a = b
    enter image description here

    enter image description here
    ⑥c.setAttribute(“c”);

    enter image description here

    经典笔试题目

    试题1

    public class Demo {
    
        public static void main(String[] args) {
    
            //demo1
            String str=new String("hello");
            char []chs={'w','o','r','l','d'};
            change(str, chs);
            System.out.println(str+" "+new String(chs));
    
            //-------------------------------------------------
            //demo2
    
            StringBuffer sb=new StringBuffer("hello");
            change(sb);
            System.out.println(sb);
    
        }
        public static void change(StringBuffer sb)
        {
            sb.append(" world");
    //      sb.deleteCharAt(0);
        }
        public static void change(String str,char[]chs)
        {
            str.replace('h', 'H');
            chs[0]='W';     
        }       
    }

    上面程序段demo1和demo2分别输出什么,这里涉及到String特性,这道题目会做了,Java按值传递和按引用传递就彻底懂了,答案和解析先匿了。

    试题2

    public class foo {
        public static void main(String sgf[]) {
    
            StringBuffer a=new StringBuffer(“A”);
            StringBuffer b=new StringBuffer(“B”);
            operate(a,b);
            System.out.println(a+”.”+b);
    
        }
    
        static void operate(StringBuffer x,StringBuffer y) {
    
            x.append(y);
            y=x;
    
        }
    }

    参考文献

    1.https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value

    展开全文
  • java按值传递还是引用传递详细解说[收集].pdf
  • Java按值传递还是引用传递详细解说
  • Java值传递

    千次阅读 2021-08-12 21:47:31
    一、值传递和引用传递 ...Java是采用值传递的,Java程序中的方法得到的总是实参值的拷贝, 二、代码运行 我们来看下下面代码的运行结果 public class Main { public static void main(String[] args) { ...

    一、值传递和引用传递

            在程序设计语言中将参数传给方法或函数的方式目前有两种:一种是值传递,一种是引用传递。

            值传递表示将实参的值传递给方法;引用传递表将实参a的地址引用传递给方法。

            Java是采用值传递的,Java程序中的方法得到的总是实参值的拷贝,

     二、代码运行

            我们来看下下面代码的运行结果

    public class Main {
        public static void main(String[] args) {
            SingleInstance instance = SingleInstance.getInstance();
            Student a = new Student();
            Student b = new Student();
            a.setName("zhangsan");
            b.setName("lisi");
            System.out.println(a);
            System.out.println(b);
            swap1(a,b);
            System.out.println(a);
            System.out.println(b);
            swap(a,b);
            System.out.println(a);
            System.out.println(b);
        }
    
        private static void swap1(Student e, Student f) {
            String name = e.getName();
            e.setName(f.getName());
            f.setName(name);
        }
    
        private static void swap(Student e, Student f) {
            Student a= e;
            e=f;
            f=a;
        }
    
     
    }
    

    结果为

    Student{name='zhangsan'}
    Student{name='lisi'}
    Student{name='lisi'}
    Student{name='zhangsan'}
    Student{name='lisi'}
    Student{name='zhangsan'}
    

    从结果我们可以看出执行swap1方法的进行了交换,这是因为a,b指向的地址没有改变,改变的是指向地址所指向的name发生了改变

    而swap方法执行时,创建了a' 和 b',虽然它们的值或地址确实发生了改变,但是方法执行完后,a'、b'出栈,没有影响到a,b,所以没有交换

    swap1方法执行前 

    swap1 方法执行中

     

    swap1方法执行后

    然后是swap方法执行前

     

     swap方法执行中

    swap方法执行后

     

     所fang

    我们再看一组例子

    public class Main {
        public static void main(String[] args) {
            int c =10;
            int d=20;
            Integer e =10;
            Integer f=20;
            swap(c,d);
            System.out.println(c);
            System.out.println(d);
            swap(e,f);
            System.out.println(e);
            System.out.println(f);
        }
    
    
        private static void swap(int a, int b) {
            int c =a;
            a=b;
            b=c;
        }
        private static void swap(Integer a, Integer b) {
            Integer c =a;
            a=b;
            b=c;
        }
    }
    

     结果为:

    
    10
    20
    10
    20

    我们发现其c,d;e,f并没有因为方法而改变;这是因为无论是基本类型还是封装好的Integer类型,都没有改变实际上的值。

    方法执行时,栈里放入了10,20,也确实进行了交换;但方法执行完毕时也进行了出栈,但c和d没有进行过交换

     方法执行前

     

    方法执行中

     

    方法执行完

     

     

    展开全文
  • 主要介绍了JAVA参数传递方式,结合实例形式分析了java按值传递与引用传递区别及相关操作注意事项,需要的朋友可以参考下
  • Java总是值调用(值传递)的。本文具体分析了为什么是Java是一种值调用的语言。

    1. 参数传递方式的分类

    “按……调用(call by)”是一个标准的计算机科学术语,它用来描述各种程序设计语言(不只是 Java ) 中方法参数的传递方式。

    参数传递方式可以区分为按值调用值传递)和按引用调用引用传递)。事实上,以前还有按名调用,不过,对于今天,这种传递方式已经成为历史。

    2. 按引用调用(引用传递)

    按引用调用(call by reference)表示方法接收的是调用者提供的变量地址,这意味着方法调用者提供的变量的值。在C++中就可以实现按引用调用,引用参数标有&符号。

    例如,我们可以在C++中利用按引用调用,很轻松的实现在方法中交换两个变量的引用参数:

    	void swap(Person& x, Person& y)
    	{
    		...
    	}
    

    在方法外部实例化两个Person类型的变量xy,然后调用swap方法,即可实现交换xy的值的功能(在按值调用中就不行)。

    对于按引用调用,在方法中对变量所做的任何修改,都会同步方法外对应的变量上去。

    3. 按值调用(值传递)

    按值调用(call by value) 表示方法接收的是调用者提供的。也就是说,方法得到的是参数值的一个拷贝,即方法不能修改传递给它的参数变量的内容。

    Java只有按值调用,虽然对象变量很容易让人们误以为Java也有按引用调用。

    事实上,即使方法传入的参数是对象变量,它也依然是按值调用的,方法所得到的只是传入参数值的一个拷贝。例如:

    public class SwapText {
    	public void swap(Person x, Person y) {
    		Person t = x;
    		x = y;
    		y = t;
    	}
    
    	public static void main(String[] args) {
    		// Person是自己定义的一个类,构造时徐接收一个String类型的对象,它的toString()方法会返回构造时传入的字符串
    		Person x = new Person("Person_X");
    		Person y = new Person("Person_Y");
    		System.out.println("x = " + x.toString);
    		System.out.println("y = " + y.toString);
    		swap(x, y);
    		System.out.println("交换后:");
    		System.out.println("x = " + x.toString());
    		System.out.println("y = " + y.toString());
    	}
    
    }
    
    /*
    * 程序输出:
    * x = Person_X
    * y = Person_Y
    * 交换后:
    * x = Person_X
    * y = Person_Y
    */
    

    可以看到,在调用了swap方法之后,main方法中的xy变量指向的对象并没有互相交换,这也证明了Java是按值调用的,方法所接收到的只是传入值的一个拷贝,修改了拷贝当然不会影响原有变量。

    但对象变量所指向的对象的状态是可以在方法中改变的,可以把对象变量理解成Java的指针,它指向了某一块内存区域,就算方法接收的只是传入值的一个拷贝,这个拷贝也是和原变量指向同一块内存区域的,通过拷贝值修改了该内存区域的内容,当原变量再查看该内存区域时,其值已经改变了。

    在这里插入图片描述
    这就是会让人们误以为Java是按引用调用的地方,但其实方法中能改变的只是原变量所指向的内存区域的值(灰色方框里的内容),并不能修改原变量指向的内存区域(即指向哪个灰色方框)。
    在这里插入图片描述
    即使我们在方法中让传入的参数引用了一个新的对象,原变量依旧指向原有对象,即原变量的值不变,所以说这是按值调用。

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

    千次阅读 2022-01-15 12:22:33
    Java中只有值传递 首先回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。 值调用(call by value):表示方法接收的是调用者提供的值。 引用调用(call by reference):表示方法接收...
  • 主要介绍了详解java值传递、地址传递、引用传递的相关资料,需要的朋友可以参考下
  • 主要介绍了Java参数传递及值传递实现原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java按值传递(一个例子彻底理解)

    千次阅读 2020-05-08 15:57:41
    1.规则 ...java调用方法,当方法的参数是引用类型时,传递的引用对象的地址 2.测试用例: public class Test { public static void main(String[] args) { int a = 10; int b = 20; exchange(...
  • java中只有值传递

    2014-07-21 16:34:25
    Java传递对象时传递的并不是对象中的内容, 而是对象的地址。
  • Java 中的按值传递

    2019-02-17 22:05:00
    Java 中只有按值传递  "Java 中只有按值传递",初看到这几个字有点不敢相信,无数次通过函数改变过对象,无数次跟同事说 Java 在传对象的时候是引用传递。后来细细想想,之所以以为 Java 传对象是...
  • 首先我们来看下什么是值传递 package com.aozhi.test; //示例一:值传递 基本数据类型都是值传递,因为他们都存在栈里边 public class ValueDemo { public static void main(String[] args) { int x = 10; ...
  • Java值传递还是引用传递

    千次阅读 2022-01-20 21:17:52
    Java值传递还是引用传递??? java中无论是基本类型还是引用类型,都是值传递
  • 值传递(pass by value)是指在调用函数时将实际参数 复制 一份传递到函数中,这样在函数中如果对 参数 进行修改,将不会影响到实际参数。传递对象往往为整型浮点型字符型等基本数据结构。 public class PassBy...
  • 与其他语言不同,Java不允许程序员选择按值传递还是引用传递各个参数,基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言,不是将对象本身传递给方法,而是将对象的...
  • java中的值传递和引用传递

    千次阅读 2021-12-07 20:07:09
    一般java中的基础类型数据传递都是值传递。 引用传递(Pass By Reference或者Call By Reference)一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。一般java中实例(包装)对象的传递...
  • Java值传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到值传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对...当然如果针对 Java 语言本身来讲,Java 中只有 值传递,没有...
  • JAVA值传递还是引用传递?

    千次阅读 2022-03-12 14:20:28
    结论:java值传递,只是, 对于基本数据类型,传递的是基本类型的量值的拷贝 对于引用类型,传递的是该引用所指向的对象在内存中的地址值的拷贝 实参和形参 public static void test(String s){ System.out....
  • Java值传递和引用传递

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

    万次阅读 多人点赞 2018-09-30 22:58:30
    首先要明确的是JAVA中没有引用传递, 全部是按值调用 令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用...
  • java值传递和引用传递

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

    千次阅读 2022-05-13 16:37:56
    直接斩钉截铁地说Java值传递的有点不太合适,这里我给出自己的看法。 c语言的引用传递 在C语言中是可以引用传递的,我们可以在方法中接收外部参数,实参使用&地址符来表示需要引用传递,这样我们在方法...
  • Java 值传递和引用传递

    千次阅读 2022-03-31 19:47:03
    值传递:在调用函数的时候,将实际参数复制一份传递到函数中,这样在函数中对参数进行修改的 时候,就不会影响到原来的实际参数 引用传递:在调用函数的时候,将实际参数的地址直接传递函数中,这样在函数中对参数进行修改...
  • java中值传递和引用传递的区别

    千次阅读 2020-11-07 17:47:42
      简单来说就是直接复制了一份数据过去,因为是直接复制,所以这种方式在传递时如果数据量非常大的话,运行效率自然就变低了,所以java在传递数据量很小的数据是值传递,比如java中的各种基本类型:int,float,...
  • 在参数传递时,一般存在参数传递的规则,JAVA 中有两者方式:按值传递址传递
  • Java值传递与引用传递的区别

    千次阅读 多人点赞 2021-09-09 22:55:57
    Java值传递与引用传递 文章目录Java值传递与引用传递前景实参与形参值传递与引用传递Java中的值传递总结 前景 关于这个问题,引发过很多广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的...
  • java篇】Java到底是值传递还是引用传递?

    千次阅读 多人点赞 2022-04-25 14:24:13
    JVM划分了很多块区域,我们创建的对象就放在堆中,而基本数据类型和局部变量都放在栈中.当传递基本数据类型时,是将数据创建了一个副本传递到方法中,所以实参不会受到形参修改的影响,如图:
  • 1“Java中参数传递都是按值传递按值传递是产地的值的拷贝,引用传递传递的是引用的地址值,所以统称为按值传递。 2 基本类型,String = “hello” 是按值传递的,其余都引用传递。函数可修改传入变量吗? ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 673,581
精华内容 269,432
关键字:

java按值传递