create database name; 创建数据库

use databasename; 选择数据库

drop database name 直接删除数据库，不提醒

show tables; 显示表

describe tablename; 表的详细描述

select 中加上distinct去除重复字段

mysqladmin drop databasename 删除数据库前，有提示。

显示当前mysql版本和当前日期

select version(),current_date;

2、修改mysql中root的密码：

shell>mysql -u root -p

mysql> update user set password=password(”xueok654123″) where user=’root’;

mysql> flush privileges //刷新数据库

mysql>use dbname； 打开数据库：

mysql>show databases; 显示所有数据库

mysql>show tables; 显示数据库mysql中所有的表：先use mysql；然后

mysql>describe user; 显示表mysql数据库中user表的列信息）；

3、grant

创建一个可以从任何地方连接服务器的一个完全的超级用户，但是必须使用一个口令something做这个

mysql> grant all privileges on *.* to user@localhost identified by ’something’ with

增加新用户

格式：grant select on 数据库.* to 用户名@登录主机 identified by “密码”

GRANT ALL PRIVILEGES ON *.* TO monty@localhost IDENTIFIED BY ’something’ WITH GRANT OPTION;

GRANT ALL PRIVILEGES ON *.* TO monty@”%” IDENTIFIED BY ’something’ WITH GRANT OPTION;

删除授权：

mysql> revoke all privileges on *.* from root@”%”;

mysql> delete from user where user=”root” and host=”%”;

mysql> flush privileges;

创建一个用户custom在特定客户端it363.com登录，可访问特定数据库fangchandb

mysql >grant select, insert, update, delete, create,drop on fangchandb.* to custom@ it363.com identified by ‘ passwd’

重命名表:

mysql > alter table t1 rename t2;

4、mysqldump

备份数据库

shell> mysqldump -h host -u root -p dbname >dbname_backup.sql

恢复数据库

shell> mysqladmin -h myhost -u root -p create dbname

shell> mysqldump -h host -u root -p dbname < dbname_backup.sql

如果只想卸出建表指令，则命令如下：

shell> mysqladmin -u root -p -d databasename > a.sql

如果只想卸出插入数据的sql命令，而不需要建表命令，则命令如下：

shell> mysqladmin -u root -p -t databasename > a.sql

那么如果我只想要数据，而不想要什么sql命令时，应该如何操作呢？

mysqldump -T./ phptest driver

其中，只有指定了-T参数才可以卸出纯文本文件，表示卸出数据的目录，./表示当前目录，即与mysqldump同一目录。如果不指定driver 表，则将卸出整个数据库的数据。每个表会生成两个文件，一个为.sql文件，包含建表执行。另一个为.txt文件，只包含数据，且没有sql指令。

5、可将查询存储在一个文件中并告诉mysql从文件中读取查询而不是等待键盘输入。可利用外壳程序键入重定向实用程序来完成这项工作。例如，如果在文件my_file.sql 中存放有查

询，可如下执行这些查询：

例如，如果您想将建表语句提前写在sql.txt中:

mysql > mysql -h myhost -u root -p database < sql.txt

转载来自：http://news.newhua.com/news1/program_database/2009/217/0921715343537K7H7IDI2CCI09JCI1DK8FJ4B07B3A04219G561C3JAB.html

人就这么一生， 我们都希望自己有个幸福的家，每天都是个快乐的人。但在生活中，不是一切都尽人意，每天我们都会遇到各种各样的困难和烦恼。人活一辈子，会遭遇多少无可奈何的事，邂逅多少恩恩怨怨的人。可是想到人不就这么一辈子吗，有什么好看不开的？人世间的烦恼忧愁，恩恩怨怨几十年后不都烟消云散了，还有什么不能化解，不能消气的呢。

