java对象赋值的⽅法_JAVA对象引⽤，以及对象赋值
关键字: java对象 引⽤
Java对象及其引⽤
关于对象与引⽤之间的⼀些基本概念。
初学Java时，在很长⼀段时间⾥，总觉得基本概念很模糊。后来才知道，在许多Java书中，把对象和对象的引⽤混为⼀谈。可是，如果我分不清对象与对象引⽤，
那实在没法很好地理解下⾯的⾯向对象技术。把⾃⼰的⼀点认识写下来，或许能让初学Java的朋友们少⾛⼀点弯路。
为便于说明，我们先定义⼀个简单的类：
1 classVehicle
2 {
3 intpassengers;4
5 intfuelcap;6
7 intmpg;8
9 }
有了这个模板，就可以⽤它来创建对象：
1 Vehicle veh1 = new Vehicle();
通常把这条语句的动作称之为创建⼀个对象，其实，它包含了四个动作。
1)右边的“new Vehicle”，是以Vehicle类为模板，在堆空间⾥创建⼀个Vehicle类对象(也简称为Vehicle对象)。
2)末尾的()意味着，在对象创建后，⽴即调⽤Vehicle类的构造函数，对刚⽣成的对象进⾏初始化。构造函数是肯定有的。如果你没
写，Java会给你补上⼀个默认的构造函数。
3)左边的“Vehicle veh 1”创建了⼀个Vehicle类引⽤变量。所谓Vehicle类引⽤，就是以后可以⽤来指向V
ehicle对象的对象引⽤。
4)“=”操作符使对象引⽤指向刚创建的那个Vehicle对象。
我们可以把这条语句拆成两部分：
1 Vehicle veh1;2
3 veh1 = new Vehicle();
效果是⼀样的。这样写，就⽐较清楚了，有两个实体：⼀是对象引⽤变量，⼀是对象本⾝。
在堆空间⾥创建的实体，与在数据段以及栈空间⾥创建的实体不同。尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。不仅如此，
我们仔细研究⼀下第⼆句，刚创建的对象叫什么名字？有⼈说，它叫“Vehicle”。不对，“Vehicle”是类(对象的创建模板)的名字。
⼀个Vehicle类可以据此创建出⽆数个对象，这些对象不可能全叫“Vehicle”。
对象连名都没有，没法直接访问它。我们只能通过对象引⽤来间接访问对象。
为了形象地说明对象、引⽤及它们之间的关系，可以做⼀个或许不很妥当的⽐喻。对象好⽐是⼀只很⼤的⽓球，⼤到我们抓不住它。引⽤变量是⼀根绳， 可以⽤来系汽球。
如果只执⾏了第⼀条语句，还没执⾏第⼆条，此时创建的引⽤变量veh1还没指向任何⼀个对象，它的值是null。引⽤变量可以指向某个对象，或者为null。
它是⼀根绳，⼀根还没有系上任何⼀个汽球的绳。执⾏了第⼆句后，⼀只新汽球做出来了，并被系在veh1这根绳上。我们抓住这根绳，就等于抓住了那只汽球。
再来⼀句：
1 Vehicle veh2;
就⼜做了⼀根绳，还没系上汽球。如果再加⼀句：
1 veh
2 = veh1;
系上了。这⾥，发⽣了复制⾏为。但是，要说明的是，对象本⾝并没有被复制，被复制的只是对象引⽤。结果是，veh2也指向了veh1所指向的对象。两根绳系的是同⼀只汽球。
如果⽤下句再创建⼀个对象：
1 veh
2 = new Vehicle();
则引⽤变量veh2改指向第⼆个对象。
从以上叙述再推演下去，我们可以获得以下结论：
(1)⼀个对象引⽤可以指向0个或1个对象(⼀根绳⼦可以不系汽球，也可以系⼀个汽球)；
(2)⼀个对象可以有N个引⽤指向它(可以有N条绳⼦系住⼀个汽球)。
如果再来下⾯语句：
1 veh1 = veh2;
按上⾯的推断，veh1也指向了第⼆个对象。这个没问题。问题是第⼀个对象呢？没有⼀条绳⼦系住它，它飞了。多数书⾥说，它被Java的垃圾回收机制回收了。
这不确切。正确地说，它已成为垃圾回收机制的处理对象。⾄于什么时候真正被回收，那要看垃圾回收机制的⼼情了。
由此看来，下⾯的语句应该不合法吧？⾄少是没⽤的吧？
1 new Vehicle();
不对。它是合法的，⽽且可⽤的。譬如，如果我们仅仅为了打印⽽⽣成⼀个对象，就不需要⽤引⽤变量来系住它。最常见的就是打印字符串：
1 System.out.println(“I am Java!”);
字符串对象“I am Java!”在打印后即被丢弃。有⼈把这种对象称之为临时对象。
对象与引⽤的关系将持续到对象回收。
Java对象及引⽤
Java对象及引⽤是容易混淆却⼜必须掌握的基础知识，本章阐述Java对象和引⽤的概念，以及与其密切相关的参数传递。
先看下⾯的程序：
1 StringBuffer s;2
3 s = new StringBuffer("Hello World!");
第⼀个语句仅为引⽤(reference)分配了空间，⽽第⼆个语句则通过调⽤类(StringBuffer)的构造函数StringBuffer(String str)为类⽣成了⼀个实例(或称为对象)。这两个操作被完成后，对象的内容则可通过s进⾏访问——在Java⾥都是通过引⽤来操纵对象的。
Java对象和引⽤的关系可以说是互相关联，却⼜彼此独⽴。彼此独⽴主要表现在：引⽤是可以改变的，它可以指向别的对象，譬如上⾯的s，你可以给它另外的对象，如：
1 s = new StringBuffer("Java");
这样⼀来，s就和它指向的第⼀个对象脱离关系。
从存储空间上来说，对象和引⽤也是独⽴的，它们存储在不同的地⽅，对象⼀般存储在堆中，⽽引⽤存储在速度更快的堆栈中。
引⽤可以指向不同的对象，对象也可以被多个引⽤操纵，如：
1 StringBuffer s1 = s;
java接口可以创建对象吗这条语句使得s1和s指向同⼀个对象。既然两个引⽤指向同⼀个对象，那么不管使⽤哪个引⽤操纵对象，对象的内容都发⽣改变，并且只有⼀份，通过s1和s得到的内容⾃然也⼀样，(String除外，因为String始终不变，String s1=”AAAA”; String s=s1，操作s,s1由于始终不变，所以为s另外开辟了空间来存储s,)如下⾯的程序：
1 StringBuffer s;2
3 s = new StringBuffer("Java");4
5 StringBuffer s1 =s;6
7 s1.append(" World");8
9 System.out.println("s1=" + s1.toString());//打印结果为：s1=Java World
10
11 System.out.println("s=" + s.toString());//打印结果为：s=Java World
上⾯的程序表明，s1和s打印出来的内容是⼀样的，这样的结果看起来让⼈⾮常疑惑，但是仔细想想，s1和s只是两个引⽤，它们只是操纵杆⽽已，它们指向同⼀个对象，操纵的也是同⼀个对象，通过它们得到的是同⼀个对象的内容。这就像汽车的刹车和油门，它们操纵的都是车速，假如汽车开始的速度是80，然后你踩了⼀次油门，汽车加速了，假如车速升到了120，然后你踩⼀下刹车，此时车速是从120开始下降的，假如下降到60，再踩⼀次油门，车速则从60开始上升，⽽不是从第⼀次踩油门后的120开始。也就是说车速同时受油门和刹车影响，它们的影响是累积起来的，⽽不是各⾃独⽴(除⾮刹车和油门不在⼀辆车上)。所以，在上⾯的程序中，不管使⽤s1还是s操纵对象，它们对对象的影响也是累积起来的(更多的引⽤同理)。
只有理解了对象和引⽤的关系，才能理解参数传递。
⼀般⾯试题中都会考Java传参的问题，并且它的标准答案是Java只有⼀种参数传递⽅式：那就是按值传递，即Java中传递任何东西都是传值。如果传⼊⽅法的是基本类型的东西，你就得到此基本类型的⼀份拷贝。如果是传递引⽤，就得到引⽤的拷贝。
⼀般来说，对于基本类型的传递，我们很容易理解，⽽对于对象，总让⼈感觉是按引⽤传递，看下⾯的程序：
1 public classObjectRef {2
3
4
5 //基本类型的参数传递
6
7 public static void testBasicType(intm) {8
9 System.out.println("m=" + m);//m=50
10
11 m = 100;12
13 System.out.println("m=" + m);//m=100
14
15 }16
17
18
19 //参数为对象，不改变引⽤的值
20
21 public static voidadd(StringBuffer s) {22
23 s.append("_add");24
25 }26
27
28
29 //参数为对象，改变引⽤的值
30
31 public static voidchangeRef(StringBuffer s) {32
33 s = new StringBuffer("Java");34
35 }36
37
38
39 public static voidmain(String[] args) {40
41 int i = 50;42
43 testBasicType(i);44
45 System.out.println(i);//i=50
46
47 StringBuffer sMain = new StringBuffer("init");48
49 System.out.println("sMain=" + String());//sMain=init
50
51 add(sMain);52
53 System.out.println("sMain=" + String());//sMain=init_add
54
55 changeRef(sMain);56
57 System.out.println("sMain=" + String());//sMain=init_add
58
59 }60
61 }
以上程序的允许结果显⽰出，testBasicType⽅法的参数是基本类型，尽管参数m的值发⽣改变，但并不影响i。
add⽅法的参数是⼀个对象，当把sMain传给参数s时，s得到的是sMain的拷贝，所以s和sMain指向同⼀个对象，因此，使⽤s操作影响的其实就是sMain指向的对象，故调⽤add⽅法后，sMain指向的对象的内容发⽣了改变。
在changeRef⽅法中，参数也是对象，当把sMain传给参数s时，s得到的是sMain的拷贝，但与add⽅法不同的是，在⽅法体内改变了s指向的对象(也就是s指向了别的对象，牵着⽓球的绳⼦换⽓球了)，给s重新赋值后，s与sMain已经毫⽆关联，它和sMain指向了不同的对象，所以不管对s做什么操作，都不会影响sMain指向的对象，故调⽤changeRef⽅法前后sMain指向的对象内容并未发⽣改变。
对于add⽅法的调⽤结果，可能很多⼈会有这种感觉：这不明明是按引⽤传递吗？对于这种问题，还是套⽤Bruce Eckel的话：这依赖于你如何看待引⽤，最终你会明⽩，这个争论并没那么重要。真正重要的是，你要理解，传引⽤使得(调⽤者的)对象的修改变得不可预期。
1 public classTest
2 { public inti,j;
3 public voidtest_m(Test a)
4 { Test b = newTest();
5 b.i = 1;
6 b.j = 2;
7 a =b;
8 }
9 public voidtest_m1(Test a )10 { a.i = 1;11 a.j = 2;12 }13 public static voidmain(String argv[])14 { Test t= newTest();15 t.i = 5;16 t.j = 6;17 System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //5,6
st_m(t);19 System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //5,6,a和t都指向了⼀个对象，⽽在test_m中s⼜指向了另⼀个对象，所以对象t不变
20
st_m1(t);22
23 System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //1,2
24
25 }26
27 }
答案只有⼀个：Java⾥都是按值传递参数。⽽实际上，我们要明⽩，当参数是对象时，传引⽤会发⽣什么状况(就像上⾯的add⽅法)？
=========================================================================
楼主，这样来记这个问题
如下表达式：
1 A a1 = new A();
它代表A是类，a1是引⽤，a1不是对象，new A()才是对象，a1引⽤指向new A()这个对象。
在JAVA⾥，“=”不能被看成是⼀个赋值语句，它不是在把⼀个对象赋给另外⼀个对象，它的执⾏过程实质上是将右边对象的地址传给了左边的引⽤，使得左边的引⽤指向了右边的对象。JAVA表⾯上看起来没有指针，但它的引⽤其实质就是⼀个指针，引⽤⾥⾯存放的并不是对象，⽽是该对象的地址，使得
该引⽤指向了对象。在JAVA⾥，“=”语句不应该被翻译成赋值语句，因为它所执⾏的确实不是⼀个赋值的过程，⽽是⼀个传地址的过程，被译成赋值语句会造成很多误解，译得不准确。
再如：
1 A a2;
它代表A是类，a2是引⽤，a2不是对象，a2所指向的对象为空null;
再如：
1 a
2 = a1;
它代表，a2是引⽤，a1也是引⽤，a1所指向的对象的地址传给了a2(传址)，使得a2和a1指向了同⼀对象。
综上所述，可以简单的记为，在初始化时，“=”语句左边的是引⽤，右边new出来的是对象。
在后⾯的左右都是引⽤的“=”语句时，左右的引⽤同时指向了右边引⽤所指向的对象。
再所谓实例，其实就是对象的同义词。
如果需要赋值，就需要类实现Cloneable接⼝，实现clone()⽅法。
class D implements Cloneable{//实现Cloneable接⼝
String sex;
D(String sex){
this.sex=sex;

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。