精华内容
下载资源
问答
  • java值传递机制

    2019-01-15 11:42:25
    Java值传递机制 方法的参数传递(重点、难点) 1.形参:方法声明时,方法小括号内的参数 实参:调用方法时,实际传入的参数的 2.规则:java中的参数传递机制:值传递机制 1)形参是基本数据类型的:将实参的值...

    Java的值传递机制

    • 方法的参数传递(重点、难点)

      1.形参:方法声明时,方法小括号内的参数
      实参:调用方法时,实际传入的参数的
      2.规则:java中的参数传递机制:值传递机制
      1)形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量
      2)形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量。

    • 【典型例题1】

    public static void main(String[] args) {
                    	TestArgsTransfer tt = new TestArgsTransfer();
                        int i = 10;
                    	int j = 5;
                    	System.out.println("i:" + i + " j:" + j);//i : 10  j : 5	
                //		//交换变量i与j的值
                //		int temp = i;
                //		i = j;
                //		j = temp;
                	tt.swap(i, j);//将i的值传递给m,j的值传递给n
                System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
               }
        //定义一个方法,交换两个变量的值
            public void swap(int m,int n){
            	int temp = m;
            	m = n;
            	n = temp;
            	System.out.println("m:" + m + " n:" + n);
            
            }
    
    • 【典型例题2】
    public class TestArgsTransfer1 {
    	public static void main(String[] args) {
    		TestArgsTransfer1 tt = new TestArgsTransfer1();
    		DataSwap ds = new DataSwap();
    		
    		System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
    		
    		tt.swap(ds);
    		System.out.println(ds);
    		
    		System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
    		
    	}
    	//交换元素的值
    	public void swap(DataSwap d){
    		int temp = d.i;
    		d.i = d.j;
    		d.j = temp;
    		System.out.println(d);//打印引用变量d的值
    	}
    }
    
    class DataSwap{
    	int i = 10;
    	int j = 5;
    }
    
    展开全文
  • Java值传递机制

    2020-08-14 18:34:08
    值传递机制 1.形参和实参 形参:在方法定义时,声明的小括号内的参数。 实参:方法调用时,实际传递给形参的数据。 1.2.Java实参值如何传入到方法 Java里面方法的参数传递方式只有一个:值传递。即将实际参数值的...

    值传递机制

    1.形参和实参

    形参:在方法定义时,声明的小括号内的参数。

    实参:方法调用时,实际传递给形参的数据。

    1.2.Java实参值如何传入到方法

    Java里面方法的参数传递方式只有一个:值传递。即将实际参数值的副本(复制品)传入到方法内,而参数本身不受影响。

    • 形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参。
    • 形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参。

    1.3.关于变量的赋值

    • 如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
    • 如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
    /*
    关于变量的赋值
     */
    public class ValueTest3 {
        public static void main(String[] args) {
    
            System.out.println("========基本数据类型=========");
            int m = 10;
            int n = m;
    
            System.out.println("m = " + m + ", n = " + n);
    
            n = 20;
            System.out.println("m = " + m + ", n = " + n);
    
            System.out.println("========引用数据类型=========");
    
            Person p1 = new Person();
            p1.id = 1000;
    
            Person p2 = p1;  //赋值以后,p1和p2的地址值相同,都指向了堆空间中同一个对象实体
    
            System.out.println("p1.id = " + p1.id + ", p2.id = " + p2.id);
    
            p2.id = 10001;
            System.out.println("p1.id = " + p1.id + ", p2.id = " + p2.id);
    
        }
    }
    
    class Person{
        int id;
    }
    

    2.值传递机制

    2.1.参数类型为基本数据类型

    • 如果参数类型为基本数据类型,此时实参赋给形参的是实参真实存储的数据值。

    在这里插入图片描述

    public class ValueTest1 {
        public static void main(String[] args) {
            int m = 100;
            int n = 200;
    
            System.out.println("m = " + m + ", n = " + n);
    
            //交换m和n的值
    //        int temp = m;
    //        m = n;
    //        n = temp;
    
            //swap方法中的m和n是另外一对m和n,方法调用完毕后,就销毁了。
            ValueTest1 value = new ValueTest1();
            value.swap(m, n);
    
            System.out.println("m = " + m + ", n = " + n);  //结果没有进行交换
        }
    
        public void swap(int m, int n){
            int temp = m;
            m = n;
            n = temp;
        }
    }
    

    2.2.参数类型为引用数据类型

    • 如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。

    在这里插入图片描述

    public class ValueTest2 {
        public static void main(String[] args) {
            Data data = new Data();
    
            data.m = 10;
            data.n = 20;
    
            System.out.println("m = " + data.m + ", n = " + data.n);
    
            //交换m和n的值
            ValueTest2 valueTest2 = new ValueTest2();
            valueTest2.swap(data);   //此时传递的数据类型为引用数据类型
    
            System.out.println("m = " + data.m + ", n = " + data.n);
        }
    
        public void swap(Data data){
            int temp = data.m;
            data.m = data.n;
            data.n = temp;
        }
    }
    
    class Data{
        int m;
        int n;
    }
    
    展开全文
  • JAVA值传递机制

    2014-07-12 11:49:28
    java中,对于方法参数传递,u

    在java中,对于方法参数传递,不论传递的是原生数据类型还是引用类型,统一都是值传递(pass by values)。引用类型传递的是地址,传完之后两个引用指向同一个对象,若其中一个引用改变了对象的属性,那么这中改变也将会反映到其他的引用中。原生数据传递的是变量的数值,传完之后你是你,我是我,你的改变不会影响到我。这么说很抽象,不容易理解,下面的代码或许对理解有帮助。

    public class ParamTest
    {
        int i = 10;
    
        public static void main (String[] args)
        {
            ParamTest param = new ParamTest();
            Person person = new Person();
            person.change(param);
            System.out.println (param.i);
        }
    }
    
    class Person
    {
        public void change(ParamTest param1)
        {
            param1.i = 20;
        }
    }
    

    输出的结果i的值为20.我们先来看看main函数:

    第一行,创建了ParamTest类的一个对象,并且把对象的地址覆给了引用变量param。当执行到Person类中的change方法时,change方法创建了一个ParamTest类的引用param1,将main方法中的param中的地址值传递给了形参param1,两个引用变量指向同一个对象。change方法利用param1这个引用变量,改变了对象的属性值,而打印输出param.i的时候,输出已改变了的值。这说明两个引用变量指向同一个对象。若一个引用变量改变了对象的属性,实际上改变了对象本身,因此这种改变也会反映到其他引用变量上。

    public class ParamTest
    {
    
        int i = 10;
    
        public static void main (String[] args)
        {
    /*        ParamTest param = new ParamTest();
            Person person = new Person();
            person.change(param); */
            int i = 10;
            person.change(i);
            System.out.println (i);
    //        System.out.println(param.i);
        }
    }
    
    class Person
    {
        public void change(ParamTest param1)
        {
            param1.i = 20;
        }
    
        public void change (int age)
        {
            age = 40;
        }
    } 
    
    以上代码中在Person类中又定义了一个change方法,它接收的参数是int型。在main函数中,我调用了第二个change方法,执行这个方法的时候,是将i的值赋给了age,之后change方法并不会改变i的值了,因此i的值打印输出为10
    展开全文
  • java值传递机制: 规则: java基本数据类型的值传递,传递的是变量的类型的值; java引用数据类型值传递,传递的是地址值或者null; 1.基本数据类型: 代码: public class ValueTransTest02 { public static void ...

    人之所以痛苦,那是因为你在成长。--------magic_guo

    java值传递机制:

    规则:

    java基本数据类型的值传递,传递的是变量的类型的值;

    java引用数据类型值传递,传递的是地址值或者null;

    1.基本数据类型:

    代码:

    public class ValueTransTest02 {
        public static void main(String[] args) {
            int m = 10;
            int n = 20;
            System.out.println("交换前:m = " + m + ", n = " + n);
            int temp = m;
            m = n;
            n = temp;
            System.out.println("交换后:m = " + m + ", n = " + n);
        }
    }
    
    结果:
    交换前:m = 10, n = 20
    交换后:m = 20, n = 10
    

    上述代码交换成功,上述代码是我们常用的交换两个变量的值的代码,对此代码我们没有什么疑问。

    下面我们来看下面的代码:

    代码分析:由于每次交换我们都会使用到交换的代码,因此将交换的代码,抽离出来变成一个函数、以后只要有交换的程序,只需要调用swap()函数即可,这也符合我们对于封装的思想。但是我们看到,结果并非如此,两个变量的值并没有得到交换,这是为什么呢?原因就在于java的基本数据类型值传递,传递的是变量的数据值。

    代码:

    public class ValueTransTest01 {
        public static void main(String[] args) {
            int m = 10;
            int n = 20;
            System.out.println("使用swap交换前:m = " + m + ", n = " + n);
            ValueTransTest01 v1 = new ValueTransTest01();
            v1.swap(m, n);
            System.out.println("使用swap交换后:m = " + m + ", n = " + n);
    
        }
    
        public void swap(int m, int n){
            int temp = m;
            m = n;
            n = temp;
        }
    }
    
    结果:
    使用swap交换前:m = 10, n = 20
    使用swap交换后:m = 10, n = 20
    

    内存分析:
    在这里插入图片描述

    声明,java中的局部变量的声明都存在于栈中,在方法中的变量都是局部变量,因此无论是main方法中的m和n,还是swap方法中的m、n和temp都是存在于栈中。

    首先我们在mian函数中定义了m=10和n=20,然后创建了类对象来调用swap函数,将main函数中的m和n作为实参传递给swap函数中的形参m和n。此时程序采用压栈的方法,在栈中将swap函数中的m和n进行了赋值,再通过变量temp来交换swap函数中的m和n的值。

    最后swap函数执行完毕,输出了swap函数中的m和n,此时在swap函数中,m和n的值是进行了交换,swap中的sout输出的是20和10,

    swap函数出栈,随之swap函数中的m和n也销毁。

    然后在main函数中的m和n的值并未进行交换。也就是一顿操作之后,并没有改变,因此输出的还是10和20。

    主要原因还是java基本数据类型的值传递,传递的是变量的类型的值

    2.引用数据类型

    public class ValueTransTest03 {
        public static void main(String[] args) {
            Data d = new Data();
            System.out.println("swap交换前:d.m = " + d.m + ", d.n = " + d.n);
            ValueTransTest03 v = new ValueTransTest03();
            v.swap(d);
            System.out.println("swap交换后:d.m = " + d.m + ", d.n = " + d.n);
    
        }
        public void swap(Data data){
            int temp = data.m;
            data.m = data.n;
            data.n = temp;
        }
    }
    
    class Data{
        int m = 10;
        int n = 20;
    }
    
    结果:
    swap交换前:d.m = 10, d.n = 20
    swap交换后:d.m = 20, d.n = 10
    

    内存分析:

    在这里插入图片描述

    可以看出,与基本数据类型相反,我们把交换的代码也抽离出来,放在swap函数中,swap函数接收一个Data 类型的对象,却交换成功,原因是什么呢?

    java引用数据类型值传递,传递的是地址值或者null

    main函数中创建了一个Data类的对象,此时在栈中有一个d对象存放对空间中地址值,在堆空间中有一块内存空间存放对象的属性m=10和n=20,地址为0x8899;

    创建类对象来调用swap函数,将d作为实参传递给swap函数中的形参data,此时data也存放了0x8899的地址值,也就是说data也指向了堆空间中d所指向的内存空间0x8899;

    然后声明temp变量来交换堆空间中的m和n的值;最后swap出栈,temp被销毁,data.m,dada.n也被销毁,但是d所指向的m和n的值已经被交换。

    ----------------------------------------------------------------------------------------------------------------------个人理解,如有不正确的地方,请留言多多指点;

    展开全文
  • 这是一个EncodingFilter,本人主要不明白的是红色部分,他这里的编码只是对arr进行编码,而最终返回的是map,最终返回的map是已经编码过的map,按照本人对java值传递机制的理解不是应该无论怎么对arr进行操作,map...
  • Java值传递机制

    2020-08-23 15:42:23
    java值传递机制 java中方法的形参的传递机制:值传递机制 形参和实参的定义: 形参:方法定义时,声明在小括号里的参数 实参:方法调用时,实际传递给形参的数据 值传递机制: 如果参数是基本数据类型,此时...
  • Java方法的值传递机制

    2016-07-24 20:39:03
    Java值传递机制——基本数据类型 package com.mipo.javase.reference; /** * 方法参数的值传递机制之基本数据类型  * 结论: * 如果参数类型是基本数据类型,那么传过来的就是这个参数的一个副本,也就是这个...
  • 值传递机制Java

    2020-12-23 09:45:48
    值传递机制 如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值 如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值 /* * 方法形参的传递机制:值传递 * * 1.形参:方法定义时,...
  • Java值传递机制

    2020-07-26 10:34:14
    1. 值传递机制 1.值传递机制 值传递的规则为: 如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。 如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。 下面看一个值传递的...
  • java值传递机制

    2018-12-09 11:23:14
    2.规则:java中的参数传递机制:值传递机制 [1].形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量 [2].形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递...
  • Java值传递机制

    2021-01-07 16:30:23
    Java中无论是基本数据类型还是引用数据类型传递的都是,不同的是基本数据类型传递的直接就是传递后各不相关。而引用数据类型传递的是地址,原变量和被赋值变量同时指向堆当中的对象,其中的任何变量改变了...
  • 传递方式只有值传递,将实际参数值的副本传入方法中。实际参数本身不会发生任何变化。详解参看: https://www.cnblogs.com/jiqing9006/p/6049142.html 在实际使用过程中遇到的坑    &...
  • java值传递机制

    2018-07-29 14:07:55
    规则:java中的参数传递机制:值传递机制  * 1)形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量  * 2)形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)...
  • Java的参数传递机制是在Java中一个比较烦的问题,一般人都不太会注意,但要详细的解释一下其机制的话还是有很多人说不上来。其实我也是,所以就查了点相关资料并且记录下来,好好理解Java的参数传递。  对于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,054
精华内容 421
关键字:

java值传递机制

java 订阅