精华内容
下载资源
问答
  • Java的值传递

    2019-04-13 14:48:41
    Java的值传递。 正文 复习《C++ Primer》第三版第89页,复习了一遍C++的引用。 再来理解Java的引用,在《Java编程思想》的第二章,有涉及到这个地方的知识,这里说Java对于对象的传递是通过引用。 ...

    概要

    Java的值传递。

    博客

    原帖收藏于IT老兵博客

    正文

    复习《C++ Primer》第三版第89页,复习了一遍C++的引用。

    找到了以前总结的笔记:

    C++的引用是怎么样的?
    “引用是C++的一个特征,它就像能自动被编译器逆向引用的常量型指针一样。 ”
    
    “使用引用时有一定的规则:
    1) 当引用被创建时,它必须被初始化。(指针则可以在任何时候被初始化。)
    2) 一旦一个引用被初始化为指向一个对象,它就不能被改变为对另一个对象的引用。(指
    针则可以在任何时候指向另一个对象。)
    3) 不可能有NULL引用。必须确保引用是和一块合法的存储单元关连。”
    
    --《C++编程思想》
    

    再来理解Java的引用,在《Java编程思想》的第二章,有涉及到这个地方的知识,这里说Java对于对象的传递是通过引用。

    https://stackoverflow.com/questions/4712798/how-to-use-references-in-java, 这里讲了原始类型和对象的传递方式。

    总结

    其实Java都是通过值传递,对于原始的类型,是值传递;对于对象,是把引用的值通过值传递传给新的变量,这个变量里面保存的是原来引用所指向的对象的地址,这个时候修改了这个值,对原本的引用不会产生影响。

    展开全文
  • 主要介绍了详解java的值传递、地址传递、引用传递的相关资料,需要的朋友可以参考下
  • java的值传递

    千次阅读 2007-03-16 13:41:00
    在Oracle技术面时候居然被问了java函数传递类型,我很清楚知道是值传递,也知道要分基本类型和对象两种情况来解释,不过在说到对象时候却怎么也想不明白了估计这个对我面试结果影响会很大 呵呵,过会写个...
    在Oracle的技术面的时候居然被问了java中的函数传递类型,我很清楚的知道是值传递,也知道要分基本类型和对象两种情况来解释,不过在说到对象的时候却怎么也想不明白了估计这个对我面试的结果影响会很大 呵呵,过会写个Oracle技术类的面经吧.

    首先还是对于一个基本类型的变量来说,比如 int,char类型的变量,传入函数的那个是该基本类型的值,也就是说在函数体中是改变不了传入的这个参数的值的.

    public void changeInt(int i) {
            i = 0;
    }

    public static void main(String[] args) {
            int i = 1;
            System.out.println("before the change , i = " + i);
            changeInt(i);
           
    System.out.println("after the change , i = " + i);
    }

    结果都是1.

    对于传入的参数是一个类的对象的话,为什么还是值传递呢?
    从我在网上搜到的东西和我自己的理解来看,主要是这样的, 传入的参数所代表的对象就是一个



    可是如果是如果变量是一个类类型的呢?那它的值是什么呢?它的值就是它的引用,传入的就是对象的句柄,我们不能改变对象本身的值,当时对传入的参数所做的修改是对该句柄指向对象的修改,这样的话 ,对象具体内容也被改变了.

    public class ValueTest {

        public static void changeString(String s) {
            s = "helloworld";
        }
       
        public static void main(String[] args) {
            String testStr = "Hiworld";
            System.out.println("before change the string is " + testStr);
            changeString(testStr);
            System.out.println("after change the string is " + testStr);
        }
    }

    结果都是Hiworld.

    这个应该是因为String是个final的类,所以
            s = "helloworld"; 是将s指向了另一个对象.

    对于一些其他非final的对象来说

    public class Valuetest {

        public static void changeDate(Date d) {
            d.setTime(1L);
        }
       
        public static void main(String[] args) {
            Date d = new Date();
            System.out.println(d.getTime());
           
    changeDate(d);
            System.out.println(d.getTime());
        }
    }

    结果就是

    1166586775750
    1

    第一个是当前时间的毫秒数.
    在这个例子中
    changeDate调用了date的一个函数修改了d的一个属性,就对传入的原来的参数起了作用..


    说的不是很清楚 不过看程序应该能明白是什么意思了吧.



     
    展开全文
  • JAVA的值传递还是引用传递——只有值传递 java语言深入(java中是传值还是引用) 关键字: java基础深入  熟悉C的程序员都用过指针,对指针可谓爱之深恨之切。指针是指向一块内存地址的内存数据(有些拗口),也...

    JAVA的值传递还是引用传递——只有值传递

    java语言深入(java中是传值还是引用)
    关键字: java基础深入 
    熟悉C的程序员都用过指针,对指针可谓爱之深恨之切。指针是指向一块内存地址的内存数据(有些拗口),也就是说指针本身是一个占用4字节内存的 int(32 位系统内),而这个int值恰恰又是另一块内存的地址。比如"hello"这个字串,存放在@0x0000F000这个地址到 @0x0000F005这段内存区域内(包括0x00的结束字节)。而在@0x0000FFF0到@0x0000FFF03这四个字节内存放着一个 int,这个int的值是 @0x0000F000。这样就形成了一个指向"hello"字串的指针。 

      在Java中,很多人说没有指针,事实上,在Java更深层次里,到处都是大师封装好的精美绝伦的指针。为了更容易的讲解Java中关于类和类型的调用,Java中出现了值与引用的说法。浅显的来说,我们可以认为 Java中的引用与C中的指针等效(其实差别非常非常大,但是为了说明我们今天的问题,把他们理解为等效是没有任何问题的)。 

      所谓传引用的说法是为了更好的讲解调用方式。基于上面对指针的理解,我们不难看出,指针其实也是一个int值,所谓传引用,我们是复制了复制了指针的 int值进行传递。为了便于理解,我们可以姑且把指针看作一种数据类型,透明化指针的int特性,从而提出传引用的概念。 

      重申一遍:Java中只有传值。 

      1所谓传值和传引用 

      传值和传引用的问题一直是Java里争论的话题。与C++不同的,Java里面没有指针的概念,Java的设计者巧妙的对指针的操作进行了管理。事实上,在懂C++的Java程序员眼中,Java到处都是精美绝伦的指针。 
      下面举个简单的例子,说明什么是传值,什么是传引用。 
      //例1 
    void method1(){ 
      int x=0; 
      this.change(x); 
      System.out.println(x); 
      } 
    
      void int change(int i){ 
      i=1; 
      } 
      很显然的,在mothod1中执行了change(x)后,x的值并不会因为change方法中将输入参数赋值为1而变成1,也就是说在执行change(x)后,x的值z依然是0。这是因为x传递给change(int i)的是值。这就是最简单的传值。 
      同样的,进行一点简单的变化。 
      //例2 
    void method1(){ 
      StringBuffer x=new StringBuffer("Hello"); 
      this.change(x); 
      System.out.println(x); 
      } 
    
      void int change(StringBuffer i){ 
      i.append(" world!"); 
      } 

      看起来没什么变化,但是这次mothed1中执行了change (x)后,x的值不再是"Hello"了,而是变成了"Hello world!"。这是因为x传递给change(i)的是x的引用。这是最经典的传引用。 
      似乎有些奇怪了,两段程序没有特别的不同,可是为什么一个传的是值而另一个传的是引用呢?...... 

      2非要搞清楚传值还是传引用的问题吗? 

      搞清楚这自然是有必要的,不然我也不需要写这么多了,不过的确没有到"非要"的地步。 
      首先,如果我们不太关心什么是传值什么是传引用,我们一样能写出漂亮的代码,但是这些代码在运行过程中可能会存在着极大的隐患。 
      全局变量是让大家深恶痛绝(又难以割舍)的东西,原因就是使用全局变量要特别注意数据的保护。如果在多线程的程序里使用全局变量简直就等于跟自己过不去。不了解传值和传引用的问题,跟使用全局变量不考虑数据保护的罪过是不相上下下的,甚至有时候比它还要糟。你会莫名其妙,为什么我的返回参数没有起作用,为什么我传进去的参数变成了这样......? 
      一个例子: 
      //例3 
    void mothed1(){ 
      int x=0; 
      int y=1; 
      switchValue(x,y); 
      System.out.println("x="+x); 
      System.out.println("y="+y); 
      } 
      void switchValue(int a,int b){ 
    
      int c=a; 
      a=b; 
      b=c; 
      } 

      上面是一个交换a,b值的函数,看起来似乎蛮正确的,但是这个函数永远也不会完成你想要的工作。 
      还有一个例子: 
      //例4 
    StringBuffer a=new StringBuffer("I am a "); 
      StringBuffer b=a; 
      a.append("after append"); 
      a=b; 
      System.out.println("a="+a); 

      在编程过程中,经常会遇到这种情况,一个变量的值要被临时改变一下,等用完之后再恢复到开始的值。就好像上面的例子,a为了保持它的值,使用b=a做赋值,之后a被改变,再之后a把暂存在b里面的值取回来。这是我们一厢情愿的想法,而事实上,这段代码执行后,你会发现a的值已经改变了。 
      以上是两个最简单的例子,真正的程序开发过程中,比这要复杂的情况每天都会遇到。 

    3类型和类 

      Java 提出的思想,在Java里面任何东西都是类。但是Java里面同时还有简单数据类型:int,byte,char,boolean,与这些数据类型相对应的类是Integer,Byte,Character,Boolean,这样做依然不会破坏Java关于任何东西都是类的提法。 
      这里提到数据类型和类似乎和我们要说的传值和传引用的问题无关,但这是我们分辨传值和传引用的基础。 

      4试图分辨传值还是传引用 

      为什么是"试图分辨"呢?很简单,传值和传引用的问题无处不在,但是似乎还没有人能正统的给出标准,怎样的就是值拷贝调用,怎样的就是引用调用。面对这个问题,我们更多的应该是来自平时积累对Java的理解。 
      回过头来,我们分析一下上面的几个例子: 
      先看例1,即使你不明白为什么,但是你应该知道这样做肯定不会改变x的值。为了方便说明,我们给例子都加上行号。 
      //例1 
       1 void method1(){ 
      2 int x=0; 
      3 this.change(x); 
      4 } 
      5 
      6 void int change(int i){ 
      7 i=7; 
      8} 

      让我们从内存的存储方式看一下x和I之间到底是什么关系。 
      在执行到第2行的时候,变量x指向一个存放着int 0的内存地址。 

      变量x---->[存放值0] 

      执行第3行调用change(x)方法的时候,内存中是这样的情形:x把自己值在内存中复制一份,然后变量i指向这个被复制出来的0。 

      变量x---->[存放值0] 
      ↓进行了一次值复制 
      变量x---->[存放值0] 

      这时候再执行到第7行的时候,变量i的被赋值为7,而这一步的操作已经跟x没有任何关系了。 

      变量x---->[存放值0] 
       
      变量x---->[存放值7] 

      说到这里应该已经理解为什么change(x)不能改变x的值了吧?因为这个例子是传值的。 
      那么,试着分析一下为什么例三中的switchValue()方法不能完成变量值交换的工作? 
      再看例2。 
      //例2 
    1void method1(){ 
      2 StringBuffer x=new StringBuffer("Hello"); 
      3 this.change(x); 
      4} 
      5 
      6void int change(StringBuffer i){ 
      7 i.append(" world!"); 
      8} 

      例2似乎和例1从代码上看不出什么差别,但是执行结果却是change(x)能改变x的值。依然才从内存的存储角度来看看例2的蹊跷在哪里。 
      在执行到第2行时候,同例1一样,x指向一个存放"Hello"的内存空间。 

      变量x---->[存放值"Hello"] 

      接下来执行第三行change(x),注意,这里就与例1有了本质的不同:调用change(x)时,变量i也指向了x指向的内存空间,而不是指向x的一个拷贝。 

      变量x \ 
      -->[存放值"Hello"] 
      变量x / 

      于是,第7行对i调用append方法,改变i指向的内存空间的值,x的值也就随之改变了。 

      变量x \ 
      -->[追加为"Hello World!"] 
      变量x / 

      为什么x值能改变呢?因为这个例子是传引用的。 
      这几个例子是明白了,可是很多人会开始有另一个疑问了:这样看来,到底什么时候是传的值什么时候是传得引用呢?于是,我们前面讲到的类型和类在这里就派上了用场:对于参数传递,如果是简单数据类型,那么它传递的是值拷贝,对于类的实例它传递的是类的引用。需要注意的是,这条规则只适用于参数传递。为什么这么说呢?我们看看这样一个例子: 
      //例5 
      String str="abcdefghijk"; 
      str.replaceAll("b","B"); 
      这两句执行后,str的内容依然是"abcdefghijk",但是我们明明是对str操作的,为什么是这样的呢?因为str的值究竟会不会被改变完全取决于replaceAll这个方法是怎么实现的。类似的,有这样一个例子: 
      //例6 
      
    1 void method1() { 
      2 StringBuffer x = new StringBuffer("Hello"); 
      3 change1(x); 
      4 System.out.println(x); 
      5 } 
      6 
      7 void method2() { 
      8 StringBuffer x = new StringBuffer("Hello"); 
      9 change2(x); 
      10 System.out.println(x); 
      11 } 
      12 
      13 void change1(StringBuffer sb) { 
      14 sb.append(" world!"); 
      15 } 
      16 
      17 void change2(StringBuffer sb) { 
      18 sb = new StringBuffer("hi"); 
      19 sb.append(" world!"); 
      20 } 

      调用method1(),屏幕打印结果为:"Hello world!" 
      调用method2(),我们认为结果应该是"hi world",因为sb传进来的是引用。可是实际执行的结果是"Hello"! 
      难道change2()又变成传值了?!其实change1()和change2()的确都是通过参数传入引用,但是在方法内部因为处理方法的不同而使结果大相径庭。我们还是从内存的角度分析: 
      执行method1()和change1()不用再多说了,上面的例子已经讲解过,这里我们分析一下method2()和change2()。 
      程序执行到第8行,x指向一个存放着"Hello"的内存空间。 

    变量x---->[存放值"Hello"] 

      第9行调用change2,将sb指向x指向的内存空间,也就是传入x的引用。 

      变量x \ 
      -->[存放值"Hello"] 
      变量x / 

      到这里为止还没有什么异样,接下来执行18行,这里就出现了类似传入值拷贝的变化:new 方法并没有改变sb指向内存的内容,而是在内从中开辟了一块新的空间存放串"hi",同时sb指向了这块空间。 

      变量x---->[存放值"Hello"] 
      ×原有的引用被切断 
      变量x---->[另一块存放"hi"的空间] 

      接下来再对sb进行append已经和x没有任何关系了。 
      所以,还有一条不成规则的规则:对于函数调用,最终效果是什么完全看函数内部的实现。比较标准的做法是如果会改变引用的内容,则使用void作为方法返回值,而不会改变引用内容的则在返回值中返回新的值。 
      虽然已经说了这么多,但是感觉传值还是传引用的问题依然没有完全说清楚。因为这个问题本身就是很难归纳总结的问题,所以更多的理解要靠平时的积累和形成。下面几个例子,给大家尝试进行分析。 
      //例7,打印结果是什么? 
      
    public static void main(String[] args) { 
      int a; 
      int b; 
      StringBuffer c; 
      StringBuffer d; 
      a = 0; 
      b = a; 
      c = new StringBuffer("This is c"); 
      d = c; 
      a = 2; 
      c.append("!!"); 
      System.out.println("a=" + a); 
      System.out.println("b=" + b); 
      System.out.println("c=" + c); 
      System.out.println("d=" + d); 
      } 


      //例8,打印结果是什么? 
      
    public class Test{ 
      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) { 
      StringBuffer sb2 = new StringBuffer("Hi "); 
      strBuf = sb2; 
      sb2.append("World!"); 
      } 
      } 

    如果是以基本数据类型(包括String类)做参数进行传递,或以某个类名(包括数组名)为类型做为参数而直接对其类进行操作(非类的属性),这样的传递叫值传递;

    如果是以某个类名为类型做为参数进行传递而针对该类的属性进行的操作,这样的传递叫做引用传递。

    也就是说在值传递的过程中其操作不会对所传进来的对象有任何的影响,它传进来的只是该对象的一个副本,其本身不会有任何的改变;而引用传递则传进来的是该对象的一个别名,即引用该对象在虚拟机中的“地址”,因此引用传递会对该“地址”的内部属性产生影响,而不会改变该“地址”在虚拟机中的位置,即引用传递在外部看来是没有发生过任何变话的,但从内部看来,它的属性会随着调用它的方法的改变而改变

    因此,也有人说JAVA只有“值传递”,而没有引用传递
    展开全文
  • java的值传递问题

    2012-04-08 12:26:41
    java中有很多东西让人纠结了又纠结,总是想弄明白,但是总又那么模模糊糊,比如说java的值传递。也用了几年java了,这个东西只是知道java是值传递,从经验来说,基本类型传递过来了不会修改基本类型的值,但是引用...

    1.Java值传递介绍

    java中有很多东西让人纠结了又纠结,总是想弄明白,但是总又那么模模糊糊,比如说java的值传递。也用了几年java了,这个东西只是知道java是值传递,从经验来说,基本类型传递过来了不会修改基本类型的值,但是引用类型传递过来之后却发现引用类型可以修改值,让人郁闷啊。

    今天周日,闲着无聊看了下php,有个地方说$value是引用传递,要值传递的话必须用&value,纠结半天,终于弄明白了java的值传递问题。在这里给大家分享一下。

    欢迎拍砖。

    介绍一下值传递:

    首先声明值是php的,没有找到java的,我的理解应该是一样的。有什么不妥之处欢迎拍砖。引自:《PHPMysql Web开发》原书第四版,ISBN978-7-111-26281-7,机械工业出版社 2009.4

    原文如下:

    ‘通常 函数获取参数的方式是是传递。当传递一个参数的时候,一个新的并且包含该传入的值的变量将被创建。他是原来那个变量的副本。可以任意方式的修改它,但函数外部原来变量的值是不会改变。’

    2.基本类型

    Java中有一些基本数据类型,booleanbytecharshortintlongfloatdouble 。

    在所谓的值传递过程中,会直接把变量本身的值传递过去,在方法中创建一个新的变量来指向传递过来的值,当修改方法中的变量的时候,不会对方法外部的变量有影响。

    工具方法:

    public static void setInt(int b){

    b = b+1;

    }

    测试方法:

    public static void main(String[] args) {

    int a = 10;

    setInt(a);

    System.out.println(a);//输出10

    }

    分析:

    1.声明一个int型变量a并赋值为10

    2.调用setInt()工具方法,

    3.在setInt()工具方法中,会新建一个变量b来指向传递过来的值10

    4.当设置b = b + 1的时候,b的值改变为11,直到方法执行结束前,b的值都是11

    5.方法执行结束之后,变量b因为超过了自己的作用域范围而被销毁,

    6.但是方法外的变量a却没改变。

    为什么a的值明明传递过去了,值也改变了a却没有改变呢,

    a的值确实是传过去了,当时在方法中,变量b首先指向的是a的值,然后修改为a+1之后就发生了一些变化,a+1的值已经不在是10,是11。在内存(这里指栈内存,请参考下面jvm内存分配),那么jvm要重新分配一部分内存来存储11。而10的内存还在(只有内存没有被任何对象或变量引用的时候才会被销毁),同事会把11的内存引用赋值给ba的值还是10不会改变。

    3.对象类型

    Java中创建对象是通过new关键字来完成的,例如:

    Date date = new Date();//创建一个日期对象。并且新创建对象的应用赋值给date

    这样说有点不好理解,下面拆开来说、:

    首先声明变量;

    Date date;// 声明一个Date类型的变量

    这里声明一个Date类型的变量date,没有给date赋值,所以说date现在没有指向任何对象(java中一切皆是对象),你可以说它现在是null

    new Date();//创建一个对象,确切的说是对象的实例,为了防止混淆,那么以后都称为对象实例或实例。

    new关键字不仅仅是创建了一个对象实例,同时它也返回了新创建对象实例的引用,注意是引用,是对象实例的引用。

    Date date = new Date();//这样的话是把创建对象实例,和对象实例引用赋值一步完成。

    明白了这一步,那么现在转入正题-java值传递

    现在有一对象

    public class Person {

    private String name;

    private int age;

    public Person() {

    }

    public Person(String name, 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 class TestP {

    public void setName(Person p1,String name){

    p1.setName(name);

    }

    }

    测试方法

    public static void main(String[] args) {

    TestP tp = new TestP();

    Person p ;

    p = new Person("张三",25);

    tp.setName(p,"小月");

    System.out.println(p.getName());//输出小月

    }

    上面为什么输出了‘小月’而不是‘张三’,选择让我们分析一下:

    首先创建了一个Person类型的变量p,然后创建了一个Person类型的对象实例,并且把该对象实例的引用赋值给p,此时p是指向Person实例对象引用的变量。

    分析一下关系:假定上面新创建的对象引用为R。实例对象为Obj。那么:他们的关系可以理解为:

    P-->R-->Obj

    也就是说P指向引用R,而引用R指向的是对象实例Obj。这些对象的值传递就好理解了,分析如下:

    1.第一步创建Person类型对象,并把实例对象的引用赋值给p

    2.调用工具类tpsetName方法,

    3.在tpsetName方法开始执行的时候,jvmp变量的值赋给了tpsetName方法里的p1(注意是p的值赋给了p1也就是说把第一步中创建Person对象实例的引用传递给了p1),在p1被赋值之后开始调用实例对象的setName方法,就是调用的是Person对象的方法setName

    4.该方法执行完之后,上面创建的Person对象实例的name属性当然会被修改。

    5.而同事方法外面的变量p执行的对象实例还是被传过来的对象实例。所以外部的对象变量p也会呗修改。

    等等 我还有一个问题,为什么使用new关键字创建对象返回的是对象的引用而不是对象本身呢? 

    这要从java对象存储方式来说:

    new关键字会创建一个对象,jvm会把创建的java对象实例放到jvm内存的堆区,同事也会生成一个该对象的引用放到jvm内存的栈中,这里和基本数据类型存储有一个不同的地方,基本数据类型的值直接存储在栈中,而不会在堆区生成对象实例。基本类型的值传递直接传递的是栈中的值,不会在想堆区中查找对应的对象。

    关于jvm内存分配请参考:

    http://blog.csdn.net/Poechant/article/details/7289093 

    关于jvm基本类型和引用类型的存储方式请参考:

    http://blog.csdn.net/program_think/article/details/3996147 

    别人理解的java值传递大家参考一下:

    http://blog.csdn.net/faintbear/article/details/198021 

    4.final修饰的对象类型

    但是有时候我们发现有些对象违反了上面对象类型的规则,例如final修饰的对象类型String,扫一下盲,String不是基本来兴,虽然String看上去和用上去基本上都和基本类型类似。但是String确实是对象类型。

    这就怪了,String是对象类型的为什么违反了上面的规则呢,

    还要从jvm内存分配说起:

    引用bocai17的话

    Bocai17博客地址:http://my.csdn.net/bocai17 

    1,内存有六块区域能够存储数据,用的最多的就是堆heap(存储对象),位于RAM中 (random access memory随即访问存储器);
    栈stack(存储引用),RAM中;
    静态存储static storage(存储static修饰的),RAM中;
    常量存储constant storage(存储不变的),所以这个常量存储有点特殊,常量存储位 于只读存储器ROM中,也就是read-only memory;
    还有2个不介绍了
    2,答案很简单了。
    static final修饰的变量就是常量,当然是在常量存储区域;
    final修饰的变量在栈中,只不过它修饰的变量只能赋一次值。因此对每个new出来的 对象来说,final修饰的变量具有唯一的特点,因为赋了一次值后就不能改变了

    从bocai17的话中可以看出,final对象类型存储在常量区里面,在常量区中的数据不会包含想其他对象实例的引用,那么可以参考基本类型来理解常量区中的数据了。

    这样就可以解释为什么final修饰对象类型违反上面所说的规则了。 

    引用xnjnmn的话 

    xnjnmn的博客地址:http://my.csdn.net/xnjnmn 

    了解详细类加载情况可以看 深入JAVA虚拟机这本书 第八和第七章有介绍final
    http://d.download.csdn.net/down/211290/lixiyue126 

    展开全文
  • java参数传递的方法有两种讨论,从不同的角度来看,两种说法都是对的,所以不必拘泥于到底是值传递还是引用传递,主要看你想达到什么目的。 值传递 java在传递基本数据类型的数据的时候,传递的是这个数据的值的...
  • JAVA的值传递和引用传递

    千次阅读 2018-07-08 20:18:46
    首先,java中方法参数传递方式是按值传递。 如果参数是基本类型,传递是基本类型字面量值拷贝。 如果参数是引用类型,传递是该参量所引用对象在堆中地址值拷贝。 这两句已经很清楚解释了JAVA是如何...
  • Java的值传递特性

    2021-02-02 19:02:49
    java函数传参的传递方式是以值传递的方式进行传递,即调用参数的时候实际上是将实际参数的值复制一份进行传递。 但是这在基本数据类型和引用数据类型的函数传参中会体现出不一致的效果: 1,基本数据类型 我们都知道...
  • JAVA引用传递和值传递
  • java的值传递与引用传递  今天一个同事也碰到一个问题,问题大致是这样的: 有一个list1对象:   ArrayList list1=new ArrayList();  list1.add(“string1”);  list1.add(“string2”);  这时候又定义了...
  • java的值传递机制

    2018-12-09 11:23:14
    形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量 [2].形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量。首 先看一下不调用方法的...
  • 这一次,彻底解决Java的值传递和引用传递 本文旨在用最通俗的语言讲述最枯燥的基本知识 学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会...
  • 文章目录实参与形参值传递与引用传递Java的值传递总结 关于这个问题,引发过很多广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的是错误的。还有的人可能知道Java中的参数传递是值传递...
  • 不记得在哪里看到Java只有值传递,也就是形参不会改变实参的数据。 但是今天测试却发现不是这样的。下面说一下我的测试结果 注:我把会改变实参的值叫做,地址值(引用)传递 测试结果如下: 1、八大基本数据类型...
  • 按值调用:表示方法接收的是调用者提供的值。而按引用调用表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。 Java总是采用按值...
  • 值传递的时候,将实参的副本传递给形参,所以无论调用的这个方法里面如何对形参进行改变,都不会影响实参的值,因为副本作为局部变量,在其行为结束时候,就会被回收(失效),故我们从main()方法中得到该变量还是...
  • 导语:最近多次面试中,面试官问到Java值传递还是引用传递?这种问题中小公司几乎必面,这里简单记录一下。 值传递:传递参数是值得拷贝。即使在函数中被改动也只是改动副本。 引用传递:传递参数是参数...
  • 全栈学习之后端基础 java的值传递

    万次阅读 2020-05-08 07:07:35
    java中是没有指针的,java中只存在值传递, 然而我们经常看到对于对象(数组,类,接口)的传递似乎有点像引用传递,可以改变对象中某个属性的值。但是不要被这个假象所蒙蔽,实际上这个传入函数的值是对象引用的...
  • 对于Java的值传递和引用传递的区别

    千次阅读 2017-07-28 19:23:24
    我知道有人会说,Java只有值传递而没有引用传递,但是如果把引用地址也看成一个值话,是可以这么说。 对于两个传递定义是什么呢? 第一,值传递是对基本型变量而言,传递是该变量一个副本,改变副本不...
  • 本文记录了java的值传递和引用传递,String的两种赋值方式的一些学习要点。 形参传递 java中的形参传递都是单向传递,传递的是原变量的副本 在方法中改变的是副本的值,而不是原变量的 值传递和引用...
  • 关于值传递和址传递在Java中老是存在疑惑,网上帖子有说Java不存在址传递,也有人说Java二者都有。下面验证一下。 经典函数SWAP(交换函数): 关于交换函数大家都学过,在学C系列语言时,专门用来讲解址和值...
  • Java参数传递都是值传递 首先java中是没有引用传递。 形参与实参概念 形式参数:是在定义函数名和函数体时候使用参数,目的是用来 接收调用该函数时传入参数。 实际参数:在调用有参函数时,主调函数...
  • 值传递和引用传递是初次接触Java一个难点,有时候记得了语法却记不得怎么实际运用,有时候会了运用却解释不出原理,而且坊间讨论话题又是充满争议:有论坛帖子说Java只有值传递,有博客说两者皆有;...
  • 结合上面分析,关于值传递和引用传递可以得出这样结论:(1)基本数据类型传值,对形参修改不会影响实参; (2)引用类型传引用,形参和实参指向同一个...“在Java里面参数传递都是按值传递”这句话意思是:
  • Java的实参如何传入方法呢? Java里的参数传递方法只有一种:值传递。即将实际参数的副本(复制品)传入方法内,而参数本身不受影响。 值传递机制 如果参数是基本数据类型,此时参数传递给形参的是实参的数据值。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,621
精华内容 5,048
关键字:

java的值传递

java 订阅