精华内容
下载资源
问答
  • java 函数参数

    千次阅读 2009-01-16 20:30:00
    Java函数参数是值传递的package wit.test;public class Test2{public static void main(String[] args) { //传对象 AA a =new AA(); a.n = 10; System.out.println("调用函数(参数是对象)前:
       
    Java函数参数是值传递的

    package wit.test;

    public class Test2
    {
    public static void main(String[] args) {
       //传对象
       AA a =new AA();
       a.n = 10;
       System.out.println("调用函数(参数是对象)前:"+a.n);
       f(a);
       System.out.println("调用函数(参数是对象)后:"+a.n);

       //传的是基本类型
       int n = 10;
       System.out.println("调用函数(参数是基本类型int)前:"+n);
       f(n);
       System.out.println("调用函数(参数是基本类型int)后:"+n);

       Integer nn = new Integer(10);
       System.out.println("调用函数(参数是基本类型Integer)前:"+nn);
       f(nn);
       System.out.println("调用函数(参数是基本类型Integer)后:"+nn);

       //传的String
       String s = new String("ou");
       System.out.println("调用函数(参数是String)前:"+s);
       f(s);
       System.out.println("调用函数(参数是String)后:"+s);

       //传递的StringBuffer
       StringBuffer sb =new StringBuffer("ouyang");
       System.out.println("调用函数(参数是StringBuffer)前:"+sb);
       f(sb);
       System.out.println("调用函数(参数是StringBuffer)后:"+sb);
       //传的是String[]
       String[] ss = new String[3];
       ss[0] = "欧";ss[1]="阳";
       System.out.println("调用函数(参数是String[])前:"+ss[0]);
       f(ss);
       System.out.println("调用函数(参数是String[])后:"+ss[0]);
      
       //传递的是int[]
       int[] ii = {10,20,30};
       System.out.println("调用函数(参数是int[])前:"+ii[0]);
       f(ii);
       System.out.println("调用函数(参数是int[])后:"+ii[0]);

      
    }
    //传对象
    public static void f(AA a) {
       a.n = 20;
    }
    //传的基本类型
    public static void f(int n) {
       n = 20;
    }
    public static void f(Integer n) {
       n = 20;
    }
    //传的String[]
    public static void f(String[] a) {
       a[0]="平";
    }
    //传的String
    public static void f(String a) {
       a = "ouyangping";
    }
    //传的int[]
    public static void f(int a[]) {
       a[0] = 20;
    }
    //传的StringBuffer
    public static void f (StringBuffer sb) {
       sb.append("ping");
    }
    };
    class AA
    {
    public int n ;
    };
    /*************************
    * 总结
    *************************/

    // Java函数参数是值传递的。

    //. 如果参数是基本类型,函数不能改变参数的值。(包括 String)
    //-----传递过去的是值传递,传递的是
    //. 如果参数是对象,函数可以改变参数的属性(包括StringBuffer,int[]等)。
    //. 如果参数是对象,函数不能使参数指向新的对象。


    //这很好解释,对于基本类型诸如int,传递进去的是存放int值的“内存单元”的一个copy,所以函数swap里面的int和外面的int根本就不是一个东西,当然不能反射出去影响外面
    //
    //的int。而对于对象类型,我们同样可以这样认为,传递进去的是存放对象类型的指针的“内存单元”一个copy(虽然Java里面没有指针的概念,但这并不妨碍我们理解)。这样,
    //
    //在swap函数里面,对其指针本身的值做任何操作当然不会影响外面的Integer,因为interger1和interger2的“内存单元”里面的值是不变的,其指向的对象类型也是没有变的。
    //
    //然后这里需要说明一个问题,就是StringBuffer这种类型的对象了。因为其内容是可以改变的,所以change函数里面的“指针”通过类似“*”的操作,改变了StringBuffer对象的
    //
    //本身,就显而易见了。(StringBuffer对象本身只有一个副本)
    //
    //然后说C++了,里面的基本类型的诸如int的值传递大家都了然于胸,就不在这里废话了。然后另一种值传递可以称为指针引用传递

    总结一下
    有两种解释方法、本质是一样的。
    1.从指针的角度考虑、不管你传什么都是指针。
    传过来时、在函数中会使用另外一个地址、但是指向的是相同的内容
    如果你只是修改了地址、而这个地址跟你传进来之前的地址没有任何关系。
    所以不会发生任何变化。但是你修改了指针的内容、你的修改就会发生作用。
    2.从引用来说、你传递的只是引用本身、并不是引用所指的对象。
    你如果只修改引用本身、也不会影响对象的值。
    一旦你通过引用修改了对象的值、那么这个修改会对对象产生影响。

    ,《Core Java™ 2: Volume I - Fundamentals》中有这样一段话:

     

     


     

        The Java programming language always uses call by value. That means, the method gets a copy of all parameter values. In particular, the method cannot modify the contents of any parameter variables that are passed to it.

        Many programming languages (in particular, C++ and Pascal) have two methods for parameter passing: call by value and call by reference. Some programmers (and unfortunately even some book authors) claim that the Java programming language uses call by reference for objects. However, that is false. Because this is such a common misunderstanding, it is worth examining a counterexample in detail.

        Let's try to write a method that swaps two employee objects:

        public static void swap(Employee x, Employee y) // doesn't work
        {
           Employee temp = x;
           x = y;
           y = temp;
        }
    

        If the Java programming language used call by reference for objects, this method would work:

       Employee a = new Employee("Alice", . . .);
        Employee b = new Employee("Bob", . . .);
        swap(a, b);
        // does a now refer to Bob, b to Alice?
    

        However, the method does not actually change the object references that are stored in the variables a and b. The x and y parameters of the swap method are initialized with copies of these references. The method then proceeds to swap these copies.

        But ultimately, this is a wasted effort. When the method ends, the parameter variables x and y are abandoned. The original variables a and b still refer to the same objects as they did before the method call.

     

    // x refers to Alice, y to Bob
        Employee temp = x;
        x = y;
        y = temp;
        // now x refers to Bob, y to Alice
     
    程序运行结果:
    调用函数(参数是对象)前:10
    调用函数(参数是对象)后:20
    调用函数(参数是基本类型int)前:10
    调用函数(参数是基本类型int)后:10
    调用函数(参数是基本类型Integer)前:10
    调用函数(参数是基本类型Integer)后:10
    调用函数(参数是String)前:ou
    调用函数(参数是String)后:ou

    调用函数(参数是StringBuffer)前:ouyang
    调用函数(参数是StringBuffer)后:ouyangping
    调用函数(参数是String[])前:欧
    调用函数(参数是String[])后:平
    调用函数(参数是int[])前:10
    调用函数(参数是int[])后:20
    展开全文
  • Java没有指针,在需要由参数直接带回结果的情况下,较C语言相比有一点差别,C任何类型可通过指针传递,在Java中,需要自定义一个类,而类可以通过函数参数返回结果。   public class testParameter { public ...

    Java没有指针,在需要由参数直接带回结果的情况下,较C语言相比有一些区别,C语言中任何类型可通过指针传递,在Java中,需要自定义一个类(标准类型不能带回参数),而这个自定义类可以通过函数的参数返回结果,达到类似C指针的效果。

     

    public class testParameter
    {
    
      public testParameter()
      {
      }
    
      public static void main(String[] args)
      {
        // 函数传入标准类型参数,测试引用
        // -------------------------------------------
        Integer a = 0;
        Integer b = 0;
        // 引用不能
        getValue(a, b);
        // 未得到期望结果
        System.out.println(a);
        System.out.println(b);
    
        // 函数传入自定义类参数,测试引用
        // -------------------------------------------
        MyValue value = new MyValue();
        value.a = 0;
        value.b = 0;
        // 引用有效
        getValue(value);
        // 得到期望结果
        System.out.println(value.a);
        System.out.println(value.b);
      }
    
      // 参数为自定义类
      private static void getValue(MyValue v)
      {
        v.a = 24;
        v.b = 57;
      }
    
      // 参数为标准类型
      private static void getValue(Integer a, Integer b)
      {
        a = 17;
        b = 37;
      }
    }
    
    // 自定义类
    class MyValue
    {
      // 变量初始化
      public int a = 0;
      public int b = 0;
    }
    


    getValue(MyValue) 的参数在函数内赋值后依然通过类将结果带出,类中的变量发生了变化。

    getValue(Integer, Integer) 的参数在函数内虽然发生了改变,但函数返回后,传入的参数未发生变化,其次 String 类型也不能将结果通过参数带回,只有通过 new 创建的对象才行

     

    字符串的话,可以使用 String[] 作为参数传入,也可以带回函数内的运行结果

     

      public static void main(String[] args)
      {
        try
        {
          String[] str = new String[1];
          str[0] = "";
          Test2(str);
          // 将显示 Test2 的赋值出结果
          System.out.print(str[0]);
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
      }
    
      private static void Test2(String[] str) throws Exception
      {
        str[0] = "hello world.";
      }


     

     blog.csdn.net/joyous/article/details/9372279
    Q群讨论:236201801

    展开全文
  • Java函数改变变量值

    千次阅读 2019-11-07 11:49:29
    当在主函数外定义一个函数时,想在一个函数改变一个变量的值,不能直接当形参传入,否则不会改变变量的值。 可以定义在外面,然后在函数里直接改变, 也可以放在数组中,然后将数组当形参传入,可以改变数组中的...

     当在主函数外定义一个函数时,想在一个函数里改变一个变量的值,不能直接当形参传入,否则不会改变变量的值。

    可以定义在外面,然后在函数里直接改变,

    也可以放在数组中,然后将数组当形参传入,可以改变数组中的元素值,

    请看代码示例:

    public class Public_static {
    	static int n=0;
    	//n不当参数传入时。可以改变它的值
    	static int[] a;
    	static void fun2(int n){
    		n=3;
    	}
    	static void fun(){
    		n=1;
    	}
    	static void fun1(int[] a){
    		a[0]=2;
    	}
    
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
    		fun2(n);//不会改变n的值
    		System.out.println(n);
    		fun();
    		System.out.println(n);
    		a=new int[1];
    		fun1(a);
    		System.out.println(a[0]);
    
    	}
    
    }

    输出如下:

    0
    1
    2
    

     

    展开全文
  • Java函数参数传递

    千次阅读 2010-12-27 21:59:00
    关于Java函数参数传递,很多人感觉比较绕,很多人理解为函数中基本数据类型是值传递,类类型是引用传递。这种理解是不正确的。在网上看到一句话“java函数是传值的,java函数传递的参数是对象的引用”,可以...

    关于Java函数的参数传递,很多人感觉比较绕,很多人理解为函数中基本数据类型是值传递,类类型是引用传递。这种理解是不正确的。在网上看到一句话“java函数是传值的,java函数传递的参数是对象的引用”,可以很精辟的解释了java的参数传递问题。这句话可以分开读,前半句表明了java函数是传值的,无论参数是基本数据类型(int,char,long...)还是类类型,后半句解释了为什么在函数内可以修改参数对象内的值。

     

    看下面的几行代码


    public Test{
            public static void main(String[] args){
            MyObject A = new MyObject(10);
            test(A);
            System.out.println(A.value);
      }

     

    public static void test(MyObject obj)
    {
             obj.value = 20;
             obj = new MyObject(30);
    }

    }

    class MyObject{
             public int value = 0;
             public MyObject(int a){
             value = a;
            }
    }


    MyObject A = new MyObject(10);

    我们可以理解为在在堆上申请了一块内存创建了MyObject对象,假设地址为0x000f000f,内存地址存放在A中。

    test(A)把0x000f000f做为参数传递给了函数test;

    因为函数的参数是值传递的,所以在test函数内部,系统偷偷对实参A做了一个拷贝,我可假设这个拷贝为B,那么B的值当然跟A一样,都为0x000f000f,当在函数内执行语句  obj.value = 20  时,其实是访问了A或B中存放的地址(0x000f000f)指向的对象的成员变量value,对它赋值,即改变了参数对象内部的值。

    而函数test内部语句obj = new MyObject(30);表明在堆上又申请了一块内存,假设地址为0xfff0eeff,把这个地址存在了拷贝B内,这个操作不会对原来的对象造成任何影响。

    输出结果就不用再解释了。这样很容易理解上面所说的“java函数是传值的,java函数传递的参数是对象的引用”。

    上面为个人见解,大家有不同观点,欢迎交流。

    展开全文
  • Java函数参数传递方式详解

    万次阅读 2012-03-22 15:52:01
    在阅读本文之前,根据自己的经验和理解,大家可以先思考并选择一下Java函数参数传递方式:  A. 是按值传递的?  B. 按引用传递的?  C. 部分按值部分按引用?  此处暂不宣布正确答案,我们通过一个简单的...
  • java . python 中函数参数传递
  • 今天学习python,提到python是通过赋值传递的。然后联想到javajava传递参数是通过什么方式...在开发中也遇到过类似的问题:最常见的翻页问题:前台传过来一个Page对象,我们后台通过调用函数参数中含有Page),在函
  • java函数参数传值还是传地址

    千次阅读 2017-03-19 23:01:19
    Java函数参数是传值还是传地址  刚接触C语言时有一道题困惑了我好久,就是交换两个数的值,本来以为相当简单,只要把要交换的a,b传进去,在函数里面利用一个中间变量就可以完成参数的交换,但如何修改程序都不行...
  • java 函数参数的传递问题。

    千次阅读 2010-02-25 15:52:00
    最近在学习java的时候,对于java函数的传递了解了一下。java的数据类型大的分为两种,一种是基本数据类型,另一种是非基本数据类型,(类数据类型)。在参数传递时候,基本的数据类型传递的是对实参数的一份拷贝,而...
  • Java函数参数是值传递的

    千次阅读 2012-01-12 10:25:15
    package wit.test; public class Test2 { public static void main(String[] args) { //传对象 AA a =new AA();... System.out.println("调用函数参数是对象)前:"+a.n); f(a); System.out.println("调用
  • 如果传入的是含有基本类型的引用数据类型 比如说 int[] 那么在此函数里的任何操作会对这个变量造成影响。 如果传入的是String 虽然这是一个引用数据类型 但是因为这个类在定义的时候就是不可变的 所以不会改变这个...
  • <Java>函数参数是数组

    千次阅读 2016-01-03 21:29:05
    用了这么久的Java,还是像C++那样用它,居然甚至没有用过参数是数组的情况,调试代码,有个异常一直未找到原因,后来自己查看调试,发现因为参数是数组,后面的操作导致原值被改变Java函数中的参数,除基本类型...
  • java函数式编程入门

    2020-12-21 01:43:18
    以前写过一篇java8的流操作,人们都说流操作是函数式编程,但函数式编程是什么呢? 什么是函数式编程 什么是函数式编程?它是一种编程范式,即一切都是数学函数函数式编程语言里也可以有对象,但通常这些对象都是...
  • Java interface 做函数参数

    千次阅读 2015-06-06 00:11:49
    在很多项目中会用到java的interface做参数的情况。 用interface做参数有两个好处。 1.使用interface做参数函数可以接受不同的类对象,只要不同的类都实现了相同的interface. 2.编写函数的只考虑函数的实现逻辑...
  • 前阵子,在写一个SWT控件的时候,发现JAVA由于没有指针,不能象C语言那样通过指针传递参数地址来取函数参数值。 于是在网上寻觅,发现StringBuffer可以有效解决这个问题,只要把入参由String改成...
  • 案例1:函数式接口作为参数 1. 1 原日志代码 public class Demo01Logger { //只有日志等级为1时,才会打印日志信息 public static void showLog(int level, String massage){ if(level==1){ System.out.println...
  • JAVA中数组作为函数参数传递

    千次阅读 2020-04-05 12:43:23
    JAVA中数组作为函数参数传递 JAVA中数组作为函数参数传递: 在程序中,调用方法并且把数组的名称作为参数传递到方法中。 本质上是传递数组的地址值。 既然传递的是数组的地址,那么方法就可以通过数组的地址改变...
  • 说到java中调用函数参数引用,就要先说一下形参和实参,以便于更好地理解参数引用。 一.形参和实参简述 形参 parameter:形式参数(形参) 形参出现在函数定义中,在整个函数体内都可以使用,离开该函数...
  • 先学习了解上面的关于Java内存管理的各个内存区域的功能: 关于JAVA值传递和引用传递首先得了解栈和堆以及常量池的基本概念: 举个栗子: String s = ‘"lizhi";  直接初始化一个String类型的变量的...
  • public void insertFirst(Object data)//第一个位置插入节点 { GListNode node = new ...类型 GList 中的方法 insertFirst(Object)对于参数(int)不适用 Graph.java /疏散模拟/src/gList 第 13 行 Java 问题
  • Java中能否利用函数参数来返回值

    万次阅读 2017-04-10 23:17:38
    这两个值互不关联并且不希望以数组的形式返回,甚至这两个返回值都不属于同一种类型,这种情况下在C或C++中可以轻易的使用一个引用的参数来将想要返回的值作为参数传入函数,等函数执行完毕后就可以得到你想要的...
  • java基本类型都统一传值,所以不行 Integer类new完数值就被写死(Integer中用final定义的成员变量),所以也不行 只剩:用成员变量、用数组、或者传自己定义的类,这些办法了。 成员变量不说了, 可以写...
  • java传参怎么改变参数

    千次阅读 2019-10-17 09:58:02
    java利用方法参数传递这个问题困扰了我一天,关于java传参有三种传递方式,《java核心技术卷I》里也提到了。 1.一个方法不能修改一个基本数据类型的参数 ( 即数值型或布尔型 ),String类型也不行 。 2.一个方法...
  • 这主要是由于string内部保存值方式的原因 string是通过一个final char[]数组进行保存的 由于final类型的数组值不能够改变,所以在外部调用函数时将string地址的引用进行传递给函数参数函数内部再修改这个...
  • 因为传递的是引用的副本,也就是说在函数里面把引用指向的真实对象变了,函数外面的引用还是指向原先的对象。 public class Main { public static void main(String[] args) { Record record = new Record();...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,232
精华内容 119,692
关键字:

java函数改变参数

java 订阅