精华内容
下载资源
问答
  • Java中参数传递

    2019-02-20 15:15:21
    概述 值传递是对基本类型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量...Java中参数传递只有按值传递。所谓按值传递可以简单理解为实参的复制,区别在于复制的实参是基本数据类似还是引用类型。

    概述

    • 值传递是对基本类型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量
    • 引用传递一般是对对象而言的,传递的是该对象地址的一个副本,本质也是值传递,并不是原对象本身。但是对对象地址的修改,会影响原对象的内容

    情景引入

    我们先来看下面这个栗子

    //冒泡排序
    public static void BubbleSort(int[] arr) {
    		if(arr==null || arr.length<2)
    			return;
    		for(int end=arr.length-1;end>0;end--) {
    			for(int i=0;i<end;i++) {
    				if(arr[i]>arr[i+1])
    					//交换
    					swap(arr[i],arr[i+1]);
    			}
    		}
    	}
    
    
    private static void swap(int x,int y) {
    		int cup;
    		cup=x;
    		x=y;
    		y=cup;
    	}
    
    public static void main(String[] args) {
    		int[] arr= {1,2,4,7,3,9};
    		BubbleSort(arr);
    		for(int i=0;i<arr.length;i++) {
    			System.out.println(arr[i]);
    		}
    	}
    

    这个栗子相信大家都不陌生,这里打印出来的结果是:

    1,2,4,7,3,9

    我们发现结果完全没改变,其实问题就是出现在了swap()方法上
    我们对swap作下修改:

    private static void swap(int[] arr, int x,int y) {
    		int cup=arr[x];
    		arr[x]=arr[y];
    		arr[y]=cup;
    	}
    

    打印结果:

    1,2,3,4,7,9

    在新的swap方法中,我们传入了数组的地址,就可以运行出来正确的结果了。接下来我们来研究下Java中参数的传递。


    参数传递的秘密

    所谓参数有实际参数和形式参数之分,函数列表中的叫做形式参数,在实际调用中它们会被实际参数传递。但是编译器并不知道每次调用的实际参数是什么,于是写编译器的高手就出个办法,让实际参数按照一定顺序放到一个大家都可以找得到的地方,以此作为方法调用的一种约定。所谓“没有规矩,不成方圆”,有了这个规矩,大家协作起来就容易多了。这个公共数据区,现在编译器的选择通常是“栈”,而所谓的顺序就是形式参数声明的顺序。显然,程序运行的过程中,作为实际参数的变量可能遍布于内存的各个位置,而并不一定要老老实实的呆在栈里。为了守“规矩”,程序只好将变量复制一份到栈中,也就是通常所说的将参数压入栈中。
    参数传递的秘密就是复制,栈中的参数是实参的副本,这就是所谓的值传递。

    • 所有的参数传递都是传值,区别在于传的是基本数据类型还是引用
    • 所有的参数传递都会在程序运行栈上新分配一个值的复制品
    • 引用变量之间复制的是地址,副本和传入的指向同一块内存
    • 基本数据类型之间复制的是内存中的值(直接量)
    
    public static void value(int x) {
    		x=1;
    	}
    	
    public static void value(int[] arr,int i) {
    		arr[i]=1;
    	}
    
    public static void main(String[] args) {
    		int x=7;
    		int[] arr= {7};
    		value(x);
    		System.out.println(x);//打印结果:7
    		value(arr,0);
    		System.out.println(arr[0]);//打印结果:1
    	}
    

    第一个例子的值没有变化,因为只是给x的副本赋值为1,与x本身没有任何关系
    第二个例子的值有变化,因为传入了数组,是引用类型,复制的另一份变量和传入的数组指向的是同一块内存,所以改变这个副本的值,会改变原来的内存。

    小结

    Java中参数传递只有按值传递。所谓按值传递可以简单理解为实参的复制,区别在于复制的实参是基本数据类似还是引用类型。

    展开全文
  • java中参数传递

    2013-06-06 09:32:33
    java中参数传递对于新手来说是一个难点,尤其是不知道而去百度的时候,更是搜出很多结果, java中究竟是传值还是传址(传引用) 导致新手们越来越迷糊.甚至很多老鸟都说不出所以然. 我的意见是java中只有传值;  值...

    java中参数的传递对于新手来说是一个难点,尤其是不知道而去百度的时候,更是搜出很多结果,    java中究竟是传值还是传址(传引用)       导致新手们越来越迷糊.甚至很多老鸟都说不出所以然.  我的意见是java中只有传值;

      值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参数的值。

    引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,方法执行中形式参数值的改变将会影响实际参数的值。

    先看基本类型作为参数传递的例子:
    public class Test1 {
    public static void main(String[] args) {
    int n = 3;
    System.out.println("Before change, n = " + n);
    changeData(n);
    System.out.println("After changeData(n), n = " + n);
    }

    public static void changeData(int nn) {
    int n = 10;
    }
    } 运行结果是这个


    说明: 基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝,原值是不会改变的.


    现在来看看对象作为参数传递的例子:

    public class Test2 {
    public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("Hello ");
    System.out.println("Before change, sb = " + sb);
    changeData(sb);
    System.out.println("After changeData(n), sb = " + sb);
    }

    public static void changeData(StringBuffer strBuf) {
    strBuf.append("World!");
    }
    }运行结果是这样的


    说明:sb的值被改变了,那么是不是可以说:对象作为参数传递时,是把对象的引用传递过去,如果引用在方法内被改变了,那么原对象也跟着改变。从上面例子的输出结果来看,这样解释是合理。

    现在我们对上面的例子稍加改动一下:
    public class Test3 {
    public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("Hello ");
    System.out.println("Before change, sb = " + sb);
    changeData(sb);
    System.out.println("After changeData(n), sb = " + sb);
    }

    public static void changeData(StringBuffer strBuf) {
    strBuf = new StringBuffer("Hi ");
    strBuf.append("World!");
    }
    }想象中的结果应该是  Before change,sb = Hello

    After changeData(n),sb = Hi World!但结果其实是这样的


    问题::对象作为参数传递时,同样是在方法内改变了对象的值,为什么有的是改变了原对象的值,而有的并没有改变原对象的值呢?这时候究竟是“传值”还是“传引用”呢?

    Test2中 创建sb是为sb创建了一个地址,里面的内容为Hello,当调用方法changeData()时,把sb的地址传给了strBuf,sb和strBuf的指向是一样的所以会输出After changeData(n),sb=Hello World!  而Test3中在运行到changeData()方法之前,strBuf被创建了一个新的地址:strBuf = new StringBuffer("Hi ");这样sb跟strBuf的指向不一样,虽然strBuf的内容改了,但是sb中的内容没有改变.所以输出的结果是After changeData(n),sb=Hello。

    综上可知:在Java中对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数。


    但是String类是个很特殊的类.它是final类型的,所以值是不变的. 看下面的例子:

    public class Example { 

     String str = new String("good");

       char[] ch = { 'a', 'b', 'c' };

     public static void main(String args[]) { 

     Example ex = new Example();

     ex.change(ex.str, ex.ch); 

    System.out.print(ex.str + " and "); 

     System.out.println(ex.ch); 

     } 

     public void change(String str, char ch[]) { 

     str = "test ok"; )

     ch[0] = 'g'; 

     } 

    输出的结果是good and gbc

    上面的代码中 

    函数中String对象引用的副本指向了另外一个新String对象,而数组对象引用的副本没有改变,而是改变对象中数据的内容.

    按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本。因此,如果函数修改了该参数,仅改变副本,而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。因此,如果函数修改了该参数,调用代码中的原始值也随之改变。

    在 Java 应用程序中,当对象引用是传递给方法的一个参数时,您传递的是该引用的一个副本(按值传递),而不是引用本身。




    展开全文
  • 主要介绍了java中参数传递方式详解的相关资料,需要的朋友可以参考下
  • java中参数传递讲解(值传递和引用传递) 参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。 在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用...

    java中参数传递讲解(值传递和引用传递)

    参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。

    在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用传递对象。Java 应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用,而 Java 应用程序是按值传递对象引用的。

     

    Java 应用程序中的变量可以为以下两种类型之一:引用类型或基本类型。当作为参数传递给一个方法时,处理这两种类型的方式是相同的。两种类型都是按值传递的;没有一种按引用传递。

     

    按值传递和按引用传递。按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本。因此,如果函数修改了该参数,仅改变副本,而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。因此,如果函数修改了该参数,调用代码中的原始值也随之改变。

    1、对象是按引用传递的
    2、Java 应用程序有且仅有的一种参数传递机制,即按值传递
    3、按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本
    4、按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本

    首先考试大来看看第一点:对象是按引用传递的
      确实,这一点我想大家没有任何疑问,例如:
      class Test01
      {
      public static void main(String[] args)
      {
      StringBuffer s= new StringBuffer("good");
      StringBuffer s2=s;
      s2.append(" afternoon.");
      System.out.println(s);
      }
      }
      对象s和s2指向的是内存中的同一个地址因此指向的也是同一个对象。
      如何解释“对象是按引用传递的”的呢?
      这里的意思是进行对象赋值操作是传递的是对象的引用,因此对象是按引用传递的,有问题吗?
      程序运行的输出是:
      good afternoon.
      这说明s2和s是同一个对象。
      这里有一点要澄清的是,这里的传对象其实也是传值,因为对象就是一个指针,这个赋值是指针之间的赋值,因此在java中就将它说成了传引用。(引用是什么?不就是地址吗?地址是什么,不过就是一个整数值)
      再看看下面的例子:
      class Test02
      {
      public static void main(String[] args)
      {
      int i=5;
      int i2=i;
      i2=6;
      System.out.println(i);
      }
      }
      程序的结果是什么?5!!!
      这说明什么,原始数据类型是按值传递的,这个按值传递也是指的是进行赋值时的行为下一个问题:Java 应用程序有且仅有的一种参数传递机制,即按值传递
      class Test03
      {
      public static void main(String[] args)
      {
      StringBuffer s= new StringBuffer("good");
      StringBuffer s2=new StringBuffer("bad");
      test(s,s2);
      System.out.println(s);//9
      System.out.println(s2);//10
      }
      static void test(StringBuffer s,StringBuffer s2) {
      System.out.println(s);//1
      System.out.println(s2);//2
      s2=s;//3
      s=new StringBuffer("new");//4
      System.out.println(s);//5
      System.out.println(s2);//6
      s.append("hah");//7
      s2.append("hah");//8
      }
      }
      程序的输出是:
      good
      bad
      new
      good
      goodhah
      bad
      考试大提示: 为什么输出是这样的?
      这里需要强调的是“参数传递机制”,它是与赋值语句时的传递机制的不同。
      我们看到1,2处的输出与我们的预计是完全匹配的
      3将s2指向s,4将s指向一个新的对象
      因此5的输出打印的是新创建的对象的内容,而6打印的原来的s的内容
      7和8两个地方修改对象内容,但是9和10的输出为什么是那样的呢?
      Java 应用程序有且仅有的一种参数传递机制,即按值传递。
      至此,我想总结一下我对这个问题的最后的看法和我认为可以帮助大家理解的一种方法:
      我们可以将java中的对象理解为c/c++中的指针
      例如在c/c++中:
      int *p;
      print(p);//1
      *p=5;
      print(*p);//2
      1打印的结果是什么,一个16进制的地址,2打印的结果是什么?5,也就是指针指向的内容。
      即使在c/c++中,这个指针其实也是一个32位的整数,我们可以理解我一个long型的值。
      而在java中一个对象s是什么,同样也是一个指针,也是一个int型的整数(对于JVM而言),我们在直接使用(即s2=s这样的情况,但是对于System.out.print(s)这种情况例外,因为它实际上被晃猄ystem.out.print(s.toString()))对象时它是一个int的整数,这个可以同时解释赋值的传引用和传参数时的传值(在这两种情况下都是直接使用),而我们在s.XXX这样的情况下时s其实就是c/c++中的*s这样的使用了。这种在不同的使用情况下出现不同的结果是java为我们做的一种简化,但是对于c/c++程序员可能是一种误导。java中有很多中这种根据上下文进行自动识别和处理的情况,下面是一个有点极端的情况:
      class t
      {
      public static String t="t";
      public static void main(String[] args)
      {
      t t =new t();
      t.t();
      }
      static void t() {
      System.out.println(t);
      }
      }

    1.对象就是传引用
    2.原始类型就是传值
    3.String类型因为没有提供自身修改的函数,每次操作都是新生成一个String对象,所以要特殊对待。可以认为是传值。



    展开全文
  • Java中参数传递——值传递(拷贝)

    千次阅读 2018-09-26 11:45:06
    Java中参数传递实际上是值传递(拷贝) 参数分为两种:基本数据类型、引用类型 比如方法M调用方法N,参数为x,则: 如果x是基本类型,则会把x的值拷贝一份放入N方法实例的栈中。 此时,方法N改变参数x的值,M中的x...

    Java中参数传递实际上是值传递(拷贝)

    参数分为两种:基本数据类型、引用类型

    比如方法M调用方法N,参数为x,则:

    • 如果x是基本类型,则会把x的值拷贝一份放入N方法实例的栈中。
      此时,方法N改变参数x的值,M中的x不受影响。
    • 如果x是引用类型,则会把x的引用拷贝一份(x’)放入N方法实例的栈中。
      此时,方法N可以通过引用x’改变x的值。因为引用x和引用x’都是指向同一个对象。
    展开全文
  • JAVA中参数传递的概念

    2013-07-06 21:20:05
    在java开发中,频繁的会用到参数传递的时候,有时候发现值发生了变化,有时候发现值却没有改变,究其原因原来java中参数传递虽然是值传递, 但值传递也分两种的: 1、按值传递(by value) 适用范围:8种基本数据...
  • Java中参数传递方式

    2018-11-20 19:12:13
    java语言方法中参数传递全部都是值传递,即只传递参数的副本。 所以当参数为基本数据类型时,方法不能改变实参,而只能改变其副本; 当参数为对象类型时,其参数为对象引用(地址),对对象的操作直接影响实参,...
  • Java中参数传递机制

    2015-11-25 21:48:43
    很多都知道Java参数传递,但是能有几个人能真正说出实参值是如何传入方法的呢? Java里方法的参数传递方式只有一种:值传递。所谓值传递,就是将实际参数值得副本(复制品)传入方法内,而参数本身不会受到任何影响。...
  • java中参数传递问题

    2019-02-19 07:54:57
    传递 用 [TOC]来生成目录: 值地址传递 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图...
  • java中参数传递理解分析

    千次阅读 2014-07-25 10:10:26
    看了很多关于java中方法参数传递的文章,有说是按值传递的也有说是按引用
  • java中参数传递——值传递、引用传递 参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。 在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用...
  • Java中参数传递是值传递,还是引用传递的一次深究 是我自己分析的,可能不准确,请大牛们指导,欢迎大家拍砖 1 先回顾一下java基础内容:对象在内存分配方式 public static void main(String[] args) { ...
  • 简要总结java参数传递知识
  • 关于JAVA中参数传递问题有两种,一种是按值传递(如果是基本类型),另一种是按引用传递(如果是對象).   首先以两个例子开始: 1) public class Test2 { public static void main (String [] args) { ...
  • Java核心技术卷I里有一个结论我觉得挺有意思的:java中没有引用传递,只有值传递 首先看定义: 值传递,是指方法接收的是调用者提供的值 引用传递,是指方法接收的是调用者提供的变量地址 以前学习C++时把参数...
  • java中参数传递方式话题终结实例

    千次阅读 2017-03-22 10:58:50
    java新手入门面临的一个经典的话题,本文意在终结这个话题,java中有说法:Java里面参数传递都是按值传递,怎么理解这句话?用文字说明恐怕不容易说明白,说明白恐怕也难以想明白。前提先明确一下,按值还是按引用的...
  • java中方法参数传递方式是按值传递。 如果参数是基本类型,传递的是基本类型的字面量值的拷贝。如果在函数中改变了副本的值不会改变原始的值。 如果参数是引用类型,传递的是该参量所引用的对象在堆中地址值的拷贝。...
  • 关于JAVA中参数传递问题的总结

    千次阅读 2006-11-14 21:54:00
    关于JAVA中参数传递问题的总结关于JAVA中参数传递问题的总结首先以两个例子开始:1)public class Test2 { public static void main (String [] args) { StringBuffer a = new StringBuffer ("A"); StringBuffer b ...
  • 关于JAVA中参数传递问题有两种,一种是按值传递(如果是基本类型),另一种是按引用传递(如果是對象). 首先以两个例子开始:1)public class Test2 { public static void main (String [] args) { StringBuffer ...
  • (11)Java中参数传递

    2019-09-13 15:37:59
    二、在参数传递时,一般存在两种参数传递的规则 1、按值传递: 指每次传递参数时,把参数的原始数据拷贝一份新的,把拷贝出来的数值传到方法内部;在方法内部修改时,则修改的是拷贝出来的值,而原始的值不会发生...
  • Java中参数传递的问题

    2012-11-18 23:34:16
    Java中参数传递,一般来说有两种,一种传值,一种传引用。但是这种说法并不准确。 (1)如果是基本数据类型就把值复制一份给临时空间(杯子复制一个给你,你摔碎了,我的杯子还是好的) (2)如果是对象就把其...
  • Sum II),在采用熟悉的C++解答之后,用Java语言再次撸了一遍,发现一些问题,特别是参数传递的问题:  【C++】  在C/C++参数传递分为两种:值传递和地址传递,其中:  1.值传递:实际参数将值传递给形式...
  • java中参数传递的方式

    2013-06-25 01:06:13
    今天在写代码的时候遇到了一个参数传递的问题,虽然我知道问题出现在哪里,但是问题的原因似懂非懂,看了很久之前写的一篇博客,在网上搜索了几篇文章 看了下,终于彻底弄懂了这个问题的原因,写篇文章总结下。 ...
  • java中参数传递的研究

    2012-11-13 21:08:38
    首先大家都懂,基本类型在传递参数的时候是复制变量到给形参的,对象则是传递地址。这些都是所谓的值传递。并不是引用传递。具体可以看看《Think in Java》这本书。   来看个例子: public class Pratice { ...
  • Java中参数传递方式(超详细)

    千次阅读 2014-11-21 16:50:32
    闲言少叙,下面我们就通过内存模型的方式来讨论一下Java中参数传递。 这里的内存模型涉及到两种类型的内存:栈内存(stack)和堆内存(heap)。基本类型作为参数传递时,传递的是这个值的拷贝。无论你怎么改变这个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,743
精华内容 5,897
关键字:

java中参数传递

java 订阅