人就这么一生，我们应快乐地度过这辈子。只要我们不丧失对生活的信心，对理想的追求，只要您虔诚地去努力，乐观地去对待，事业上有好的机遇,就快速反应,抓住机遇,果断决策,应有超人的智慧去完成自己的人生理想,因为人生短暂,时光如剑,让我们人生的每个季节都光辉灿烂.

人就这么一生，我们不能白来这一遭。所以让我们从快乐开始！做你想做的，爱你想爱的。做错了，不必后悔，不要埋怨，世上没有完美的人。跌倒了，爬起来重新来过。不经风雨怎能见彩虹，相信下次会走得更稳。

人就这么一生，人就到这世上匆匆忙忙地来一次，我们每个人的确应该有个奋斗的目标。如果该奋斗的我们去奋斗了，该拼搏的我们去拼搏了，但还不能如愿以偿。我们是否可以换个角度想一想：人生在世，有多少梦想是我们一时无法实现的，有多少目标是我们难以达到的。我们在仰视这些我们无法实现的的梦想，眺望这些我们无法达到的目标之时，是否应该以一颗平常心去看待我们的失利。“岂能尽如人意，但求无愧我心。”对于一件事，只要我们尽力去做了，我们就应该觉得很充实，很满足，而无论其结果如何。

人就这么一生，要想活得轻松，活得洒脱，你就该“记住该记住的，忘记该忘记的。改变能改变的，接受不能改变的。”唯有这样，你才会活出一个富有个性的全新自我！

人就这么一生，不要去过份地苛求，不要有太多的奢望。若我们苦苦追求过却还是一无所获，我们不妨这样想：既然上帝不偏爱于我，不让我鹤立鸡群，不让我出类拔萃，我又何必硬要去强求呢？别人声名显赫，而自己却平平庸庸。我们不妨这样安慰自己：该是你的，躲也躲不过；不是你的，求也求不来。我又何必要费尽心思绞尽脑汁地去占有那些原本不属于我的东西呢？金钱、权力、名誉都不是最重要的，最重要的还是应该善待自己，就算拥有了全世界，随着死去也会烟消云散。若我们要是这样想，我们就不会再为自己平添那些无谓的烦恼了。

我们都曾经以为，有些事情是不可以放手的。“我是不会放手一个人的。” 其实，没有什么东西是不能放手的。时日渐远，当你回望，你会发现，你曾经以为不可以放手的东西，只是生命瞬间的一块跳板。所有的哀伤、痛楚，所有不能放弃的事情，不过是生命里一个过渡，你跳过了，就可以变得更精采。失恋、失意，甚至失婚，以至我们在爱情里所受的苦，都不过是一块跳板，然而令你成长。人在跳板上，最辛苦的不是跳下来那一刻，而是跳下来之前，心里的挣扎、犹豫、无助和患得患失，根本无法向别人倾诉。我们以为跳不过去了，闭上眼睛，鼓起勇气，却跳过了。

人就这么一生，开心也是一天，不开心也是一天，干吗硬要逼着自己不开心呢？是啊，人就这么一辈子，做错事不可以重来的一辈子；碎了的心难再愈合的一辈子；过了今天就不会再有另一个今天的一辈子；一分一秒都不会再回头的一辈子，我们为什么不好好珍惜眼前，为什么还要拼命地自怨自艾，痛苦追悔呢？

人就这么一生，我们可以淡然面对，也可以积极的把握，当你看不开、当你春风得意、当你愤愤不平、当你深陷痛苦中请想想它，不管怎么样，你总是幸运的拥有了这一辈子．

人就这么一生，没有来世。所以让我们从微笑开始！人活一辈子,开心最重要。拥有健康的体魄，在快乐的心境中做自己喜欢做的事情，安全地实现自身价值，是人生最大的幸福。

好景不常在,好花不长开;人生短暂,好好地去珍惜它，善待它，把握它吧！珍惜你身边的每个人。珍惜！珍惜！珍重！珍重！

