作为一个有着 8 年 Java 编程经验的 IT 老兵，说起来很惭愧，我被 Java 当中的四五个名词一直困扰着：对象、引用、堆、栈、堆栈（栈可同堆栈，因此是四个名词，也是五个名词）。每次我看到这几个名词，都隐隐约约觉得自己在被一只无形的大口慢慢地吞噬，只剩下满地的衣服碎屑（为什么不是骨头，因为骨头也好吃）。
 
记得中学的课本上，有一篇名为《狂人日记》课文；那时候根本理解不了鲁迅写这篇文章要表达的中心思想，只觉得满篇的“吃人”令人心情压抑；老师在讲台上慷慨激昂的讲，大多数的同学同我一样，在课本面前“痴痴”的发呆。
 
十几年后，再读《狂人日记》，恍然如梦：
 
 
 
鲁迅先生以狂人的口吻，再现了动乱时期下中国人的精神状态，视角新颖，文笔细腻又不乏辛辣之味。
 
 
当时的中国，混乱成了主色调。以清廷和孔教为主的封建旧思想还在潜移默化地影响着人们的思想，与此同时以革命和新思潮为主的现代思想已经开始了对大众灵魂的洗涤和冲击。
 
 
最近，和沉默王二技术交流群（120926808）的群友们交流后，Java 中那四五个会吃人的名词：对象、引用、堆、栈、堆栈，似乎在脑海中也清晰了起来，尽管疑惑有时候仍然会在阴云密布时跑出来——正鉴于此，这篇文章恰好做一下归纳。
 
一、对象和引用
 
在 Java 中，尽管一切都可以看做是对象，但计算机操作的并非对象本身，而是对象的引用。 这话乍眼一看，似懂非懂。究竟什么是对象，什么又是引用呢？
 
先来看对象的定义：按照通俗的说法，每个对象都是某个类（class）的一个实例（instance）。那么，实例化的过程怎么描述呢？来看代码（类是 String）：
 
new String("我是对象张三");
new String("我是对象李四");
 
在 Java 中，实例化指的就是通过关键字“new”来创建对象的过程。以上代码在运行时就会创建两个对象——“我是对象张三"和"我是对象李四”；现在，该怎么操作他们呢？
 
去过公园的同学应该会见过几个大爷，他们很有一番本领——个个都能把风筝飞得老高老高，徒留我们眼馋的份！风筝飞那么高，没办法直接用手拽着飞啊，全要靠一根长长的看不见的结实的绳子来牵引！操作 Java 对象也是这个理，得有一根绳——也就是接下来要介绍的“引用”（我们肉眼也常常看不见它）。
 
String zhangsan, lisi;
zhangsan = new String("我是对象张三");
lisi = new String("我是对象李四");
 
这三行代码该怎么理解呢？
 
先来看第一行代码：String zhangsan, lisi;——声明了两个变量 zhangsan 和 lisi，他们的类型为 String。
 
①、歧义：zhangsan 和 lisi 此时被称为引用。
 
你也许听过这样一句古文：“神之于形，犹利之于刀；未闻刀没而利存，岂容形亡而神在？”这是无神论者范缜（zhen）的名言，大致的意思就是：灵魂对于肉体来说，就像刀刃对于刀身；从没听说过刀身都没了刀刃还存在，那么怎么可能允许肉体死亡了而灵魂还在呢？
 
“引用”之于对象，就好比刀刃之于刀身，对象还没有创建，又怎么存在对象的“引用”呢？
 
如果 zhangsan 和 lisi 此时不能被称为“引用”，那么他们是什么呢？答案很简单，就是变量啊！（鄙人理解）
 
②、误解：zhangsan 和 lisi 此时的默认值为 null。
 
应该说 zhangsan 和 lisi 此时的值为 undefined——借用 JavaScript 的关键字；也就是未定义；或者应该是一个新的关键字 uninitialized——未初始化。但不管是 undefined 还是 uninitialized，都与 null 不同。
 
