精华内容
下载资源
问答
  • Java 值传递 引用传递

    2011-10-27 13:55:46
    Java 值传递 引用传递   Java中除了八大基本数据类型以及相对应的封装类和String类型,是值传递已外,其他都是引用传递

     Java 值传递 引用传递

     

    Java中除了八大基本数据类型以及相对应的封装类和String类型,是值传递已外,其他都是引用传递。

    展开全文
  • java值传递引用传递

    2018-12-24 15:48:05
    当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递?   答:是值传递Java 编程语言只有值传递参数。当一个对象实例作为一个参数被...

    当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递? 

          答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变,但对象的引用(不是引用的副本)是永远不会改变的。

          Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。

          如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.。

          如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的 地址,所以不会改变参数的值。 

     例子:

    package com.demo.test;
    
    public class Employee {
        
        private String name;
        private double salary;
        
        public Employee(String name,double salary){
            this.name = name;
            this.salary = salary;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    }
    package com.demo.test;
    
    public class ParamTest {
    
        public static void main(String[] args) {
            /**
             * Test 1: Methods can't modify numeric parameters
             */
            System.out.println("Testing tripleValue:");
            double percent = 10;
            System.out.println("Before: percent=" + percent);
            tripleValue(percent);
            System.out.println("After: percent=" + percent);
    
            /**
             * Test 2: Methods can change the state of object parameters
             */
            System.out.println("\nTesting tripleSalary:");
            Employee harry = new Employee("Harry", 50000);
            System.out.println("Before: salary=" + harry.getSalary());
            tripleSalary(harry);
            System.out.println("After: salary=" + harry.getSalary());
    
            /**
             * Test 3: Methods can't attach new objects to object parameters
             */
            System.out.println("\nTesting swap:");
            Employee a = new Employee("Alice", 70000);
            Employee b = new Employee("Bob", 60000);
            System.out.println("Before: a=" + a.getName());
            System.out.println("Before: b=" + b.getName());
            swap(a, b);
            System.out.println("After: a=" + a.getName());
            System.out.println("After: b=" + b.getName());
        }
    
        private static void swap(Employee x, Employee y) {
            Employee temp = x;
            x = y;
            y = temp;
            System.out.println("End of method: x=" + x.getName());
            System.out.println("End of method: y=" + y.getName());
        }
    
        private static void tripleSalary(Employee x) {
            x.setSalary(x.getSalary()*3);
            System.out.println("End of method: salary=" + x.getSalary());
        }
    
        private static void tripleValue(double x) {
            x = 3 * x;
            System.out.println("End of Method X= " + x);
        }
    }
    Testing tripleValue:
    Before: percent=10.0
    End of Method X= 30.0
    After: percent=10.0
    
    Testing tripleSalary:
    Before: salary=50000.0
    End of method: salary=150000.0
    After: salary=150000.0
    
    Testing swap:
    Before: a=Alice
    Before: b=Bob
    End of method: x=Bob  //可见引用的副本进行了交换
    End of method: y=Alice
    After: a=Alice  //引用本身没有交换
    After: b=Bob

    因为java中是没有指针的,java中只存在值传递。  然而我们经常看到对于对象(数组,类,接口)的传递似乎有点像引用传递,可以改变对象中某个属性的值。但是不要被这个假象所蒙蔽,实际上这个传入函数的值是对象引用的拷贝,即传递的是引用的地址值,所以还是按值传递。

    展开全文
  • Java 值传递 引用传递

    千次阅读 2010-09-03 12:50:00
    Java代码 public class ParamTest {   // 初始为0   protected int num = 0;     // 为方法参数重新赋值   public void change(int i) {   i ...

    Java代码
    public class ParamTest { 
        // 初始值为0 
        protected int num = 0; 
     
        // 为方法参数重新赋值 
        public void change(int i) { 
            i = 5; 
        } 
     
        // 为方法参数重新赋值  //只是改变了局部变量t的引用。
        public void change(ParamTest t) { 
            ParamTest tmp = new ParamTest(); 
            tmp.num = 9; 
            t = tmp; 
        } 
     
        // 改变方法参数的值 
        public void add(int i) { 
            i += 10; 
        } 
     
        // 改变方法参数属性的值 
        public void add(ParamTest pt) { 
            pt.num += 20; 
        } 
     
        public static void main(String[] args) { 
            ParamTest t = new ParamTest(); 
     
            System.out.println("参数--基本类型"); 
            System.out.println("原有的值:" + t.num); 
            // 为基本类型参数重新赋值 
            t.change(t.num); 
            System.out.println("赋值之后:" + t.num); 
            // 为引用型参数重新赋值 
            t.change(t); 
            System.out.println("运算之后:" + t.num); 
     
            System.out.println(); 
     
            t = new ParamTest(); 
            System.out.println("参数--引用类型"); 
            System.out.println("原有的值:" + t.num); 
            // 改变基本类型参数的值 
            t.add(t.num); 
            System.out.println("赋引用后:" + t.num); 
            // 改变引用类型参数所指向对象的属性值 
            t.add(t); 
            System.out.println("改属性后:" + t.num); 
        } 
    }

    这段代码的运行结果如下:

    参数--基本类型
    原有的值:0
    赋值之后:0
    运算之后:0

    参数--引用类型
    原有的值:0
    赋引用后:0
    改属性后:20

    从上面这个直观的结果中我们很容易得出如下结论:

    对于基本类型,在方法体内对方法参数进行重新赋值,并不会改变原有变量的值。
    对于引用类型,在方法体内对方法参数进行重新赋予引用,并不会改变原有变量所持有的引用。
    方法体内对参数进行运算,不影响原有变量的值。
    方法体内对参数所指向对象的属性进行运算,将改变原有变量所指向对象的属性值。

    上面总结出来的不过是我们所看到的表面现象。那么,为什么会出现这样的现象呢?这就要说到值传递和引用传递的概念了。这个问题向来是颇有争议的。

    大家都知道,在JAVA中变量有以下两种:

    基本类型变量,包括char、byte、short、int、long、float、double、boolean。
    引用类型变量,包括类、接口、数组(基本类型数组和对象数组)。

    当基本类型的变量被当作参数传递给方法时,JAVA虚拟机所做的工作是把这个值拷贝了一份,然后把拷贝后的值传递到了方法的内部。因此在上面的例子中,我们回头来看看这个方法:
    Java代码
    // 为方法参数重新赋值  
    public   void  change( int  i) { 
        i = 5 ; 



    在这个方法被调用时,变量i和ParamTest型对象t的属性num具有相同的值,却是两个不同变量。变量i是由JAVA虚拟机创建的作用域在 change(int i)方法内的局部变量,在这个方法执行完毕后,它的生

    命周期就结束了。在JAVA虚拟机中,它们是以类似如下的方式存储的:

     

    很明显,在基本类型被作为参数传递给方式时,是值传递,在整个过程中根本没有牵扯到引用这个概念。这也是大家所公认的。对于布尔型变量当然也是如此,请看下面的例子:
    Java代码
    public   class  BooleanTest { 
        // 布尔型值  
        boolean  bool =  true ; 
     
        // 为布尔型参数重新赋值  
        public   void  change( boolean  b) { 
            b = false ; 
        } 
     
        // 对布尔型参数进行运算  
        public   void  calculate( boolean  b) { 
            b = b && false ; 
            // 为了方便对比,将运算结果输出  
            System.out.println("b运算后的值:"  + b); 
        } 
     
        public   static   void  main(String[] args) { 
            BooleanTest t = new  BooleanTest(); 
     
            System.out.println("参数--布尔型" ); 
            System.out.println("原有的值:"  + t.bool); 
            // 为布尔型参数重新赋值  
            t.change(t.bool); 
            System.out.println("赋值之后:"  + t.bool); 
     
            // 改变布尔型参数的值  
            t.calculate(t.bool); 
            System.out.println("运算之后:"  + t.bool); 
        } 



    输出结果如下:

    参数--布尔型
    原有的值:true
    赋值之后:true
    b运算后的值:false
    运算之后:true

    那么当引用型变量被当作参数传递给方法时JAVA虚拟机又是怎样处理的呢?同样,它会拷贝一份这个变量所持有的引用,然后把它传递给JAVA虚拟机为方法创建的局部变量,从而这两个变量指向了同一

    个对象。在篇首所举的示例中,ParamTest类型变量t和局部变量pt在JAVA虚拟机中是以如下的方式存储的:

     

    有一种说法是当一个对象或引用类型变量被当作参数传递时,也是值传递,这个值就是对象的引用,因此JAVA中只有值传递,没有引用传递。还有一种说法是引用可以看作是对象的别名,当对象被当作

    参数传递给方法时,传递的是对象的引用,因此是引用传递。这两种观点各有支持者,但是前一种观点被绝大多数人所接受,其中有《Core Java》一书的作者,以及JAVA的创造者James Gosling,而

    《Thinking in Java》一书的作者Bruce Eckel则站在了中立的立场上。

    我个人认为值传递中的值指的是基本类型的数值,即使对于布尔型,虽然它的表现形式为true和false,但是在栈中,它仍然是以数值形式保存的,即0表示false,其它数值表示true。而引用是我们用来

    操作对象的工具,它包含了对象在堆中保存地址的信息。即使在被作为参数传递给方法时,实际上传递的是它的拷贝,但那仍是引用。因此,用引用传递来区别与值传递,概念上更加清晰。

    最后我们得出如下的结论:

    基本类型和基本类型变量被当作参数传递给方法时,是值传递。在方法实体中,无法给原变量重新赋值,也无法改变它的值。
    对象和引用型变量被当作参数传递给方法时,在方法实体中,无法给原变量重新赋值,但是可以改变它所指向对象的属性。至于到底它是值传递还是引用传递,这并不重要,重要的是我们要清楚当一个

    引用被作为参数传递给一个方法时,在这个方法体内会发生什么。

    基本类型:int,float,byte,short,char,double,string,long传值。
    其它对象类型:传引用。

    展开全文
  • java 值传递 引用传递

    今天逛论坛,又发现了一篇有关于值传递和引用传递的,本以为自己对其已经掌握了。没想到又遇到了点麻烦。

    先看代码:

    public class test {
    	public static void main(String[] args){
    	int i = 3;
    	Integer j = new Integer(3);
    	StringBuffer t = new StringBuffer("hello,");
    
    	System.out.println(i+"   "+j+"  "+t);
    	//System.out.println(j.hashCode());
    	setValue(i);
    	setValue(j);
    	setString(t);
    	System.out.println(i+"  "+j+"  "+t);
    	
    	
    }
    public static void setValue(Integer a){
    	//System.out.println(a.hashCode());
    	a=5;
    }
    public static void setString(StringBuffer t){
    	t.append("hi");
    }
    }

    本以为输出结果是:

    3 3 hello,

    3 5 hello,hi

    结果来了:

    3   3
    3  3
    hell
    o,hi

    这里还是简单介绍一下值传递和引用传递。值传递只是简单的变量赋值,不会改变外层的值,而引用传递改变的是地址对应的值,会改变外层的值。

    但这里为什么传递了Integer对象,还是不会变呢。原来Integer类是一个特殊对象,在Integer中的值,相当于用final定义的,一经建立就不能改变了。

    这就是原因。

    展开全文
  • java 值传递 引用传递

    2008-10-24 01:54:00
    Java代码 public class ParamTest { // 初始为0 protected int num = 0; // 为方法参数重新赋值 public void change(int i) { i = 5; } // 为方法参数重新赋值 public void chang
  • 基本数据类型和String的构造两种方法都是值传递
  • 今天看到java值传递引用传递的讨论,觉得用着会用,但是不能说明白,google后发现了这篇文章,言简意赅。原文在此。 基本类型不用说,大家都懂,如果传入的是一个对象的引用,那么如果用这个引用新new一个对象,...
  • 首先值传递引用传递的区别就不多说了 ,相关的在很多人的博客都有解释且很详细:http://www.blogjava.net/jiafang83/archive/2007/10/23/155412.html 但有一种写法,在主类中 定义一个如下方法: package ...
  • 保证了引用传递的准确性,除非给变量赋值了新的地址,String作为参数传递时是 值传递,值指的是对象的引用的地址! StringBuffer属于可变对象 , 可能有人会问String str=“aa”;str="bb";这句话也能...
  • Java代码 public class ParamTest {   // 初始为0   protected int num = 0;     // 为方法参数重新赋值   public void change(int i) {   i = 5; //不能...
  • JAVA中的传递都是值传递吗?有没有引用传递呢? 在回答这两个问题前,让我们首先来看一段代码: Java代码 public class ParamTest { // 初始值为0 protected int num = 0; // 为方法参数重新...
  • java中的参数传递(只有值传递没有引用传递

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。 java中的数据类型 Java中...
  • java值传递 引用值传递
  • 语句注释去掉,最终会返回 null,因为 Java值传递而不是引用传递。 总结以上示例: ①: finally块的语句在try或catch中的return语句执行之后返回之前执行且finally里的修改语句可能影响...
  • java值传递还是引用传递 许多编程语言都允许按引用或按值传递参数。 在Java中,我们只能按value传递参数。 这施加了一些限制,并且引起了疑问。 例如,如果在方法中更改了参数值,方法执行后该值会怎样? 您可能还想...
  • 主要为大家详细介绍了Java值传递引用传递,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • JAVA值传递引用传递

    2021-03-04 11:04:35
    JAVA值传递引用传递** 一、值传递和引用传递有什么区别 值传递:指的是在方法调用时,传递的参数是按值的拷贝传递,传递的是值的拷贝,也就是说传递后就 互不相关了。 引用传递:指的是在方法调用时,传递的参数是...
  • Java值传递引用传递

    2017-09-11 19:24:28
    Java值传递引用传递
  • java值传递引用传递

    2020-07-21 10:54:01
    java值传递引用传递 很好理解的一片文章,点击查看
  • java 引用 值传递 引用传递 参考文章:https://www.cnblogs.com/laipDIDI/articles/2524309.html 引用:java用一个类创建一个对象,这个对象就是一个引用,同时,它也是一个变相的指针,每个对象都会指向一个地址。 ...
  • java值传递引用传递

    2019-09-29 22:18:09
    java值传递引用传递结论值传递和引用传递定义 结论 先说结论:值传递!妥妥的值传递,没有任何引用传递 看这个 很好 值传递和引用传递定义 值传递(pass by value)是指在调用函数时将实际参数复制一份传递到函数...
  • java 值传递引用传递 https://blog.csdn.net/qq_26542493/article/details/103898866
  • 1、值传递 在方法的调用过程中,实参把它的实际值传递给形参,此传递...引用传递弥补了值传递的不足,如果传递的数据量很大,直接复过去的话,会占用大量的内存空间,而引用传递就是将对象的地址值传递过去,函数接...
  • java值传递引用传递

    2019-03-24 20:25:52
    JAVA传递参数有值传递引用传递值传递是传递数据:如基本数据类型都是值传递 引用传递是把形参和实参的指针指向了堆中的同一对象,对象的引用和数组的引用。 实参,Java的基本数据类型,如int,double等在...
  • 值传递引用传递java Java严格按值传递 (Java is Strictly Pass by Value) In Java, it is very confusing whether java is pass by value or pass by reference. 在Java中,是按值传递还是按引用传递Java,这非常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,913
精华内容 3,165
关键字:

java值传递引用传递

java 订阅