精华内容
下载资源
问答
  • 对象作为形参
    2022-04-15 02:03:20

    在Java中,调用方法时的实参为一个对象时,形参传递的是引用的拷贝,即该对象的地址,当在调用的方法中对该对象的属性更改时,形参和实参的属性都会改变

    /*
     *  如果参数是引用数据类型,此时实参赋值给形参的是实参存储数据的地址值。
     */
    public class ValueTransferTest2 {
    
    	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的值
    //		int temp = data.m;
    //		data.m = data.n;
    //		data.n = temp;
    
    		ValueTransferTest2 test = new ValueTransferTest2();
    		test.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;
    }

    更多相关内容
  • python中的可变对象和不可变对象可变对象,是指该对象所指向的内存中的值可以被改变。变量改变后,实际上是其所指向的对象的值发生了变化,也就是说在原地址发生了变化。不可变对象,是指该变量所指的内存中的对象的...

    python中的可变对象和不可变对象

    可变对象,是指该对象所指向的内存中的值可以被改变。变量改变后,实际上是其所指向的对象的值发生了变化,也就是说在原地址发生了变化。

    不可变对象,是指该变量所指的内存中的对象的值不能被改变。

    Python中,字符串、数值类型(int和float)与元组是典型的不可变对象,而列表list、字典dict、集合set是典型的可变对象类型。

    如何判断对象是否改变?

    在Python中,对象是由对象的id来唯一确定的,因此我们可以用id(object)方法来查看每个对象的id,从而进行比较。

    还有一种简单的方法是,可以用is来比较两个变量是否指向同一个对象,其所对应的,==用来比较两个变量指向的对象是否相等。

    python中的可变对象作为形参的默认值

    在python中,一个函数的签名中的形参是可以设置默认值的,这是非常方便的一个特性,但是在使用的时候,要注意,默认值最好设置为不可变的对象类型的值,如数字、元组或字符串,如果设置为可变的对象类型的话,如列表,会产生种种不容易预期的后果,原因是,这些对象并不是我们每次调用函数的时候会生成一个新的对象,而是一个函数的默认值,在函数定义的时候,被赋值一次,且这是唯一的一次初始化。

    详细的可以看下面的例子:

    def get_extended_list(extend_value, list_to_extend=[]):

    list_to_extend.append(extend_value)

    return list_to_extend

    if __name__ == "__main__":

    list_1 = get_extended_list(1)

    list_2 = get_extended_list(2, [])

    list_3 = get_extended_list('a')

    print "list_1:\t", list_1

    print "list_2:\t", list_2

    print "list_3:\t", list_3

    print "list_1 is list_2:\t", list_1 is list_2

    print "list_1 is list_3:\t", list_1 is list_3

    list_4 = [1, 'a']

    print "list_4 is list_1:\t", list_4 is list_1

    print "list_4 == list_1:\t", list_4 == list_1

    print id(list_1)

    print id(list_2)

    print id(list_3)

    print id(list_4)

    输出结果:

    list_1:[1, 'a']

    list_2:[2]

    list_3:[1, 'a']

    list_1 is list_2:False

    list_1 is list_3:True

    list_4 is list_1:False

    list_4 == list_1:True

    140275885988896

    140275077913848

    140275885988896

    140275885281648

    中间,我们重点关注list_1与list_3,它们之所以是同一个对象,是因为它们都指向内存中的同一个列表,也就是函数get_extended_list在被定义的时候初始化出的形参list_to_extend,之后的每一次调用这个函数的时候,如果用到这个形参的初始值,都是对同一个对象进行操作,因此产生了如上的输出。

    解决方案

    在我们明白了问题之后,接下来就是思考如何解决这样的问题了。

    如果我们是想要对于一个函数而言,如果某个参数并没有输入,则为其创建一个新的可变对象(如列表),我们这时就不能直接将这个可变对象放到函数的形参中,而是放到函数的代码中,如下:

    def get_extended_list(extend_value, list_to_extend=None):

    if list_to_extend is None:

    list_to_extend = []

    list_to_extend.append(extend_value)

    return list_to_extend

    在如上的代码中,我们将形参list_to_extend的默认值设置为None,也就是说如果没有输入这个参数的话,函数会将其设为默认值None,之后在函数中的起始部分,会检测该变量是否为None,如果是的话,会为其开辟一块新的内存来创建一个新的列表,最后返回这个新的列表。

    因此,如果再调用之前的main函数的话,就可以输出我们直观上认为会有的输出了:

    list_1:[1]

    list_2:[2]

    list_3:['a']

    list_1 is list_2:False

    list_1 is list_3:False

    list_4 is list_1:False

    list_4 == list_1:False

    139858452864032

    139857644788984

    139858452156784

    139858452156568

    展开全文
  • Java基础:把对象作为参数

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

    在学习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); 
     } 
    }
    

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

    展开全文
  • thread在使用类对象作为参数传递过程中,常常会出现多次拷贝构造的情况,理想中的情况是只需一次拷贝构造。原因是由于不同编译器对thread函数处理是不同的。 测试代码 #include <iostream> #include <...

    thread在使用类对象作为参数传递过程中,常常会出现多次拷贝构造的情况,理想中的情况是只需一次拷贝构造。原因是由于不同编译器对thread函数处理是不同的。

    测试代码

    #include <iostream>
    #include <unistd.h>
    #include <thread>
    using namespace  std;
    
    
    /**
     * 用类对象创建线程
     */
    class SonTheardClass{
    public:
        SonTheardClass(int i):num(i)
        {
            cout <<"构造函数被执行,线程ID:"<<this_thread::get_id()<<endl;
        }
        SonTheardClass(const SonTheardClass &mysonthread):num(mysonthread.num)
        {
            cout<<"拷贝构造被执行,线程ID:"<<this_thread::get_id()<<endl;
        }
        void operator() ()//不能带参数
        {
            cout<<"mySonTheardClass is begining!"<<endl;
            cout<<"作为类参数对象被执行,线程ID:"<<this_thread::get_id()<<endl;
            cout<<"mySonTheardClass is over!"<<endl;
        }
        ~SonTheardClass(){
            cout<<"析构被执行,线程ID"<<this_thread::get_id()<<endl;
        }
    public:
        int num;
    };
    
    int main(int argc, char *argv[])
    {
    
        cout << "主线程:开始"<<endl;//主线程是从main函数开始执行,执行到return ,主线程结束
        SonTheardClass mySonTheardClass(6);
    
        thread thread1(mySonTheardClass);//创建线程,线程起点是mySonThread
    
       thread1.join();//主线程执行到这里开始阻塞,等待mySonThread执行完,主线程继续往下执行
    
        cout<<"主线程:结束"<<endl;
    
        return 0;
    }
    
    

    测试结果

    linux 下GCC编译器测试结果:

    在这里插入图片描述 对象被拷贝构造了两次后,被析构掉一次,将第一次拷贝构造的对象传入子线程。

    Windows下VS2015测试结果

    在这里插入图片描述
    可以看到,在VS2015平台上,对象仅被拷贝构造一次就被送入到子进程中。

    Windows下 VS2013测试结果

    在这里插入图片描述
    可以看到在VS2013平台上,对象被拷贝构造了三次,而且被传入到子进程中还要进行一次拷贝构造。

    结论

    因此可以看出不同的编译器或平台,对于thread函数处理的方式是不一样

    展开全文
  • 对象作为参数传递的特点 在Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用,这是一个饱受争议的话题。若传的是值,那么函数接收的只是实参的一个副本,函数对形参的操作并不会对实参产生影响...
  • 主要给大家介绍了在spring MVC中传递对象参数的相关资料,文中通过示例代码介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面来一起看吧。
  • java 对象作为参数的解析

    千次阅读 2019-12-11 20:57:09
    此文章帮助初学者区分参数的值传递和引用传递 java 和C区别之处在于缺少指针概念,C可以通过指针标志内存...2)java 中对象作为参数,传递的都是对象的引用(可以理解为指针概念,实际操作的都是内存中原始对象的成...
  • SpringMVC前端接收对象作为参数 实体类:User.java public class User { private int id; private String name; private int age; public void setId(int id) { this.id = id; } public void setName...
  • c++ 对象作为参数,指针作为参数,引用作为参数

    千次阅读 多人点赞 2018-10-14 22:53:44
    c++ 对象作为参数,指针作为参数,引用作为参数
  • 在C++中对象作为参数采用的是“传值调用”,当实参通过形参传递时,会调用对象(实参)的拷贝构造函数(如果没有显式的定义拷贝构造函数,将自动调用默认拷贝构造函数,它的功能是将实参中的对象原样的拷贝到形参中,...
  • 【1】C++中对象作为形式参数

    千次阅读 2020-10-31 11:58:26
    那么对象作为形参时是哪种传递呢? 可想而知,对象是引用数据类型,指向了其类下的数据成员和方法成员。 我们又知道,值传递相当与将变量的等值复制作为参数传入函数,函数内对其修改并不会影响传入值。 相反地,当...
  • 对象作为参数传递时:实际上传递的是一份“引用的拷贝”。 引用,可以理解为指针,在主函数中是实参; 引用的拷贝,传递给子函数,是形参; 所以引用在传递给子函数时,是copy版,不是真正的实参。 当实参和形参...
  • JS处理函数将对象作为参数传递

    千次阅读 2020-10-04 23:04:54
    JSON.stringify() 方法用于将 JavaScript 值( 通常为对象或数组)转换为 JSON 字符串。 二代码 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></ti...
  • 前言在Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用,这是一个饱受争议的话题。若传的是值,那么函数接收的只是实参本,函数对形参的操作并不
  • C++中,对象作为函数参数的几种情况

    千次阅读 2020-10-07 09:37:34
    Passing Objects to Functions (对象作为函数参数) Objects as Function Arguments (对象作为函数参数) You can pass objects by value or by reference. (对象作为函数参数,可以按值传递,也可以按引用传递) ...
  • 对象作为形参,本质上与基本类型作为形参并无区别。但是考虑到普通类型作为形参,使用的是值传递,也就是将实参值拷贝一份给形参。如果是类对象的话,此时将会调用一个拷贝构造函数。也就是以实参为参数拷贝构造...
  • 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")...
  • 这个是数组作为对象中的参数 如果是集合判断条件应该是size 这个是给数组赋值 对象中的数组
  • java中对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递;引用类型,地址值传递,所以叫值传递。  当主函数的变量,对象(主本)传递到副函数时,传递的...
  • Json对象作为参数的传递和接收

    千次阅读 2019-08-17 10:06:52
    var user = encodeURL(JSON.stringify(data[i])); data[i]为json对象 var temp = JSON.parse(decodeURL(obj)); 接收编码后的数据并转为JSON对象
  • c++,类的对象作为形参时一定会调用复制构造函数吗?答:如果参数是引用传递,则不会调用任何构造函数;如果是按值传递,则调用复制构造函数,按参数的值构造一个临时对象,这个临时对象仅仅在函数执行是存在,函数...
  • 将JSON对象作为参数的方法

    千次阅读 2018-12-11 09:06:55
    这里一定要注意单引号和双引号的用法,否则就不能正确传递。原因是json内包含双引号。 return "&lt;div&gt;&...button class='btn btn-xs btn-warning btnEditSupervisorDuty ' onclick='...
  • 对象作为Java中的参数

    千次阅读 2021-02-28 18:09:13
    在Java中,将原始类型传递给方法时,可以通过按值调用来完成。通过引用调用隐式传递对象。这意味着当我们将原始数据类型传递给方法时,它将仅将值传递给函数参数,因此对参数所...在函数中传递对象作为参数classAdd{...
  • java中把对象作为参数传递的理解

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

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

    万次阅读 多人点赞 2019-09-12 17:13:03
    c++类的对象作为参数传递时,有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR...
  • Java中接口对象作为参数传递

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,949,174
精华内容 779,669
关键字:

对象作为形参