转载: http://zhichang.umiwi.com/2011/0113/3358.shtml

 
《父亲》之父女篇
 

 
《父亲》之父子篇
 

1、此次iOS 5.0.1完美越狱工具是针对以下设备：(iPhone 4S和iPad 2的iOS 5.0.1版暂不能完美越狱)

    – iPhone4
- iPhone4-CDMA
- iPhone3GS
- iPad1
- iPod touch 3G
- iPod touch 4G

2.越狱前准备越狱工具和事先准备：

     一.将你的iTunes更新到最新版本。

     二. 越狱前备份机子的SHSH,

     三.下载红雪 redsn0w 0.9.10b3

越狱工具包 点击下载

3.越狱步骤：

    一.将你的设备更新升级到iOS 5.0.1并连接电脑。

    二.打开红雪RedSn0w 0.9.10b3，点击“jailbreak”。 注意：该版本红雪不需要验证固件

二.点击Jaibreak按钮后进入这个界面，并关闭你的设备，然后点击进入Next.

3.接着就进入到新手最害怕的DFU模式，按照redsnow的提示一步步进行即可，

根据图中的提示来做，这里我总结了一下(破解时，心里默默的数秒数)

1.先按住power键（开机键）3秒

2.power键+home键15秒 大约在倒数第8秒时屏幕会变黑，不用理会

3.放开power键继续按住home键15秒，直到软件成功进入如下界面，放开home键。

这个模式过了以后，越狱就成功一半了！接下来就由红雪来帮你完成接下来的任务，过程有点长，你可以边喝咖啡边玩其他的！

越狱过程

此时你会看到菠萝图，这将意味着你越狱成功！

博客很久很没更新了,那阵子忙来忙去，今晚终于停下来了,一个人独自呆在家，带着耳机听着舒畅的音乐，想起2011年经历的那些事，11年我20岁了，11年恋爱了，记得12月7日，经家里的同意并给予大力的支持，我有幸参加了第五届WebReBuild前端技术交流年会，那时我出发了，那是我人生中第一次外出，一个人踏上路途中的火车，去了成都天府软件园，去了阿里巴巴旗下的分公司 “支付宝 ”，虽然在这一路上很囧迫，但在这路上我学到不少，懂得不少，见了不少，参观了中国互联网巨头公司的工作环境，听到别人所讲述的思想与技术，我认知了，我想那就是我一直坚持了8年的梦中目的地，去了那让我有股冲动，有股很强大的力量，并时时刻刻鼓励着自己努力，向上，技术交流会结束后，回到学校，又遇学期期末考试，一直忙，一直忙，考试结束后，就这样，我的大二第一学期就这样没了！ 回想这学期，自己都在干些什么？ 都在忙些什么？自己还真想不出来。 Java一直在很努力的学，在这路上一直提醒自己，不管在艰难，一定要坚持，坚持，再坚持，我总是相信成功的曙光是属于自己的，但在这学习的过程中，由于生活中的杂七杂八的破事，导致自己若隐若学的，一直没跟上自己事先制定的学习步伐，我知道，对自己说“什么事什么事占用了这途中的..........导致自己没学好，没跟上步伐” 这些话，都是对自己的一种敷衍！一种极其不负责任的做法！我想2011年这些破事，我觉得是我个人毅力不够坚强，导致这些问题的发生。

2012来了，离自己实习的距离越来越逼近了，我想这几个月中，我因该把握好每时每刻，做好每件事！正像“悠游度过一天的24小时”书上所说的，安排好自己的一天24小时时间和技术交流会上 彪叔 所说的“时间管理，把重要和不重要的事安排好，什么事该做，什么时候做，什么事先做，什么事后做”等问题，我想这方面我很欠缺，我还在路上，加油！

2011年，感谢老妈，老爸，感谢所有帮助和支持我的朋友，同学，老师，感谢一直关照我的 冰哥 ， 谢谢！ 谢谢！

   public static final int AGE_OF_PERSON = 20;