既然没有初始化，zhangsan 和 lisi 此时就不能被使用。假如强行使用的话，编译器就会报错，提醒 zhangsan 和 lisi 还没有出生（初始化）；见下图。
 
 
如果把 zhangsan 和 lisi 初始化为 null，编译器是认可的（见下图）；由此可见，zhangsan 和 lisi 此时的默认值不为 null。
 
 
再来看第二行代码：zhangsan = new String("我是对象张三");——创建“我是对象张三"的 String 类对象，并将其赋值给 zhangsan 这个变量。
 
此时，zhangsan 就是"我是对象张三"的引用；“=”操作符赋予了 zhangsan 这样神圣的权利。
 
第三行代码 lisi = new String("我是对象李四");和第二行代码 zhangsan = new String("我是对象张三");同理。
 
现在，我可以下这样一个结论了——对象是通过 new 关键字创建的；引用是依赖于对象的；= 操作符把对象赋值给了引用。
 
我们再来看这样一段代码：
 
String zhangsan, lisi;
zhangsan = new String("我是对象张三");
lisi = new String("我是对象李四");
zhangsan = lisi;
 
当 zhangsan = lisi; 执行过后，zhangsan 就不再是"我是对象张三"的引用了；zhangsan 和 lisi 指向了同一个对象（“我是对象李四”）；因此，你知道 System.out.println(zhangsan == lisi); 打印的是 false 还是 true 了吗？
 
二、堆、栈、堆栈
 
谁来告诉我，为什么有很多地方（书、博客等等）把栈叫做堆栈，把堆栈叫做栈？搞得我都头晕目眩了——绕着门柱估计转了 80 圈，不晕才怪！
 
我查了一下金山词霸，结果如下：
 
 
我的天呐，更晕了，有没有！怎么才能不晕呢？我这里有几招武功秘籍，你们尽管拿去一睹为快：
 
1）以后再看到堆、栈、堆栈三个在一起打牌的时候，直接把“堆栈”踢出去；这仨人不适合在一起玩，因为堆和栈才是老相好；你“堆栈”来这插一脚算怎么回事；这世界上只存在“堆、栈”或者“堆栈”（标点符号很重要哦）。
 
2）堆是在程序运行时在内存中申请的空间（可理解为动态的过程）；切记，不是在编译时；因此，Java 中的对象就放在这里，这样做的好处就是：
 
 
 
当需要一个对象时，只需要通过 new 关键字写一行代码即可，当执行这行代码时，会自动在内存的“堆”区分配空间——这样就很灵活。
 
 
另外，需要记住，堆遵循“先进后出”的规则（此处有雷）。就好像，一个和尚去挑了一担水，然后把一担水装缸里面，等到他口渴的时候他再用瓢舀出来喝。请放肆地打开你的脑洞脑补一下这个流程：缸底的水是先进去的，但后出来的。所以，我建议这位和尚在缸上贴个标签——保质期 90 天，过期饮用，后果自负！
 
还是记不住，看下图：
 
 
（不好意思，这是鼎，不是缸，将就一下哈）
 
3）栈，又名堆栈（简直了，完全不符合程序员的思维啊，我们程序员习惯说一就是一，说二就是二嘛），能够和处理器（CPU，也就是脑子）直接关联，因此访问速度更快；举个十分不恰当的例子哈——眼睛相对嘴巴是离脑子近的一方，因此，你可以一目十行，但绝对做不到一开口就读十行字，哪怕十个字也做不到。
 
既然访问速度快，要好好利用啊！Java 就把对象的引用放在栈里。为什么呢？因为引用的使用频率高吗？
 
不是的，因为 Java 在编译程序时，必须明确的知道存储在栈里的东西的生命周期，否则就没法释放旧的内存来开辟新的内存空间存放引用——空间就那么大，前浪要把后浪拍死在沙滩上啊。
 
现在清楚堆、栈和堆栈了吧？
 
三、基本数据类型
 
先来看《Java 编程思想》中的一段话：
 
 
 
在程序设计中经常用到一系列类型，他们需要特殊对待。之所以特殊对待，是因为 new 将对象存储于“堆”中，故用 new 创建一个对象──特别小、简单的变量，往往不是很有效。因此，不用new来创建这类变量，而是创建一个并非是引用的变量，这个变量直接存储值，并置于栈中，因此更加高效。
 
 
在 Java 中，这些基本类型有：boolean、char、byte、short、int、long、float、double 和 void；还有与之对应的包装器：Boolean、Character、Byte、Short、Integer、Long、Float、Double 和 Void；它们之间涉及到装箱和拆箱，点击链接。
 
