精华内容
下载资源
问答
  • java参数传递机制
    千次阅读
    2021-12-20 19:52:56

    Java方法中的参数传递机制的具体体现

    具体来说是两种:值传递和址传递
    以swap(Object obj1,Object obj2)方法为例:
    1:如果传递进去的是基本数据类型参数得值,那么再调用swap()函数的地方,传入的两个数值并没有发生改变。
    2:如果传入的是引用数据类型的地址,那么在调用swap()函数的地方,传入的两个地址之后,这两个引用数据类型的数值发生改变。
    说明:Java中没有指针,但是有地址。

    更多相关内容
  • 主要介绍了Java方法参数传递机制原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java参数传递机制总结

    2016-10-11 20:32:46
    java语言的参数传递方式只有一种:值传递。值传递的意思就是,将实际参数的值的副本传入方法中,而原参数的值不受任何影响。 一、基本数据类型:  如以下代码: public class Test { public static void main...

    java语言的参数传递方式只有一种值传递。值传递的意思就是,将实际参数的值的副本传入方法中,而原参数的值不受任何影响。

    一、基本数据类型:

     如以下代码:

    public class Test {
    	
    	public static void main(String[] args) {
    		
    		Person person=new Person();
    		person.a=5;
    		person.b=10;
    		
    		int x=5;
    		int y=10;
    		swap(x, y);
    		System.out.println("x="+x+" y="+y);
    		
    	}
    	//交换x,y的值
    	public static void swap(int x, int y){
    		int temp;
    		temp=x;
    		x=y;
    		y=temp;
    	}
    }

    输出结果:


    由输出结果可以看出,通过swap方法并不能改变原x,y的值。

    二、引用类型:传递的是地址的副本

    如以下代码:

    public class Test {
    	
    	public static void main(String[] args) {
    		
    		Person person=new Person();
    		person.a=5;
    		person.b=10;
    		
    		swap(person);
    		System.out.println("person.a="+person.a+" person.b="+person.b);
    	}
    	//交换person.a与person.b的值
    	public static void swap(Person person1){
    		int temp;
    		temp=person1.a;
    		person1.a=person1.b;
    		person1.b=temp;
    		
    	     person1=null;
    	}
    }
    
    class Person{
    	public int a;
    	public int b;
    }

    输出结果:

    由输出结果可以看出,执行完以后,即使在swap方法中最后将person1=null,两个属性的值还是被改变了。这很容易造成一种错觉,不是java都是值传递吗?不是说不会改变原来参数的值吗,为什么最后还是交换了?因为在这里,person1只是person的复制器,也可以理解为对于引用类型,传进去的是地址的副本,person、person1同时指向同一个地址,所以能修改属性的值。下面通过画图希望能够帮助大家加深理解:

    通过参数传递,person1与person指向同一个对象:     

                                          

      当person1=null时,相当于断开person1对person对象的引用,但原先对person对象属性的修改却保留了下来:



           打一个浅显的比方,甲拿着自己房间的钥匙复制了一把给乙。乙拿着复制的钥匙打开了甲的房间,对甲房间里面的布置做了一些修改,然后乙的钥匙丢了,但是对乙对甲房间的布置修改却会保留下来。


    注:对于String,StringBuffer,也是一样的,但是StringBuffer对象的append()方法却可以改变原参数的值,原理跟以上是类似的。


    总结:对于基本类型的参数传递,不会改变原参数的值;

              对于引用类型的参输传递,不会改变原参数对对象的引用,但是会修改原参数指向的对象的属性的值。


    PS:以上是自己总结的,如有不对之处,敬请指正!









    展开全文
  • Java方法参数传递机制

    2022-03-15 11:01:54
    java中方法参数传递

    1.总述

          Java中参数传递是值传递!!!(很重要)。

    如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.

      如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的地址,所以不会改变参数的值。

    2.细述

    参数类型:

    • 实参:在主调函数中调用一个函数时,函数名后面括号中的参数称为“实际参数”,简称“实参

      changeStr(str); //这里的str就是实参

    • 形参:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数,简称“形参”

      static void changeStr(String str) //这里的参数str就是形参

    实参传递给方法:

    就是通过方法的传递机制进行传递

    • 值传递:是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数复制,在函数中对参数进行修改不会影响到实际参数)、

      复制的是参数的引用(地址值),并不是引用指向的存在于堆内存中的实际对象

    • 引用传递:是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。(传地址,会影响实际参数

    方法参数有基本数据类型、引用数据类型

    • 基本数据类型string、int等类型,很明显这里的str并没有被改变,这里很明显的看到出来:java使用的是值传递

    • public static void changeStr(String str){
          str="welcome";
      }
      
      /***
       * 主要是值传递
       */
      private static void changeStrDemo() {
          String str="1234";
          changeStr(str);  //这里的str就是实参
          System.out.println(str);  //输出1234,而不是welcome
      } 

    • 引用数据传递:

    • 这里可以看到调用方法后user中的name属性的值改变了,但是实际上java传递参数还是通过值传递,这里之所以会有产生引用传递的错觉:

      因为复制的是地址!!!

      main方法中的user是一个引用(也就是一个指针),它保存了User对象的地址值,当把user的值赋给pass方法的user形参后,即让pass方法的user形参也保存了这个地址值,即也会引用到堆内存中的User对象

      上面代码中,之所以产生引用传递的错觉,是因为参数保存的是实际对象的地址值,你改变的只是地址值指向的堆内存中的实际对象,并没有真正改变参数,参数的地址值没有变。

    Demo0315 demo0315 = new Demo0315();
    
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    
    System.out.println("pass方法调用前,user=" + user.toString());
    demo0315.pass(user);
    System.out.println("pass方法调用后,user=" + user.toString());
    
     public void pass(User user) {
            user.setName("李四");
            System.out.println("pass方法中,user = " + user.toString());
        }
        
        
    这里的输出:
    pass方法调用前,user=User{name='张三', age=18}
    pass方法中,user = User{name='李四', age=18}
    pass方法调用后,user=User{name='李四', age=18}

    一个生活化例子:

    引用传递:

    你有一把钥匙,当你的朋友想要去你家的时候,如果你直接把你的钥匙给他了,这就是引用传递。这种情况下,如果他对这把钥匙做了什么事情,比如他在钥匙上刻下了自己名字,那么这把钥匙还给你的时候,你自己的钥匙上也会多出他刻的名字。

    值传递:

    你有一把钥匙,当你的朋友想要去你家的时候,你复刻了一把新钥匙给他,自己的还在自己手里,这就是值传递。这种情况下,他对这把钥匙做什么都不会影响你手里的这把钥匙。

    但是,不管上面哪种情况,你的朋友拿着你给他的钥匙,进到你的家里,把你家的电视砸了(这里就是改变了那个user中属性的值)。改变的不是那把钥匙(地址值),而是钥匙打开的房子(地址值对应的实际对象)。

    但是为什么基本数据类型不是砸电视呢???

    因为基本数据类型的复制的直接就是参数的值,引用数据类型复制的参数是数据的地址(在内存当中的地址),实际上,在引用数据类型传值的时候,复制的参数是没有改变的即地址没有改变(这就是典型的值传递)

    展开全文
  • 主要介绍了Java方法的参数传递机制,结合实例形式详细分析了java方法参数传递机制原理、实现方法及操作注意事项,需要的朋友可以参考下
  • java参数传递机制浅析

    千次阅读 2014-04-28 09:46:47
    欢迎转载,转载请声明出处! ----------------------------...下面将通过几个例子来说明java中的参数传递机制,这些例子基本涵盖了所有参数传递的情况。 1.基本数据类型: public static void testBase(int i)
    欢迎转载,转载请声明出处!
    -----------------------------------------
    前言:
    java语言中,参数的传递只有一种机制,那就是值传递
    举例:
    下面将通过几个例子来说明java中的参数传递机制,这些例子基本涵盖了所有参数传递的情况。
    1.基本数据类型:
    public static void testBase(int i)   
     {
           i = 2;
     }

     测试:
    int i = 10;
    System.out.println(i);//10
    testBase(i);
    System.out.println(i);  //10

    结果当然很显然都是10,因为 基本数据类型传递的是值的一份拷贝(副本) ,对副本操作不影响原始值。

    2.对象:
        2.1.对参数重新赋值:
    public static void testObj(Object o)
    {
       o = new Object();
    }

    测试:
    Object o = new Object();
    System.out.println(o);// java.lang.Object@1ff61bcf  
    testObj(o);
    System.out.println(o);//java.lang.Object@1ff61bcf

    方法中的参数只是原始对象的一份拷贝,更准确的讲是地址的一份拷贝,故而对其进行重新赋值并不会影响原始对象。

      2.2.改变对象内部数据:
    public class S
    {
        private Object o = new Object();
        private int i = 2;
        
        public Object getO()
        {
            return o;
        }
        public void setO(Object o)
        {
            this.o = o;
        }
        public int getI()
        {
            return i;
        }
        public void setI(int i)
        {
            this.i = i;
        }
    }
    
    测试方法:
    public static void testA(S s)
    {
       s.setI(100);
       s.setO(new Object());
    }

    测试:
    S s = new S();
    System.out.println(s.getI()+","+s.getO());// 2,java.lang.Object@11b75be2  
    testA(s);
    System.out.println(s.getI()+","+s.getO());//100,java.lang.Object@1cf15b84

    因为对象作为参数传递的是对象的引用地址(注意,这是值传递),故参数所指的对象和原始引用 所指的对象都是堆中的 同一个对象,故在测试方法中修改对象内容会改变对象的数据。

    试试自己分析这个例子(跟上面是一样的):
    package test;
    public class A
    {
        int t = 6;
        Object obj = new Object();
        public static void main(String[] args)
        {
            A a = new A();  
            a.func(a.t,a.obj);//问t和obj的值是否变化,答案:不变化
        }
        public void func(int t,Object obj)
        {
            t = 7;
            obj = null;
        }
    }
    3.数组:
        3. 1.对参数重新赋值:
      public static void testArr(int[] arr)
        {
            arr = null;
        }
    测试:
    int[] arr = {1,2};
    System.out.println(arr[0]);//1
    testArr(arr);
    System.out.println(arr[0]);  //1
    传递机制跟对象一样,也是传递的对象地址,故而也不改变原始值。
          3.2.改变参数内部数据:
     public static void testArr(int[] arr)
        {
            arr[0] = 100;
        }
    测试:
    int[] arr = {1,2};
    System.out.println(arr[0]);//1
    testArr(arr);
    System.out.println(arr[0]);//100
    结果无须解释了吧。
    4.基本数据类型的包装类型:
        其实跟基本类型是一样的。
    public static void testWrapper(Float f)
    {
         f = 100.0f;
    }
    测试:
    Float f = 12.0f;
    System.out.println(f);//12.0
    testWrapper(f);
    System.out.println(f);//12.0
    5. 【重点】 字符串:
    字符串作为参数的情形比较特殊。
        5.1.对参数重新赋值:
    public static void testStr1(String str)
    {
        str = "testOK";
    }
    测试:
     String str = "test";       
     System.out.println(str);//test
     testStr1(str);
     System.out.println(str);//test
    根据前面的思路,字符串也是对象,参数拷贝的是对象的地址,在方法内部将参数指向另一个堆对象并不影响原始对象引用的指向。

     5.2.对参数执行替换、连接等操作:
     public static void testStr2(String str)   
     {
         str = str.concat("OK");
         str = str.toUpperCase();
     }
    测试:
    String str = "test";
    System.out.println(str);//test
    testStr2(str);
    System.out.println(str);//test

    也是对str的重新赋值,不改变原始串.
        5.3.对参数执行+的操作
    public static void testStr3(String str)
        {
            str += "OK";
        }
    测试:
    String str = "test";
    System.out.println(str);//test
    testStr3(str);
    System.out.println(str);//test
    如果你以为第二次输出testOK,那就错啦,String类的’+‘是经过重载的,编译时会还原成StringBuilder的append操作,并且new了一个StringBuilder对象:
    str += "OK";
    str = new StringBuilder(str).append("OK").toString();//编译时会还原成这样
    显然也是对副本重新赋值,并不影响原始的对象。
    使用javap -c反编译一下会很直观:

    6.StringBuffer或StringBuilder作为参数:
        6.1重新赋值
    public static void testStringBuilder(StringBuilder sb)
    {
         sb = new StringBuilder("testOK");
    }
     测试:
    StringBuilder sb = new StringBuilder("test");
    System.out.println(sb.toString());//test
    testStringBuilder(sb);
    System.out.println(sb.toString());//test
       6.2在方法内部调用StringBuffer或StringBuilder的append方法:
    public static void testStringBuilder(StringBuilder sb)
    {
        sb.append("OK");
    }
     测试:
    StringBuilder sb = new StringBuilder("test");
    System.out.println(sb.toString());//test
    testStringBuilder(sb);
    System.out.println(sb.toString());//testOK
    7.交换问题
        经过上面的例子,相信对java参数传递机制比较清楚了,所以请不要再写这样的代码了:
    public static void swap(Integer a, Integer b)
    {
     Integer temp = a;
     a = b;
     b = temp;
    }
    这根本不能交换两个数.



    总结:
    1.如果参数是基本数据类型(包括对应的包装类型),那么参数传递时只是原始值的一份拷贝或者叫副本,对副本操作并不影响原始值;
    2.如果参数是对象(引用类型),那么参数传递时传递的是对象的地址的一份拷贝,所以对对象内部属性的操作会改变原始对象相应值,但是对该参数进行重新赋值并不会影响原始对象;
    3.String类型作为参数进行传递时,传递的也是地址。但是String类比较特殊,对参数进行concat,replace,’+‘等操作时不影响原始的串,对参数重新赋值当然也不影响原始字符串。
    4.数组类型作为参数跟传递对象时一样的。

















    展开全文
  • Java基础(五)Java中的参数传递机制

    千次阅读 多人点赞 2015-08-11 16:02:21
    通过前一篇文章的介绍,我们从整体上明白了,Java类中变量的差异性、...Java方法的参数传递机制Java方法的参数传递只有一种:值传递。所谓值传递,就是将实际参数值的副本,传入方法内,而参数本身不会受到任...
  • Java 参数传递机制

    千次阅读 2011-03-13 08:02:00
    在方法调用时,需要根据方法声明传入适当的参数,通过每次调用方法时传参,极大的...  例如如下代码:  /**  * 参数传递代码示例  */ public class TransferValueDemo {  
  • java参数传递(超经典)

    千次阅读 2021-02-12 12:18:16
    Java中的参数传递机制一直以来大家都争论不休,究竟是“传值”还是“传址(传引用)”,争论的双方各执一词,互不相让。不但“菜鸟”们一头雾水,一些“老鸟”也只知道结果却说不出所以然来。我相信看过下面的内容后,...
  • Java里方法的参数传递方式只有一中——值传递,即是将实际参数复制一份传入方法中,实际参数本身不会受到任何影响,参照C语言中的函数参数传递,形参与实参(当时学的时候真的好晕);
  • 主要介绍了说明Java传递与回调机制的代码示例分享,传递与回调机制Java入门学习中的基础知识,需要的朋友可以参考下
  • Java参数传递——值传递还是址传递? 首先是变量的存储方式 各种变量的存储方式: 基本数据类型: int age = 20; 变量名age和值20都存储在jvm栈中 引用数据类型: 字符串见 ...
  • Java的数据类型和参数传递(详解)

    千次阅读 2021-02-12 15:15:40
    Java提供的数据类型主要分为两大类:基本数据类型和引用数据类型。Java中的基本数据类型名称大小取值范围byte型 (字节)8bit-128-127 (-2^7到2^7-1)short型 (短整型)16bit-2^15到2^15-1int型 (整形)32bit-2^31到2^31-...
  • 方法的参数传递机制测试类,以供大家交流之用。
  • java值的传递机制

    千次阅读 2018-07-29 14:07:55
    规则:java中的参数传递机制:值传递机制  * 1)形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量  * 2)形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)...
  • java参数传递(超经典)

    千次阅读 2021-03-07 01:14:30
    Java中的参数传递机制一直以来大家都争论不休,究竟是“传值”还是“传址(传引用)”,争论的双方各执一词,互不相让。不但“菜鸟”们一头雾水,一些“老鸟”也只知道结果却说不出所以然来。我相信看过下面的内容后,...
  • 上次已经为大家介绍过java中的参数传递机制是什么?实例展示的相关内容,今天在为大家介绍一些和参数有关的内容,也就是java中方法参数如何引用传递,并且通过生动的图片为大家展示。一.首先为大家展示一段代码,如...
  • java参数传递

    2011-11-29 10:09:35
    清晰的描述java参数传递机制,有效地帮助不管是java初学者还是高手解决参数传递疑惑。
  • } } java参数传递机制 值传递,传递过去的是当前一份变量的拷贝,内部改变不影响值 Myclass.java public class Myclass { public static void main(String[] args) { { int a = 10; Person q = new Person(); q.test...
  • java里的方法不能单独存在,调用方法我们使用类或者对象。调用static方法使用类,因为它是属于类级别的方法。 没有static的普通方法,使用对象进行调用,不能使用类直接调用,它是属于对象级别的。 ​像我们上面的玩...
  • 两类参数传递 参数传递主要分为两种:一种是参数是基本类型,一种是参数为引用类型。 基本数据类型 这个相信大家都没什么问题,基本类型作为参数传递的时候是在一个方法栈中开辟了一块新内存,拷贝了原来的数据值...
  • 序:这个问题确实不容易理解,各种代码实验啊,和c语言比较啊,面试题啊,内存...}其次,方法调用是分支,总要回到main这条主线,方法调用前后要保证main主线中param是逻辑正确的所以java心里想,管你参数用param想干嘛
  • Java的实参、形参和参数传递机制

    千次阅读 2018-12-29 01:16:31
    1.形参:用来接收调用该方法是传递参数。在被调用时才分配内存空间,一旦调用结束就释放内存,作用域为方法内部。 public void swapValue(int a, int b) { int temp = b; b = a; a = temp; System.out....
  • Java学习笔记(十)——方法的参数传递机制

    万次阅读 热门讨论 2017-11-15 10:38:33
    在之前用C++的时候,参数传递...Java参数传递机制只有一种:值传递。值传递就是将实际参数值得副本传入方法内,而参数本身不会受到任何影响。 基本数据类型参数传递 举个栗子: public class PrimitiveTrans...
  • 参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。写它是为了揭穿普遍存在的一种神话,即认为 Java 应用程序按引用传递参数,以避免因依赖“按引用传递”这一行为而导致的...
  • import java.util.Arrays; class MyData { int a = 10; } public class Exam { public static void main(String[] args) { int i = 1; String str = "hello"; Integer num = 200; int[] arr = {1,2,3,4...
  • 本问题已经有最佳答案,请猛点这里访问。Possible Duplicate:Is Java"pass-by-reference"?数组不是Java中的原始类型,但它们也不是对象...所有参数传递都是按值传递的。在对象的情况下,传递的是对该对象(即指针)的...
  • 如果声明方法时包含来了形参声明,则调用方法时必须给这些形参指定参数值,调用方法时传给形参的参数值也被称为shican  Java 编程语言只有值传递参数。... Java参数,不管是原始类型还是引用类型
  • Java中并没有传递引用这一说,只有一种参数传递机制,就是按值传递 首先,最主要要强调的一点就是,Java 应用程序有且仅有的一种参数传递机制,并没有传递引用这一说。造成这一误解,主要是因为有这么一概念------...
  • 第1关:学习-Java类和对象之参数传值机制之求球面积 100 过关任务 参考答案 评论 任务描述 相关知识 形参和实参 值传递和引用传递 基本数据类型参数的传值 引用类型参数的传值 编程要求 测试说明 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 282,211
精华内容 112,884
关键字:

java参数传递机制