2.在Java中声明final常量时通常都会加上static关键字，这样对象的每个实例都会访问唯一一份常量值。

3.Java集合：

  ArrayList实现类中方法：

•       add(): 加入数据类型。
•       get(index)：返回一个Object。
•       size()：相当于数组当中的length，检索长度。
•       clear():清除元素中的所有数据
•      isEmpty()：判断是否为空。
•       remove(index)：删除元素。
•       indexOf(numberof):判断某个对象的索引在第几个位置上。
•       toArray():转换成一个数组。

注：集合中只能放对象，不能放原生数据类型。

4.集合中存放的依然是对象的引用而不是对象本身。

5.ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会在底层生成一个长度为10的object类型数组。

6.如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新的素组当中。当新素组无法容纳增加的元素时，重复该过程。

7.对于 ArrayList元素的删除操作，需要将被删除元素的后续元素向前移动，代价比较高。

8.集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加到集合当中。

9.集合当中放置的都是object类型，因此取出来的也是object类型，那么必须要使用强制类型转换将其转换为真正的类型（放置进去的类型）。

10.

     LinkedList实现类中的方法：

•  addLast(增加内容);在最后面增加一个元素。
•  addFirst(增加内容);在最前面增加第一个元素。
• add(元素位置,增加内容)<重载的add方法>:在指定的位置增加元素。
• set(int index, E element) ：将此列表中指定位置的元素替换为指定的元素。

11.关于ArrayList与LinkedList的比较分析。

• ArrayList底层采用数组实现而LinkedList底层采用双向链表实现。
• 当执行插入或者删除操作时，采用LinkedList比较好。
• 当执行搜索操作时，采用ArrayList比较好。

12.ArrayList底层采用了数组，LinkedList采用了链表。

2.数组（Array）：相同类型数据的集合就叫数组。

3.如何定义数组：type[] 变量名 = new type[数组长度];可以按照下列方式定义长度为10的数组：
int[] a = new int[10];或者int a[] = new int[2];

4.数组中的元素索引是从0开始的。对于数组来说，最大索引== 数组的长度 – 1。

5.定义数组的第3中方式：type[] 变量名 = new type[]{逗号分隔的初始化值列表}; 或：int[] a = {1,2,3,4,5,6,7,8};

6.Java中的每个数组都有一个名为length的属性，它表示数组的长度。length属性是public ,final ,int 的。数组长度一旦确定就不能改变大小。

7.int[] a = new int[10],其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。

8.二维数组：二维数组是一种平面的二维结构，本质上是数组的数组。二维数组的定义方式：type[][] a = new type[2][3];

9.三维数组。type[][][] a = new type[2][3][4];

Singleton模式可以是很简单的，它的全部只需要一个类就可以完成（看看这章可怜的UML图）。但是如果在“对象创建的次数以及何时被创建”这两点上较真起来，Singleton模式可以相当的复杂，比头五种模式加起来还复杂，譬如涉及到DCL双锁检测（double checked locking）的讨论、涉及到多个类加载器（ClassLoader）协同时、涉及到跨JVM（集群、远程EJB等）时、涉及到单例对象被销毁后重建等。对于复杂的情况，本章中会涉及到其中一些

目的：

希望对象只创建一个实例，并且提供一个全局的访问点。

场景：

Kerrigan对于Zerg来说是个至关重要的灵魂人物，无数的Drone、Zergling、Hydralisk……可以被创造、被牺牲，但是Kerrigan得存在关系到Zerg在这局游戏中的生存，而且Kerrigan是不允许被多次创造的，必须有且只有一个虫族刀锋女王的实例存在，这不是游戏规则，但这是个政治问题。

分析：

如前面一样，我们还是尝试使用代码来描述访问Kerrigan的过程，看看下面的UML图，简单得我都不怎么好意思放上来占版面。

图6.1 单例模式的UML图

