精华内容
下载资源
问答
  • JAVA的参数传递

    千次阅读 2007-08-24 10:09:00
    而且,这个特性,也对函数的参数传递有着重要的影响。用过dephi的人都知道,在object Pascal中,函数的参数传递有两种方式,值传递和变参传递,简单的说,就是加不加var的区别。加了var,就是变参传递,实质上传递的...
    Java是种面向对象的语言,可以说,Java所有一切都是对象,这句话很好的描述的Java和别的面向对象的编程语言,例如Object Pascl的区别。而且,这个特性,也对函数的参数传递有着重要的影响。
    用过dephi的人都知道,在object Pascal中,函数的参数传递有两种方式,值传递和变参传递,简单的说,就是加不加var的区别。加了var,就是变参传递,实质上传递的是这个参数的指针,也就是说,在函数中对参数的任何修改,实际上就是参数对应的变量的修改,这样程序执行完后,作为参数传进来的变量的值可能发生改变。而不加var,则就是值传递,实质上,就是将值先拷贝一份,然后,将拷贝的传递给函数,这样,修改实际上对原来的变量没有影响,(因为只是对拷贝的修改)而且,等到函数返回时,函数调用的空间退栈,拷贝的参数空间也被收回。
    而Java来说,由于所有的皆是对象,所以,参数传递有所不同。其中,没有了var的区别。但实际上,由于对象作为参数,也就是相当于var式传递,因为,传递给函数的是原对象的指针,这样,对传入的参数的修改,实际上就是作为参数的对象的修改,在这一点上,Java的参数传递实际上和var方式很象。但在简单数据类型做参数上,Java却是遵循值传递的原则,即在函数中修改不会对传入的简单数据类型的变量产生影响,比如象int类型的参数,即使函数中有过修改,也不会对传入的原变量有影响。由于这样,我们在对简单类型的变量作修改时(比如,想让它们作函数参数,然后在函数中修改它们),会误以为真的修改了变量,其实不然,知道值参的传递就会很容易明白这个道理。所以,我们需要将变量包装成一个对象(例如,设一个对象,以一个int值的变量作参数)这样,以此对象作参数,当在函数中对对象中的int变量修改后,原对象中的值便得到修改了。
    由此,我们可以更加深入的看看递归函数的问题。递归函数通过不断的调用自身,其实在做一个不断的入栈然后出栈的过程,随着递归的进行,新递归函数不断的入栈,等到条件满足返回时,再不断的出栈。这样,对于值参的话,每次递归都要将其现在的数据保存到栈中,而变参,则只保存引用,所以,递归函数在不同的编程语言中的应用要相应的注意。比如,数组类型的数据,在object pascal中要定义数组类型的type,这样,每次递归时,实际上是将当前的数组参数作值参存储,即每次递归就要存储相应的数组,这样,每次递归过程实际上是对一个新的数组进行操作。而java就不同,它是以数组变量作参数,这样,每次的递归操作实际上是对同一个数组进行操作。由于有这样的不同,所以,需要在对数组改变后作还原操作,这样,每次才能正确地递归。
     
    展开全文
  • java的参数传递是值传递还是地址传递结论: 1、基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝,原值是不会改变的 2、对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数。 ...

    java的参数传递是值传递还是地址传递结论:

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

    2、对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数。

     

    基本类型作为参数传递

    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) {

            n = 10;

        }

    }

    // 输出结果为:

    Before change, n = 3

    After changeData(n), n = 3

     

    那么,我们现在来看看对象作为参数传递的例子,这也是大家争论的地方。

    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!");

        }

    }

    先看输出结果:

    Before change, sb = Hello

    After changeData(n), sb = Hello 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!

    但运行一下这个程序,你会发现结果是这样的:

    Before change, sb = Hello

    After changeData(n), sb = Hello

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

    下面就让我们仔细分析一下,来揭开这中间的奥秘吧。

    先看Test2这个程序:

    StringBuffer sb = new StringBuffer("Hello ");

    这一句执行完后,就会在内存的堆里生成一个sb对象,请看图1:java参数传递(超经典)

    如图1所示,sb是一个引用,里面存放的是一个地址“@3a”(这个“@3a”是我举的代表内存地址的例子,你只需知道是个内存地址就行了),而这个地址正是“Hello ”这个字符串在内存中的地址。

    changeData(sb);

    执行这一句后,就把sb传给了changeData方法中的StringBuffer strBuf,由于sb中存放的是地址,所以,strBuf中也将存放相同的地址,请看图2:

    java参数传递(超经典)

    此时,sb和strBuf中由于存放的内存地址相同,因此都指向了“Hello”。

    strBuf.append("World!");

    执行changeData方法中的这一句后,改变了strBuf指向的内存中的值,如下图3所示:

    java参数传递(超经典)

    所以,Test2 这个程序最后会输出:

    After changeData(n), sb = Hello World!

     

    再看看Test3这个程序。

    在没有执行到changeData方法的strBuf = new StringBuffer(“Hi “);之前,对象在内存中的图和上例中“图2”是一样的,而执行了strBuf = new StringBuffer(“Hi “);之后,则变成了:

    java参数传递(超经典)

     

    此时,strBuf中存放的不再是指向“Hello”的地址,而是指向“Hi ”的地址“@3b” (同样“@3b”是个例子)了,new操作符操作成功后总会在内存中新开辟一块存储区域。

           strBuf.append("World!");

           而执行完这句后,

    java参数传递(超经典)

    通过上图可以看到,由于sb和strBuf中存放地址不一样了,所以虽然strBuf指向的内存中的值改变了,但sb指向的内存中值并不会变,因此也就输出了下面的结果:

    After changeData(n), sb = Hello

     

    String类是个特殊的类,对它的一些操作符是重载的,如:

    String str = “Hello”; 等价于String str = new String(“Hello”);

    String str = “Hello”;

    str = str + “ world!”;等价于str = new String((new StringBuffer(str)).append(“ world!”));

    因此,你只要按上面的方法去分析,就会发现String对象和基本类型一样,一般情况下作为参数传递,在方法内改变了值,而原对象是不会被改变的。

    展开全文
  • java的参数传递

    2005-01-21 02:12:00
    话,说明你明白参数传递的本质。 说明两点, 1 java里面只有值传递  记住引用传递是改变参数值,而在这个程序里面,参数值(对象引用)始终没有改变 2String改变,将新建一个对象,他不能像...

    先看一个程序
    public class Test {

     public static void parameter(){
       String param="1";
       StringBuffer parab=new StringBuffer("a");
       setParameter(param);
       setParameterb(parab);
       System.out.println(param);
       System.out.println(parab);
     }

     public static void setParameter(String para){
       para=para+"2";
     }
     public static void setParameterb(StringBuffer parab){
       parab.append("b");
     }

     public static void main(String[] args) {
       Test.parameter();
     } 
     }
    能猜到结果么,是这样么
    1
    ab
    是的话,说明你明白参数传递的本质。
    说明两点,
    1 java里面只有值传递
        记住引用传递是改变参数的值,而在这个程序里面,参数的值(对象的引用)始终没有改变
    2String的改变,将新建一个对象,他不能像StringBuffer那样改变parab,在方法setParameter中,para已经
    不是param的引用了。

    展开全文
  • Java的参数传递总结

    2012-10-22 10:29:54
    Java的参数传递总结: JAVA的参数传递总是传"值",但是传值方式也分为两种方式,它们是靠传递参数的类型区分的。这两种类型分别为JAVA的基础类型和Object(对象)类型;基础类型包括boolean,byte,short,char,int,...
    Java的参数传递总结: 
     
    JAVA的参数传递总是传"值",但是传值方式也分为两种方式,它们是靠传递参数的类型区分的。这两种类型分别为JAVA的基础类型和Object(对象)类型;基础类型包括boolean,byte,short,char,int,long,float,double,而Object就是对象,如数组.在参数为基础类型时,见代码:
       public class A{
         public static void main(String arg[]){
           int a=3;
           method1(a);
           System.out.println(a);
         }
         public static void method1(int a){
          a=4;
         }
       }
    此时结果的输出将是1,而且只要你的值在Main函数中没变,a的值不管怎么传都不回变,这是因为a是传值,而这个"值"是a的一个拷贝,a的值在传递后的改变只是改变了a的拷贝的内容,并没有改变真正的a的值;对于参数为对象
        public class A{                                   public class A{
         public static void main(String arg[]){    public static void main(String arg[]){
           int[] a=new int[1];                                int[] a=new int[1];
           a[0]=3;                                               a[0]=3;
           method1(a);                                        method1(a);
           System.out.println(a[0]);                       System.out.println(a[0]);
         }                                          }
         public static void method1(int[] a){         public static void method1(int[] a){
          a[0]--;                                                  a=new int[0];
         }                                                           a[0]=4;
       }                                                            }
                                                                  }
    左边的结果将是2,右边的结果将是3(未变),原因是:在传递的参数为对象时,这个传递的"值"中放的内容实际上是对向所在的地址,左边的情况是指针定位到对象的地址后,在上面把内容给改了,所以数组的值后会改变,而右边的情况为给对象新分配了一个指针到新的地址上面去,所以所有的操作都在新的地址上面,并不会影响原来的值。注:对于String,Interger,Boolean,Double等的系统对象,它们虽然是Object,但是任何方式的传递参数的值得改变并不会影响原来的值。
    展开全文
  • JAVA的参数传递问题

    2016-08-14 21:46:38
    * java的参数传递问题 * 基本类型:形式参数的改变对实际参数没有影响 * 引用类型:形式参数的改变直接影响实际参数 * JAVA中只有一种传递:值传递 * 引用传递实质是传递地址值 */ public class PassBy...
  • 代码写越急,程序跑得越慢。—— Roy Carlson
  • Jni中C++和Java的参数传递  http://www.cnblogs.com/mandroid/archive/2011/06/15/2081093.html JNI错误总结
  • java的参数传递原理

    2011-03-26 21:29:00
    java 参数传递和c++ 区别
  • 所谓参数传递就是用函数调用所给出实参(实际参数)向函数定义所给出形参(形式参数)设置初始值过程。基本有三种参数分别为: (1)传值:  (2)传址(即是传指针) (3)传引用 以上这些都...
  • 首先看一段代码: public static void ...(String[] args) { ...值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际...Java的参数传值方式是值传递 ,而非引用传递
  • 关于Java的参数传递

    2006-11-23 12:06:00
    我要崩溃了,Java的方法参数传递不管是值类型还是引用类型居然都是按值传递, 就是说他始终传递参数的副本.我们将不能通过我们常用的swap方式来交换2个变量的值,他没有C++中的,&,*,更没有C#中的ref,对于值类型的参数,...
  • java的参数传递与内存分配问题

    千次阅读 2015-03-04 21:09:23
    本文可作为北京尚学堂java课程学习笔记。 看下面这段代码。 class BirthDate { private int day; private int month; private int year; public BirthDate(int d, int m, int y) { day = d; month =
  • java的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    所以在java方法中改变参数的值是不会改变原变量,但为什么改变引用变量属性值却可以呢?请看下面解答。 java数据类型 Java中数据类型分为两大类:基本类型和引用类型。相应,变量也分这两种类型:...
  • java的参数传递问题。

    2007-04-02 22:19:00
    我们在使用一门语言的时候经常的要...他们的具体区别是, 值传递你在函数中如果改变了参数的值,当离开这个函数的时候值不会改变,但是引用传递,在你离开函数之后,你的参数的值会发生改变。现在我们再来研究一下jav
  • 基本数据类型传递的是数值package test; public class PersonTest { // 基本数据类型传递的是数值 public static void main(String[] args) { int num = 5; System.out.println("方法调用前num值为\t" + ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,303
精华内容 8,521
关键字:

java的参数传递

java 订阅