看两行简单的代码：
 
 int a = 3;
 int b = 3;
 
这两行代码在编译的时候是什么样子呢？
 
编译器当然是先处理 int a = 3;，不然还能跳过吗？编译器在处理 int a = 3; 时在栈中创建了一个变量为 a 的内存空间，然后查找有没有字面值为 3 的地址，没找到，就开辟一个存放 3 这个字面值的地址，然后将 a 指向 3 的地址。
 
编译器忙完了 int a = 3;，就来接着处理 int b = 3;；在创建完 b 的变量后，由于栈中已经有 3 这个字面值，就将 b 直接指向 3 的地址；就不需要再开辟新的空间了。
 
依据上面的概述，我们假设在定义完 a 与 b 的值后，再令 a=4，此时 b 是等于 3 呢，还是 4 呢？
 
思考一下，再看答案哈。
 
答案揭晓：当编译器遇到 a = 4;时，它会重新搜索栈中是否有 4 的字面值，如果没有，重新开辟地址存放 4 的值；如果已经有了，则直接将 a 指向 4 这个地址；因此 a 值的改变不会影响到 b 的值哦。
 
最后，留个作业吧，下面这段代码在运行时会输出什么呢？
 
public class Test1 {
    public static void main(String args[]) {
        int a = 1;
        int b = 1;

        a = 2;

        System.out.println(a);
        System.out.println(b);

        TT t = new TT("T");
        TT t1 = t;
        t.setName("TT");


        System.out.println(t.getName());
        System.out.println(t1.getName());
    }
}

class TT{
    private String name;

    public TT (String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name1) {
        this.name = name1;
    }
}
 
 
上一篇：如何理解 Java 中的继承？
 
下一篇：Java 的操作符——“=”号
 
微信搜索「沉默王二」公众号，关注后回复「免费视频」获取 500G Java 高质量教学视频（已分门别类）。
 

 
   浅谈一下JAVA对象，对象引用以及对象赋值
 
         今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会，自己总结一下JAVA对象，对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子，整理汇总形成下面的文章。
 
 
 
Java对象及其引用
 
    初学Java，总是会自觉或不自觉地把Java和C++相比较。在学习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对象和引用以及与其密切相关的参数传递
 
    先看下面的程序：
 
    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 World
 
    System.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=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的拷贝，所以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的话：这依赖于你如何看待引用，最终你会明白，这个争论并没那么重要。真正重要的是，你要理解，传引用使得（调用者的）对象的修改变得不可预期。
 
 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,a和t都指向了一个对象，而在test_m中s又指向了另一个对象，所以对象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()方法。
 
 
 
 
 
 
 
class D implements Cloneable{//实现Cloneable接口
 String sex;
 D(String sex){
  this.sex=sex;
 }
 @Override
 protected Object clone() throws CloneNotSupportedException {
  // 实现clone方法
  return super.clone();
 }
}
 
 
 
  赋值的时候：
 
 
 
 
 
 
 
D d=new D("男");
D d2=(D) d.clone();//把d赋值给d2
 
 
 
    如果类中的变量不是主类型，而是对象，也需要调用该对象的clone()方法
 下面是一个完整的例子：
 
 
 
 
 
 
 
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();
 }
}
 
 
 
 
 
 
 
Java强引用、 软引用、 弱引用、虚引用
 
      既然讨论到了java的引用问题，自然就会想到java的引用分为几种情况，下面详细说一下Java的四种引用。
 
 1、对象的强、软、弱和虚引用
     在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及（reachable）状态，程序才能使用它。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
 
 
              图1
 
图1为对象应用类层次
     1)强引用（StrongReference）
     强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
     2)软引用（SoftReference）
     如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存（下文给出示例）。
     软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
 