结构是简单的，只是我们还有一些小小的要求如下：

1.最基本要求：每次从getInstance()都能返回一个且唯一的一个Kerrigan对象。

2.稍微高一点的要求：Kerrigan很忙，很多人找，所以希望这个方法能适应多线程并发访问。

3.再提高一点的要求：Zerg是讲究公务员效率的社会，希望找Kerrigan的方法性能尽可能高。

4.最后一点要求是Kerrigan自己提出的：体谅到Kerrigan太累，希望多些睡觉时间，因此Kerrigan希望实现懒加载（Lazy Load），在需要的时候才被构造。

5.原本打算说还提要处理多ClassLoader、多JVM等情况，不过还是不要把情况考虑的太复杂了，暂且先放过作者吧（-_-#）。

我们第一次写的单例模式是下面这个样子的：

/**
 * 实现单例访问Kerrigan的第一次尝试
 */
public class SingletonKerriganA {

    /**
     * 单例对象实例
     */
    private static SingletonKerriganA instance = null;

    public static SingletonKerriganA getInstance() {
        if (instance == null) {                              //line A
            instance = new SingletonKerriganA();          //line B
        }
        return instance;
    }
}

这个写法我们把四点需求从上往下检测，发现第二点的时候就出了问题，假设这样的场景：两个线程并发调用SingletonKerriganA.getInstance()，假设线程一先判断完instance是否为null，既代码中的line A进入到line B的位置。刚刚判断完毕后，JVM将CPU资源切换给线程二，由于线程一还没执行line B，所以instance仍然是空的，因此线程二执行了new SignletonKerriganA()操作。片刻之后，线程一被重新唤醒，它执行的仍然是new SignletonKerriganA()操作，好了，问题来了，两个Kerrigan谁是李逵谁是李鬼？

紧接着，我们做单例模式的第二次尝试：

/**
 * 实现单例访问Kerrigan的第二次尝试
 */
public class SingletonKerriganB {

    /**
     * 单例对象实例
     */
    private static SingletonKerriganB instance = null;

    public synchronized static SingletonKerriganB getInstance() {
        if (instance == null) {
            instance = new SingletonKerriganB();
        }
        return instance;
    }
}

比起第一段代码仅仅在方法中多了一个synchronized修饰符，现在可以保证不会出线程问题了。但是这里有个很大（至少耗时比例上很大）的性能问题。除了第一次调用时是执行了SingletonKerriganB的构造函数之外，以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的，绝大部分的耗时都用在synchronized修饰符的同步准备上，因此从性能上说很不划算。

那继续把代码改成下面的样子：

/**
 * 实现单例访问Kerrigan的第三次尝试
 */
public class SingletonKerriganC {

    /**
     * 单例对象实例
     */
    private static SingletonKerriganC instance = null;

    public static SingletonKerriganC getInstance() {
        synchronized (SingletonKerriganC.class) {
            if (instance == null) {
                instance = new SingletonKerriganC();
            }
        }
        return instance;
    }
}

基本上，把synchronized移动到代码内部是没有什么意义的，每次调用getInstance()还是要进行同步。同步本身没有问题，但是我们只希望在第一次创建Kerrigan实例的时候进行同步，因此我们有了下面的写法——双重锁定检查（DCL）。

/**
 * 实现单例访问Kerrigan的第四次尝试
 */
public class SingletonKerriganD {

    /**
     * 单例对象实例
     */
    private static SingletonKerriganD instance = null;

    public static SingletonKerriganD getInstance() {
        if (instance == null) {
            synchronized (SingletonKerriganD.class) {
                if (instance == null) {
                    instance = new SingletonKerriganD();
                }
            }
        }
        return instance;
    }
}

看起来这样已经达到了我们的要求，除了第一次创建对象之外，其他的访问在第一个if中就返回了，因此不会走到同步块中。已经完美了吗？

