对象和对象的引用
关于对象和对象引用的关系
关于对象和对象引⽤的关系 初学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 veh1”创建了⼀个Vehicle类引⽤变量。
所谓Vehicle类引⽤，就是以后可以⽤来指向Vehicle对象的对象引⽤。
4）“=”操作符使对象引⽤指向刚创建的那个Vehicle对象。
我们可以把这条语句拆成两部分： Vehicle veh1; //对象引⽤变量 veh1 = new Vehicle(); //对象本⾝效果是⼀样的。
这样写，就⽐较清楚了，有两个实体：⼀是对象引⽤变量，⼀是对象本⾝。
在堆空间⾥创建的实体，与在数据段以及栈空间⾥创建的实体不同。
尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。
不仅如此，我们仔细研究⼀下第⼆句，找找刚创建的对象叫什么名字？有⼈说，它叫“Vehicle”。
不对，“Vehicle”是类（对象的创建模板）的名字。
⼀个Vehicle类可以据此创建出⽆数个对象，这些对象不可能全叫“Vehicle”。
对象连名都没有，没法直接访问它。
对象的四种引用
对象的四种引用在Java编程中，对象的引用是非常重要的概念。
在Java中，对象的引用可以分为四种类型：强引用、软引用、弱引用和虚引用。
这四种引用类型在Java中都有着不同的用途和特点。
一、强引用强引用是Java中最常见的引用类型。
当我们使用new关键字创建一个对象时，这个对象就会被分配到堆内存中，并且会返回一个指向该对象的强引用。
只要强引用存在，垃圾回收器就不会回收该对象。
当强引用被赋值为null时，该对象就会成为垃圾，等待垃圾回收器回收。
二、软引用软引用是一种比较灵活的引用类型。
当一个对象只被软引用引用时，垃圾回收器会根据内存的情况来决定是否回收该对象。
如果内存充足，垃圾回收器就不会回收该对象；如果内存不足，垃圾回收器就会回收该对象。
软引用通常用于缓存数据，当内存不足时，可以自动释放缓存数据，避免内存溢出。
三、弱引用弱引用是一种比较弱的引用类型。
当一个对象只被弱引用引用时，垃圾回收器会立即回收该对象。
弱引用通常用于实现一些特殊的数据结构，如WeakHashMap等。
四、虚引用虚引用是一种比较特殊的引用类型。
虚引用并不会影响对象的生命周期，也不会影响垃圾回收器的回收行为。
虚引用通常用于跟踪对象被垃圾回收器回收的状态。
当一个对象被回收时，虚引用会收到一个通知，可以在收到通知后执行一些特殊的操作。
总结在Java中，对象的引用可以分为四种类型：强引用、软引用、弱引用和虚引用。
强引用是最常见的引用类型，只要强引用存在，垃圾回收器就不会回收该对象。
软引用是一种比较灵活的引用类型，通常用于缓存数据。
弱引用是一种比较弱的引用类型，当一个对象只被弱引用引用时，垃圾回收器会立即回收该对象。
虚引用是一种比较特殊的引用类型，通常用于跟踪对象被垃圾回收器回收的状态。
了解这四种引用类型的特点和用途，可以帮助我们更好地理解Java中的对象引用机制，从而编写出更加高效和健壮的Java程序。
对象间的4种关系
对象间的4种关系对象间的4种关系：一、依赖关系依赖关系是指一个对象在完成某个操作时，需要借助另一个对象的帮助。
在依赖关系中，一个对象被另一个对象所依赖，被依赖的对象通常称为被依赖对象，而依赖的对象称为依赖对象。
以购物系统为例，购物车与商品之间存在着依赖关系。
购物车的功能是将用户选择的商品添加到购物车中，而购物车需要借助商品对象来实现这个操作。
购物车依赖于商品对象，只有在商品对象的存在和合法性确认之后，购物车才能将商品添加到购物车中。
二、关联关系关联关系是指两个对象之间存在着连接，一个对象知道另一个对象的存在。
关联关系是一种较强的关系，通常体现为一个对象是另一个对象的成员或属性。
以学校系统为例，学生与班级之间存在着关联关系。
一个班级可以包含多个学生，而一个学生只属于一个班级。
学生对象中会包含一个班级对象的引用，通过这个引用，学生对象可以知道自己所属的班级。
三、聚合关系聚合关系是指一个对象包含另一个对象，但又不是强依赖的关系。
聚合关系是一种拥有关系，其中整体对象拥有部分对象，但部分对象并不是整体对象的一部分。
以图书馆系统为例，图书馆与图书之间存在着聚合关系。
图书馆可以拥有多本图书，而图书作为图书馆的一部分，并不依赖于图书馆的存在。
当图书馆关闭时，图书对象仍然存在。
四、组合关系组合关系是指一个对象包含另一个对象，并且另一个对象是整体对象的一部分。
组合关系是一种强依赖关系，整体对象的生命周期与部分对象的生命周期紧密相关。
以汽车系统为例，汽车与发动机之间存在着组合关系。
发动机是汽车的一部分，没有发动机汽车就无法正常运行。
整个汽车对象的生命周期与发动机对象的生命周期是紧密相关的，当汽车被销毁时，发动机也会被销毁。
总结：依赖关系是一种较弱的关系，表示一个对象需要借助另一个对象来完成某个操作；关联关系是一种较强的关系，表示一个对象知道另一个对象的存在；聚合关系是一种拥有关系，表示一个对象包含另一个对象，但另一个对象并不是整体对象的一部分；组合关系是一种强依赖关系，表示一个对象包含另一个对象，并且另一个对象是整体对象的一部分。
C++函数传递类对象和类对象的引用
C++函 数 传 递 类 对 象 和 类 对 象 的 引 用
1 #include <iostream>
2 #include<string>
3 using namespace std;
4
5 class Point {
6 public:
7 Point(int a, int b) :x(a), y(b) {};
24 Point res(a, b); //创建的是局部变量
25 return res; //传递对象引用(类似指针)
26 }
27
28 Point& re_PonitReference2(int a, int b) {
29 Point* res = new Point(a, b); //动态内存分配
13 }
14 private:
15 int x, y;
16 };
17
18 Point re_Ponit(int a,int b) {
19 Point res(a, b); //创建的是局部变量
20 return res; //传递对象实体
21 }
22
23 Point& re_PonitReference1(int a, int b) {
38 Point& a3 = re_PonitReference2(2, 3); //引用赋值(该函数传递的是一个堆内存变量的引用)
39 a1.print(); //源自,240 a2.print(); //随机值
41 a3.print(); //2,3
42 }
30 return *res; //传递对象引用
java对象的四种引用：强引用、软引用、弱引用和虚引用
java对象的四种引⽤：强引⽤、软引⽤、弱引⽤和虚引⽤在JDK1.2之前，创建的对象只有在处于可触及（reachable）的状态下，才能被程序使⽤。
也就是说，若⼀个对象不被任何变量引⽤，那么程序就⽆法再使⽤这个对象。
垃圾回收器⼀旦发现这些⽆⽤对象，就会对其进⾏回收。
但是，在某些情况下，我们会希望有些对象不需要被⽴即回收，或者说从全局的⾓度来说没有⽴即回收的必要性。
⽐如缓存系统的设计，在内存不吃紧或者说为了提⾼运⾏效率的情况下，⼀些暂时不⽤的对象仍然可放置在内存中，⽽不是⽴即进⾏回收。
为了满⾜这种要求，从JDK1.2版本开始，Java的设计⼈员把对象的引⽤细分为强引⽤（Strong Reference）、软引⽤（Soft Reference）、弱引⽤（Weak Reference）和虚引⽤（Phantom Reference）四种级别，细分的准则是体现在被GC回收的优先级上：强引⽤>软引⽤>弱引⽤>虚引⽤。
这样，从JDK1.2开始，GC垃圾回收器回收对象时，对象的有效性分析不仅仅是需要考虑对象可达性，还需要考虑对象的引⽤强度，从⽽使程序可以更加灵活地控制对象的⽣命周期。
可以⽤⼀个公式概括：对象的有效性=可达性+引⽤类型。
强引⽤（Strong Reference）强引⽤表⽰⼀个对象处在【有⽤，必须】的状态，是使⽤最普遍的引⽤。
如果⼀个对象具有强引⽤，那么垃圾回收器绝不会回收它。
就算在内存空间不⾜的情况下，Java虚拟机宁可抛出OutOfMemoryError错误，使程序异常终⽌，也不会通过回收具有强引⽤的对象来解决内存不⾜的问题。
Student student = new Student(); // 这就是强引⽤后⾯的软引⽤、弱引⽤和虚引⽤都是基于强引⽤的，都需要强引⽤的对象。
意思就是说，必须先有强引⽤的对象，然后在这个强引⽤的对象上做⽂章，通过⼀定操作把它变成软引⽤、弱引⽤或虚引⽤的对象。
【Java引用方式】对象的4种引用方式
【Java 引⽤⽅式】对象的4种引⽤⽅式概念强引⽤，软引⽤，弱引⽤，虚引⽤分类2.1强引⽤是指创建⼀个对象并把这个对象赋给⼀个引⽤变量。
只要对象和强引⽤还有关联JVM 就不会回收这个强引⽤的对象例⼦:Object obj=new Object()，obj 作为强引⽤存在虚拟机栈中，⽽new Object()作为对象存在于堆中，当obj 的作⽤域结束，对应的虚拟机栈消失，obj 引⽤也同时消失，但new Object()对象却仍然存在于堆中。
obj 强引⽤消失后，new Object()和它的关联也就断了，这样就不再和GC Roots 相连接，gc 在之后的某个时间就会回收这个对象了。
2.2软引⽤（SoftReference ）在Java 中⽤ng.ref.SoftReference 类来表⽰ 只有在内存不⾜的时候JVM 才会回收该对象对于这个MyObject 对象，有两个引⽤路径，⼀个是来⾃SoftReference 对象的软引⽤，⼀个来⾃变量aReference 的强引⽤，所以这个MyObject 对象是强可及对象随即，我们可以结束aReference 对这个MyObject 实例的强引⽤:aRef = null;个MyObject 对象成为了软可及对象。
如果垃圾收集线程进⾏内存垃圾收集，并不会因为有⼀个SoftReference 对该对象的引⽤⽽始终保留该对象。
2.3弱引⽤（WeakReference）当JVM 进⾏垃圾回收时，⽆论内存是否充⾜，都会回收被弱引⽤关联的对象在java 中，⽤ng.ref.WeakReference 类来表⽰当⼀个对象仅仅被weak reference 指向, ⽽没有任何其他strong reference 指向的时候, 如果GC 运⾏, 那么这个对象就会被回收2.4虚引⽤（PhantomReference）虚引⽤和前⾯的软引⽤、弱引⽤不同，它并不影响对象的⽣命周期。
为将对象引用设置到对象实例的方法
为将对象引用设置到对象实例的方法嘿呀，朋友们，今天咱们来聊聊那个让人摸不着头脑的“为将对象引用设置到对象实例”。
这就像是你想打开一个神秘宝藏的大门，但是手里却拿着一把不知道能不能匹配的钥匙。
你看啊，对象就像是一个个性格各异的小怪兽。
有的像可爱的皮卡丘，电闪雷鸣的很有活力；有的呢，像慢吞吞的树懒，半天不动一下。
而对象引用呢，就好比是你要抓住这些小怪兽的缰绳。
要是没设置好对象实例，那就相当于你想抓住皮卡丘，结果手里拿的是根面条，皮卡丘“嗖”的一下就跑没影了，只留下你在那干瞪眼，就像个丢了糖的小孩子，一脸茫然。
这就好比你去钓鱼，对象实例是鱼，对象引用是你的鱼竿。
你满心期待能钓上大鱼，结果鱼竿都没组装好，还怎么钓呀？你就只能看着水里的鱼游来游去，它们仿佛还在嘲笑你：“嘿嘿，你连鱼竿都搞不定，还想抓我们呢！”这时候的你啊，就像个小丑，在岸边瞎忙活。
再夸张一点说，对象引用设置到对象实例就像是给超级英雄找到他的专属战衣。
要是没设置好，那超级英雄就只能穿着睡衣去拯救世界啦，这画面是不是超级滑稽？他可能一飞起来，睡衣就被吹走了，然后他就羞红了脸在空中乱扑腾，像只没头的苍蝇。
有时候啊，这个过程就像给火箭装燃料。
对象实例是燃料，对象引用就是连接燃料的管道。
要是管道没接好，火箭就只能在原地干冒烟，根本飞不起来。
那火箭就像个生气的大铁桶，“哼，你不给我好好装燃料，我就不走啦！”而且这就如同你要给一群小鸭子找到它们的鸭妈妈。
对象实例是鸭妈妈，对象引用是你带领小鸭子的路线。
要是路线不对，小鸭子们就会满世界乱跑，鸭妈妈在那边干着急，你也只能在旁边挠着头，像个做错事的小学生。
要是在代码的世界里，没设置好对象引用到对象实例，就像是厨师炒菜却找不到锅铲。
那厨师只能拿着个空盘子在那挥舞，假装在炒菜，而锅里的菜早就糊成一团了，就像一堆烂泥巴，整个厨房都乱了套。
又像是指挥家找不到他的指挥棒，乐队在那等着演奏，结果指挥家只能用筷子来指挥，那音乐肯定会乱成一锅粥，就像一群喝醉的蚂蚁在乱爬一样。
标签制作软件中一个对象如何引用其他多个的对象中的数据
在平时使用标签制作软件去批量制作可变数据标签的时候，通常只是标签中的一个对象引用另外一个对象中的数据，其实软件还可以一个对象引用标签中的多个对象中的数据。
接下来我们就以植物标签为例子，来演示一下标签制作软件中如何一个对象引用其他多个对象中的数据？
一、打开软件，在“文档设置”中根据实际标签纸张大小去设置纸张尺寸。
二、数据库导入植物标签中可变的植物数据信息。
——点击软件上方“数据库设置”，添加一个“Excel数据源”，把保存Excel表中的植物信息通过数据库导入软件中。
三、添加植物标签中的文字。
1）在标签空白处添加普通文本。
打开普通文本的“图形属性”-“数据源”，修改文本默认数据，数据对象类型选择“数据库导入”，导入Excel表中的“植物名称”字段。
字体大小颜色可以根据自己的需要修改。
2）在绘制一个普通文本，植物标签中固定的文字使用“手动输入”的方式去进行添加，可变的数据信息按照上面数据库导入方式添加即可。
3）因为接下来植物标签二维码数据中显示的就是植物名称、别称、科属的信息，所以在图形属性——基本中分别记下，这几个数据对象在标签制作软件中ID是几。
四、一个对象引用多个对象中的数据。
1）点击软件左侧绘制二维码，双击绘制的二维码，弹出图形属性，在数据源中点击修改，数据对象类型选择“数据引用”，将植物名称图形ID填写进去；
2）接着在二维码数据对象下点击“+”，以上面同样的操作步骤去添加别称、科属在软件中的ID。
到这里在标签制作软件中一个对象引用其他多个对象中的数据操作步骤就介绍完了。
有需要的小伙伴可以按照文章中的操作步骤去进行设置哦。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
关键字: 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 veh1”创建了一个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;这条语句使得s1和s指向同一个对象。
既然两个引用指向同一个对象，那么不管使用哪个引用操纵对象，对象的内容都发生改变，并且只有一份，通过s1和s得到的内容自然也一样，(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 WorldSystem.out.println("s=" + s.toString());//打印结果为：s=Java World上面的程序表明，s1和s打印出来的内容是一样的，这样的结果看起来让人非常疑惑，但是仔细想想，s1和s只是两个引用，它们只是操纵杆而已，它们指向同一个对象，操纵的也是同一个对象，通过它们得到的是同一个对象的内容。
这就像汽车的刹车和油门，它们操纵的都是车速，假如汽车开始的速度是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=50m = 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=50StringBuffer sMain = new StringBuffer("init");System.out.println("sMain=" +sMain.toString());//sMain=initadd(sMain);System.out.println("sMain=" +sMain.toString());//sMain=init_addchangeRef(sMain);System.out.println("sMain=" +sMain.toString());//sMain=init_add}}以上程序的允许结果显示出，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的话：这依赖于你如何看待引用，最终你会明白，这个争论并没那么重要。