精华内容
下载资源
问答
  • 主要介绍了Java参数传递及值传递实现原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了详解java值传递、地址传递、引用传递的相关资料,需要的朋友可以参考下
  • 主要介绍了 Java 值传递和引用传递详解及实例代码的相关资料,需要的朋友可以参考下
  • 主要为大家详细介绍了Java值传递和引用传递,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java值传递和引用传递

    千次阅读 2018-08-20 10:35:24
    通过这两天的实习面试,发现自己的基础实在烂的不行,先不打算投简历了,安安心心的在家学了几个月,把最基本的东西全部搞懂再说。之前看到别人也在写类似的模块,觉得挺好的,因此我打算每天(也有可能几...值传递 ...

    通过这两天的实习面试,发现自己的基础实在烂的不行,先不打算投简历了,安安心心的在家学了几个月,把最基本的东西全部搞懂再说。之前看到别人也在写类似的模块,觉得挺好的,因此我打算每天(也有可能几天…)整理一个常考的知识点,帮助自己整理和巩固,加油把

    一、前言

    先分清楚两个概念

    • 按值传递:方法接收的是调用者提供的值
    • 按引用传递:方法接收的是调用者提供的变量地址

    《Java 核心技术》中说:“Java程序设计语言总是采用按值来调用的,即,方法得到的是所有参数值的一个拷贝。因为传递过来的相当于是一个副本,因此方法只能改变这个副本所对应的值或者对象。

    二、分析

    2.1 将基本数据类型作为参数传递

    我们可以直接看一个值传递的例子

    public void swap(int x, int y) {
    	int temp = x;
    	x = y;
    	y = temp;
    }
    	
    @Test
    void testObject() {
    	int a = 100;
    	int b = 200;
    	swap(100, 200);
    	System.out.println("a: " + a);
    	System.out.println("b: " + b);
    }
    
    //输出
    a: 100
    b: 200
    

    可见,a 和 b 的值在经过“所谓的”交换函数之后,并没能把值交互。这是为什么呢?

    这就是因为java是值传递的。也就是说,我们在调用一个需要传递参数的函数时,传递给函数的参数并不是我们传进去的参数本身,而是它的副本。

    以这个例子来说,当我们调用 swap 这个函数时,并不是传入的真正的 a 和 b 这两个参数,而是他们俩的复制品,比如我们定义这两个复制品为 x 和 y,此时 x 会指向另一个 100,y 会指向另一个 200。之后在方法 swap 中的所有操作,其实都是基于这两个复制出来的变量 x 和 y 进行着的。尽管 x 和 y 的值确实交换了,但是他们值的改变并不能影响到 a 和 b。

    再来看一个例子:

    void foo(int val) {
    	val = 100;
    }
    
    void foo1(String text) {
    	text = "win";
    }
    
    @Test
    public void print() {
    	int val = 200;
    	foo(val);
    	System.out.println(val);
    	
    	String text = "hello";
    	foo1(text);
    	System.out.println(text);
    }
    

    无可厚非,输出分别是 200 和 hello。可以用图片来描述一下流程

    首先,在调用方法之前,会先创建一个形参 val

    当调用 foo 函数的时候,实参 val 将自身的值拷贝一份,将拷贝的副本传给形参
    这里写图片描述

    当执行函数中的语句时,其实都是对拷贝的那个参数,即形参 val 进行赋值,可以看到,我们将他直接变为了 100,而实际的参数 val,还是原来的 200
    这里写图片描述

    2.2 将对象引用作为参数传递

    顾名思义,就是方法的参数是一个类的引用

    class People {
    	int age;
    }
    
    @Test
    void testObject() {
    	People p1 = new People();
    	People p2 = new People();
    	p1.age = 10;
    	p2.age = 15;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    	
    	p1 = p2;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    	
    	p1.age = 30;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    }
    
    //输出
    p1.age: 10 p2.age: 15
    p1.age: 15 p2.age: 15
    p1.age: 30 p2.age: 30
    

    通过图示我们可以分析一下

    首先在栈中建立两个引用 p1 和 p2,分别指向堆中 new 出来的对象
    这里写图片描述

    执行 p1=p2 这个语句,把栈中 p1 指向 p2 在堆中指向的位置,即第二个 People 对象,此时 p1 和 p2 都指向了堆中第二个 People 对象
    这里写图片描述

    执行 p1.age=30 这个语句,即把第二个 People 对象的 age 属性变为30,由于 p1 和 p2 都指向这个对象,因此 p1 和 p2 的 age 属性都是 30
    这里写图片描述

    我们可以再来看一个例子

    void foo(StringBuffer stringBuffer) {
    	stringBuffer.append("world");
    }
    
    @Test
    void bufferTest2() {
    	StringBuffer sb = new StringBuffer("hello");
    	foo(sb);
    	System.out.println(sb);
    }
    

    输出结果是 helloworld,表明原来的值已被改变。照例,我们画个图

    一开始,栈中的 StringBuffer 引用指向堆中的 StringBuffer 对象,该对象里面的值为 “hello”
    这里写图片描述

    当使用方法时,形参会先产生一个 StringBuffer 引用 stringBuffer,然后指向堆中的对象
    这里写图片描述

    然后调用方法,append 方法直接改变的就是原来 String 的值。可以看到,此时堆中 StringBuffer 对象中的值已经改变,此时两个引用 sb 和 stringBuffer 都指向同一个对象
    这里写图片描述

    我们再来看另一个例子

    void foo1(StringBuffer stringBuffer) {
    	stringBuffer = new StringBuffer("world");
    }
    
    @Test
    void bufferTest2() {
    	StringBuffer sb = new StringBuffer("hello");
    	
    	foo1(sb);
    	System.out.println(sb);
    }
    

    此时输出的值没有改变,还是 “hello”。这是为什么呢?

    当调用 fool 方法的时候,实际在栈中又新创建了一个 StringBuffer 的引用 stringBuffer,这个引用重新指向了一个新的 StringBuffer 对象。
    这里写图片描述

    所以即使当执行方法之后,输出 sb,依旧还是原来的 sb 指向的对象中的值,即 “hello”

    2.3 值传递和引用传递

    由于 C++ 有值传递和引用传递两种方式,那么 Java 呢?实际上,Java 是采用的值传递

    class Employee {
        int x;
    
        Employee(int a) {
            this.x = a;
        }
    }
    
    public class ObjectTest2 {
        static void swap(Employee x, Employee y){
            Employee temp = x;
            x = y;
            y = temp;
        }
    
        public static void main(String[] args) {
            Employee employee = new Employee(100);
            Employee employee1 = new Employee(200);
            System.out.println("交换前:" + employee.x + " " + employee1.x);
            swap(employee, employee1);
            System.out.println("交换后:" + employee.x + " " + employee1.x);
        }
    }
    

    结果是:

    交换前:100 200
    交换后:100 200
    

    这个例子很明显,如果 Java 是引用传递,那么在调用完那个方法之后,应该可以实现数据的交换,但实际上,并没有交换。

    可以看到,两个对象引用传到方法之后,拷贝出了两个对象引用 x, y,x 指向 的是第一个 Employee 对象,y指向的是第二个。然后 swap() 方法中交换的其实仅仅是拷贝所指向的地址

    最后,方法结束,x 和 y 也被回收,而最原始的两个对象引用 employee 和 employee1 还是指向之前的两个对象

    那为什么不是引用传递呢?

    其实可以联想一下 C++ 是如何进行引用传递的

    void swap(int *p1, int *p2){
        int *temp;
        temp = p1;
        p1 = p2;
        p2 = temp;
    }
    

    可以看到,同样也是传入两个参数的地址,然后直接改变两个参数所在的内存地址。这个时候从内存中取出对应的数值应该就是相反的值了

    然后我们再看 Java,同样传入的是地址,那么他是如何实现的呢?传入一个引用,拷贝一份,再传入一个,再拷贝一个,之后的事情就很简单了,直接对拷贝的引用所指向的对象进行操作。因此,他和 C++ 的引用传递是是不一样的。

    因此,Java 本至上还是值传递

    结论
    • 一个方法不能修改一个基本数据类型的参数
    • 一个方法可以改变一个对象参数的状态
    • 一个方法不能让对象参数引用一个新的对象
    展开全文
  • 与其他语言不同,Java不允许程序员选择按值传递还是按引用传递各个参数,基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言,不是将对象本身传递给方法,而是将对象的...

    许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。

     

    与其他语言不同,Java不允许程序员选择按值传递还是按引用传递各个参数,基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言,不是将对象本身传递给方法,而是将对象的的引用或者说对象的首地址传递给方法,引用本身是按值传递的-----------也就是说,讲引用的副本传递给方法(副本就是说明对象此时有两个引用了),通过对象的引用,方法可以直接操作该对象(当操作该对象时才能改变该对象,而操作引用时源对象是没有改变的)。

     

    现在说说数组:如果将单个基本类型数组的元素传递给方法,并在方法中对其进行修改,则在被调用方法结束执行时,该元素中存储的并不是修改后的值,因为这种元素是按值传递,如果传递的是数组的引用,则对数组元素的后续修改可以在原始数组中反映出来(因为数组本身就是个对象,int[] a = new int[2];,这里面的int是数组元素的类型,而数组元素的修改是操作对象)。

     

    对于单个非基本类型数组的元素在方法中修改,则在被调用方法结束执行时,该元素中存储的是修改后的值,因为这种元素是按引用传递的,对象的改动将在源数组的数组元素中反映出来。

     

    下面看个小程序:

    public class Test{
        
        String str = new String("good");
        char[] ch = {'a','b','c'};
        int i = 10;
        public void change(String str,char[] ch,int i){
        
            str = "test ok";
            ch[0] = 'g';
            i++;    
        }
        
        public static void main(String[] args){
        
            Test tt = new Test();
            tt.change(tt.str,tt.ch,tt.i);
            System.out.println(tt.i);
            System.out.print(tt.str+" and ");
            System.out.println(tt.ch);     
        }
    }


    str是String类型的引用,i是基本类型变量,ch是数组名,也是数组对象的引用

    在chang()方法里,str="test ok",是一个新的对象把首地址放在引用变量str上;

    而ch[0]='g';因为传的是数组的引用,而此时ch[0]='g';是对数组元素的操作,能修改源数组的内容;

    i是整型值,只是把值copy了一份给方法,在方法的变化是不改变的源i的。

    所以结果是:

    10
    
    good and gbc

     

    现在咱们把代码变化一下:

    public class Test{
        
        String str = new String("good");
        char[] ch = {'a','b','c'};
        int i = 10;
        public void change(String str,char ch,int i){
        
            str = "test ok";
            ch = 'g';
            this.i = i+1;    
        }
        
        public static void main(String[] args){
        
            Test tt = new Test();
            tt.change(tt.str,tt.ch[0],tt.i);
            System.out.println(tt.i);
            System.out.print(tt.str+" and ");
            System.out.println(tt.ch);     
        }
    }
    

    仔细观察下实参以及入参有何变化?

    change()方法里的入参char[] ch变成--------------char ch;

    这次传递的是个char值的单个数组元素,按照上面的解析,此时ch='9';是不影响源数组元素的。

    this.i = i+1;这里面等号左边的i是属性i,等号右边的i是局部变量(入参里的i);

    此时i+1后赋值给属性的i,自然会改变属性i的值,同时17行,tt.i又是调用属性的i,这次的结果是:

    11
    
    good and abc

    现在是不是有点明白了?

    那好再看下面一个小程序

    public class Test{
        
        public void change(StringBuffer x,StringBuffer y){
            
            x.append(y);
            y=x;    
        }
        public static void main(String[] args){
        
            StringBuffer buffA = new StringBuffer("a");
            StringBuffer buffB = new StringBuffer("b");
            new Test().change(buffA,buffB);
            System.out.println(buffA+","+buffB);   
        }
    }


    这次传递的是两个对象的引用的值,

    在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。

     y=x;是一个修改内容的对象把首地址赋值给引用变量y了,此时操作的是引用,而先前y是new StringBuffer("b");的引用变量,所以输出结果是:

    ab,b

    下面是个稍难的小程序,先自己用笔画画过程,写出自己的结果,而后再上机操作下,如果自己的结果和在电脑上的结果一样,那么再碰到这类题就不难了,如果不一样,回头仔细体会下我前面的讲解,找找原因。

    public class Test{
        
        private String nn = new String("1");
        private String[] mm = {"2","5"};
        
        void test(String nn,String[] mm){
            
            nn = new String("3");
            this.nn = "9";
            
            mm[0] = "4";
            System.out.println("in test(),mm[0]: "+mm[0]);
            mm = new String[]{"8","7"};
            System.out.println("in test(),nn: "+nn);
            System.out.println("this.nn: "+this.nn);
            System.out.println("mm[0]: "+mm[0]);
        }
        
        public static void main(String[] args){
            
            Test s = new Test();
            s.test(s.nn,s.mm);
            System.out.println(s.nn+"  "+s.mm[0]);
        }
    }

     

    转载于:https://my.oschina.net/u/2935389/blog/3030265

    展开全文
  • java值传递和引用传递 面试题

    千次阅读 2017-05-21 10:53:12
    某坑公司的面试题如下 我认真了想想,这无非就是Java值传递和引用传递,利用反射是可以做到的 反射public static void doSomethingReflect(Integer a, Integer b) throws Exception { Field field = a.getClass...

    前言

    某坑公司的面试题如下

    这里写图片描述

    我认真了想想,这无非就是Java 的值传递和引用传递,利用反射是可以做到的

    反射

    public static void doSomethingReflect(Integer a, Integer b) throws Exception {
            Field field = a.getClass().getDeclaredField("value");
            field.setAccessible(true);
            field.set(a, 400);
    
            Field fieldb = b.getClass().getDeclaredField("value");
            fieldb.setAccessible(true);
            fieldb.set(b, 500);
        }

    jni

    public class JniMain {
    
        public static void main(String[] args) {
            int a, b;
            a = 4;
            b = 5;
            doSomething(a, b);
            System.out.println(String.format("a = %s ; b= %s ", a, b));
        }
    
        private static void doSomething(int a, int b) {
            System.load(JniMain.class.getResource("JniMain.jnilib").getPath());
            doSomethingInC(a, b);
        }
    
        static native int doSomethingInC(Integer a, Integer b);
    }
    #include <jni.h>
    #include "jni_JniMain.h"
    
    
    JNIEXPORT jint JNICALL Java_jni_JniMain_doSomethingInC
      (JNIEnv *env, jobject thiz, jobject p1, jobject p2){
    
        jclass c;
        jfieldID id;
        c = (*env)->FindClass(env,"java/lang/Integer");
        if (c==NULL)
        {
            return -1;
        }
    
        id = (*env)->GetFieldID(env,c, "value", "I");
        if (id==NULL)
        {
            return -1;
        }
    
        (*env)->SetIntField(env,p1, id, 400);
        (*env)->SetIntField(env,p2, id, 500);
      }

    Done

    展开全文
  • java中都是值传递,它是继承于c++但是移除出了很多难懂的语法, js也是值传递; 1.啥叫值传递啊: 顾名思义,就是值的传递,基本类型,引用类型,在创建出来,就是存在于当前方法所在的栈帧,就是调用其他方法,传的...
  • Java 值传递和对象传递详解

    千次阅读 2016-05-12 17:46:04
    堆和栈:Java中基本数据类型的和对象的引用保存在栈中,具体对象保存在堆中。传递原理: 一个方法传递的参数如果是基本数据类型,则是对具体的拷贝;如果是对象数据类型,则是对对象引用地址的拷贝,而非...

    1、需要明白的概念:
    堆和栈:Java中基本数据类型的值和对象的引用保存在栈中,具体对象值保存在堆中。

    传递原理:
    一个方法传递的参数如果是基本数据类型,则是对具体值的拷贝;如果是对象数据类型,则是对对象引用地址值的拷贝,而非具体值拷贝。下面分析三种情况:

    ①一个方法不能改变传入基本类型的参数值。
    示例代码:

    public class Test2 {
    
        public static void main(String[] args) {
            int a = 1;
            System.out.println("--->>>before a:"+a);
            change(a);
            System.out.println("--->>>after a:"+a);
        }
    
    
        private static void change(int b){
            b = 2;
            System.out.println("--->>>current b:"+b);
        }
    
    }

    打印:

    --->>>before a:1
    --->>>current b:2
    --->>>after a:1

    图解:
    这里写图片描述
    说明:
    b=2单独开了一片空间,和a没有任何关系,所以改变b是不会对a的值有任何影响的。

    ②一个方法不能改变传入对象类型的参数的引用地址。
    示例代码:

    public class Test3 {
    
        public static void main(String[] args) {
            Person pa = new Person("张三");
            System.out.println("--->>>before pa:"+pa.getName());
            change(pa);
            System.out.println("--->>>after pa:"+pa.getName());
        }
    
    
        private static void change(Person pb){
            Person pc = new Person("李四");
            pb = pc;
            System.out.println("--->>>current pc:"+pc.getName());
            System.out.println("--->>>current pb:"+pb.getName());
        }
    
        public static class Person{
            private String name;
    
            public Person(String name){
                this.name = name;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
        }

    打印:

    --->>>before pa:张三
    --->>>current pc:李四
    --->>>current pb:李四
    --->>>after pa:张三

    图解:这里写图片描述

    说明:
    当开始调用change(pa)的时候,实际上是将pa的地址拷贝了一份然后给了pb,所以pa和pb都指向张三;
    pc是从新new的,会重新开辟栈区和堆区的空间;
    然后经过pb = pc的赋值操作后,实际上是让他们同时指向堆区的李四。

    ③一个方法能够改变传入对象类型的参数某一个属性。
    实例代码:

    public class Test4 {
    
        public static void main(String[] args) {
            Person pa = new Person("张三");
            System.out.println("--->>>before pa:"+pa.getName());
            change(pa);
            System.out.println("--->>>after pa:"+pa.getName());
        }
    
    
        private static void change(Person pb){
            pb.setName("李四");
            System.out.println("--->>>current pb:"+pb.getName());
        }
    
        public static class Person{
            private String name;
    
            public Person(String name){
                this.name = name;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
        }
    
    }

    打印:

    --->>>before pa:张三
    --->>>current pb:李四
    --->>>after pa:李四

    图解:
    这里写图片描述
    说明:
    调用change(pa)方法后,实际上是将pa的地址拷贝了一份然后给了pb,所以pa和pb都指向张三;
    调用pb.setName(“李四”)后,实际上是将张三变成了李四,pa和pb引用地址不变,所以pa和pb都指向了李四。

    总结:
    ①一个方法不能改变传入基本类型的参数值。

    ②一个方法不能改变传入对象类型的参数的引用地址。

    ③一个方法能够改变传入对象类型的参数某一个属性。

    展开全文
  • 主要介绍了java通过实例了解值传递和引用传递,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java值传递和引用传递基础分析

    千次阅读 2017-08-29 21:51:36
    针对Java中值传递和引用传递进行简单分析总结
  • Java值传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到值传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对...当然如果针对 Java 语言本身来讲,Java 中只有 值传递,没有...
  • Java 值传递 & 引用传递 引发的思考

    千次阅读 多人点赞 2019-12-21 20:57:24
    这是一篇正经又带点幽默的文章,希望各位观众老爷们喜欢。 Java 到底是值传递还是引用传递,这是一个问题。 本文先由概念出发,穿插Java内存结构,最后举例探讨该问题。
  • Java值传递和引用传递详细说明

    千次阅读 多人点赞 2020-07-14 15:53:17
    学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运用却解释不出原理,而且坊间讨论的话题又是充满争议:有的论坛帖子说Java只有值传递,...
  • JAVA参数传递方式 (按值传递与引用传递区别)

    千次阅读 多人点赞 2018-09-30 22:58:30
    首先要明确的是JAVA中没有引用传递, 全部是按调用 令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用...
  • 偶然在别人的博客(参考链接见文章最后)上看到一篇关于Java值传递还是传递地址的文章,我自己考虑了以下,也做错了。试了下,感觉有收获。因此,贴在这里。在Java中,如果参数是简单类型,那么传递的就是值,比如int...
  • 与其他语言不同,Java不允许程序员选择按值传递还是按引用传递各个参数,基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言,不是将对象本身传递给方法,而是将对象的...
  • java 值传递和引用传递的比较区别,包括代码及详解
  • JAVA值传递和引用传递

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

    千次阅读 多人点赞 2019-01-25 18:20:09
    所以我们说,在Java中只有值传递这一种参数传递方式。 面试官 :恩,你的理解已经非常到位了,那额外问一句,对于上面的三种类型User、String、int,当输出结果如何时,才可以认定是引用传递呢? 我 :对于...
  • 主要介绍了java到底是值传递还是引用传递的相关知识,本文通过几个例子给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • java 中没有引用传递,都是值传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • 为什么说Java中只有值传递

    万次阅读 多人点赞 2018-04-03 00:00:00
    ...所以我们可以说Java的传递是按共享传递,或者说Java中的传递是值传递。 —————END————— 喜欢本文的朋友们,欢迎长按下图关注订阅号 程序员小灰 ,收看更多精彩内容
  • Java值传递

    千次阅读 2016-01-31 17:18:26
    java中值传递,我的理解:一个参数A,传递A本身内容给变量B,在使用过程中若B直接改变A传递过来的内容,则A就会变化,否则不会变化。 而对于A本身内容,若是基本类型,则传递本身;若是对象,则传递他指向的地址。...
  • java中的值传递和引用传递的区别?

    千次阅读 2018-11-29 21:04:51
    1.值传递概念:值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。 实例: public class Main { public static void main(String[] args) { int ...
  • 主要介绍了JAVA参数传递方式,结合实例形式分析了java值传递与引用传递区别及相关操作注意事项,需要的朋友可以参考下
  • Java:按值传递还是按引用传递详细解说
  • 这一次,让你彻底明白Java值传递和引用传递!

    万次阅读 多人点赞 2018-10-29 08:39:00
    本文旨在用最通俗的语言讲述最枯燥的基本知识学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运...
  • JAVA值传递和引用传递剖析

    千次阅读 2019-08-18 17:02:47
    我想了半天没太想明白,赶紧甩到了”java小葵花妈妈课堂“里,想要难为他们一番,结果可想而知,直接被吐槽成开坦克的贝塔。。。(图片引用自网络,仅供学习之用!) 今天刚好有时间,我给大家普及下知识点。 实参...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 582,210
精华内容 232,884
关键字:

java值传递

java 订阅