精华内容
下载资源
问答
  • java方法的参数传递
    千次阅读
    2022-01-20 23:07:02

    Java 方法参数传递

    - 在编程语言中,方法对于参数的调用分为 按值调用(call by value) 和 按引用调用(call by reference).
    - 按值调用(call by value):方法接收的是调用者提供的值.
    - 按引用调用(call by reference):方法接收的是调用提供的变量地址.
    - Java 程序设计语言总是采用 按值调用(call by value).
    - 引用《Java 核心技术卷1》
    

    在 Java 中方法参数的传递总是 按值调用(call by value) 的。也就是说方法得到的是所有参数值的一个拷贝,方法不能修改传递给它的任何参数变量的内容。然而有时候这与我们所看到的不太一样。

    在 Java 中方法参数共有两种类型:

    基本数据类型(数值、字符、布尔);
    对象引用

    基本数据类型

    public class ParamTest {
    
        public static void main(String[] args){
            double num = 10.0;
            System.out.println("Before... --> num = "+num);
            quadruple(num);
            System.out.println("After... --> num = "+num);
            
            System.out.println("--------------********----------------------");
            
            double a = 20.0;
            double b = 15.0;
            System.out.println("Before... --> a = "+a+",b = "+b);
            swap(a,b);
            System.out.println("After... --> a = "+a+",b = "+b);
            
        }
        
        public static void quadruple(double num){
            num*=4;
            System.out.println("quadruple...--> num = "+num);
        }
        
        public static void swap(double a,double b){
            double c = a;
            a = b;
            b = c;
            System.out.println("swap...--> a = "+a+",b = "+b);
        }
    }
    

    上面代码中方法 quadruple()在方法内部将参数num放大了四倍,swap() 方法试图将两个变量的值进行调换。

    Before... --> num = 10.0
    quadruple...--> num = 40.0
    After... --> num = 10.0
    --------------********----------------------
    Before... --> a = 20.0,b = 15.0
    swap...--> a = 15.0,b = 20.0
    After... --> a = 20.0,b = 15.0
    

    从运行结果来看,变量numab都没有发生改变。这是因为 基本数据类型传递过去的都是 值 的拷贝,所以方法内部无论怎么修改变量的值都不会对外部变量产生影响。

    对象引用

    package com.yun;
    
    public class ObjParamTest {
        public static void main(String[] args) {
            Student stu = new Student("晓风","软件");
            
            System.out.println("Before... --> stu = "+stu);
            change(stu);
            System.out.println("After... --> stu = "+stu);
            
            System.out.println("--------------********----------------------");
            
            Student stu1 = new Student("春雨","电子");
            Student stu2 = new Student("夏雷","幼教");
            System.out.println("Before... --> stu1 = "+stu1+",stu2 = "+stu2);
            swap(stu1,stu2);
            System.out.println("After... --> stu1 = "+stu1+",stu2 = "+stu2);
        }
        
        public static void change(Student stu){
            stu.setName("秋风");
            stu.setMojar("汽修");
            System.out.println("change...--> stu = "+stu);
        }
        
        public static void swap(Student s1,Student s2){
            Student t = s1;
            s1 = s2;
            s2 = t;
            System.out.println("swap...--> s1 ="+s1+",s2 = "+s2);
        }
    }
    class Student {
        
        private String name;
        private String mojar;
        
        public Student(String name,String mojar){
            this.name = name;
            this.mojar = mojar;
        }
        /** Getter / Setter **/
        @Override
        public String toString(){
            return "Studnet["+
                        "name = "+name+
                        ",mojar = "+mojar+"]";
        }
    }
    

    上面代码中,change()方法对 stu 变量的信息进行了修改并输出,swap()方法依旧是将两个变量进行交换,如果依照 基本数据类型 一样,那么所有的对象引用将不会发生改变,然而事情并不是像我们想的那样:

    Before... --> stu = Studnet[name = 晓风,mojar = 软件]
    change...--> stu = Studnet[name = 秋风,mojar = 汽修]
    After... --> stu = Studnet[name = 秋风,mojar = 汽修]
    --------------********----------------------
    Before... --> stu1 = Studnet[name = 春雨,mojar = 电子],stu2 = Studnet[name = 夏雷,mojar = 幼教]
    swap...--> s1 =Studnet[name = 夏雷,mojar = 幼教],s2 = Studnet[name = 春雨,mojar = 电子]
    After... --> stu1 = Studnet[name = 春雨,mojar = 电子],stu2 = Studnet[name = 夏雷,mojar = 幼教]
    

    可以看到,change()方法竟然成功修改了变量stu。既然 Java 总是按值传递的,那为什么这里对象引用有成功被修改了呢?是不是说 Java 对象引用是按引用传递的呢?答案肯定是不可能的,因为可以看到swap()方法依旧没能调换两个变量的值。

    change()方法为什么能够改变对象引用的状态呢,这是因为 Java 中对象引用传递的是 地址值,当两个变量同时只向同一个 地址时,也就是说两个对象引用在操作一个对象。我认为它就像将一个对象变量赋值给另一个对象变量:

    Student shily = new Student("Shily","Java");
    Student stu = shily;
    

    这里stu的状态发生改变,shily的状态跟着改变,这就相当于change()方法。swap()方法就像:

    Student shily = new Student("Shily","Java");
    Student stu = shily;
    Student darn = new Student("Darn","C++");
    stu = darn;
    

    此时 变量stu又重新指向了darn的地址,然而这并不会对变量shily产生任何影响。

    在对象引用中,还有一个特殊的对象 String

    String

    public class ObjParamTest {
        public static void main(String[] args) {
            String str = "original";
            System.out.println("Before... --> str = "+str);
            change(str);
            System.out.println("After... --> str = "+str);
        }
        public static void change(String str){
            str = "change...";
            System.out.println("change...--> str = "+str);
        }
    }
    
    Before... --> str = original
    change...--> str = change...
    After... --> str = original
    

    String 类并没有发生改变,String类像基本类型一样。

    总结:

    • 一个方法不能修改一个基本数据类型的参数
    • 一个方法可以改变一个对象参数的状态
    • 一个方法不能让对象参数引用一个新的对象
    更多相关内容
  • java方法参数传递方式有两种,按值传递和引用传递 1.按值传递 参数类型是int,long等基本数据类型(八大基本数据类型),参数传递的过程采用值拷贝的方式 代码片段1: public class Test { public static void ...

    java的方法参数传递方式有两种,按值传递和引用传递
    1.按值传递

    参数类型是int,long等基本数据类型(八大基本数据类型),参数传递的过程采用值拷贝的方式

    在这里插入图片描述

    代码片段1:

    public class Test {

    public static void main(String[] args) {
        int a = 5;
        fun(a);
        System.out.println(a);// 输出结果为5
    }
    
    private static void fun(int a) {
        a += 1;
    }
    

    }

    2.引用传递

    参数类型为引用类型,参数传递的过程采用拷贝引用的方式

    在这里插入图片描述

    代码片段2:

    public class Test {

    public static void main(String[] args) {
        A a = new A(5);
        fun(a);
        System.out.println(a.a);// 输出结果为6
    }
    
    private static void fun(A a) {
        a.a += 1;
    }
    
    static class A {
        public int a;
    
        public A(int a) {
            this.a = a;
        }
    }
    

    }

    结论:按值传递,不会改变原来的值,引用传递,会改变引用对象的值

    再看下面这种情况:

    代码片段3:

    public class Test {

    public static void main(String[] args) {
        Integer a = 5;
        fun(a);
        System.out.println(a);// 输出结果为5
    }
    
    private static void fun(Integer a) {
        a += 1;
    }
    

    }
    这里明明是引用传递,为什么没有改变对象的值呢?

    这里其实使用了基本数据类型封装类的自动装箱功能。
    Integer a = 5,编译后实际为Integer a = Integer.valueOf(5),查看Integer的源码,并没有改变原对象的值,只是将其引用指向了另一个对象。
    在这里插入图片描述

    代码片段3中的过程可以用下图来表示:

    在这里插入图片描述

    直接改变了栈帧中的地址,指向另一个对象,所以并没有改变原来的值。

    ————————————————
    版权声明:本文为CSDN博主「zhenge1990」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/zhenge1990/article/details/78897166

    展开全文
  • java方法参数传递方式--按值传递、引用传递

    万次阅读 多人点赞 2017-12-25 21:33:28
    java方法参数传递方式有两种,按值传递和引用传递 1.按值传递

    java的方法参数传递方式有两种,按值传递和引用传递


    1.按值传递

    参数类型是int,long等基本数据类型(八大基本数据类型),参数传递的过程采用值拷贝的方式


    代码片段1:

    public class Test {
    
        public static void main(String[] args) {
            int a = 5;
            fun(a);
            System.out.println(a);// 输出结果为5
        }
    
        private static void fun(int a) {
            a += 1;
        }
    }

    2.引用传递

    参数类型为引用类型,参数传递的过程采用拷贝引用的方式


    代码片段2:

    public class Test {
    
        public static void main(String[] args) {
            A a = new A(5);
            fun(a);
            System.out.println(a.a);// 输出结果为6
        }
    
        private static void fun(A a) {
            a.a += 1;
        }
    
        static class A {
            public int a;
    
            public A(int a) {
                this.a = a;
            }
        }
    }

    结论:按值传递,不会改变原来的值,引用传递,会改变引用对象的值


    再看下面这种情况:

    代码片段3:

    public class Test {
    
        public static void main(String[] args) {
            Integer a = 5;
            fun(a);
            System.out.println(a);// 输出结果为5
        }
    
        private static void fun(Integer a) {
            a += 1;
        }
    
    }

    这里明明是引用传递,为什么没有改变对象的值呢?

    这里其实使用了基本数据类型封装类的自动装箱功能。

    Integer a = 5,编译后实际为Integer a = Integer.valueOf(5),查看Integer的源码,并没有改变原对象的值,只是将其引用指向了另一个对象。


    代码片段3中的过程可以用下图来表示:


    直接改变了栈帧中的地址,指向另一个对象,所以并没有改变原来的值。

    展开全文
  • java方法参数传递

    千次阅读 2022-03-27 15:16:53
    Java方法参数传递方式只有一种:值传递。 基本数据类型,值是保存在栈中; 引用对象,值保存在堆中,栈中存的是对象在堆中的地址。 方法参数传递之基本数据类型 public class Main { public static void main...

    方法:必须有其所在类或对象调用才有意义。

    若方法含有参数:

    • 形参:方法声明时的参数
    • 实参:方法调用时实际传给形参的参数值

    Java里方法的参数传递方式只有一种:值传递。

    在这里插入图片描述

    基本数据类型,值是保存在栈中;
    引用对象,值保存在堆中,栈中存的是对象在堆中的地址。

    方法参数传递之基本数据类型

    public class Main {
        public static void main(String args[]) {
        	int a = 0;
        	swap(a);
        	System.out.println("main方法中的参数a的值:" + a);
        }
        
        public static void swap(int i) {
        	i = 6;
        	System.out.println("swap方法中的参数i的值:" + i);
        }
    }
    

    运行结果如下:
    在这里插入图片描述
    分析:
    先执行的int a = 0; 在栈中开辟了一块内存,地址是XXXX,存的值是0.
    再调用swap方法,执行int i 部分,在栈中开辟一块内存,地址是XXXX1,值就是从a那里复制过来的值0,执行swap的方法体里面的代码,i=6,把 i 在栈中的值改成6.

    方法参数传递之基引用对象

    public class Main {
        public static void main(String args[]) {
        	DataSwap ds = new DataSwap();
        	System.out.println("调用swap方法之前,ds.a的值是:" + ds.a);
        	swap(ds);
        	System.out.println("调用swap方法之后,ds.a的值是:" + ds.a);
        }
        
        public static void swap(DataSwap ds1) {
        	ds1.a=6;
        	System.out.println("在swap方法中,ds1.a的值是:" + ds1.a);
        }
    }
    
    public class DataSwap {
    	public int a;
    }
    

    运行结果如下:
    在这里插入图片描述
    分析:
    1、DataSwap ds = new DataSwap();把new DataSwap()存到堆内存中,地址是XXXX
    2、ds引用对象存到栈中,地址是XXXX1,值是new DataSwap()对象在堆中的的地址
    3、调用swap方法,给ds1引用对象保存到栈中,地址是XXXX2,存的值是来源于实参(ds),也就是ds的栈中存的值,这个值实际上就是之前new DataSwap()对象在堆内存的地址
    在这里插入图片描述

    总结:
    在这里插入图片描述

    展开全文
  • 必踩的坑之Java方法中形参、实参传递

    千次阅读 多人点赞 2022-03-24 11:05:10
    首先亮明Java方法参数传递的规则,这两点很重要: 如果实参是基本类型(包括包装类型)或者String,则实参不会变(传的是值); 如果实参是对象集合或者数组,则实参会改变(传的是引用)。
  • java泛型方法参数传递

    千次阅读 2021-01-27 01:38:10
    Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始...
  • Java函数参数传递方式

    千次阅读 2021-12-09 15:08:59
    在阅读本文之前,根据自己的经验和理解,大家可以先思考并选择一下Java函数的参数传递方式: A. 是按值传递的? B. 按引用传递的? C. 部分按值部分按引用? 此处暂不宣布正确答案,我们通过一个简单的例子让大家...
  • java中将方法当作参数传递的方式

    千次阅读 2021-11-25 16:57:44
    Java8中引入了一个函数式接口Consumer的对象,该对象可以把方法作为参数进行传递。 接口定义: @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T>...
  • Java参数传递分析

    千次阅读 2021-02-28 06:08:03
    Java之中的参数传递,只有按值传递!...Java参数传递是值传递还是引用传递?当一个对象被当作参数传递到一个方法后,在此方法内可以改变这个对象的属性,那么这里到底是值传递还是引用传递?答:是值传递。Ja...
  • Java中的参数传递,到底是值传递还是引用传递?

    千次阅读 多人点赞 2020-05-12 18:23:29
    Java中的参数传递,到底是值传递还是引用传递? 错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的...
  • Java泛型传递参数

    千次阅读 2021-02-12 19:17:26
    我做了这个方法:public static void myMethod(Map,MyInterface> map) {}使用参数T以确保用作键的类与用作MyInterface中的参数的类相同.现在我想传递一个不同类作为键的映射,当然还有MyInterface的相应实现.但它...
  • public class Enumvalues{enum courseList {JAVA,C,PYTHON,PERL}enum generalInformation {NAME,AGE,PHONE}enum sex {MALE,FEMALE}}public static void main(String args[]) {printEnumValue(generalInformation);...
  • java参数是如何传递

    千次阅读 2021-02-28 14:59:36
    总的来说,计算机语言给子程序传递参数方法有两种。第一种方法是按值传递(call-by-value )。这种方法将一个参数值(value )复制成为子程序的正式参数。这样,对子程序的参数的改变不影响调用它的参数。第二种传递...
  • Java8中引入了一个函数式接口Consumer的对象,该对象可以把方法作为参数进行传递。 实例如下: package com.test; import org.junit.jupiter.api.Test; import java.util.function.Consumer; public class ...
  • java 学习笔记之多参数传递

    千次阅读 2022-03-18 20:58:45
    第一次写博客记录学习java遇到的问题,学习java学到方法的时候,在想见过c语言有类似多个参数传递的写法,java也应该有类似的写法,通过学习掌握的这种写法,如下 public class Test { public static void print...
  • Java 程序将lambda表达式作为方法参数传递在此示例中,我们将学习将lambda表达式作为Java中的方法参数传递。要理解此示例,您应该了解以下Java编程主题:示例1:将lambda表达式定义为方法参数示例importjava.util....
  • 如何在Java中将函数作为参数传递

    千次阅读 2021-02-12 12:23:10
    这个问题在这里已有答案:Java Pass方法作为参数 14个答案是否可以将方法作为参数传递Java方法? 如果是这样,有人可以指导我吗? 这似乎并不重要Jason asked 2019-01-26T17:30:56Z8个解决方案379 votesJava 8及...
  • 我试图制作一个程序,当类名和方法名作为String参数传递给调用者时,该程序执行特定的方法。考虑下面的代码。我有一个CarBean类:public class CarBean {private String brand;private String color;/*** @return ...
  • Java方法中的参数传递机制的具体体现 具体来说是两种:值传递和址传递 以swap(Object obj1,Object obj2)方法为例: 1:如果传递进去的是基本数据类型参数得值,那么再调用swap()函数的地方,传入的两个数值并没有...
  • java main方法参数传递

    万次阅读 2017-06-22 14:35:01
    并且需要输入参数的时候就需要用到main的参数传递 首先main方法中传递的参数是String数组 我们直接打印这个数组是没有值得空数组 所以可以编辑其下的代码 package com; public class TestMain {
  • Java接口作为参数传递

    千次阅读 2021-01-30 15:55:50
    Java接口作为参数传递 原文出处http://www.jufanshare.com/content/70.html Java接口作为参数传递的两种方式实现 方式一: 预先准备待使用类TestClassA package com.jufanshare; /** * @功能: * @开发者: 大...
  • 1、我们传递参数到对应方法里,然后通过方法里的一系列运算,最后的原本对象的值也改变了。 2、但是我们有时候对一个变量进行计算时,返回结果之后却又变成了原本的值,这并不是我们的方法不对而是没有搞清楚变量的...
  • java 枚举 参数传递

    千次阅读 2020-01-21 17:10:22
    java 枚举 参数传递 具体问题是这样的,JAVA定义一个枚举(如 RED、BLUE、GREEN)对象,初始值为RED,作为一个方法的参数传入,在方法中对该枚举对象进行修改(修改为BLUE),在调用该方法后,该对象还是为RED,...
  • Java中的参数传递

    万次阅读 多人点赞 2018-01-19 13:52:15
    Java中没有真正的引用传递 只有值传递! 传引用参数指的还是原来的那个引用,但是Java...指的是在方法调用时,传递参数是按值的拷贝传递。示例如下: public class TempTest { private void test1(int a){ //
  • 我无法理解该函数如何通过Lambda传递给此方法public class OrderUtil {public static List runInBatches(List inputList,Function, List> functionToRunInBatches) {return Lists.partition(inputList, BATCH_...
  • 该楼层疑似违规已被系统折叠...Java代码:------------------------------------------------------public class Main {public static void modify(int a) {a = 5;}public static void modify(Person p) {p = new P...
  • java 参数传递 空对象 null

    千次阅读 2021-03-14 11:31:36
    前两天,写程序时候,想传递一个数组名给一个函数,然后给数组new一下,并初始化数据,这样就使用非return,获得了一个初始化过对象,但是运行程序报“NullPointerException”。这是为什么???代码如下:public ...
  • java Runnable接口:是一个接口,它里面只有一个run()方法,没有start()方法,继2113承...向线程中传递数据的三种方法:一、通过构造函数传递参数public class MyThread1 extends Thread{private String name;p...
  • java两种参数传递方式

    千次阅读 2020-02-14 13:49:27
    java参数传递方式有两种: 按值传递 按址传递(引用传递) 一、按值传递 方法操作的是参数变量(也就是原型变量的一个值的拷贝),改变的也只是原型变量的一个拷贝而已,而非变量本身,所以变量原型并不会随...
  • 方法传递的Lambda表达式具有功能接口类型的参数。如果我们需要传递lambda表达式作为参数,则接收lambda表达式参数参数类型必须是功能接口类型。在下面的示例中,可以在参数类型为“ TestInterface ”的方法中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 797,037
精华内容 318,814
关键字:

java方法的参数传递