3) 弱引用（WeakReference）
     弱引用与软引用的区别在于：弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
     弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
 4)虚引用（PhantomReference）
     “虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。
  
     程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 2、对象可及性的判断
     在很多时候，一个对象并不是从根集直接引用的，而是一个对象被其他对象引用，甚至同时被几个对象所引用，从而构成一个以根集为顶的树形结构。如图2所示
 
 
    在这个树形的引用链中，箭头的方向代表了引用的方向，所指向的对象是被引用对象。由图可以看出，从根集到一个对象可以由很多条路径。比如到达对象5的路径就有①-⑤，③-⑦两条路径。由此带来了一个问题，那就是某个对象的可达性如何判断:
     单条引用路径可达性判断:在这条路径中，最弱的一个引用决定对象的可达性。
     多条引用路径可达性判断:几条路径中，最强的一条的引用决定对象的可达性。
     比如，我们假设图2中引用①和③为强引用，⑤为软引用，⑦为弱引用，对于对象5按照这两个判断原则，路径①-⑤取最弱的引用⑤，因此该路径对对象5的引用为软引用。同样，③-⑦为弱引用。在这两条路径之间取最强的引用，于是对象5是一个软可达对象。
 

 3、使用软引用构建敏感数据的缓存
 

 3.1 为什么需要使用软引用
     首先，我们看一个雇员信息查询系统的实例。我们将使用一个Java语言实现的雇员信息查询系统查询存储在磁盘文件或者数据库中的雇员人事档案信息。作为一个用户，我们完全有可能需要回头去查看几分钟甚至几秒钟前查看过的雇员档案信息(同样，我们在浏览WEB页面的时候也经常会使用“后退”按钮)。这时我们通常会有两种程序实现方式:一种是把过去查看过的雇员信息保存在内存中，每一个存储了雇员档案信息的Java对象的生命周期贯穿整个应用程序始终;另一种是当用户开始查看其他雇员的档案信息的时候，把存储了当前所查看的雇员档案信息的Java对象结束引用，使得垃圾收集线程可以回收其所占用的内存空间，当用户再次需要浏览该雇员的档案信息的时候，重新构建该雇员的信息。很显然，第一种实现方法将造成大量的内存浪费，而第二种实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集，包含雇员档案信息的对象仍然完好地保存在内存中，应用程序也要重新构建一个对象。我们知道，访问磁盘文件、访问网络资源、查询数据库等操作都是影响应用程序执行性能的重要因素，如果能重新获取那些尚未被回收的Java对象的引用，必将减少不必要的访问，大大提高程序的运行速度。
 
 
 3.2 如果使用软引用
     SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。另外，一旦垃圾线程回收该Java对象之后，get()方法将返回null。看下面代码:
     MyObject  aRef  =  new   MyObject();
     SoftReference  aSoftRef = new  SoftReference( aRef );
     此时，对于这个MyObject对象，有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aRef的强引用，所以这个MyObject对象是强可及对象。
 随即，我们可以结束aRef对这个MyObject实例的强引用:
     aRef  =  null ;
     此后，这个MyObject对象成为了软可达对象。如果垃圾收集线程进行内存垃圾收集，并不会因为有一个SoftReference对该对象的引用而始终保留该对象。Java虚拟机的垃圾收集线程对软可达对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象，而且虚拟机会尽可能优先回收长时间闲置不用的软可达对象，对那些刚刚构建的或刚刚使用过的软可达对象会被虚拟机尽可能保留。在回收这些对象之前，我们可以通过:
     MyObject  anotherRef =(MyObject) aSoftRef .get()
     重新获得对该实例的强引用。而回收之后，调用get()方法就只能得到null了。
  
 3.3 使用ReferenceQueue清除失去了软引用对象的SoftReference
     作为一个Java对象，SoftReference对象除了具有保存软引用的特殊性之外，也具有Java对象的一般性。所以，当软可及对象被回收之后，虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制，避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候，使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法，如:
     ReferenceQueue  queue  =  new   ReferenceQueue();
     SoftReference   ref = new   SoftReference( aMyObject ,  queue );
     那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出，它是一个队列，当我们调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象。
     在任何时候，我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可达对象被回收。如果队列为空，将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法，我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。常用的方式为:
     SoftReference ref =  null ;
     while  ((ref = (SoftReference)q .poll()) !=  null ) {
      // 清除 ref
     }
     理解了ReferenceQueue的工作机制之后，我们就可以开始构造一个Java对象的高速缓存器了。
  
 3.4通过软可及对象重获方法实现Java对象的高速缓存
     利用Java2平台垃圾收集机制的特性以及前述的垃圾对象重获方法，我们通过一个雇员信息查询系统的小例子来说明如何构建一种高速缓存器来避免重复构建同一个对象带来的性能损失。我们将一个雇员的档案信息定义为一个Employee类:
 public   class  Employee {
      private  String  id ; // 雇员的标识号码
      private  String  name ; // 雇员姓名
      private  String  department ; // 该雇员所在部门
      private  String  Phone ; // 该雇员联系电话
      private   int   salary ; // 该雇员薪资
      private  String  origin ; // 该雇员信息的来源
 
 

      // 构造方法
      public  Employee(String id) {
         this . id  = id;
        getDataFromlnfoCenter();
     }
 

      // 到数据库中取得雇员信息
      private   void  getDataFromlnfoCenter() {
         // 和数据库建立连接井查询该雇员的信息，将查询结果赋值
         // 给 name， department， plone， salary等变量
         // 同时将 origin赋值为 "From DataBase"
     }
 ……
 }
     这个Employee类的构造方法中我们可以预见，如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:
  
 import  java.lang.ref.ReferenceQueue;
 import  java.lang.ref.SoftReference;
 import  java.util.Hashtable;
 

 public   class  EmployeeCache {
      static  private  EmployeeCache  cache ; // 一个 Cache实例
      private  Hashtable<String, EmployeeRef>  employeeRefs ; // 用于 Chche内容的存储
      private  ReferenceQueue<Employee>  q ; // 垃圾 Reference的队列
 
      // 继承 SoftReference，使得每一个实例都具有可识别的标识,
      // 并且该标识与其在 HashMap内的 key相同。
      private class EmployeeRef extends SoftReference<Employee> {
         private  String  _key  =  "" ;
 

         public  EmployeeRef(Employee em, ReferenceQueue<Employee> q) {
             super (em, q);
             _key  = em.getID();
        }
     }
 
      // 构建一个缓存器实例
      private  EmployeeCache() {
         employeeRefs  =  new  Hashtable<String,EmployeeRef>();
         q  =  new  ReferenceQueue<Employee>();
     }
 
      // 取得缓存器实例
      public   static synchronized EmployeeCache getInstance() {
        if  (cache == null){
             cache = new EmployeeCache();
        }
        return cache ;
     }
 

      // 以软引用的方式对一个 Employee对象的实例进行引用并保存该引用
      private   void  cacheEmployee(Employee em) {
        cleanCache(); // 清除垃圾引用
        EmployeeRef ref =  new  EmployeeRef(em,  q );
         employeeRefs .put(em.getID(), ref);
     }
 
      // 依据所指定的 ID号，重新获取相应 Employee对象的实例
      public  Employee getEmployee(String ID) {
        Employee em =  null ;
         // 缓存中是否有该 Employee实例的软引用，如果有，从软引用中取得。
         if  ( employeeRefs .containsKey(ID)) {
            EmployeeRef ref = (EmployeeRef)  employeeRefs .get(ID);
            em = (Employee) ref.get();
        }
         // 如果没有软引用，或者从软引用中得到的实例是 null，重新构建一个实例，
         // 并保存对这个新建实例的软引用
         if  (em ==  null ) {
            em =  new  Employee(ID);
            System. out .println( "Retrieve From EmployeeInfoCenter. ID="  + ID);
             this .cacheEmployee(em);
        }
         return  em;
     }
 

      // 清除那些所软引用的 Employee对象已经被回收的 EmployeeRef对象
      private   void  cleanCache() {
        EmployeeRef ref =  null ;
         while  ((ref = (EmployeeRef)  q .poll()) !=  null ) {
             employeeRefs .remove(ref. _key );
        }
     }
 }
 
