精华内容
下载资源
问答
  • 要把其中一个对象的一些属性赋值给另一个对象。 最原始的方式是依次调用两个对象的set和get方法,挨个赋值。 但是spring提供了BanUtils的方法copyPrpperties可以实现。 注: 博客:...

    场景

    两个不同的类,其中一部分的属性相同。

    要把其中一个对象的一些属性赋值给另一个对象。

    最原始的方式是依次调用两个对象的set和get方法,挨个赋值。

    但是spring提供了BanUtils的方法copyPrpperties可以实现。

    注:

    博客:
    https://blog.csdn.net/badao_liumang_qizhi
    关注公众号
    霸道的程序猿
    获取编程相关电子书、教程推送与免费下载。

    实现

    引入包

    import org.springframework.beans.BeanUtils;

    然后调用

    BeanUtils.copyProperties(kqDkszJl,kqDksz);

    其中左边是要取值的对象,右边是要赋值的对象。

    展开全文
  • java中的对象引用与c++中的对象赋值

    千次阅读 2014-10-05 15:57:47
    JAVA之等号、传类对象参数与c++的区别JAVA之等号、传类对象参数与c++的区别

    1、java中的的对象引用与c++中的对象赋值比较

    1.1在JAVA中用等号对类对象进行赋值,实际上操作的是对象的地址。等号左边的对象名是对象引用,右边可以是对象引用或者对象本身。

    eg:

    package MyText;  
       
    class ClassA  
    {  
        int value;  
        public void seta(int value)  
        {  
            this.value = value;  
        }  
        public void show()  
        {  
            System.out.println("the value:" + value);  
        }  
    }  
    public class MyText {  
        public static void main (String []args)  
        {  
            ClassA a = new ClassA();  
            a.seta(1);  
            a.show();  
            System.out.println("a:" + a);//a的地址  
            ClassA b = new ClassA();  
            b.seta(2);  
            b.show();  
            System.out.println("b:" + b);//b的地址  
            System.out.println("======================");  
            b = a;  
            a.show();  
            b.show();  
            System.out.println("a:" + a + ", b:" + b);  
            b.seta(3);  
            a.show();  
            b.show();  
            System.out.println("a:" + a + ", b:" + b);  
        }  
    }

    运行结果:
    the value:1
    a:MyText.ClassA@14a55f2
    the value:2
    b:MyText.ClassA@15093f1
    ======================
    the value:1
    the value:1
    a:MyText.ClassA@14a55f2, b:MyText.ClassA@14a55f2
    the value:3
    the value:3
    a:MyText.ClassA@14a55f2, b:MyText.ClassA@14a55f2

    在java中向函数传入类对象参数实际上操作的也是地址eg:
    package MyText;  
       
    class ClassA  
    {  
        int value;  
        public void seta(int value)  
        {  
            this.value = value;  
        }  
        public void show()  
        {  
            System.out.println("the value:" + value);  
        }  
    }  
    public class MyText {  
        public static void showClassA(ClassA a)  
        {  
            a.show();  
            System.out.println("a:" + a);  
            a.seta(5);  
            a.show();  
            System.out.println("a:" + a);  
        }  
        public static void main (String []args)  
        {  
            ClassA a = new ClassA();  
            a.seta(1);  
            a.show();  
            System.out.println("a:" + a);  
            showClassA(a);  
            a.show();  
            System.out.println("a:" + a);  
        }  
    }

    运行结果:
    the value:1
    a:MyText.ClassA@5e55ab
    the value:1
    a:MyText.ClassA@5e55ab
    the value:5
    a:MyText.ClassA@5e55ab
    the value:5
    a:MyText.ClassA@5e55ab

    1.2在C++中对于利用等号对对象进行赋值,实际上是对对象成员的值按值传递。

    相互赋值是把一个对象中成员变量的值对应赋值给另一个对象对应成员变量,而不是传递地址。两个对象的类类型必须相同。eg:

    # include <iostream>  
    using namespace std;  
       
    class ClassA  
    {  
    private:  
        int value;  
    public:  
        void seta(int value)  
        {  
            this->value = value;  
        }  
        void show()  
        {  
            cout<<"the value : "<<value<<endl;  
        }  
    };  
    int main ()  
    {  
        ClassA a;  
        a.seta(3);  
        a.show();  
        cout<<"a:"<<&a<<endl;  
        ClassA b;  
        b.seta(4);  
        b.show();  
        cout<<"b:"<<&b<<endl;  
        b = a;  
        a.show();  
        b.show();  
        cout<<"a:"<<&a<<", b"<<&b<<endl;  
        b.seta(6);  
        a.show();  
        b.show();  
        cout<<"a:"<<&a<<", b"<<&b<<endl;  
    }

    运行结果:
    the value : 3
    a:0x22fefc
    the value : 4
    b:0x22fef8
    the value : 3
    the value : 3
    a:0x22fefc, b0x22fef8
    the value : 3
    the value : 6
    a:0x22fefc, b0x22fef8

    向函数传递类对象参数时,也是按值传递的,即实参与形参间进行成员变量赋值操作,而不是地址。eg:

    # include <iostream>  
    using namespace std;  
       
    class ClassA  
    {  
    private:  
        int value;  
    public:  
        void seta(int value)  
        {  
            this->value = value;  
        }  
        void show()  
        {  
            cout<<"the value : "<<value<<endl;  
        }  
    };  
    void show(ClassA a)  
    {  
        a.show();  
        cout<<"a:"<<&a<<endl;  
        a.seta(5);  
        a.show();  
    }  
    int main ()  
    {  
        ClassA a;  
        a.seta(3);  
        a.show();  
        cout<<"a:"<<&a<<endl;  
        show(a);  
        a.show();  
    }

    运行结果:
    the value : 3
    a:0x22fefc
    the value : 3
    a:0x22fea0
    the value : 5
    the value : 3

    1.3对比小结

    在java中
    ClassA a = new ClassA();

    可以分解为:

    ClassA a;//声明一个对象引用变量
    a = new ClassA();//在队空间创建一个对象实体,并且让a指向它。

    这里的a与c++中的对象指针相当。而在c++中

    ClassA a;//就已经在堆中初始化了一个对象a;

    2详解c++中的对象间赋值

    如果对一个类定义了两个或多个对象,则这些同类的对象之间可以互相赋值,或者说,一个对象的值可以赋给另一个同类的对象。这里所指的对象的值是指对象中所有数据成员的值。

    对象之间的赋值也是通过赋值运算符“=”进行的。本来,赋值运算符“=”只能用来对单个的变量赋值,现在被扩展为两个同类对象之间的赋值,这是通过对赋值运算符的重载实现的。

    实际这个过程是通过成员复制来完成的,即将一个对象的成员值一一复制给另一对象的对应成员。

    对象赋值的一般形式为:
        对象名1 = 对象名2;
    注意对象名1和对象名2必须属于同一个类。例如
        Student stud1,stud2; //定义两个同类的对象
        stud2=stud1; //将stud1赋给stud2

    通过下面的例子可以了解怎样进行对象的赋值。
    eg: 对象的赋值。

    <pre name="code" class="cpp" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 22.399999618530273px;">int Box::gethight( )
    {
       return hight; //返回体积
    }
    #include <iostream>using namespace std;class Box{ public : Box(int =10,int =10,int =10); //声明有默认参数的构造函数 int gethight( );

     
    
       void sethight(int);
       private :
       int hight;
       int width;
       int length;
    };
    Box::Box(int h,int w,int len)
    {
       hight=h;
       width=w;
       length=len;
    }
    void Box::sethight(int h)
    {
    <span style="white-space:pre">	</span>hight=h;
    }
    int Box::gethight( )
    {
       return hight; //返回体积
    }
    int main( )
    {
       Box box1(15,30,25),box2; //定义两个对象box1和box2,此时两个对象已经在栈区被初始化。
       cout<<"The hight of box1 is "<<box1.gethight( )<<endl;//15
    <pre name="code" class="cpp" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 22.399999618530273px;">   cout<<"The hight of box2 is "<<box1.gethight( )<<endl;//默认构造10
    box2=box1; //与java不同,这里将box1的值赋给box2,而不是box1和box2指向同一个对象
       cout<<"The hight of box1 is "<<box1.gethight( )<<endl;//15
    <pre name="code" class="cpp">   cout<<"The hight of box2 is "<<box1.gethight( )<<endl;//15
       box2.sethight(20);//不影响box1的值,这里与java不同,box2和box1是两个对象,不是一个对象的两个引用。
    <pre name="code" class="cpp" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 22.399999618530273px;">   cout<<"The hight of box1 is "<<box1.gethight( )<<endl;//15
    <pre name="code" class="cpp">   cout<<"The hight of box2 is "<<box1.gethight( )<<endl;//20
     
    
     
    
     
    
     
    
    
    }


    运行结果如下:
    The hight of box1 is 15
    The hight of box2 is  10

    The hight of box1 is 15
    The hight of box2 is 15

    The hight of box1 is 15
    The hight of box2 is 20
    说明:

    • 对象的赋值只对其中的数据成员赋值,而不对成员函数赋值。数据成员是占存储空间的,不同对象的数据成员占有不同的存储空间,赋值的过程是将一个对象的数据成员在存储空间的状态复制给另一对象的数据成员的存储空间。而不同对象的成员函数是同一个函数代码段,不需要、也无法对它们赋值。
    • 类的数据成员中不能包括动态分配的数据,否则在赋值时可能出现严重后果 (在此不作详细分析,只需记住这一结论即可)。

    3、java对象引用以及赋值

    Java对象及其引用

    关于对象与引用之间的一些基本概念。

           初学Java时,在很长一段时间里,总觉得基本概念很模糊。后来才知道,在许多Java书中,把对象和对象的引用混为一谈。可是,如果我分不清对象与对象引用,

           那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。

           为便于说明,我们先定义一个简单的类:

           class Vehicle {

           int passengers;      

           int fuelcap;

           int mpg;

                       }

    有了这个模板,就可以用它来创建对象:

           Vehicle veh1 = new Vehicle();

    通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作。

    1)右边的“new Vehicle”,是以Vehicle类为模板,在堆空间里创建一个Vehicle类对象(也简称为Vehicle对象)。

    2)末尾的()意味着,在对象创建后,立即调用Vehicle类的构造函数,对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写,Java会给你补上一个默认的构造函数。

    3)左边的“Vehicle veh 1”创建了一个Vehicle类引用变量。所谓Vehicle类引用,就是以后可以用来指向Vehicle对象的对象引用。

    4)“=”操作符使对象引用指向刚创建的那个Vehicle对象。

    我们可以把这条语句拆成两部分:

    Vehicle veh1;

    veh1 = new Vehicle();

    效果是一样的。这样写,就比较清楚了,有两个实体:一是对象引用变量,一是对象本身。

           在堆空间里创建的实体,与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。不仅如此,

           我们仔细研究一下第二句,找找刚创建的对象叫什么名字?有人说,它叫“Vehicle”。不对,“Vehicle”是类(对象的创建模板)的名字。

           一个Vehicle类可以据此创建出无数个对象,这些对象不可能全叫“Vehicle”。

           对象连名都没有,没法直接访问它。我们只能通过对象引用来间接访问对象。

           为了形象地说明对象、引用及它们之间的关系,可以做一个或许不很妥当的比喻。对象好比是一只很大的气球,大到我们抓不住它。引用变量是一根绳, 可以用来系汽球。

           如果只执行了第一条语句,还没执行第二条,此时创建的引用变量veh1还没指向任何一个对象,它的值是null。引用变量可以指向某个对象,或者为null

           它是一根绳,一根还没有系上任何一个汽球的绳。执行了第二句后,一只新汽球做出来了,并被系在veh1这根绳上。我们抓住这根绳,就等于抓住了那只汽球。

           再来一句:

           Vehicle veh2;

    就又做了一根绳,还没系上汽球。如果再加一句:

           veh2 = veh1;

    系上了。这里,发生了复制行为。但是,要说明的是,对象本身并没有被复制,被复制的只是对象引用。结果是,veh2也指向了veh1所指向的对象。两根绳系的是同一只汽球。

           如果用下句再创建一个对象:

    veh2 = new Vehicle();

    则引用变量veh2改指向第二个对象。

           从以上叙述再推演下去,我们可以获得以下结论:

    1)一个对象引用可以指向0个或1个对象(一根绳子可以不系汽球,也可以系一个汽球);

    2)一个对象可以有N个引用指向它(可以有N条绳子系住一个汽球)。

           如果再来下面语句:

           veh1 = veh2;

    按上面的推断,veh1也指向了第二个对象。这个没问题。问题是第一个对象呢?没有一条绳子系住它,它飞了。多数书里说,它被Java的垃圾回收机制回收了。

    这不确切。正确地说,它已成为垃圾回收机制的处理对象。至于什么时候真正被回收,那要看垃圾回收机制的心情了。

           由此看来,下面的语句应该不合法吧?至少是没用的吧?

    new Vehicle();

    不对。它是合法的,而且可用的。譬如,如果我们仅仅为了打印而生成一个对象,就不需要用引用变量来系住它。最常见的就是打印字符串:

        System.out.println(“I am Java!”);

    字符串对象“I am Java!”在打印后即被丢弃。有人把这种对象称之为临时对象。

           对象与引用的关系将持续到对象回收。

      

    Java对象及引用

     

    Java对象及引用是容易混淆却又必须掌握的基础知识,本章阐述Java对象和引用的概念,以及与其密切相关的参数传递。

     

    先看下面的程序:

    StringBuffer s;

    s = new StringBuffer("Hello World!");

    第一个语句仅为引用(reference)分配了空间,而第二个语句则通过调用类(StringBuffer)的构造函数StringBuffer(String str)为类生成了一个实例(或称为对象)。这两个操作被完成后,对象的内容则可通过s进行访问——在Java里都是通过引用来操纵对象的。

     

    Java对象和引用的关系可以说是互相关联,却又彼此独立。彼此独立主要表现在:引用是可以改变的,它可以指向别的对象,譬如上面的s,你可以给它另外的对象,如:

    s = new StringBuffer("Java");

    这样一来,s就和它指向的第一个对象脱离关系。

     

    从存储空间上来说,对象和引用也是独立的,它们存储在不同的地方,对象一般存储在堆中,而引用存储在速度更快的堆栈中。

     

    引用可以指向不同的对象,对象也可以被多个引用操纵,如:

    StringBuffer s1 = s;

    这条语句使得s1s指向同一个对象。既然两个引用指向同一个对象,那么不管使用哪个引用操纵对象,对象的内容都发生改变,并且只有一份,通过s1s得到的内容自然也一样,(String除外,因为String始终不变,String s1=”AAAA”; String s=s1,操作s,s1由于始终不变,所以为s另外开辟了空间来存储s,)如下面的程序:

    StringBuffer s;

    s = new StringBuffer("Java");

    StringBuffer s1 = s;

    s1.append(" World");

    System.out.println("s1=" + s1.toString());//打印结果为:s1=Java World

    System.out.println("s=" + s.toString());//打印结果为:s=Java World

      

    上面的程序表明,s1s打印出来的内容是一样的,这样的结果看起来让人非常疑惑,但是仔细想想,s1s只是两个引用,它们只是操纵杆而已,它们指向同一个对象,操纵的也是同一个对象,通过它们得到的是同一个对象的内容。这就像汽车的刹车和油门,它们操纵的都是车速,假如汽车开始的速度是80,然后你踩了一次油门,汽车加速了,假如车速升到了120,然后你踩一下刹车,此时车速是从120开始下降的,假如下降到60,再踩一次油门,车速则从60开始上升,而不是从第一次踩油门后的120开始。也就是说车速同时受油门和刹车影响,它们的影响是累积起来的,而不是各自独立(除非刹车和油门不在一辆车上)。所以,在上面的程序中,不管使用s1还是s操纵对象,它们对对象的影响也是累积起来的(更多的引用同理)。

     

    只有理解了对象和引用的关系,才能理解参数传递。

    一般面试题中都会考Java传参的问题,并且它的标准答案是Java只有一种参数传递方式:那就是按值传递,即Java中传递任何东西都是传值。如果传入方法的是基本类型的东西,你就得到此基本类型的一份拷贝。如果是传递引用,就得到引用的拷贝。

     

    一般来说,对于基本类型的传递,我们很容易理解,而对于对象,总让人感觉是按引用传递,看下面的程序:

    public class ObjectRef {

     

        //基本类型的参数传递

        public static void testBasicType(int m) {

            System.out.println("m=" + m);//m=50

            m = 100;

            System.out.println("m=" + m);//m=100

        }

       

        //参数为对象,不改变引用的值 ??????

        public static void add(StringBuffer s) {

            s.append("_add");

        }

       

        //参数为对象,改变引用的值 ?????

        public static void changeRef(StringBuffer s) {

            s = new StringBuffer("Java");

        }

       

        public static void main(String[] args) {

            int i = 50;

            testBasicType(i);

            System.out.println(i);//i=50

            StringBuffer sMain = new StringBuffer("init");

            System.out.println("sMain=" + sMain.toString());//sMain=init

            add(sMain);

            System.out.println("sMain=" + sMain.toString());//sMain=init_add

            changeRef(sMain);

            System.out.println("sMain=" + sMain.toString());//sMain=init_add

        }

    }

    以上程序的允许结果显示出,testBasicType方法的参数是基本类型,尽管参数m的值发生改变,但并不影响i

          add方法的参数是一个对象,当把sMain传给参数s时,s得到的是sMain的拷贝,所以ssMain指向同一个对象,因此,使用s操作影响的其实就是sMain指向的对象,故调用add方法后,sMain指向的对象的内容发生了改变。

          在changeRef方法中,参数也是对象,当把sMain传给参数s时,s得到的是sMain的拷贝,但与add方法不同的是,在方法体内改变了s指向的对象(也就是s指向了别的对象,牵着气球的绳子换气球了),给s重新赋值后,ssMain已经毫无关联,它和sMain指向了不同的对象,所以不管对s做什么操作,都不会影响sMain指向的对象,故调用changeRef方法前后sMain指向的对象内容并未发生改变。

     

    对于add方法的调用结果,可能很多人会有这种感觉:这不明明是按引用传递吗?对于这种问题,还是套用Bruce Eckel的话:这依赖于你如何看待引用,最终你会明白,这个争论并没那么重要。真正重要的是,你要理解,传引用使得(调用者的)对象的修改变得不可预期。

     

     public   class   Test
    {   public int   i,j;  
        public   void   test_m(Test   a)
        {     Test   b   =  new   Test();
              b.i   =   1;
              b.j   =   2;
              a   =   b;
        }
        public   void   test_m1(Test   a   )
        {     a.i   =   1;
            a.j   =   2;
        }
        public   static   void   main(String   argv[])
        {     Test   t=   new   Test();
              t.i   =   5;
              t.j   =   6;
              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //5,6
              t.test_m(t);
              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //5,6,
    at都指向了一个对象,而在test_ms又指向了另一个对象,所以对象t不变!!!

              t.test_m1(t);

              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //1,2

        }

    }

    答案只有一个:Java里都是按值传递参数。而实际上,我们要明白,当参数是对象时,传引用会发生什么状况(就像上面的add方法)?

     

    =========================================================================

    楼主,这样来记这个问题
    如下表达式:
    A a1 = new A();
    它代表A是类,a1是引用,a1不是对象,new A()才是对象,a1引用指向new A()这个对象。

    在JAVA里,“=”不能被看成是一个赋值语句,它不是在把一个对象赋给另外一个对象,它的执行过程实质上是将右边对象的地址传给了左边的引用,使得左边的引用指向了右边的对象。JAVA表面上看起来没有指针,但它的引用其实质就是一个指针,引用里面存放的并不是对象,而是该对象的地址,使得该引用指向了对象。在JAVA里,“=”语句不应该被翻译成赋值语句,因为它所执行的确实不是一个赋值的过程,而是一个传地址的过程,被译成赋值语句会造成很多误解,译得不准确。

     

    再如:
    A a2;
    它代表A是类,a2是引用,a2不是对象,a2所指向的对象为空null;

     

    再如:
    a2 = a1;
    它代表,a2是引用,a1也是引用,a1所指向的对象的地址传给了a2(传址),使得a2和a1指向了同一对象。

    综上所述,可以简单的记为,在初始化时,“=”语句左边的是引用,右边new出来的是对象。
    在后面的左右都是引用的“=”语句时,左右的引用同时指向了右边引用所指向的对象。

    再所谓实例,其实就是对象的同义词。

     

     

     

    如果需要赋值,就需要类实现Cloneable接口,实现clone()方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    class D implements Cloneable{//实现Cloneable接口
    	String sex;
    	D(String sex){
    		this.sex=sex;
    	}
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		// 实现clone方法
    		return super.clone();
    	}
    }

    赋值的时候:

    1
    2
    
    D d=new D("男");
    D d2=(D) d.clone();//把d赋值给d2

    如果类中的变量不是主类型,而是对象,也需要调用该对象的clone()方法
    下面是一个完整的例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    
    public class Test2 {
    	public static void main(String[] args) throws CloneNotSupportedException {
    		// TODO Auto-generated method stub
    		D d=new D("男");
    		C c=new C("张三","20",d);
    		C new_c=(C) c.clone();//调用clone方法来赋值
    		new_c.name="李四";
    		d.sex="女";//d
    		System.out.println(c.d.sex);
    		System.out.println(c.name);
     
    	}
     
    }
     
    class C implements Cloneable{
    	String name;
    	String age;
    	D d;
    	C(String name,String age,D d) throws CloneNotSupportedException{
    		this.name=name;
    		this.age=age;
    		this.d=(D) d.clone();//调用clone方法来赋值,这样即便外部的d发生变化,c里的也不会变
    	}
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		// TODO Auto-generated method stub
    		return super.clone();
    	}
    }
    class D implements Cloneable{//实现Cloneable接口
    	String sex;
    	D(String sex){
    		this.sex=sex;
    	}
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		// 实现clone方法
    		return super.clone();
    	}
    }


    内容来源:

    http://blog.sina.com.cn/s/blog_4cd5d2bb0100ve9r.html

    http://www.cnblogs.com/fly1988happy/archive/2012/04/26/2471099.html

    http://see.xidian.edu.cn/cpp/biancheng/view/207.html

    http://www.2cto.com/kf/201309/241135.html

    展开全文
  • 1、首先来说一下java中引用类型对象是怎么赋值: java中对于引用类型的对象的赋值(即用“=”把他们两种相连)都是指针传递,即复制一个指针给另外一个对象,这两个对象大家都指向同一处堆内存空间(如果这个对象是...

    1、首先来说一下java中引用类型对象是怎么赋值:

    java中对于引用类型的对象的赋值(即用“=”把他们两种相连)都是指针传递,即复制一个指针给另外一个对象,这两个对象大家都指向同一处堆内存空间(如果这个对象是new的)即同一块地址。所以当前一个对象赋值为null后,后面那个对象同样可以指向之前的内容,丝毫没有影响。这个相当于c++对象之间的浅拷贝,即把指针也一块拷贝过去了。

    下面看一个简单的java的demo

    package indi.demo;
    
    public class Test {
    	
    	public static void main(String[] args) {
    		/*总结:java中对于引用类型的对象都是指针传递,即复制一个指针给另外一个对象,大家都指向同一处堆内存空间。
    		而c++若成员变量中含有指针的对象的赋值和“=”,是真正的复制,也就是说只是复制的内容,涉及到开辟内存空间的是就新开辟一个内存空间
    		来存储复制的内容,当然地址(指针)也就发生了变化,但是指向的内容相等,不能说相同,因为存储相等东西的存储地址变了。
    		为什么C++不像java那样呢,因为完全没必要啊,若真的想指向同一个内容(内存区域),完全传递指针或者引用就可以了啊,java中它是没指针的。
    		*/
    		Student s1=new Student("zhangsan","001",new Student("呵呵","002", null));
    		Student s2=null;
    		s2=s1;
    		s2.getStu().setName("呵呵1");
    		System.out.println(s1.getStu().getName());
    		s1=null;
    		System.out.println(s2.getStu().getName()+"s2");
    	}
    
    }

     

    2、再来了解下C++中成员变量含有指针的对象间的赋值:

    c++中成员变量含有指针的对象的赋值(即用“=”把他们相连),是真正的复制,也就是说只是复制的内容,涉及到需要开辟内存空间的就新开辟一个内存空间来存储复制的内容(这个需要在拷贝构造函数,或者=号操作符重载中进行操作,当然也需要在析构函数中delete掉该对象中自己新开辟的堆内存空间),因此地址(指针)也就发生了变化,但是指向的内容相等不能说相同,因为存储相等东西的存储地址变了(指针里面就是存的该存储空间的首地址)。

    问题:为什么C++不能像java那样直接赋值呢:两个同类对象间直接进行引用传递。答案是:如果对象内不含指针,也就是类中包含的数据元素全部在栈上,没在堆上,浅拷贝也是完全可以的,对象将完全和java一样直接赋值,和java唯一的区别是这个对象是在栈上,而java中new的对象是在堆上。但是,如果对象内部含有指针,也就是类中的数据元素有在堆内存上的,就不能像java那样只是用"="简单赋值了,还应该建立相应的拷贝构造函数和"='等号操作符重载函数,为存放在堆内存上的数据重新开辟空间,防止析构的时候重复删除对应指针出的内容,导致宕机。java它有自己的垃圾回收机制,会自动清理堆内存中的垃圾,而c++中一般是通过析构函数中delete或者手动delete。凡是指向堆内存的指针都不能delete掉两次,不然程序都会出错。所以c++中的“=”分两种情况,都在栈上时就是指针传递,含有堆内存数据时就是复制,java中除基本类型外都是指针传递。这儿需要明确一点,c++中通过new创建的数据都是存放在堆内存的,new返回的都是指向堆内存空间的指针,当然c语言中的malloc函数开辟的空间也是在堆内存上,与new相似,只是new与delete会调用构造和析构函数,所以c++中用new和delete,用new开辟的堆内存空间,一定要手动删除。

    这儿额外补充个知识:c++中用new和不用new创建对象的本质区别!

    1:作用域不同

    不用new:作用域限制在定义类对象的方法中,当方法结束时,类对象也被系统释放了,(安全不会造成内存系统泄漏)。

    用new:创建的是指向类对象的指针,作用域变成了全局,当程序结束时,必须用delete删除,系统不会自动释放,(不注意可能造成内存泄漏)。

    2:用new 是在堆内存上开辟空间,而不用new就是在栈上,相当于一个局部变量。

    下面给出一个c++成员变量含有指针的一个对象的demo:

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    using namespace std;
    
    
    class Student
    {
    private:
    	int id;
    	char *name;
    public:
    	Student() {
    		id = 0;
    		name = NULL;
    	}
    	//构造函数中,对于成员函数是指针的同样要开辟存储空间
    	Student(int id, char *name) {
    		this->id = id;
    		int len = strlen(name);
    		this->name = new char[len + 1];
    		strcpy(this->name, name);
    	}
    	//拷贝构造函数
    	Student(const Student &std) {
    		this->id = std.id;
    		//执行深拷贝
    		int len = strlen(std.name);
    		this->name = new char[len+1];
    		//将之前的name对应的字符串拷贝到现在新开辟的内存空间对应的name地址
    		strcpy(this->name, std.name);
    	}
    	//等号操作符重载
    	Student & operator=(const Student & std) {
    		//思路:成员变量中含有指针的对象赋值,必须考虑重新开辟一个存储空间,而且开辟之前要把自己指针所对应的空间销毁
    		//防止出现自身赋值
    		if (this->name == std.name) {
    			return *this;
    		}
    		//将指针之前对应的内存空间销毁
    		if (this->name != NULL) {
    			delete name;
    			name = NULL;
    			this->id = 0;
    		}
    		//开辟新的内存空间,用于复制想要拷贝的东西
    		this->id = std.id;
    		int len = strlen(std.name);
    		this->name = new char[len+1];
    		strcpy(name, std.name);
    	}
    	//析构函数,必须清理掉自身开辟的内存空间,c++只给你清理本身对象所对应的空间,而你自己开辟的对应指针的空间需自己销毁,
    	//而java什么都不用你操心
    	~Student() {
    		//判断name是否为空,不为空就清理掉它对应的内存空间,并将name赋值为空
    		if (name != NULL) {
    			//注意指针对应的若是数组,应该用delete[]!!!
    			delete[] name;
    			name = NULL;
    		}
    	}
    	int getId() {
    		return this->id;
    	}
    	const char * getName() {
    		return this->name;
    	}
    };
    int main() {
    	Student s1(1, "zhang3");
    	Student s2(2, "li4");
    	Student s3=s2;
    	cout << s1.getId() << "," << s1.getName() << endl;
    	//s3 = s2;
    	cout << s3.getId() << "," << s3.getName() << endl;
    }

     

    展开全文
  • Java 对象之间相同属性的赋值

    千次阅读 2018-09-06 15:03:31
    1.BeanUtils.copyProperties import org.springframework.beans.BeanUtils; User src = new User(); User dest = new User(); BeanUtils.copyProperties(dest, src);...项目应用场景:将具有相同属性的ProductVO 转为...

    1.BeanUtils.copyProperties

    import org.springframework.beans.BeanUtils;
    User src = new User();
    User dest = new User();
    BeanUtils.copyProperties(dest, src);

    项目应用场景:将具有相同属性的ProductVO 转为Product。(ProductVO 包含的属性比Product多,包括不在product表里的list<Tag>,List<Qa>等)

     

    展开全文
  • 各位童鞋在java编程中,肯定会遇到继承、重写时对象到底执行哪个函数的问题,如果只是简单的用覆盖隐藏解释,还真的会傻傻分不清楚,下面我就针对以下2种情况逐个介绍。 一,常规的覆盖隐藏继承遵循以下几个原则: ...
  • 代表语言:Java举例:五子棋游戏 面向过程的设计思路: 首先分析问题的步骤: 1、开始游戏 2、黑子先走 3、绘制画面 4、判断输赢 5、轮到白子 6、绘制画面 7、判断输赢 8、返回步骤2, 9、输出最后结果。...
  • Java一行代码可声明多个同类变量

    万次阅读 2017-12-28 14:57:34
    Java支持一句语句声明多个同类变量。Example:String a = "Hello", c = "hello"; int x = 5, y = 5;
  • * 不同实体类,相同的属性赋值 * @param sourceData * @param toData * @param <T> */ public static <T> void copyFields(T sourceData, T toData) { if (sourceData == null || toData == null)...
  • 关于浅克隆与深克隆网上都有很多代码,但克隆的是相同类型的类,那么如果两个类是不同的类,而属性的值又是一样的该怎么赋值呢! 我们可以定义一个父类Entity(名字随便你们怎么定义),实现Cloneable接口,重写...
  • 一个Java程序展示(1)对象数组的使用;(2)不同类、同类中属性与方法的调用;(3)方法的封装 对象数组:数组中每一个元素为一个对象。 为对象数组分配内存空间: Animal [] animal = new Animal[10]; 对象数组...
  • 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char 引用数据类型变量包括哪些:数组,类,接口,枚举 class JavaObject { public static void main(String [] args) { Person p = new Person();...
  • 话不多说,上代码,小人拙见,不足之处望见谅! public String 方法名(参数) throws NoSuchMethodException, ...同类实现方法可以用BeanUtils.copyProperties(newObject,oldObject),实现对象的拷贝(后付前)。
  • 谨慎使用多个非同类; 多异常并列 多异常并列在一个catch中 ——从JDK7.0开始引入,简化写法; 示例: try { test(); } catch (IOException ex) { //异常处理 } catch (SQLException ex) { //异常处理 } try { ...
  • } catch(IOException | SQLException ex){ //从jdk7开始,支持一个catch写多个异常 } 多个异常之间不能有直接或者间接继承关系,否则报错 处理方法不一样也不能写在一起 整数类型可以用二进制直接赋值 数组也可以 ...
  • 两个对象赋值

    2017-04-27 17:53:00
    一:同类对象赋值 import java.lang.reflect.Field; public class ObjectUtil { /** * 赋值同类对象 * 非空或者非""才赋值 */ public static <T> void mergeObject(T origin, T destination...
  •  以上是赋值同类对象,下面是赋值给非同类的对象的同名属性例子 package test.test; import java.lang.reflect.Field; class Temp{ String a = null ; String b = null ; String c = null ; ...
  • Java

    千次阅读 2020-08-01 09:56:23
    Java 1、Java 简介 Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表...
  • java

    2018-04-02 23:06:15
    本人接触java几年有余,直到现在java10都快出来对java的理解还是不是太深,以前没写过博客第一次,在大家心中什么是怎么看待??简单理解为面向对象??。。看我下面搜索的理解。。Java是一门面向对象编程语言,不仅...
  • 我竟然不再抗拒 Java 的类加载机制了

    万次阅读 多人点赞 2019-07-10 12:47:50
    很长一段时间里,我对 Java 的类加载机制都非常的抗拒,因为我觉得太难理解了。但为了成为一名优秀的 Java 工程师,我决定硬着头皮研究一下。 01、字节码 在聊 Java 类加载机制之前,需要先了解一下 Java 字节码,...
  • 给相同的类对象赋值

    2015-12-11 15:06:45
    最近用到了给两个相同的类对象赋值。已知一个类对象已赋值,让该对象值赋给另一个对象,该类属性还包含有List属性。ClassReflction类是赋值的主要实现, package com.example.administrator.beanassignment; import...
  • 解读 Java 并发队列 BlockingQueue 转自:https://javadoop.com/post/java-concurrent-queue 最近得空,想写篇文章好好说说 java 线程池问题,我相信很多人都一知半解的,包括我自己在仔仔细细看源码之前,也有...
  • Java 解惑(Java Puzzler)

    千次阅读 2011-11-29 10:39:18
    郑重声明本文内容来源于《Java解惑》一书,不是本人所独创,请尊重原创作者的劳动成果和著作的知识版权。本文摘录原著内容,并做部分学习标记,仅作为自己的学习笔记数值表达式篇1. 奇偶判断不要使用 i % 2 == 1 ...
  • 通俗来讲数组就相当于一个专门盛放同类物种的容器,如:生产一箱矿泉水,首先要生产纸箱,但是生产纸箱需要告诉生产人需要生产多大(声明数组),比如这个纸箱能存放24瓶农夫就好比数组中的声明数组(创建数组),...
  • JAVA常量池

    2015-10-12 17:46:09
    Java程序运行在JVM上,JVM实现了java程序的平台无关性。Java的内存分配都在JVM中进行。 JVM为每个已加载的类维护一个常量池。用来保存 基本数据类型,String,对其他类,方法,字段的符号引用。 在Java语言中不是...
  • Java虚拟机规范 JavaSE8版 - Java虚拟机结构第2章 Java虚拟机结构2.1 class文件格式2.2 数据类型2.3原始类型与值2.3.1 整数类型与整型值2.3.2 浮点类型、取值集合及浮点值2.3.3 returnAddress 类型和值2.3.4 boolean...
  • JAVA

    2019-05-10 10:58:18
    import java.util.Scanner;导入包 Scanner input=new Scanner(System.in);创建Scanner对象 input随意 int 变量=input.next();接受输入的信息保存在变量中 使用 Arrays 类操作 Java 中的数组 import java.util....
  • 本文会结合虚拟机对引用和对象的不同处理来介绍三大特性的原理。 具体代码在我的GitHub中可以找到: ... 文章首发于我的个人博客: ...Java中的继承只能单继承,但是可以通过内部类继承其他类来实...
  • Java面试题-Java基础

    2021-03-06 11:47:58
    1. 什么是JavaJava是一门面向对象的编程语言,可跨平台的语言,与操作系统无关。 2. Java的特点? 简单性 面向对象(封装、继承、多态) 平台无关性 可靠性 安全性 多线程 网络编程 编译与解释共存 3. Java面向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,769
精华内容 4,307
关键字:

java同类赋值

java 订阅