精华内容
下载资源
问答
  • Java方法传参

    千次阅读 2018-04-21 00:00:12
    Java方法传参:在java中方法的参数传递为值传递。给方法传值,其实是就是将实参数值的副本(内存中实参的一份复制)传入方法内,而参数本身不受到影响。简单数据类型和复合数据类型都传递一份实参栈值的副本。下面...

    Java方法传参:

    在java中方法的参数传递为值传递。

    给方法传值,其实是就是将实参数值的副本(内存中实参的一份复制)传入方法内,而参数本身不受到影响。

    简单数据类型和复合数据类型都传递一份实参栈值的副本。

    下面我们来看一个例子:

    public class Demo
    {
    	//更改这两个变量的值
    	public static void change(int i,int j)
    	{
    		int t = i;
    		i = j;
    		j = t;
    		System.out.println("改更后:i = "+ i +"\tj = "+j);
    		
    	}
    	public static void change(Point p)
    	{
    		int t = p.x;
    		p.x = p.y;
    		p.y = t;
    		System.out.println("交换后:x = "+ p.x + "\ty=" + p.y);
    		
    	}
    	public static void main(String args[])
    	{  
    	    int a=10,b=20;
    		Demo.change(a,b);//方法传参,传的是实参副本,不是实参本身
    		System.out.println("a = " + a + "\tb = "+b);
    		
    		System.out.println("---------------------------------");
    		
    		Point p=new Point(60,80);
    		p.info();
    		change(p);
    		p.info();  
    	}
    }
    class Point
    {
    	int x;
    	int y;
    	public Point(int x,int y)
    	{
    		this.x = x;
    		this.y = y;
    	}
    	
    	public void info()
    	{
    		System.out.println("x = "+x+"\ty = "+y);
    	}
    	
    }

    运行结果截图:

    从运行结果我们可以看出将a与b传给change方法后a与b的值并没有改变,但p中的x与y的值却改变了。

    想知道为什么我们可以简单画一个该程序在JVM中的内存图解

    我们知道基本数据类型直接在栈中开辟内存由上图可知,change交换了a1与b1的值但不会改变a与b的值;而对象(复杂)数据类型在堆中开辟内存因为p1是p的副本所以其指向堆中同一块内存,change方法对p1的操作改变了p1所指向内存中x与y的值所以p所指向内存中x与y的值也改变了。


    展开全文
  • Java 方法传参

    2017-09-19 11:08:48
    java程序设计语言总是采用值传递进行调用,无论是基本数据类型还是对象 由以下实例代码即可证明:public static void main(String[] args) { Employee a = new Employee("a", 1000, new Date()); Employee b = new...

    java程序设计语言总是采用值传递进行调用,无论是基本数据类型还是对象
    由以下实例代码即可证明:

    public static void main(String[] args) {
    
        Employee a = new Employee("a", 1000, new Date());
        Employee b = new Employee("b", 3000, new Date());
    
        System.out.println("a: " + a); 
        // a: Employee [name=a, salary=1000.0, hireDay=Wed Sep 06 13:49:43 CST 2017, id=0]
        System.out.println("b: " + b); 
        // b: Employee [name=b, salary=3000.0, hireDay=Wed Sep 06 13:49:43 CST 2017, id=0]
    
        swap(a, b);
    
        System.out.println("a: " + a);
        // a: Employee [name=a, salary=1000.0, hireDay=Wed Sep 06 13:49:43 CST
        System.out.println("b: " + b);
        // b: Employee [name=b, salary=3000.0, hireDay=Wed Sep 06 13:49:43 CST  
    
        }
    public static void swap(Employee a, Employee b) {
        Employee temp = a;
        a = b;
        b = temp;
    }
    

    由此可以得出java中方法参数使用的情况:
    - 一个方法不能修改一个基本数据类型参数的值(值传递,只是对该参数的拷贝)
    - 一个方法可以改变对象参数(即引用类型参数)的状态(对象的实例变量的值是可以在方法中改变的)
    - 一个方法不能让对象参数引用一个新的对象(java传参采用按值传递,对象类型参数传递时是对其引用的拷贝,而不是对象本身)

    展开全文
  • java 方法传参

    2015-04-27 18:05:00
    java 有两种数据类型:基本数据类型(int,short,long,byte,float,double,boolean,char),引用数据类型(基本数据类型之外的数组,String,对象等等)。 在方法中传参数有两种方式:值传递和引用传递 先看下面的一...

    这是小弟的第一篇博客,写得不好还请看官见谅哈!

    java 有两种数据类型:基本数据类型(int,short,long,byte,float,double,boolean,char),引用数据类型(基本数据类型之外的数组,String,对象等等)。

    在方法中传参数有两种方式:值传递和引用传递

    先看下面的一个实例。

    public class Stu {
    String name;
    int age;
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    public int getAge() {
    return age;
    }
    public void setAge(int age) {
    this.age = age;
    }
    }
    
    public class Test {
    
    protected static void updateStu(Stu stu) {
    stu.setAge(5);
    stu.setName("Li");
    //stu=new Stu();
    //stu.setAge(5);
    //stu.setName("Li");
    //用上面注释的代码替换掉未注释,修改前后的stu是一样的,即3,zhang
    }
    protected static void updateStr(String str) {
    str=new String("update");
    //str="update";
    //这两行代码效果一样
    }
    protected static void updateInteger(Integer i) {
    i=10;
    }
    protected static void updateBasic(int i) {
    i=10;
    }
    protected static void updateArray(int[] test) {
    if(test.length>1)
    test[0]=10;
    }
    protected static void updateCharArray(char[] cs) {
    cs=new char[3];
    cs[0]='a';
    cs[1]='b';
    cs[2]='c';
    }
    public static void main(String[] args)
    {
    Stu stu=new Stu();
    stu.setAge(3);
    stu.setName("Zhang");
    System.out.println("1-----------当方法参数为普通对象");
    System.out.println("初始值");
    System.out.println(stu.getAge());
    System.out.println(stu.getName());
    updateStu(stu);
    System.out.println("修改后");
    System.out.println(stu.getAge());
    System.out.println(stu.getName());
    System.out.println("2-----------当方法参数为String");
    String str1=new String("haha");
    String str2="hehe";
    System.out.println("初始值");
    System.out.println(str1);
    System.out.println(str2);
    updateStr(str1);
    updateStr(str2);
    System.out.println("修改后");
    System.out.println(str1);
    System.out.println(str2);
    System.out.println("3-----------当方法参数为Integer");
    Integer integer=new Integer(5);
    System.out.println("初始值");
    System.out.println(integer);
    updateInteger(integer);
    System.out.println("修改后");
    System.out.println(integer);
    System.out.println("4-----------当方法参数为八种基本类型");
    int t=5;
    System.out.println("初始值");
    System.out.println(t);
    updateBasic(t);
    System.out.println("修改后");
    System.out.println(t);
    System.out.println("5-----------当方法参数为整数数组");
    int[] test ={1,2,3};
    System.out.println("初始值");
    System.out.println(test[0]+"--"+test[1]+"--"+test[2]);
    updateArray(test);
    System.out.println("修改后");
    System.out.println(test[0]+"--"+test[1]+"--"+test[2]);
    System.out.println("6-----------当方法参数为字符数组");
    char[] cs ={'1','2','3'};
    System.out.println("初始值");
    System.out.println(cs);
    updateCharArray(cs);
    System.out.println("修改后");
    System.out.println(cs);
    }
    }

     

    =======================================输出

    1-----------当方法参数为普通对象
    初始值
    3
    Zhang
    修改后
    5
    Li
    2-----------当方法参数为String
    初始值
    haha
    hehe
    修改后
    haha
    hehe
    3-----------当方法参数为Integer
    初始值
    5
    修改后
    5
    4-----------当方法参数为八种基本类型
    初始值
    5
    修改后
    5
    5-----------当方法参数为整数数组
    初始值
    1--2--3
    修改后
    10--2--3
    6-----------当方法参数为字符数组
    初始值
    123
    修改后
    123

     

    根据上面的结果,可以得出这样的结论

    1、基本数据类型采用的是值传递,(类似C里面的传值),它不会修改实参的值

    2、引用数据类型采用的是引用传递,(类似C里面的传指针),和值传递类似,传的是引用的一份拷贝,而非引用本身(通过下面的例子证实),引用可以理解成JAVA的指针,它指向对象在堆里面分配的首地址。

    3、String修改后为什么实参没变,这个我看过很多文章说String就相当于是char[]的包装类。包装类的特质之一就是在对其值进行操作时会体现出其对应的基本类型的性质。

    但是小弟有另一番理解:str="update",这句话会有有如下动作,在栈里面查找有没有value="update"的String引用,要是有就将str指向堆里面的该地址,要是没有就会重新创建一个String对象"update",并将str指向该对象在堆中的地址。在上面的实例中,调用updateStr方法,会将str的引用赋给形参str,而在这个方法中str又重新指向了另一个String对象,但是这个过程并没有修改实参所指向的String对象,这个就和updateStu方法一样,只要new了一个新的对象,那么实参指向的对象就不会改变。

     

        public static void main(String[] args) throws Exception
        {
            Demo demo=new Demo(5);
            changeDemo(demo);
            System.out.println(demo.val);
            setDemo(demo);
            System.out.println(demo.val);
        }
        public static void changeDemo(Demo demo)
        {
            demo=new Demo(6);
        }
        public static void setDemo(Demo demo)
        {
            demo.setVal(6);
        }
        static class Demo
        {
            int val;
            Demo(int val)
            {
                this.val=val;
            }
            
            public void setVal(int val)
            {
                this.val=val;
            }
        }

    输出

    5
    6

    从上面的例子可以看出setDemo将形参引用指向了一个新的对象,它的值是6,但是这个并没有改变实参的值,说明函数传递的并非实参引用本身,而是实参引用的一份拷贝

    setValue,通过形参引用来改变实参的值,是因为,此时实参引用和形参引用指向的是同一对象。

    转载于:https://www.cnblogs.com/maydow/p/4460900.html

    展开全文
  • java 方法传参是引用传递还是值传递

    java 方法传参是引用传递还是值传递

    在开始之前先看个简单的例子,将一个对象通过方法传递,然后在方法体内又进行了new操作来创建类,在方法执行完之后再对对象进行操作,如下这个示列
    
    创建一个对象 User
    public class User {
        private String name;
        private Integer age;
        private String telNo;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getTelNo() {
            return telNo;
        }
    
        public void setTelNo(String telNo) {
            this.telNo = telNo;
        }
     }
    
     创建一个测试类 Test ,在Test类写一个initBean 方法来实例User 对象,
     public class Test {
    
        public static void main(String[] args) {
            User user = null;
            initBean(user);
            System.out.println(user.getName());
        }
    
        private static void initBean(User user){
            if (user == null){
                user = new User();
            }
            user.setName("张三");
            user.setAge(28);
            user.setTelNo("18695486987");
        }
     }
    
     执行main方法来看下结果,结果报了NullPointerException异常。
     Exception in thread "main" java.lang.NullPointerException
    at hx.data.mybatis.aop.Test.main(Test.java:12),
    这里明明已经实例化这个对象了为什么还会报错呢,下面我们打个断点跟进去看下
    
    在initBean方法之前,user = null
    

    这里写图片描述

        进入initBean,还没有进行new 操作时方法参数中user是null
    

    这里写图片描述

    进行new 操作创建对象,参数的user就给分配了一个对象地址
    

    这里写图片描述

    当执行完initBean之后,main方法中的user 任然为 null
    

    这里写图片描述

    上面是看的引用对象,下面我们再看下基本数据类型作为参数传递是怎么样的,看下面这个简单的例子,我们通过change方法将x,y传递进去,然后进行修改,最后打印出x,y的值,看是否发生变化。
    
    public static void main(String[] args) {
        int x = 0;
        int y = 0;
        change(x,y);
        System.out.println("X = "+x+" Y = "+y);
    }
    
    private static void change(int arg1,int arg2){
        arg1 = arg1+2;
        arg2 = arg2+5;
    }
    

    执行结果是 X = 0 Y = 0,这会不会是跟上面的情况一样呢,下面我们还是断点进去看下

    执行change之前x,y的值为0,
    

    这里写图片描述

    进入change,在执行修改之前参数arg1,和arg2的值也都是0,
    

    这里写图片描述

    进行修改操作之后arg1 = 2,arg2 = 5;
    

    这里写图片描述

    执行完change之后,x,y仍然是0,感觉这里结果一样的。
    

    这里写图片描述

    方法的参数传递到底值怎么传递的呢。
    在java中方法的参数传递实际是值的传递。但并不是将变量值进行传递,而是复制一个副本进行值的传递。当我们传递的是基本数据类型时,复制的是基本数据类型在栈中的字面值进行传递。如果传递的是对象参数,复制的不是对象本身的值,而是存储在栈中对象引用地址字面值进行传递。
     1、基本数据类型传递的实际情况
    

    这里写图片描述

    2、引用数据类型传递实际情况
    

    这里写图片描述
    这里写图片描述
    这里写图片描述

    总结:java中方法值的传递不管是基本类型还是引用对象都是值的传递,一个传的是字面值一个传递的是引用地址值,传递的值都是副本形式传递。

    展开全文
  • Java方法传参中有一个让疑惑又很经典的问题:在方法传递时,到底传递的是值,还是引用? 其实Java只有值传递这一种。不过是传数据值还是地址值的问题。 首先我们要知道两个Java存储区:栈(虚拟机栈)和堆。 我们...
  • ...这个问题是面试的时候经常会问到的一道题吧?...本来我想借着这次机会分享一下java方法传参的机制,但是经过几天的学习,了解,发现网上的博客基本上没有一篇能让人看后就清清楚楚的明白的,讲的
  • xsl调用java方法传参 XSL转换 (XSLT)是将一个XML文档转换为另一个XML文档的强大机制。 但是,在Java中,XML操作相当冗长和复杂。 即使是简单的XSL转换,也必须编写几十行代码—如果需要适当的异常处理和日志记录...
  • JAVA方法传参分析

    2021-03-31 21:35:51
    那么java方法的实参传递给形参具体是怎么做的呢? 下面先定义一个测试类Tese 里面只有一个fun方法 public class Test { void fun(int i){ int b =i; } public static void main(String[] args) { new ...
  • java方法传参问题

    2019-01-22 20:20:46
    1、基本数据类型的值传递,不改变其值 2、引用数据类型的值传递,改变其值 3、String类型虽然是引用数据类型,但它作为参数传递时和基本数据类型时一样的...
  • Java方法传参之可变参数

    千次阅读 2020-06-05 16:55:42
    * 方法传参之可变参数 * 在JDK1.5后,若方法内需要传递多个相同类型的参数,可以使用简化形式; * 语法:访问修饰符 返回值类型 方法名(参数类型 ... 参数名){}; * 等价于:访问修饰符 返回值类型 方法名(数据类型 []...
  • Java方法传参和可变参数的个别说明,以及foreach的语法和编译后的实现
  • Java是通过值传递的,也就是通过拷贝传递的。 先来看基本数据类型的传递过程: 对象的传递过程其实也是一样,不过这回x里放的是对象在堆里的地址,结果上会有所不同:
  • java方法传参只传值

    2017-06-22 23:02:00
    //为什么可以改变对象的属性?传入的值是引用,为什么是值呢,下面这个例子,在c语言中也写到, 转载于:https://www.cnblogs.com/zeigongzi/p/7067705.html
  • 我的测试如下: Node是一个节点类,其有一个Node类型的属性 ``` public class Node { public Node next;...当我想通过change方法改变node时 ...却发现node.next改变了,这是为什么啊,java不是值传递吗
  •  引用传递参考C++,在C++中调用函数时传递引用,若该引用在函数内部发生改变(引用了其他对象),原引用也会发生改变,而Java不会。public class Test { static void fun(String s) { s = new String("b&...
  • Java 方法传参方式: 按值调用

    千次阅读 2016-11-07 09:03:04
    Java 2016-11-01 22:20 程序设计语言中将参数传递给方法的几种方式: 按名调用(call by name) : Algol 语言采用此方式, 已成为历史; 按值调用(call by value) : 方法接收到的是调用者提供的 变量值 ; 按引用...
  • 程序设计语言中将参数传递给方法的几种方式: 按名调用(call by name): Algol 语言采用此方式, 已成为历史; 按值调用(call by value): 方法接收到的是调用者提供的 变量值; 按引用调用(call by reference): 方法接受...
  • 把一个变量带进一个方法,该方法执行结束后,它的值有时会改变,有时不会改变。一开始会觉得--“好神奇呀”。当我们了解java内存分析的知识后,一切都是那么简单明了了--“哦,这么回事呀”。但是今天的上机课,对于...
  • 今天因为一个接口传参问题,被开发经理批评了,于是我就想搞明白我到底错了没有。 我这个接口,是为了做统计用的,也就是说,是针对某种情况写的接口。而不是像前端综合查询那样很稳定,需要很多查询条件的接口。 ...
  • public class Test { /** * @param args ...如果将changeMap方法改为 public static void changeMap (Map map){ // map=null; map.clear(); } 结果又是什么? 请各位解答,谢谢大侠!
  • 关键就在member=me这里:在java中,给对象赋值是传递的对象地址(指针变量)! 因此member=me就让member和me指向了同一个对象,操作member相当于操作me。 当执行 member.setId( 1001 ); member.setName( ...
  • System.out.println("传参前: name = " + t.name + " age = " + t.age); di.devilerFunc(1,t); //parm$1传递的是值,TestObject eg传递的是引用(地址),c里面是指针 System.out.println("传参后: parm$1 =...

空空如也

空空如也

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

java方法传参

java 订阅