我们来看看这个场景：假设线程一执行到instance = new SingletonKerriganD()这句，这里看起来是一句话，但实际上它并不是一个原子操作（原子操作的意思就是这条语句要么就被执行完，要么就没有被执行过，不能出现执行了一半这种情形）。事实上高级语言里面非原子操作有很多，我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现，这句话被编译成8条汇编指令，大致做了3件事情：

1.给Kerrigan的实例分配内存。

2.初始化Kerrigan的构造器

3.将instance对象指向分配的内存空间（注意到这步instance就非null了）。

但是，由于Java编译器允许处理器乱序执行（out-of-order），以及JDK1.5之前JMM（Java Memory Medel）中Cache、寄存器到主内存回写顺序的规定，上面的第二点和第三点的顺序是无法保证的，也就是说，执行顺序可能是1-2-3也可能是1-3-2，如果是后者，并且在3执行完毕、2未执行之前，被切换到线程二上，这时候instance因为已经在线程一内执行过了第三点，instance已经是非空了，所以线程二直接拿走instance，然后使用，然后顺理成章地报错，而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来，真是一茶几的杯具啊。

DCL的写法来实现单例是很多技术书、教科书（包括基于JDK1.4以前版本的书籍）上推荐的写法，实际上是不完全正确的。的确在一些语言（譬如C语言）上DCL是可行的，取决于是否能保证2、3步的顺序。在JDK1.5之后，官方已经注意到这种问题，因此调整了JMM、具体化了volatile关键字，因此如果JDK是1.5或之后的版本，只需要将instance的定义改成“private volatile static SingletonKerriganD instance = null;”就可以保证每次都去instance都从主内存读取，就可以使用DCL的写法来完成单例模式。当然volatile或多或少也会影响到性能，最重要的是我们还要考虑JDK1.42以及之前的版本，所以本文中单例模式写法的改进还在继续。

代码倒越来越复杂了，现在先来个返璞归真，根据JLS（Java Language Specification）中的规定，一个类在一个ClassLoader中只会被初始化一次，这点是JVM本身保证的，那就把初始化实例的事情扔给JVM好了，代码被改成这样：

/**
 * 实现单例访问Kerrigan的第五次尝试
 */
public class SingletonKerriganE {

    /**
     * 单例对象实例
     */
    private static SingletonKerriganE instance = new SingletonKerriganE();

    public static SingletonKerriganE getInstance() {
        return instance;
    }
}

好吧，如果这种写法是完美的话，那前面那么几大段话就是作者在消遣各位读者。这种写法不会出现并发问题，但是它是饿汉式的，在ClassLoader加载类后Kerrigan的实例就会第一时间被创建，饿汉式的创建方式在一些场景中将无法使用：譬如Kerrigan实例的创建是依赖参数或者配置文件的，在getInstance()之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。

再来看看下面这种我觉得能应对较多场景的单例写法：

/**
 * 实现单例访问Kerrigan的第六次尝试
 */
public class SingletonKerriganF {

    private static class SingletonHolder {
        /**
         * 单例对象实例
         */
        static final SingletonKerriganF INSTANCE = new SingletonKerriganF();
    }