结语：
 
 
       上述是从自己见过的感觉对理解Java对象，对象引用以及对象赋值，目前最优价值的帖子中挑选而来。希望对大家有用。
 
 
 
 
 
主要参考资料：
 
http://blog.sina.com.cn/s/blog_4cd5d2bb0100ve9r.html
 
http://bxkqzjt521.blog.163.com/blog/static/202818420119102362458/
 
http://www.2cto.com/kf/201207/139522.html
 
 
 
 

程序设计语言中将参数传递给方法的几种方式: 
 按名调用(call by name) : Algol 语言采用此方式, 已成为历史; 
 按值调用(call by value) : 方法接收到的是调用者提供的 变量值 ; 
 按引用调用(call by reference) : 方法接受到的是调用者提供的 变量地址 ; 
 C++ 支持 按值调用 和 按引用调用 : 
 
 
而 Java 只支持按值调用 , 也就是说方法得到的是所有参数值的一个拷贝, 在方法内对参数值进行修改是不会影响参数原值的.因为退出方法后会对修改后的参数进行销毁
 
然而方法参数有两种类型: 
 基本数据类型: 数字, 布尔值; 
 对象引用. 
 当方法参数是 对象引用 时, 在方法很容易的调用其 setXXX 方法修改该对象属性值, 在退出方法后该修改仍然有效, 但这仍旧只是按值调用 . 
 因为参数是 对象引用 , 在该方法内仍旧执行原对象(类似 C++ 的指针), 调用它的 setXXX 方法当然能修改对象属性了. 但也仅限于修改对象属性(状态), 而不能通过new 等方式对原对象进行修改. 
 如果还有疑问, 就请看看这个例子: 
  
 请问在执行 swap() 函数后, 对象 a 和 对象 b 的 name 是否变化? 
 答案是没有变化. 在 testSwap() 方法中, first 和 second 完成交换并分别指向对方. 但是, 在进入方法时, 它们拿到的是对象引用的拷贝(位置), 类似于: 
 进入 swap() 方法前, a 知道在内存地址为 100 的地方存储了一个 MyObject 对象, ‘b’ 知道在内存地址为 200 的地方存储了另一个MyObject 对象; 
 进入 swap() 方法时, a 将它的对象引用复制一份给 first , 也就是说first 知道内存地址为 100 的地方有一个 MyObject 对象. second 同理; 
 在退出 swap() 方法时, first 与 second 交换值, 也就是说first 知道内存地址为 200 的地方有一个 MyObject 对象, 它已经跟内存地址为 100 的 MyObject 对象没有任何关系了. second 同理; 
 在退出 swap() 方法后, first 与 second 被销毁, a 仍旧是知道内存地址为 100 的地方有一个 MyObject 对象… 
 其实, 这就是 C/C++ 的指针. 
 顺便说一句, 通过 C++ 的 按引用调用 可以很方便实现 swap() 函数. 当然, 用指针也是支持的, 只不过稍微复杂点(这里只给出声明, 有兴趣的同学自己去写实现吧): 
  
 综上, 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;
 
