精华内容
下载资源
问答
  • java对象作为参数传递
    千次阅读
    2020-11-19 16:54:20

    在学习Java的时候总会遇到一些问题,今天就给大家说下如何把对象作为参数。
    到目前为止,我们都使用简单类型作为方法的参数。但是,给方法传递对象是正确的,也是常用的。例如,考虑下面的简单程序:

    // Objects may be passed to methods. 
    class Test { 
     int a,b; 
     Test(int i,int j) { 
     a = i; 
     b = j; 
     } 
     // return true if o is equal to the invoking object 
     boolean equals(Test o) { 
      if(o.a == a && o.b == b) return true; 
      else return false; 
     } 
    } 
    class PassOb { 
     public static void main(String args[]) { 
      Test ob1 = new Test(10022); 
      Test ob2 = new Test(10022); 
      Test ob3 = new Test(-1-1); 
      System.out.println("ob1 == ob2: " + ob1.equals(ob2)); 
      System.out.println("ob1 == ob3: " + ob1.equals(ob3)); 
     } 
    }
    

    该程序产生如下输出:

    ob1 == ob2: true 
    ob1 == ob3: false
    

    在本程序中,在Test中的equals()方法比较两个对象的相等性,并返回比较的结果。也就是,它把调用的对象与被传递的对象作比较。

    如果它们包含相同的值,则该方法返回值为真,否则返回值为假。注意equals中的自变量o指定Test作为它的类型。尽管Test是程序中创建的类的类型,但是它的使用与Java的内置类型相同。

    对象参数的最普通的使用涉及到构造函数。你经常想要构造一个新对象,并且使它的初始状态与一些已经存在的对象一样。

    为了做到这一点,你必须定义一个构造函数,该构造函数将一个对象作为它的类的一个参数。例如,下面版本的Box允许一个对象初始化另外一个对象:

    // Here,Box allows one object to initialize another. 
    class Box { 
     double width; 
     double height; 
     double depth; 
     // construct clone of an object 
     Box(Box ob) { // pass object to constructor 
      width = ob.width; 
      height = ob.height; 
      depth = ob.depth; 
     } 
     // constructor used when all dimensions specified 
     Box(double w,double h,double d) { 
      width = w; 
      height = h; 
      depth = d; 
     } 
     // constructor used when no dimensions specified 
     Box() { 
      width = -1; // use -1 to indicate 
      height = -1; // an uninitialized 
      depth = -1; // box 
     } 
     // constructor used when cube is created 
     Box(double len) { 
      width = height = depth = len; 
     } 
     // compute and return volume 
     double volume() { 
      return width * height * depth; 
     } 
    } 
    class OverloadCons2 { 
     public static void main(String args[]) { 
    // create boxes using the various constructors 
     Box mybox1 = new Box(102015); 
     Box mybox2 = new Box(); 
     Box mycube = new Box(7); 
     Box myclone = new Box(mybox1); 
     double vol; 
    // get volume of first box 
    vol = mybox1.volume(); 
    System.out.println("Volume of mybox1 is " + vol); 
    // get volume of second box 
    vol = mybox2.volume(); 
    System.out.println("Volume of mybox2 is " + vol); 
    // get volume of cube 
    vol = mycube.volume(); 
    System.out.println("Volume of cube is " + vol); 
    // get volume of clone 
    vol = myclone.volume(); 
    System.out.println("Volume of clone is " + vol); 
     } 
    }
    

    在本程序中你能看到,当你开始创建你自己的类的时候,为了方便高效的构造对象,必须为同一构造函数方法提供多种形式。

    更多相关内容
  • 关于Java对象作为参数传递是传值还是传引用的问题

    万次阅读 多人点赞 2016-09-06 22:37:20
    前言 在Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用,这是一个饱受争议的话题。若传的是值,那么函数接收的只是实参的一个副本,函数对形参的操作并不会对实参产生影响;若传的是引用,...

    前言

      在Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用,这是一个饱受争议的话题。若传的是值,那么函数接收的只是实参的一个副本,函数对形参的操作并不会对实参产生影响;若传的是引用,那么此时对形参的操作则会影响到实参。
      首先我们来看一句代码:

    Object obj = new Object();
    

      这句话的意思是:创建一个Object对象,再创建一个名为obj的引用,让这个引用指向这个对象,如下图所示:

      1.png-4.3kB

    在有了上面的基础之后,我们便来看下面这组在网上很流行的例子:

    基本数据类型作为参数传递:

    例1:

    public class test {
        public static void main(String[] args) {
            int i = 1;
            System.out.println("before change, i = "+i);
            change(i);
            System.out.println("after change, i = "+i);
        }
        public static void change(int i){
            i = 5;
        }
    }
    

      这个例子不难理解,当基本数据类型作为参数传递时,传递的是实参值的副本,即传的是值,无论在函数中怎么操作这个副本,实参的值是不会被改变的。所以以上代码执行的结果是:
      
      before change, i = 1
      after change, i = 1
      
      

    对象作为参数传递:

      在下面的例2中,我们把StringBuffer对象作为参数传递到change函数。
      
      例2:

    public class test {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer("Hello ");
            System.out.println("before change, sb is "+sb.toString());
            change(sb);
            System.out.println("after change, sb is "+sb.toString());
        }
        public static void change(StringBuffer stringBuffer){
            stringBuffer.append("world !");
        }
    }
    

      为了方便推理出结论,我们先直接看程序的运行结果:
      
      before change, sb is Hello
      after change, sb is Hello world !
      
      从输出结果中我们可以发现,sb所指向的对象的值被改变了,那么是否我们可以推论出,在Java中,当对象作为参数传递时,传递的是该对象的引用呢?我们再来看下面这个例子:
      
      例3:

    public class test {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer("Hello ");
            System.out.println("before change, sb is "+sb.toString());
            change(sb);
            System.out.println("after change, sb is "+sb.toString());
        }
        public static void change(StringBuffer stringBuffer){
            stringBuffer = new StringBuffer("Hi ");
            stringBuffer.append("world !");
        }
    }
    

      如果上面的推论是正确的,即Java中对象作为参数传递,实际传递的是该对象的引用,那么在调用change函数之后,原对象的值应该是会改变的,变为“Hi world !”,但是,当我们运行程序后,结果却是如下所示:
      
      before change, sb is Hello
      after change, sb is Hello
      
      原对象的值并没有被改变,这与上面的推论相矛盾!为什么在Java中,当对象作为参数传递时,有的时候实参被改变了,而有的时候实参并未被改变呢?下面让我们来分析一下其中的原因:
      从文章的开头我们知道,当执行StringBuffer sb = new StringBuffer(“Hello “)时,我们创建了一个指向新建对象“new StringBuffer(“Hello “)”的引用“sb”,如下图所示:
      
      2.png-3.2kB
      
      在例2中,当我们调用change函数后,实际上,形参stringBuffer也指向了实参sb所指向的对象,即:
      
      3.png-6.3kB
      
      那么当我们执行stringBuffer.append(“world !”)后,便通过对象的引用“stringBuffer”修改了对象的值,使之变成了“Hello world !”,即:
      
      4.png-6.6kB
      
      但是,在例3中的change函数中,我们又新建了一个对象“new StringBuffer(“Hi “)”(这实际上在内存中开辟了一块在原对象地址之外的新区域),这让形参stringBuffer实际指向了这个新建的对象,并将新对象的值设置为“Hi world !”,即:
      
      image_1art4suka65r1m4o1a0spgcjr89.png-10.1kB
      
      那么我们就不难理解,为何在执行完change函数之后,实参的值仍为“Hello”了。
      

    结论

      综上所述,我们可以得出结论:在Java中,当对象作为参数传递时,实际上传递的是一份“引用的拷贝”。
      
      

    展开全文
  • java 对象作为方法的参数传递

    万次阅读 2018-03-24 14:45:25
    说到对象作为方法的参数传递的时候,大家都知道,当方法有返回值的时候,我们在其他方法定义一个接收他的对象就把他的值给获取到了,可是如果不定义对象接收呐?请看方法有返回值的情况下:这种情况下,打印出来的值...

    说到对象作为方法的参数传递的时候,大家都知道,当方法有返回值的时候,我们在其他方法定义一个接收他的对象就把他的值给获取到了,可是如果不定义对象接收呐?

    请看方法有返回值的情况下:
    这种情况下,打印出来的值是321,我没有定义对象去接受这个返回值,怎么这个值就发生变化了?这就牵扯到java中的对象在传递的过程中到底是值传递还是引用传递了。在基本数据类型(int,doule,long等)传递的过程中传递的是值

    这种情况下,局部方法的改变不会引起主函数的i的变化,String对象也是如此。当传递的参数是对象的时候,这个时候java中的传递是引用传递。说白了就是c和c++中的指针,用c的说法是指针指向了变量的地址,在java中引用相当于是一种指针,引用的也是对象的地址,定义的对象在栈中存放。两者不管是谁发生了变化,都会引起另一个发生变化。
    展开全文
  • java对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递;引用类型,地址值传递,所以叫值传递。  当主函数的变量,对象(主本)传递到副函数时,传递的...

    看完绝对清晰~

    java中对象作为参数传递给一个方法,到底是值传递,还是引用传递?

    pdd:所谓java只有按值传递:基本类型  值传递;引用类型,地址值传递,所以叫值传递。

        当主函数的变量,对象(主本)传递到副函数时,传递的变量、对象(方法中的形参)其实都是副本,而副本的改变不会影响主  本。

    基本类型:传递的是值的拷贝,也就是说传递后就互不相关了,也就是说,不过副函数的副本如何变化,主本永远不会被影响。

    引用类型:传递的是引用地址值,有可能会被影响。

    string:具有不可变。是特殊的引用类型,其作用跟基本类型一样,传递后不相关。

     

    原作者:

    String和int参数传递是按值传递还是引用传递?

    一道面试题目,String的传递:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    public String change(String s){

         s = "222";

         return s; 

    }

    public static void main(Stirng[] args){

        String s = "111"

        change(s);

        sout(s);

    }

    我看到题目愣了一下,本来不假思考的结果是111,但仔细想,String是对象类型的,对象传递的是地址,那么地址传递到方法里面后,将指向修改成222,那么结果应该是222才对。实际恰恰相反。

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

    java传递参数都是值,如果是对象的话,就是将引用的值复制一份给方法当参数。如果是根据引用把堆里的对象修改了,那么对象真被修改了,不过不是被创建赋值给的那个引用修改的,是方法里的一个复制的引用副本给修改的。换句话说,施瓦星格的媳被施瓦星格的克隆人亲了下。

    用实例去理解,其实这个理解也就是根据jdk的结果告诉我自己记住规则是这样的,以后要记住。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

      public String change(String s, int i, StringBuffer sb, Person p){

            s="123";

            i=3;

            sb.append("woshi");

            p.setAge(100);

            sb = new StringBuffer("sbsb");

            p = new Person("bb",44);

            return s;

        }

     

        @Test

        public void testChange(){

            StringBuffer sb = new StringBuffer("buff");

            String s = "aaa";

            int i = 1;

            Person p = new Person("aa",12);

            i=2;

            change(s,i,sb,p);

    //        s="222";

            System.out.println(s);

            System.out.println(i);

            System.out.println(sb.toString());

            System.out.println(p);

        }

    这里一共测试了String,int,一个对象StringBuffer,一个对象people。让我们来仔细看看这些传递都发生了什么。我想有很大一部分人都猜不出打印结果。

    1

    2

    3

    4

    aaa

    2

    buffwoshi

    Person{id=0, name='aa', age=100, Country=null, hashcode=638783031}

    我们来一个个分析。

    首先是String。

    1

    String s = "aaa";

    这里,jvm创建一个变量引用s,在堆中创建一个对象aaa,将aaa放进常量池。s指向aaa。

    然后就到了change方法里。这里这样理解:将s引用的一个拷贝传给方法change。这样change有一个变量s,这个s也是指向aaa的。那么我们来通过debug来看后来发生了什么。

    1.s指向aaa的时候:

    2.s运行到change方法里的时候

    然后看s再次赋值的时候:

    然后我们运行结束change方法后到主方法里:

    到这里s就结束了。那么如果我们按照传递的是s这个变量的引用,即String s="aaa"中这个s本身,那么,s这个本身是个变量,s指向aaa,在方法change里s又指向了123,回到主方法后s变量的指向被改变了?错!显然s仍旧是aaa,那么只能这样理解:s传递到方法里的时候,复制了s指向的地址给change,change里的s是另一个s,s指向aaa(@718),然后在change中s又指向了123(@731),由于String是不可变类(final and Immutable),这里只是把副本s的指向修改成731,原地址718里的对象没有发生改变因为String不可变。那么,回到主方法的时候,s变量本身没有任何改变,s仍旧指向地址718,718的内容是aaa。所以最终打印aaa。

    然后是StringBuffer

    int是基本类型,所以int只是将值复制一份给别的方法用,这个大家都知道,就不去测试了。现在看StringBuffer发生的改变。

    1.初始化:

    2.到change方法中:

    3.发生append

    4.指向新对象

    这里就要说一下了,副本指向了新对象。就好比,施瓦星格的克隆人找了另一个女的当老婆,而真正的施瓦星格老婆没有变。

    5.回到主方法:

     

    到这里,StringBuffer就结束了。我们必须知道,虽然我们没有去研究源码是怎样实现的,change方法得到是一个sb的副本,只不过这个副本指向708,在change里对708的对象追加,708的对象就真的改变了。然后又把sb副本指向新地址737。这只是把副本指向的地址修改了,如果你在这里打印sb.toString(),打印的就是737里的内容。当跳出change,回到主方法的时候,原sb仍旧还是指向708的,最终就是打印708的结果。和String不同的是,StringBuffer的结果发生了变量,因为StringBuffer是可变的,可以append。而String是不可变的,在change中s=123就是发生两个行为,一个是查找常量池中是否有123,如果没有就在堆中创建123,一个是将s指向123.也就是说这时候是创建了一个新的String对象,而不是把原来的String对象s内容修改。这样,回到主方法的时候,s仍旧是aaa。

    同理,看自己创建的对象people

     

    1.初始化:

    2.p传递到change里的时候

    3.p副本设置age

    4.p副本重新赋值

     这里仍旧要说一下,p副本修改了自己指向,并不影响主方法里的p的指向。主方法里的p的指向没有发生变化,依旧应该还是720.

    5.回到主方法

    总结:

    通过上面对String,StringBuffer,People的研究,应该明白一个道理,重要的话说三遍,重要的规则我都演示了三遍。如果跟着步骤一步步走的,肯定牢记住了:

    java所有的参数传递都是传递的副本,变量所代表的值的副本!java所有的参数传递都是传递的副本,变量所代表的值的副本!java所有的参数传递都是传递的副本,变量所代表的值的副本!

    这里必须记住的就是副本概念。在方法里,运行的时候到这里的线程都会把传过来的参数拷贝副本带自己的工作区中,在工作区中对这个副本的值发生一些改变。最终改变的是副本,如果通过副本的指向修改了指向中的内容,那么那个指向的地址里的内容确实改变了。如果修改了副本的指向,即给副本重新赋值,那么关原来的变量何事?元变量仍旧指向最初的地址。

    那么,String传递过去的是副本,修改了副本的指向,打印元string是不会改变的,因为副本没有能力修改final的String类。

     

    出处:http://blog.csdn.net/zzp_403184692/article/details/8184751

    展开全文
  • Java编程中,当对象作为参数传递给方法时候,是按引用传递的,但是有的人会说这实质上是按值传递的。其实两者说的都不错,只是理解的方式不一样罢了,二者的原理其实是一样的。
  • java 对象作为参数的解析

    千次阅读 2019-12-11 20:57:09
    此文章帮助初学者区分参数的值传递和引用传递 java 和C区别之处在于缺少指针概念,C可以通过指针标志内存...2)java对象作为参数传递的都是对象的引用(可以理解为指针概念,实际操作的都是内存中原始对象的成...
  • Java中接口对象作为参数传递

    千次阅读 2016-05-23 18:56:14
    Java中接口对象作为参数传递(小例子)
  • 如何在Java中将函数作为参数传递

    千次阅读 2021-02-12 12:23:10
    如何在Java中将函数作为参数传递?这个问题在这里已有答案:Java Pass方法作为参数 14个答案是否可以将方法作为参数传递Java方法? 如果是这样,有人可以指导我吗? 这似乎并不重要Jason asked 2019-01-26T17:30:...
  • java中String对象作为参数传递问题

    千次阅读 多人点赞 2020-06-03 15:24:04
    java中将对象作为参数传递究竟是值传递还是引用传递? 1、基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝,原值是不会改变的。 2、对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了...
  • Java中将函数作为参数进行传递

    千次阅读 2021-03-18 22:19:56
    Java中将函数作为参数进行传递 现在了解到的有两种:Java8之前,一个常见的模式是将它“包装”在一个界面中,例如Callable接口,然后传入一个Callable。Java8以及之后就是今天学到的一种方法,通过Java8的新特性...
  • NDK开发有时需要Java和C/C++把对象作为参数互相传递, 详情参考: C/C++传递对象Java:https://blog.csdn.net/niuba123456/article/details/80994037 Java传递对象到C/C+:...
  • JAVA在方法中对象作为参数传递

    千次阅读 2018-02-23 17:42:35
    但是在java中,将方法A中的某个对象传递到方法B中进行修改后,再返回到A中,我们会发现对象在B中的修改在A中也有效。示例代码如下:有一个bean类:public class DemoBean { private String id; pu...
  • java中把对象作为参数传递的理解

    万次阅读 2017-12-29 14:24:12
    只不过,当把对象作为参数传递时,可以通过该副本引用改变该对象的的属性。 而我上面程序在方法里 issuePublishDate = null; 这里已经对变量重新赋值了。此时的变量 issuePublishDate 已经不再是参数传进来的那个...
  • java 参数传递对象 null

    千次阅读 2021-03-14 11:31:36
    前两天,写程序时候,想传递一个数组名给一个函数,然后给数组new一下,并初始化数据,这样就使用非return,获得了一个初始化过对象,但是运行程序报“NullPointerException”。这是为什么???代码如下:public ...
  • 问:当一个对象被当做参数传递到一个方法后,此方法可改变这个对象的属性,并返回变化后的结果,那么这里到底是值传递还是引用传递? 答:是值传递。在java语言中只有值传递参数;当一个对象实例作为一个参数被...
  • 对象作为参数传递给方法

    千次阅读 2018-12-06 16:55:06
    //新建一个对象c1接收返回的c System.out.println(i+"\t"+c1.getArea()); } } public void gettime(){ Circle c=new Circle(); Scanner sc=new Scanner(System.in); System.out.println("请输入time")...
  • Java参数传递分析

    千次阅读 2021-02-28 06:08:03
    Java之中的参数传递,只有按值传递!!!传递类型按值传递:就是把原来的参数的值...当一个对象被当作参数传递到一个方法后,在此方法内可以改变这个对象的属性,那么这里到底是值传递还是引用传递?答:是值传递。Ja...
  • } 执行方法后 方法体内对参数的操作 会影响到方法体外的对象62616964757a686964616fe4b893e5b19e31333337616461 所以传的是引用public static void main(String[] args) { int a = 5; System.out....
  • Java对象,对象引用,参数传递

    千次阅读 2018-07-01 19:45:46
    Java中,万物皆对象! 比如定义一个学生类 public class Student { private int id; private String name; private int age; public Student() { // TODO Auto-generated constructor stub su...
  • 如何在Java传递一个类作为参数

    千次阅读 2021-03-08 06:04:27
    使用 void callClass(Class classObject) { //do something with class } 一个Class也是一个Java对象,所以你可以使用它的types来引用它。 从官方文档中了解更多信息。 这种事情不容易。 这是一个调用静态方法的...
  • Java8中引入了一个函数式接口Consumer的对象,该对象可以把方法作为参数进行传递。 实例如下: package com.test; import org.junit.jupiter.api.Test; import java.util.function.Consumer; public class ...
  • Java中的参数传递,到底是值传递还是引用传递? 错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的...
  • Java RestTemplate post请求传递对象参数

    千次阅读 2020-12-03 15:26:43
    LoginParam param = LoginParam.builder().loginName(loginName).password(password).build(); ...String>...>(JSON.toJSONString(param), getHeader("")); String url = DustConstant.DUST_URL.concat(DustConstant...
  • Java 方法参数传递

    千次阅读 2022-01-20 23:07:02
    Java 方法参数传递 - 在编程语言中,方法对于参数的调用分为 按值调用(call by value) 和 按引用调用(call by reference). - 按值调用(call by value):方法接收的是调用者提供的值. - 按引用调用(call by reference):...
  • 在多次添加同一个list对象到另一个list里的时候 List<List<Integer>> listtwo = new LinkedList<>(); List<Integer> list = new LinkedList<>(); list.add(1); list.add(2); list...
  • Java泛型传递参数

    千次阅读 2021-02-12 19:17:26
    希望有人可以帮助我摆脱这种困扰.我做了这个方法:public ...现在我想传递一个不同类作为键的映射,当然还有MyInterface的相应实现.但它不起作用,因类型参数而导致语法错误.这是代码,我希望是自我解释.import java...
  • java】方法的参数传递

    千次阅读 2022-03-27 15:16:53
    Java里方法的参数传递方式只有一种:值传递。 基本数据类型,值是保存在栈中; 引用对象,值保存在堆中,栈中存的是对象在堆中的地址。 方法参数传递之基本数据类型 public class Main { public static void main...
  • 7 个答案:答案 0 :(得分:27)看起来您想要调整Josh Bloch所谓的Typesafe异类容器模式:您传递的是类型标记Class,并且您想要返回List。普通的旧THC可以以类型安全的方式将Class映射到T,但由于您实际上想要List,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 598,447
精华内容 239,378
关键字:

java对象作为参数传递

友情链接: wufengtietu.rar