    public static SingletonKerriganF getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

这种写法仍然使用JVM本身机制保证了线程安全问题；由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖JDK版本。

其他单例模式的写法还有很多，如使用本地线程（ThreadLocal）来处理并发以及保证一个线程内一个单例的实现、GoF原始例子中使用注册方式应对单例类需要需要继承时的实现、使用指定类加载器去应对多ClassLoader环境下的实现等等。我们做开发设计工作的时，应当既要考虑到需求可能出现的扩展与变化，也应当避免“幻影需求”导致无谓的提升设计、实现复杂度，最终反而带来工期、性能和稳定性的损失。设计不足与设计过度都是危害，所以说没有最好的单例模式，只有最合适的单例模式。

到这里为止，单例模式本身就先告一段落了，最后在介绍从其他途径屏蔽构造单例对象的方法：

1.直接new单例对象

2.通过反射构造单例对象

3.通过序列化构造单例对象。

对于第一种情况，一般我们会加入一个private或者protected的构造函数，这样系统就不会自动添加那个public的构造函数了，因此只能调用里面的static方法，无法通过new创建对象。

对于第二种情况，反射时可以使用setAccessible方法来突破private的限制，我们需要做到第一点工作的同时，还需要在在 ReflectPermission(“suppressAccessChecks”) 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现。

对于第三种情况，如果单例对象有必要实现Serializable接口（很少出现），则应当同时实现readResolve()方法来保证反序列化的时候得到原来的对象。

基于上述情况，将单例模式增加两个方法：

/**
 * 能应对大多数情况的单例实现
 */
public class SingletonKerrigan implements Serializable {

    private static class SingletonHolder {
        /**
         * 单例对象实例
         */
        static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
    }

    public static SingletonKerrigan getInstance() {
        return SingletonHolder.INSTANCE;
    }

    /**
     * private的构造函数用于避免外界直接使用new来实例化对象
     */
    private SingletonKerrigan() {
    }

    /**
     * readResolve方法应对单例对象被序列化时候
     */
    private Object readResolve() {
        return getInstance();
    }
}

总结：

本章通过一次次的的尝试，去了解单例模式各种实现方案的优缺点。对双锁锁定检测进行了简单的讨论，相信大家能从各种尝试的演化过程中，明白为何单例模式是最简单而又最复杂的一种构造模式。

各种构造模式之间可以互相比较，但是没 有优劣好坏之分，只有确定了上下文环境，才能谈应用什么模式。学习设计模式我觉得也没有必要去强背一些代码模版，应当去理解每种模式的出现的原因和解决的 问题，当你发现你的设计需要更大灵活性时，设计便会向着合适的模式演化，这时候你就真正的掌握了设计模式。

转载来自：http://www.iteye.com/topic/575052

2.接口中也可以定义成员变量。接口中的成员变量都是public,final,static的。

3.一个类不能即是final，，又是abstract的。因为abstract的主要目的是定义一种约定，让子类去实现这种约定，而final表示该类不能被继承，这样abstract希望该类可以被继承而final明确说明该类不能被继承，两者矛盾。因此一个类不能即是final的，又是abstract的。

4. Desing Pattern(设计模式)。单例模式（Singleton)：表示一个类只会生成唯一的一个对象。

5.包(package)。用于将完成不同功能的类分门别类，放在不同的目录（包）下。包的命名规则：将公司域名反转作为包名，对于包名：每个字母都需要小写。如果定义类的时候没有使用package,那么java就认为我们所定义的类位于默认包里面(default package)。

6.编译带有package声明的java源文件有两种方式：

一.直接编译，然后根据类中所定义的包名，逐一手工建立目录结构，最后将生成的class文件放到该目录结构中。

二.使用编译参数 -d,方式为：javac -d .源文件.java，这样在编译后，编译器会自动帮助我们建立好包所对应的目录结构。

三.执行通过java 目录.class文件。

7.有两个包名，分别是aa.bb.cc与aa.bb.cc.dd,那么我们称后者为前者的子包。

8.导入(import),将使用package分离的各个类导入回来，让编译器能够找到所需要的类。

9.import的语法：import com.csssea.PackageTest;

10.import con.csssea.* ,表示导入com.csssea包下面的所有类。

11.import aa.bb.* 并不会导入aa.bb.cc包下面的类。这时需要这样写：

import aa.bb.*;

import aa.bb.cc.*;

12.关于package,import,class的顺序问题：

一.首先需要定义包(package),可选。

二.接下来使用import进行导入，可选。

三.然后才是class或interface的定义。

13.如果两个类在同一个包下面，那么则不需要导入，直接使用即可。

14.访问修饰符（access modifier)。