这条语句使得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 World

System.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=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的拷贝，所以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的话：这依赖于你如何看待引用，最终你会明白，这个争论并没那么重要。真正重要的是，你要理解，传引用使得（调用者的）对象的修改变得不可预期。
 
 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,a和t都指向了一个对象，而在test_m中s又指向了另一个对象，所以对象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()方法。 
 如果类中的变量不是主类型，而是对象，也需要调用该对象的clone()方法** 
 关于通过方法来改变对象的值：两种方法对比如下： 
 第一种：不可以改变对象的值：
 
package 第3章;

public class 第3章a
{   
   public static void main (String[] args)
   {
       Employee[] man=new Employee[2];
       man[0]=new Employee("boy",13);
       man[1]=new Employee("girl",15);
       System.out.println("man[0] is: "+man[0].getName()+"  ,man[0] is: "+man[1].getName());
       Employee.swap(man[0],man[1]);
       System.out.println("man[0] is: "+man[0].getName()+" , man[0] is: "+man[1].getName());

   }

   }
class Employee
   {
       private String name;
       private final int number;
       public Employee(String well,int good)
       {
           name=well;
           number=good;
       }
       public String getName()
       {
           return name;
       }

       **public static void swap(Employee x,Employee y)
       {
           Employee goodTemp=x;
           x=y;
           y=goodTemp;
       }**
}
run:
man[0] is: boy  ,man[0] is: girl
man[0] is: boy , man[0] is: girl
成功构建 (总时间: 0 秒)
 
