--sunfruit
介绍了JAVA的反射机制，比较全面
Java Reflection (JAVA反射)
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。
Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。
1. 一个简单的例子
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
} catch (Throwable e) {
System.err.println(e);
}
}
}
按如下语句执行：
java DumpMethods java.util.Stack
它的结果输出为：
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)
这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。
这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。
2.开始使用 Reflection
用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。
下面就是获得一个 Class 对象的方法之一：
Class c = Class.forName("java.lang.String");
这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：
Class c = int.class;
或者
Class c = Integer.TYPE;
它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的第一个方法的原型。
在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。
模拟 instanceof 操作符
得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：
class A {
}
public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("A");
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new A());
System.out.println(b2);
} catch (Throwable e) {
System.err.println(e);
}
}
}
在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer(37) 不是，但 new A() 是。
3.找出类的方法
找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：
import java.lang.reflect.*;
public class method1 {
private int f1(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method1");
Method methlist[] = cls.getDeclaredMethods();
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println("name = " + m.getName());
System.out.println("decl class = " + m.getDeclaringClass());
Class pvec[] = m.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = m.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("return type = " + m.getReturnType());
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。如果你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能获得继承来的各个方法的信息。
取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。
输出的结果如下：
name = f1
decl class = class method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name = main
decl class = class method1
param #0 class [Ljava.lang.String;
return type = void
-----
4.获取构造器信息
获取类构造器的用法与上述获取方法的用法类似，如：
import java.lang.reflect.*;
public class constructor1 {
public constructor1() {
}
protected constructor1(int i, double d) {
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor1");
Constructor ctorlist[] = cls.getDeclaredConstructors();
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println("name = " + ct.getName());
System.out.println("decl class = " + ct.getDeclaringClass());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。
这个程序运行的结果是：
name = constructor1
decl class = class constructor1
-----
name = constructor1
decl class = class constructor1
param #0 int
param #1 double
-----
5.获取类的字段(域)
找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：
import java.lang.reflect.*;
public class field1 {
private double d;
public static final int i = 37;
String s = "testing";
public static void main(String args[]) {
try {
Class cls = Class.forName("field1");
Field fieldlist[] = cls.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println("name = " + fld.getName());
System.out.println("decl class = " + fld.getDeclaringClass());
System.out.println("type = " + fld.getType());
int mod = fld.getModifiers();
System.out.println("modifiers = " + Modifier.toString(mod));
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。这个程序的输出是：
name = d
decl class = class field1
type = double
modifiers = private
-----
name = i
decl class = class field1
type = int
modifiers = public static final
-----
name = s
decl class = class field1
type = class java.lang.String
modifiers =
-----
和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也可以取得父类中定义的字段 (getFields) 。
6.根据方法的名称来执行方法
文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：
import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod("add", partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = meth.invoke(methobj, arglist);
Integer retval = (Integer) retobj;
System.out.println(retval.intvalue());
} catch (Throwable e) {
System.err.println(e);
}
}
}
假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 (例如，JavaBean 开发环境中就会做这样的事)，那么上面的程序演示了如何做到。
上例中，getMethod 用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的 Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84。
7.创建新的对象
对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 (准确的说，创建一个对象的过程包括分配内存和构造对象)。所以，与上例最相似的例子如下：
import java.lang.reflect.*;
public class constructor2 {
public constructor2() {
}
public constructor2(int a, int b) {
System.out.println("a = " + a + " b = " + b);
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Constructor ct = cls.getConstructor(partypes);
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = ct.newInstance(arglist);
} catch (Throwable e) {
System.err.println(e);
}
}
}
根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。
8.改变字段(域)的值
reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：
import java.lang.reflect.*;
public class field2 {
public double d;
public static void main(String args[]) {
try {
Class cls = Class.forName("field2");
Field fld = cls.getField("d");
field2 f2obj = new field2();
System.out.println("d = " + f2obj.d);
fld.setDouble(f2obj, 12.34);
System.out.println("d = " + f2obj.d);
} catch (Throwable e) {
System.err.println(e);
}
}
}
这个例子中，字段 d 的值被变为了 12.34。
9.使用数组
本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：
import java.lang.reflect.*;
public class array1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("java.lang.String");
Object arr = Array.newInstance(cls, 10);
Array.set(arr, 5, "this is a test");
String s = (String) Array.get(arr, 5);
System.out.println(s);
} catch (Throwable e) {
System.err.println(e);
}
}
}
例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。
下面这段代码提供了一个更复杂的例子：
import java.lang.reflect.*;
public class array2 {
public static void main(String args[]) {
int dims[] = new int[]{5, 10, 15};
Object arr = Array.newInstance(Integer.TYPE, dims);
Object arrobj = Array.get(arr, 3);
Class cls = arrobj.getClass().getComponentType();
System.out.println(cls);
arrobj = Array.get(arrobj, 5);
Array.setInt(arrobj, 10, 37);
int arrcast[][][] = (int[][][]) arr;
System.out.println(arrcast[3][5][10]);
}
}
例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37。注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。
注意创建数组时的类型是动态的，在编译时并不知道其类型。
--sunfruit
提供了获得汉字的拼音首字母的方法
JDK版本 无版本限制
功能 实现了获得一个汉字的拼音首字母功能，为汉字排序提供了方便
欢迎大家提意见，交流
代码如下：
/**
* Title:获得汉字的拼音首字母
* Description: GB 2312-80 把收录的汉字分成两级。第一级汉字是常用汉字，计 3755 个，
* 置于 16～55 区，按汉语拼音字母／笔形顺序排列；第二级汉字是次常用汉字，
* 计 3008 个，置于 56～87 区，按部首／笔画顺序排列，所以本程序只能查到
* 对一级汉字的声母。同时对符合声母（zh，ch，sh）只能取首字母（z，c，s）
* Copyright: Copyright (c) 2004
* Company:
* @author not attributable
* @version 1.0
*/
public class GetFirstLetter {
// 国标码和区位码转换常量
private static final int GB_SP_DIFF = 160;
//存放国标一级汉字不同读音的起始区位码
private static final int[] secPosvalueList = {
1601, 1637, 1833, 2078, 2274, 2302, 2433, 2594, 2787,
3106, 3212, 3472, 3635, 3722, 3730, 3858, 4027, 4086,
4390, 4558, 4684, 4925, 5249, 5600};
//存放国标一级汉字不同读音的起始区位码对应读音
private static final char[] firstLetter = {
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'w', 'x', 'y', 'z'};
//获取一个字符串的拼音码
public static String getFirstLetter(String oriStr) {
String str = oriStr.toLowerCase();
StringBuffer buffer = new StringBuffer();
char ch;
char[] temp;
for (int i = 0; i < str.length(); i++) { //依次处理str中每个字符
ch = str.charAt(i);
temp = new char[] {
ch};
byte[] uniCode = new String(temp).getBytes();
if (uniCode[0] < 128 && uniCode[0] > 0) { // 非汉字
buffer.append(temp);
}
else {
buffer.append(convert(uniCode));
}
}
return buffer.toString();
}
/** 获取一个汉字的拼音首字母。
* GB码两个字节分别减去160，转换成10进制码组合就可以得到区位码
* 例如汉字"你"的GB码是0xC4/0xE3，分别减去0xA0（160）就是0x24/0x43
* 0x24转成10进制就是36，0x43是67，那么它的区位码就是3667，在对照表中读音为‘n'
*/
private static char convert(byte[] bytes) {
char result = '-';
int secPosvalue = 0;
int i;
for (i = 0; i < bytes.length; i++) {
bytes[i] -= GB_SP_DIFF;
}
secPosvalue = bytes[0] * 100 + bytes[1];
for (i = 0; i < 23; i++) {
if (secPosvalue >= secPosvalueList[i] &&
secPosvalue < secPosvalueList[i + 1]) {
result = firstLetter[i];
break;
}
}
return result;
}
}
--sunfruit
在面试的时候会问及如何不用第三个变量来交换a,b的值，下面给出答案
a=a^b;
b=b^a;
a=a^b;
使用了位操作，至于为什么可以，列举下面的示例你就会明白
1^1=0;
0^0=0;
1^0=1;
0^1=1;
是不是明白了，呵呵，要是面试的时候再有人问你你就可以从容的回答了，而且不怕他问为什么
--sunfruit
一段令人深有感触地话
一个老工程师的话
诸位，咱当电子工程师也是十余年了，不算有出息，环顾四周，也没有看见几个有出息的！回顾工程师生涯，感慨万千，愿意讲几句掏心窝子的话，也算给咱们师弟师妹们提个醒，希望他们比咱们强！
[1]好好规划自己的路，不要跟着感觉走！根据个人的理想决策安排，绝大部分人并不指望成为什么院士或教授，而是希望活得滋润一些，爽一些。那么，就需要慎重安排自己的轨迹。从哪个行业入手，逐渐对该行业深入了解，不要频繁跳槽，特别是不要为了一点工资而转移阵地，从长远看，这点钱根本不算什么，当你对一个行业有那么几年的体会，以后钱根本不是问题。频繁地动荡不是上策，最后你对哪个行业都没有摸透，永远是新手！
[2]可以做技术，切不可沉湎于技术。千万不可一门心思钻研技术！给自己很大压力，如果你的心思全部放在这上面，那么注定你将成为孔乙己一类的人物！适可而止为之，因为技术只不过是你今后前途的支柱之一，而且还不是最大的支柱
[3]不要去做技术高手，只去做综合素质高手！在企业里混，我们时常瞧不起某人，说他“什么都不懂，凭啥拿那么多钱，凭啥升官！”这是普遍的典型的工程师的迂腐之言。8051很牛吗？人家能上去必然有他的本事，而且是你没有的本事。你想想，老板搞经营那么多年，难道见识不如你这个新兵？人家或许善于管理，善于领会老板意图，善于部门协调等等。因此务必培养自己多方面的能力，包括管理，亲和力，察言观色能力，攻关能力等，要成为综合素质的高手，则前途无量，否则只能躲在角落看示波器！技术以外的技能才是更重要的本事！！从古到今，美国日本，一律如此！
[4]多交社会三教九流的朋友！不要只和工程师交往，认为有共同语言，其实更重要的是和其他类人物交往，如果你希望有朝一日当老板或高层管理，那么你整日面对的就是这些人。了解他们的经历，思维习惯，爱好，学习他们处理问题的模式，了解社会各个角落的现象和问题，这是以后发展的巨大的本钱
[6]抓住时机向技术管理或市场销售方面的转变！要想有前途就不能一直搞开发，适当时候要转变为管理或销售，前途会更大，以前搞技术也没有白搞，以后还用得着。搞管理可以培养自己的领导能力，搞销售可以培养自己的市场概念和思维，同时为自己以后发展积累庞大的人脉！应该说这才是前途的真正支柱！！！
[7]逐渐克服自己的心里弱点和性格缺陷！多疑，敏感，天真（贬义，并不可爱），犹豫不决，胆怯，多虑，脸皮太薄，心不够黑，教条式思维。。。这些工程师普遍存在的性格弱点必须改变！很难吗？只在床上想一想当然不可能，去帮朋友守一个月地摊，包准有效果，去实践，而不要只想！不克服这些缺点，一切不可能，甚至连项目经理都当不好--尽管你可能技术不错！
[8]工作的同时要为以后做准备！建立自己的工作环境！及早为自己配置一个工作环境，装备电脑，示波器（可以买个二手的），仿真器，编程器等，业余可以接点活，一方面接触市场，培养市场感觉，同时也积累资金，更重要的是准备自己的产品，咱搞技术的没有钱，只有技术，技术的代表不是学历和证书，而是产品，拿出象样的产品，就可技术转让或与人合作搞企业！先把东西准备好，等待机会，否则，有了机会也抓不住！
[9]要学会善于推销自己！不仅要能干，还要能说，能写，善于利用一切机会推销自己，树立自己的品牌形象，很必要！要创造条件让别人了解自己，不然老板怎么知道你能干？外面的投资人怎么相信你？提早把自己推销出去，机会自然会来找你！搞个个人主页是个好注意！！特别是培养自己在行业的名气，有了名气，高薪机会自不在话下，更重要的是有合作的机会...
[10]该出手时便出手！永远不可能有100%把握！！！条件差不多就要大胆去干，去闯出自己的事业，不要犹豫，不要彷徨，干了不一定成功，但至少为下一次冲击积累了经验，不干永远没出息，而且要干成必然要经历失败。不经历风雨，怎么见彩虹，没有人能随随便便成功！
--sunfruit
获得系统提供的所有字体
GraphicsEnvironment eq = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fontNames = eq.getAvailableFontFamilyNames();
说明：如果在linux下需要安装界面相关的包，具体的那个包记不清了，如果不安装可能会无法获得字体列表.
当时的版本是red hat 7.0，至于现在的版本默认安装是否包括需要的包就不知道了
--sunfruit
成长中的应该知道的。。。追求忘我
不要把自己当做鼠，否则肯定被猫吃。
1858年，瑞典的一个富豪人家生下了一个女儿。然而不久，孩子染患了一种无法解释的瘫痪症，丧失了走路的能力。
一次，女孩和家人一起乘船旅行。船长的太太给孩子讲船长有一只天堂鸟，她被这只鸟的描述迷住了，极想亲自看一看。于是保姆把孩子留在甲板上，自己去找船长。孩子耐不住性子等待，她要求船上的服务生立即带她去看天堂鸟。那服务生并不知道她的腿不能走路，而只顾带着她一道去看那只美丽的小鸟。奇迹发生了，孩子因为过度地渴望，竟忘我地拉住服务生的手，慢慢地走了起来。从此，孩子的病便痊愈了。女孩子长大后，又忘我地投入到文学创作中，最后成为第一位荣获诺贝尔文学奖的女性，也就是茜尔玛·拉格萝芙。
温馨提示：忘我是走向成功的一条捷径，只有在这种环境中，人才会超越自身的束缚，释放出最大的能量。
--sunfruit
成长中的应该知道的。。。心中的顽石
阻碍我们去发现、去创造的，仅仅是我们心理上的障碍和思想中的顽石。
从前有一户人家的菜园摆着一颗大石头，宽度大约有四十公分，高度有十公分。到菜园的人，不小心就会踢到那一颗大石头，不是跌倒就是擦伤。
儿子问：“爸爸，那颗讨厌的石头，为什么不把它挖走？”
爸爸这么回答：“你说那颗石头喔？从你爷爷时代，就一直放到现在了，它的体积那么大，不知道要挖到到什么时候，没事无聊挖石头，不如走路小心一点，还可以训练你的反应能力。”
过了几年，这颗大石头留到下一代，当时的儿子娶了媳妇，当了爸爸。
有一天媳妇气愤地说：“爸爸，菜园那颗大石头，我越看越不顺眼，改天请人搬走好了。”
爸爸回答说：“算了吧！那颗大石头很重的，可以搬走的话在我小时候就搬走了，哪会让它留到现在啊？”
媳妇心底非常不是滋味，那颗大石头不知道让她跌倒多少次了。
有一天早上，媳妇带着锄头和一桶水，将整桶水倒在大石头的四周。
十几分钟以后，媳妇用锄头把大石头四周的泥土搅松。
媳妇早有心理准备，可能要挖一天吧，谁都没想到几分钟就把石头挖起来，看看大小，这颗石头没有想像的那么大，都是被那个巨大的外表蒙骗了。
温馨提示：你抱着下坡的想法爬山，便无从爬上山去。如果你的世界沉闷而无望，那是因为你自己沉闷无望。改变你的世界，必先改变你自己的心态。
--sunfruit
为JAVA的图形界面的字体设置统一的格式
执行下列代码
//设置系统的默认字体
private static void setUIFont() {
Font myFont = new Font("宋体", 9, 12);
javax.swing.plaf.FontUIResource fontRes = new javax.swing.plaf.
FontUIResource(myFont);
java.util.Enumeration keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof javax.swing.plaf.FontUIResource) {
UIManager.put(key, fontRes);
}
}
}
--sunfruit
成长中的应该知道的。。。成功并不像你想像的那么难
并不是因为事情难我们不敢做，而是因为我们不敢做事情才难的。
1965年，一位韩国学生到剑桥大学主修心理学。在喝下午茶的时候，他常到学校的咖啡厅或茶座听一些成功人士聊天。这些成功人士包括诺贝尔奖获得者，某一些领域的学术权威和一些创造了经济神话的人，这些人幽默风趣，举重若轻，把自己的成功都看得非常自然和顺理成章。时间长了，他发现，在国内时，他被一些成功人士欺骗了。那些人为了让正在创业的人知难而退，普遍把自己的创业艰辛夸大了，也就是说，他们在用自己的成功经历吓唬那些还没有取得成功的人。
作为心理系的学生，他认为很有必要对韩国成功人士的心态加以研究。1970年，他把《成功并不像你想像的那么难》作为毕业论文，提交给现代经济心理学的创始人威尔;布雷登教授。布雷登教授读后，大为惊喜，他认为这是个新发现，这种现象虽然在东方甚至在世界各地普遍存在，但此前还没有一个人大胆地提出来并加以研究。惊喜之余，他写信给他的剑桥校友--当时正坐在韩国政坛第一把交椅上的人--朴正熙。他在信中说，“我不敢说这部著作对你有多大的帮助，但我敢肯定它比你的任何一个政令都能产生震动。”
后来这本书果然伴随着韩国的经济起飞了。这本书鼓舞了许多人，因为他们从一个新的角度告诉人们，成功与“劳其筋骨，饿其体肤”、“三更灯火五更鸡”、“头悬梁，锥刺股”没有必然的联系。只要你对某一事业感兴趣，长久地坚持下去就会成功，因为上帝赋予你的时间和智慧够你圆满做完一件事情。后来，这位青年也获得了成功，他成了韩国泛业汽车公司的总裁。
温馨提示：人世中的许多事，只要想做，都能做到，该克服的困难，也都能克服，用不着什么钢铁般的意志，更用不着什么技巧或谋略。只要一个人还在朴实而饶有兴趣地生活着，他终究会发现，造物主对世事的安排，都是水到渠成的。
--sunfruit
成长中的应该知道的。。。永远的坐票
生活真是有趣：如果你只接受最好的，你经常会得到最好的。
有一个人经常出差，经常买不到对号入坐的车票。可是无论长途短途，无论车上多挤，他总能找到座位。
他的办法其实很简单，就是耐心地一节车厢一节车厢找过去。这个办法听上去似乎并不高明，但却很管用。每次，他都做好了从第一节车厢走到最后一节车厢的准备，可是每次他都用不着走到最后就会发现空位。他说，这是因为像他这样锲而不舍找座位的乘客实在不多。经常是在他落座的车厢里尚余若干座位，而在其他车厢的过道和车厢接头处，居然人满为患。
他说，大多数乘客轻易就被一两节车厢拥挤的表面现象迷惑了，不大细想在数十次停靠之中，从火车十几个车门上上下下的流动中蕴藏着不少提供座位的机遇；即使想到了，他们也没有那一份寻找的耐心。眼前一方小小立足之地很容易让大多数人满足，为了一两个座位背负着行囊挤来挤去有些人也觉得不值。他们还担心万一找不到座位，回头连个好好站着的地方也没有了。与生活中一些安于现状不思进取害怕失败的人，永远只能滞留在没有成功的起点上一样，这些不愿主动找座位的乘客大多只能在上车时最初的落脚之处一直站到下车。
温馨提示：自信、执着、富有远见、勤于实践，会让你握有一张人生之旅永远的坐票。