1) public(公共的)：被public所修饰的属性和方法可以被所有类访问。

2）protected(受保护的)：被protected所修饰的属性和方法可以在类内部，相同包以及该类的子类访问。

3） private(私有的)：被private所修饰的属性和方法只能在该类内部使用。

4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。

15.Instaceof：判断某个对象是否是某个类的实例。语法形式：引用名 instanceof 类（接口名），它返回一个boolean值。

public class Instanceof

{

public static void main(String[] args)

{

People people = new Man();

System.out.println(people instanceof People);

}

}

class People

{

}

class Man extends People //结果为true，因为Man是Ppeople的子类，根据继承，子类就是父类，因此Man也可以看作是People的实例。

{

}

16.相等性的比较：

1)对于原声数据类型来说，比较的是左右两边的值是否相等。

2）对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两边的引用地址是否相同。

17.Java.lang.Object类。 Java.lang包在使用的时候无需显式导入，编译时由编译器自动帮助我们导入。

18.API（application program interface），应用编程接口。

19.当打印引用时，实际上会打印出引用所指对象的toString()方法的返回值，因为每个类都直接或间接地继承object,而object类中定义了toString(),因此每个类都有toString()这个方法。

20.equals()方法，该方法定义在Object类当中，因此Java中的每个类都具有该方法，对于object类的equals（）方法来说，它是判断调用equals方法的引用与传进来的引用是否一致，既这两个引用是否指向的是同一个对象。对于object类的equals()方法来说，等价于 ==。

21.对于string类的equals（）方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。

22.对于string对象的相等性判断来说，请使用equals方法，而不要使用==。

23.String是常量，其对象一旦创建完毕就无法改变。当使用+号拼接字符串时，会生成新的String对象，而不是向原有的String对象追加内容。

24.String pool（字符串池），

25.string s = “aaa”; （采用字面值方式赋值）

   1）查找string pool中是否存在”aaa “这个对象，如果不存在，则在string pool中创建一个”aaa”对象，然后将string pool中的这个”aaa”对象地址反回来，赋给引用变量s，这样s会指向string pool中的这个”aaa”字符串对象。

   2）如果存在，则不创建任何对象，直接将string pool中的这个”aaa”对象地址反回来，赋给s引用。

26.string s = new String(“aaa”);

   1)首先在string pool 中查找有没有”aaa”这个个字符串对象，如果有则不在string pool 中再去创建 “aaa”这个对象了，直接在堆中（heap）中创建一个”aaa”字符串对象，然后将堆中的这个”aaa”对象的地址反回来，赋给s 引用，导致s指向堆中创建的这个”aaa”字符对象。

   2）如果没有，则首先在string pool 中创建一个“aaa”对象，然后再在堆中（heap）创建一个”aaa”对象，然后将堆中的这个”aaa”对象的地址返回来，赋给s引用，导致s引用，导致s指向了堆中所创建的这个“aaa”对象。

清晨，坐着学校老爷车，去奥体中心干活。

有时候这老爷车，闯红灯，换5，6档，油门踩到极限。严重违反交通制度。

开始大家对这些行为都不理解，还以为老师傅拿生命开玩笑。（PS：这位老师傅是我们学校教练）

后来通过同学在车上的一番询问老师傅，得知，这辆校车，开了14年了，明年没审车的资格了。

“14年了 “  当听到老师傅在车上说这句话，从师傅眼里能看出，师傅很舍不得这辆老爷车报销。

今晨，还是坐这这辆老爷车，车上正放着80年代的歌曲……车上的同学亦如的安静，欣赏着。

每当坐着这辆车去奥体中心干活时。都使我感觉一股浓浓的情意味。

情啊…..情啊…….情啊…….情啊……

我想对待自己的爱好，职业规划，感情甚至许许多多生活中的事儿，我也因该像师傅一样，热衷….并努力去实现着，追着，奋斗着。