第二种，可以改变对象内的值：
 
package 第3章;

public class 第3章a
{   
   public static void main (String[] args)
   {
       Employee[] man=new Employee[2];
       man[0]=new Employee("boy",13);
       man[1]=new Employee("girl",15);
       System.out.println("man[0] is: "+man[0].getName()+"  ,man[0] is: "+man[1].getName());
       Employee.swap(man[0],man[1]);
       System.out.println("man[0] is: "+man[0].getName()+" , man[0] is: "+man[1].getName());

   }

   }
class Employee
   {
       private String name;
       private final int number;
       public Employee(String well,int good)
       {
           name=well;
           number=good;
       }
       public String getName()
       {
           return name;
       }
   **public  static void swap(Employee a,Employee b)
       {
           String temp=a.name;
           a.name=b.name;
           b.name=temp;
       }**
}
run:
man[0] is: boy  ,man[0] is: girl
man[0] is: girl , man[0] is: boy
成功构建 (总时间: 0 秒)
 
这个过程说明： 
 在java程序设计语言对对性采用的不是引用调用，实际上，对象引用是按值传递的。
 
下面总结一下java种方法参数的使用情况
1、方法不能修改基本数据类型参数（即数值型和布尔型，因为是参数是拷贝的原基本数据类型数据的副本，且没有引用（指针），所以不可以改变）
2、方法可以改变对象型参数的对象状态（对象内的实例域，比如name，number之类）
3、方法不能让对象型参数引用（指向）一个新的对象（已经通过上面的程序证明过，因为对象型参数也是副本，如同两个完全一样的指针指向同一个对象，可以修改对象，带不可以改变指向对象的指针来之向别处）
 
参数是值，那么修改不了原值 
 参数是对象，那么可以修改原对象的值

    Vehicle veh1 = new Vehicle(); veh1是对象引用变量，它不是对象的容器，而是类似于指向对象的指针，或者可以说是地址。对象只会存在垃圾回收的堆上。
     Vehicle veh1 = new Vehicle(); 代表取得Vehicle对象的方法，以字节形式，放进引用变量veh1中。而对象本身没有放进变量中。不同于基本数据类型 byte x = 7; 代表数字七的字节（00000111）被放入变量x中。
    那么对象引用变量占多少个字节呢？

    答：不知道。不过所有对象引用的大小都是相同的，不管它指向Apple对象还是Vehicle对象。



关于对象与引用之间的一些基本概念。转自：java对象及对象引用

       初学Java时，在很长一段时间里，总觉得基本概念很模糊。后来才知道，在许多Java书中，把对象和对象的引用混为一谈。可是，如果我分不清对象与对象引用，
       那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来，或许能让初学Java的朋友们少走一点弯路。
       为便于说明，我们先定义一个简单的类：
       class Vehicle {
       int passengers;      
       int fuelcap;
       int mpg;
                   }
有了这个模板，就可以用它来创建对象：
       Vehicle veh1 = new Vehicle();
通常把这条语句的动作称之为创建一个对象，其实，它包含了四个动作。
1）左边的“Vehicle veh 1”创建了一个Vehicle类引用变量。所谓Vehicle类引用，就是以后可以用来指向Vehicle对象的对象引用。

2）右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。
3）末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写，Java会给你补上一个默认的构造函数。（小插曲：先有对象还是先执行构造函数？ 上面的2、3步已经说出了答案——先有对象。具体解释看文末）


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!”在打印后即被丢弃。有人把这种对象称之为临时对象。
       对象与引用的关系将持续到对象回收




创建对象时，先有对象，还是先有构造函数？ 摘录自CSDN论坛
  答：运行过程中，执行到创建对象的时候，系统先按照对象的数据结构为对象分配内存空间，一旦分配完毕，对象即物理上存在了，但是对象的数据成员这时还没有初始化，它对应的内存空间还是随机的，于是执行对象的构造函数可对数据成员赋初值（当然也可做一些其他事）。至于构造函数和其他函数的代码，系统是最先都要调入内存的，但如果没有对象去使用，它们是永远也不会被执行！总结：1、全部代码进入内存；2、为对象分配内存，对象存在；3、执行对象的构造函数完成初始化