精华内容
下载资源
问答
  • 形参的改变不影响实参
    千次阅读
    2020-08-26 21:16:02

    形参

    所谓形参,就是形式参数,在你没有调用它的时候他是没有值的。

    实参

    可以理解为你创建的变量就是实参,有具体的值。就算你不赋值他也会有默认的初始值。

    形参会不会影响实参?

    答案是:会!
    但是并不是全部都会影响
    形参不会影响基本数据类型的实参

    public static void changeNumber(int num) {
            num = 10;
            System.out.println("执行change方法时" + num);
        }
    
    
        public static void main(String[] args) {
            /*基本数据类型*/
            int num = 1;
            System.out.println("执行方法前:" + num);
            changeNumber(num);
            System.out.println("执行方法后:" + num);
        }
    

    输出结果

    执行方法前:1
    执行change方法时10
    执行方法后:1
    

    结果显示基本数据类型时,形参并不会影响实参。
    形参可以影响引用类型的实参

        public static void main(String[] args) {
            /*引用数据类型*/
            StringBuffer stringBuffer = new StringBuffer("abc");
            System.out.println("执行方法前:"+stringBuffer);
            changeString(stringBuffer);
            System.out.println("执行方法后:"+stringBuffer);
        }
    
    
        public static void changeStringBuffer(StringBuffer stringBuffer){
            stringBuffer.append("def");
            System.out.println("执行方法时:"+stringBuffer);
        }
    

    输出结果

    执行方法前:abc
    执行方法时:abcdef
    执行方法后:abcdef
    

    形参影响了引用类型的实参!
    下一个例子!

    public static void main(String[] args) {  
            /*引用数据类型*/
            String string = "abc";
            System.out.println("执行方法前"+string);
            changeString(string);
            System.out.println("执行方法后"+string);
        }
        public static void changeString(String string) {
            string = string.concat("def");
            System.out.println("执行方法时" + string);
    
        }
    

    执行结果:

    执行方法前abc
    执行方法时abcdef
    执行方法后abc
    

    形参没有影响引用类型的实参?
    那么什么情况下才会有 形参影响实参呢?
    这就要考虑到底是怎么改变的。
    首先要知道引用数据类型,变量存储的只是一个地址值!
    形参只有在执行的时候才会创建一个临时的空间存储这个形式参数,方法结束这个形式参数的生命周期就结束了。那么形式参数影响实参的时机就肯定是在这个生命周期内!
    一步一步考虑,调用方法的时候需要将实参传入方法,让形参暂时有一个值,因为是引用数据类型,所以形参此时存储的是和实参一样的地址值。
    此时形式参数进行一系列的操作都是对堆空间中的同一个内容进行操作的,所以如果形式参数对堆空间的值修改了,那么实参再查看堆空间里面的数据的时候就是已经被改变过了的数据。这就是为什么StringBuffer受到了形参的影响的原因。
    那么为什么String就没有受到影响呢?
    changeString()方法种,执行的是String的concat方法。

        public String concat(String str) {
            int otherLen = str.length();
            if (otherLen == 0) {
                return this;
            }
            int len = value.length;
            char buf[] = Arrays.copyOf(value, len + otherLen);
            str.getChars(buf, len);
            return new String(buf, true);
        }
    

    这是String类中的concat方法,怎么处理的不用看明白,直接看他的返回值

    return new String(buf, true);
    

    new是干嘛的?创建了新的对象啊!创建对象就是再堆空间新开辟空间了呀!
    这就意味着此时形参存储的地址值现在已经不再是最开始实参给他的地址值了,不管他在怎么操作都是对一个新的堆空间地址中的数据进行操作,原来的实参的堆空间的数据没有发生过改变,所以方法结束后,实参的内容并没有发生改变。
    总结来说就是形参影响引用数据类型的实参,要看地址值是不是发生了改变,如果形参的地址值发生了改变,那么形参就不会影响实参,如果形参的地址值没有发生改变,那他就会影响实参。

    总结

    形参并不会影响基本数据类型的实参。
    形参只有在存储的地址值不发生变化的时候才会影响实参。

    更多相关内容
  • java形参改变影响实参吗?

    千次阅读 2021-05-07 11:42:27
    java形参改变影响实参吗? 昨天做题的时候遇到了这个问题(如图所示),传入的参数是int[]数组,实参跟着形参一起改变了。但是之前传入int型参数时形参改变是不会影响实参的。所以想探究一下这个问题,到底...

    java形参的改变会影响实参吗?

    昨天做题的时候遇到了这个问题(如图所示),传入的参数是int[]数组,实参跟着形参一起改变了。但是之前传入int型参数时形参的改变是不会影响实参的。所以想探究一下这个问题,到底什么情况下形参的改变会影响实参。参数是int[]数组

    1. 形参和实参:首先分清楚形参和实参区别。简要来说形参就是定义方法的时候用到的参数,方法被调用时就是靠它来接收传入的参数。例如上图中的reverse(int[] arr,int k),这里的arr和k就是形参。实参就是调用方法时传进去的参数。例如上图中的reverse(arr,k),这里的arr和k是实参。
    2. 值传递和引用传递: 值传递就是在调用方法时,实参把它的值给到形参,形参把这个值拷贝一份,再拿到方法里用。所以传参之后它俩互不相关了,形参的改变就不会影响到实参。而引用传递,在调用方法时传递的是值的引用,也就是说形参拿到的是实参所对应的内存空间的地址,那么传参之后形参和实参指向的就是同一个内存空间,理所当然实参会跟形参一起改变。

    分清了值传递和引用传递之后再来看文章开头说的int[]和int类型的参数有什么区别。
    当参数为int[]数组:

    // int[]数组作为参数
    public static void main(String[] args){
       	int[] arr = {3,2,1,4}; 
       	reverse(arr,3);
       	System.out.println("翻转后数组为:");
       	for(int i : arr) {
       		System.out.print(i);
       	}
          }
          //翻转数组从0到k-1
          public static void  reverse(int[] arr,int k) {
       	   int i = 0,j=k-1;
       	   int temp=0;
       	   while(i<j) {
       		  temp= arr[i];
       		  arr[i]=arr[j];
       		  arr[j]=temp;
       		  i++;
       		  j--;
       	   }
          }
    

    输出结果:
    在这里插入图片描述
    可见调用方法之后实参跟着形参一起被修改了。

    当参数为int数值:

    // 当参数为int型
     public static void main(String[] args){
    		int a = 0;
    		changeInt(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeInt(int a) {
    		   a=100;
    		   System.out.println("changeInt方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    可见形参虽然被修改了,但是实参还是原来的值,并没有一起被修改。

    发生这样的情况,原因在于:数组是引用类型,它作为参数时发生的传递是引用传递;而int是基本类型,它作为参数时发生的传递是值传递。

    特别:需要注意的是封装类和String类比较特殊,虽然是引用类型,但是由于其本质是由final修饰的,不能被修改,所以作为传参时实参是不会跟随形参发生改变的。
    例如Integer作为参数:

     public static void main(String[] args){
    		Integer a = 0;
    		changeInt(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeInt(Integer a) {		
    		   a=100;
    		   System.out.println("changeInt方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    String作为参数:

      public static void main(String[] args){
    		String a = "0";
    		changeString(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeString(String a) {		
    		   a="100";
    		   System.out.println("changeString方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    总结:例如数组之类的引用类型作为参数时,形参的修改会影响实参;而基本类型和特别的引用类型(封装类、String类)作为参数时,形参的修改不会影响实参。

    关于封装类的地址传递参考链接: Interger是值传递还是地址(引用)传递?

    展开全文
  • 浅谈c++中形参不改变实参

    千次阅读 2020-04-03 18:48:52
    c语言我们都知道形参不改变实参,实参能改变形参,我们能保证自己很熟悉这个概念吗,能能保证自己每次都犯错,掉坑里。 #include <iostream.h> #include <string.h> void fun( char *s) { char a...

    c语言我们都知道形参不能改变实参,实参能改变形参,我们能保证自己很熟悉这个概念吗,能不能保证自己每次都不犯错,掉坑里。
    #include <iostream.h>
    #include <string.h>
    void fun( char *s)
    {
    char a[10];
    strcpy ( a, “AAAAAA” );
    cout<<“形参未改变,实参传递给实参的值:”<<s<<endl;
    s=a;
    cout<<"形参改变后字符串后的值: "<<s<<endl;
    }
    main( )
    {
    char *p= “BBBBBB” ;
    fun( p );
    cout<<"实参在形参被改变后的值: "<<p<<endl;
    }
    这是我自己写的实参改变形参的一段代码,末尾我会附上运行截图
    在谈论这个问题前先明确几个概念

    形参是什么?
    形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。

    实参是什么?
    实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使实参获得确定值。

    要实现调用函数,形参传递到实参要注意的事项有哪些?

    实参的类型,数量定义的顺序都是不能改变的,这样才能调用,不然会出现不匹配错误,比如定义一个函数
    void ss(int a,char c) //a和c就是形参
    我们在调用的时候就要提前定义实参,严格按照 整形,字符型的顺序才能调用
    int f;
    char v;
    ss(f,v);//f和v就是实参
    参数的传递方向是单向的,只能从实参传到形参(不要妄想形参反客为主改变实参,那是不可能的,之后用代码进一步证明)

    附上我写的字符串复制的例子,感兴趣的话可以自己实践一下,也可以复制我的操作一下

    简单解释一下我的这个指针指向的例子
    实参p是字符型指针,赋给初始值为BBBBBB,然后利用函数,形参为字符型指针s,形参改变实参的证明就是我们没给s赋初值但是初始值为实参的值,这里输出BBBBBB,所以实参改变了形参;

    s初始值和实参一样为BBBBBB,我们这里继续改变形参的值,改为AAAAAA,输出,发现形参s改变成AAAAAA;

    我们都知道C语言是从上到下按顺序执行的,我们在main函数调用函数后来看一下有没有通过改变形参的值改变了实参,输出实参p,实际上没有改变,实参p的值依然是BBBBBB,所以实参并没有受到改变;

    本人很菜,有什么不完全或者有误的地方请指出,有问题请留言或者私聊我,写作不易,有帮助的话请留下一个赞,谢谢。
    附上我的运行截图帮助理解:

    在这里插入图片描述

    展开全文
  • 这篇文章就是想说一个结论,结论就是标题 —— Java形参改变不会影响实参下面通过代码来理解这个结论。 public class Main { public static void main(String[] args) { int a = 10; int b = 20; System.out....

    这篇文章就是想说一个结论,结论就是标题 —— Java形参的改变不会影响实参下面通过代码来理解这个结论。

    public class Main {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            System.out.println("交换前a = " + a);
            System.out.println("交换前b = " + b);
            
            exchange(a,b);
            System.out.println("交换后a = " + a);
            System.out.println("交换后b = " + b);
        }
        public static void exchange(int a, int b){
            int temp = a;
            a = b;
            b = temp;
        }
    }
    

    运行结果如下:
    在这里插入图片描述
    下面通过栈帧的角度去理解为什么实参a,b的值为什么没有互换成功:
    在这里插入图片描述
    main中a,b就没有动过。
    改变的是方法exchange()中a,b的值。
    所以Java形参的改变不会影响实参。

    展开全文
  • 形参实参影响

    千次阅读 2020-12-25 20:26:44
    形参改变一般不会影响实参改变。 传值 void fun1(int a,int b) { int t; t = a; a = b; b = t; } int main() { int a=4,b=3; fun1(a,b); printf("%d %d\n",a,b); return 0; } 输出:4 3 由上面的例子...
  • 对于基本数据类型的参数,形参改变不影响实参的值。 public class comDemo { public static void main(String[] args) { int number = 100; System.out.println("调用change方法前"+number); change(number...
  • 形参实参

    千次阅读 多人点赞 2021-04-18 17:06:52
    形参变量: 形参变量是功能函数里的变量,只有在被调用的时候才分配内存单元,调用结束后立即释放。所以形参只在函数内部...举例一:(形参不改变实参) 看看下面这段代码中实参和形参的位置, 这个过程中实参并
  • 一、基本数据类型 public static void main(String[] args) { int num=10; change(num); System.out.println("num:"+num);...当change方法创建形参num后,实参num会将自己的值直接传递给形参num
  • 形参如何改变实参

    2021-12-17 21:34:45
    形参实参
  • 关于值传递形参不改变实参原理及如何使用地址传递修改实参
  • 形参的值改变不影响实参的值,不是为了说明,形参的值改变,调用函数进行计算出来的值不变,而是为了说明,形参实参同名的情况下,改变形参的值实参的值不变。 34 在C语言中,只有在使用时才占用内存单元的...
  • 故:引用类型的形参的引用地址与实参一样时,形参改变影响实参(非String和基本类型) 举例:如果change2的方法中写的是 arr = new String[]{}; 也就是 private voidchange2(String[] arr){//arr[1] = "lll"; ...
  • JAVA:形参改变实参影响

    千次阅读 2020-12-22 14:08:40
    JAVA:形参改变实参影响 熟悉C/C++的同学都知道,如果想在传入形参的函数中,实现形参改变,实参也跟着改变的话,我们需要手动将实参的地址或引用传入给形参,这样形参生成的拷贝副本,就是实参指向存储单元的...
  • 形参改变如何影响实参

    千次阅读 多人点赞 2016-08-10 21:24:04
    在编程中,形参改变是无法影响实参的,那么有什么办法能将数据返还给调用自己的上层函数呢? 通过return,全局变量,指针,引用即可。 return的缺点是每次只能返回一个参数;如果想返回多个,可能需要将数据存入...
  • 1.修改值类型,这个实参是完全无法修改的 2.当形参传递的是引用类型时,修改形参的内容,实参...只有传递给形参的是实参的地址的时候,对形参的修改才能改变实参,当形参不指向实参的地址时,修改形参也没用了。 ...
  • 四、传递对象发生修改情况 代码: public class UserTest {  public static void main(String[] args){  User user=new User("hanmeimei",29);  System.out.println(user);  method(user);  ...
  • c语言说形参不改变实参的值,为什么这个赋值语句可以0cpystr(q1;printf("cpystr(char *p1,*q2,char *p2){while(*p2++=*p1++);,b),q2);}main(){char *q1=&quot.h>,b[20],q1;q2=b;%s %s"china"stdio#include&...
  • 对属性赋值 function changeVal(params) { params.name = 'lisi' } let obj = {name: 'zhangsan'} changeVal(obj) console.log(obj.name) // lisi 2. 对变量赋值 function changeVal(params) { ...
  • 如题,C语言在函数间传递参数时,形参的变化是不会改变实参的值的!!! 如: include void main(){  void swap(int,int);  int a,b;  scanf("%d,%d",&a,&b);  swap(a,b);  } void swap(int a,int b){  int ...
  • 形参不能传任何东西给实参实参传过去的东西都是一个副本!!! 下面以一个交换数据的被调函数片段为例 在指针变量由实参传递给形参时传过去的实际是指针变量的值,即一个地址,在 t=*p1 *p1=*p2 *p2=t 的过程中实际是...
  • 实参:可以是常量、变量、表达式、函数等, 无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的.../*** 注意:* 传递参数:形参(方法中)的改变有没有影响实参(main函数中)* 1.基本数据类型 没有影响* ...
  • 自定义一个测试函数,通过对比形参实参的ID来研究修改形参实参影响。 def test(a) : print("a =",a,id(a)) c = 20 test(c) print("c =",c,id(c)) a = 20 140707504189792 c = 20 140707504189792 传参后a...
  • Java中将实参传给方法之后,值发生改变是在方法里面,没有影响实参。 栈内存的特点是先进后出,如同装东西一样,最先装进去的东西往往是最后出来的 附上测试代码: public class Test { public static ...
  • 下面小编就为大家带来一篇c++指针使用形参改变实参的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。 形式参数(形参): 形式参数是指函数名后括号中的变量,因为形式参数只有在函数被调用的过程中才实例化(分配内存单元...
  • 当函数需要用形参改变实参时,简单的传值能解觉问题。这时就需要使用指针解决问题。 例:int a=10;b=20;要求写一个函数将a,b的值互换。 错误代码: 1. //交换失败,原因a,b仅仅只是赋值,main中的a和Swap中的a不是...
  • 必备知识:c语言中的函数调用和...函数的一个功能就是传递数值进行运算,那么我们如何利用函数和指针变量通过形参变量的值改变实参变量的值呢?首先,让我们先举一个例子。#includeint main(){void func(int a,int ...
  • 1.当使用基本数据类型作为参数传递时,形参变量的改变不会影响实参的数值; 即如果形参是基本类型或者String,则实参不会变(传的是值) public class Test { public static void main(String[] args) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,958
精华内容 27,583
热门标签
关键字:

形参的改变不影响实参