BlogJava- oDiBo “开封菜”WWW.KFC.IM-随笔分类-J2SE

JDK1.5新特性之一----静态导入

London2012 — Sun, 19 Jul 2009 23:18:00 GMT

package staticEx;

public class TranscendentalConstants {

public static final double PI = 3.14159;

public static final double E = 2.71828;

}

public class IrrationalConstants {

public static final double SQRT_TWO = 1.414;

public static final double SQRT_THREE = 1.732;

}

//在类中导入静态变量和方法

package staticEx;

import static staticEx.IrrationalConstants.SQRT_TWO;

import static staticEx.IrrationalConstants.SQRT_THREE;

import static staticEx.TranscendentalConstants.PI;

public class ConstantsWithStaticImport {

public static double sinPiOverFour() {

return SQRT_TWO / 2;

}

public static void main(String[] args) {

System.out.println("Pi is approximately " + PI);

System.out.println("The sin of Pi/4 is about " +

sinPiOverFour());

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/qiuchun/archive/2004/10/09/129502.aspx

London2012 2009-07-20 07:18 发表评论

可变参数列表-Java SE5新特性

London2012 — Sun, 19 Jul 2009 23:15:00 GMT

1．可变参数列表的简单实现

当调用方法时，方法的参数个数或类型未知时，称其为可变参数列表。在以前的Java代码中，可以使用Object数组来实现这样的功能。因为，所有的类都是直接或间接继承于Object类。

VarArgs.java

package sample;

class A1{}

public class VarArgs {

static void printArray(Object[] args){

for(Object obj:args)

System.out.print(obj+" ");

System.out.println();

}

public static void main(String[] args){

printArray(new Object[]{

new Integer(47),new Float(3.14),new Double(11.11)

});

printArray(new Object[]{"one","two","three"});

printArray(new Object[]{new A1(),new A1(),new A1()});

}

结果：

47 3.14 11.11

one two three

sample.A1@a90653 sample.A1@de6ced sample.A1@c17164

这里printArray方法使用Object数组作为参数，并使用foreach语法遍历数组，打印每个对象。

2．Java SE5实现可变参数列表

同样的方法，参数可以这样定义，(Object…args)，这样达到同样的效果。

NewVarArgs.java

package sample;

class A{}

public class NewVarArgs {

static void printArray(Object...args){

for(Object obj:args)

System.out.print(obj+" ");

System.out.println();

}

public static void main(String[] args){

printArray(new Integer(47),new Float(3.14),new Double(11.11));

printArray(47,

printArray("one","two","three");

printArray(new A(),new A(),new A());

printArray((Object[])new Integer[]{1,2,3,4});

printArray();

}

结果：

47 3.14 11.11

one two three

sample.A@a90653 sample.A@de6ced sample.A@c17164

1 2 3 4

这里没有显式的使用数组作为参数，但编译器实际上会为你填充数组。所以同样可以使用foreach语法来遍历之。

注意倒数第二行，编译器已经发现它是一个数组，所以不会在其上执行任何转换。最后一行表明，可以传递零个参数。

也可以指定所有可变参数的类型，下面的程序指定所有可变参数都必须是String。

OptionalArguments.java

package sample;

public class OptionalArguments {

static void f(String...trailing){

for(String s:trailing)

System.out.print(s+" ");

System.out.println();

}

public static void main(String[] args){

f("one");

f("two","three");

f();

}

结果：

one

two three

可以在可变参数列表中同时使用原始类型与包装类。

AutoboxingVarargs.java

package sample;

public class AutoboxingVarargs {

public static void f(Integer...args){

for(Integer i:args)

System.out.print(i+" ");

System.out.println();

}

public static void main(String[] args){

f(new Integer(1),new Integer(2));

f(3,4,5,6,7,8,9);

f(10,new Integer(11),12);

}

结果：

1 2

3 4 5 6 7 8 9

10 11 12

3．可变参数列表的重载（Overloading）

如果出现重载的情况，则编译器会自动调用最适合的方法匹配之。

OverloadingVarargs.java

package sample;

public class OverloadingVarargs {

static void f(Character...args){

System.out.print("first ");

for(Character c:args)

System.out.print(c+" ");

System.out.println();

}

static void f(Integer...args){

System.out.print("second ");

for(Integer i:args)

System.out.print(i+" ");

System.out.println();

}

static void f(Long...args){

System.out.print("third ");

for(Long l:args)

System.out.print(l+" ");

System.out.println();

}

static void f(Double...args){

System.out.print("forth ");

for(Double d:args)

System.out.print(d+" ");

System.out.println();

}

public static void main(String[] args){

f('a','b','c');

f(1);

f(2,1);

f(0.1);

}

结果：

first a b c

second 1

second 2 1

forth 0.1

third 0

但下面的情况是不允许的，即某个方法中增加一个非可变参数。

OverloadingVarargs2.java

package sample;

public class OverloadingVarargs2 {

static void f(float i,Character...args){

System.out.println("first");

}

static void f(Character...args){

System.out.println("second");

}

public static void main(String[] args){

f(1,'a');

f('a','b');//Error

}

但可以这样解决问题。

package sample;

public class OverloadingVarargs2 {

static void f(float i,Character...args){

System.out.println("first");

}

static void f(char c,Character...args){

System.out.println("second");

}

public static void main(String[] args){

f(1,'a');

f('a','b');

}

即重载的方法必须保持一致的参数形式。

London2012 2009-07-20 07:15 发表评论

java中产生随机数的两种方式

London2012 — Mon, 29 Jun 2009 05:01:00 GMT

在java中，我们可以通过两种方式来获取随机数(generating a random number)一种是大家熟悉的java.lang.Math.Random()静态方法,另一种是创建java.util.Random对象。下面是两种方法的使用过程:

1、java.lang.Math.random()

在使用这一静态方法的时候，我们不需要import任何包，因为java.lang.*包是默认载入的,下面举例说面使用方法:

public class RandomTest{ public static void main(String[] args){ int i=Math.random();//random()会自动产生一个0.0-1.0的双精度随机数 System.out.println(i);//输出 i=Math.random()*1000;//产生0-1000的双精度随机数 System.out.println(i); int b=(int)(Math.random()*1000);//产生0-1000的整数随机数 System.out.println(b); } }

2、创建java.util.Random对象

import java.util.random public class RandomTest{ public static void main(String[] args){ Random random=new Random();//创建random对象 int intNumber=random.nextInt();//获取一个整型数 float floatNumber=random.nextFloat();//获取一个浮点数(0-1) double doubleNumber=random.nextDouble();//获取双精度数(0-1) boolean booleanNumber=random.nextBoolean();//获取boolean数 System.out.println("intNumber:"+intNumber); System.out.println("floatNumber:"+floatNumber); System.out.println("doubleNumber:"+doubleNumber); System.out.println("booleanNumber:"+booleanNumber); } }
http://www.mscto.com

random在产生随机数的时候使用当前的时间作为基数，我们可以同过System.currentTimeMillis()来获取这个基数。当然我们也可以指定基数: 软件开发网

Random random=new Random(100); [url]www.jhaccp.com.cn[/url] 同一基数所产生的随机数序列是一样的，可以用下面这一段程序进行印证: import java.util.random public class RandomTest{ public static void main(String[] args){ Random random1=new Random(100); Random random2=new Random(100); for(int i=0;i<5;i++){ System.out.print(random1.nextInt()+"t"); System.out.println(random2.nextInt()+"t"); System.out.println("---------------------------------"); } } }

我们可以发现random1和random2所产生的随机数是相同的。
软件开发网

London2012 2009-06-29 13:01 发表评论

学习：socket

London2012 — Sun, 28 Jun 2009 14:02:00 GMT

socket的编程，两个代码，保存下
Server

import java.net.*;
import java.io.*;
public class TCPServer {
    public static void main(String[] args) throws Exception {
        ServerSocket ss=new ServerSocket(6666);
//        while(true){
            Socket s=ss.accept();
            DataInputStream dis=new DataInputStream(s.getInputStream());
            System.out.println(dis.readUTF());
            dis.close();
            s.close();
//        }
    }
}

Client

import java.net.*;
import java.io.*;
public class TCPClient {
    public static void main(String[] args) throws Exception{
        Socket s=new Socket("127.0.0.1",6666);
        DataOutputStream dos=new DataOutputStream(s.getOutputStream());
        dos.writeUTF("洞1洞1，洞7报告！");
        dos.flush();
        dos.close();
        s.close();
    }
}

London2012 2009-06-28 22:02 发表评论

java调用外部程序的方法

London2012 — Sun, 28 Jun 2009 13:57:00 GMT

在一个java应用中，可能会遇到这样的需求，就是需要调用一些外部的应用做一些处理，比如调用excel，然后在继续程序的运行。
下面就开始进入java调用外部程序的一些演示，让java应用更加灵活。
1：最简单的演示：
Runtime.getRuntime().exec("notepad.exe");
记事本被打开了是吧。
2：传递应用程序的参数：
Runtime runtime=Runtime.getRuntime();
String[] commandArgs={"notepad.exe","c:/boot.ini"};
runtime.exec(commandArgs);
现在不单单打开了记事本，而且还装载了boot.ini文件是吧。
现在已经完全解决了调用外部程序的问题，不是吗，但是大家会发现exec方法是有返回值，那么继续我们的演示吧。
1：Process的waitFor：
Runtime runtime=Runtime.getRuntime();
String[] commandArgs={"notepad.exe","c:/boot.ini"};
Process process=runtime.exec(commandArgs);
int exitcode=process.waitFor();
System.out.println("finish:"+exitcode);
执行上面的代码以后发现不同的地方了吗，waitFor会使线程阻塞，只有外部程序退出后才会执行System.out.println("finish:"+exitcode);
这个功能很有用是吧，因为多数时候你都需要等待用户处理完外部程序以后才继续你的java应用。
2：Process的destroy：
Runtime runtime=Runtime.getRuntime();
String[] commandArgs={"notepad.exe","c:/boot.ini"};
final Process process=runtime.exec(commandArgs);
new Thread(new Runnable(){
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {}
process.destroy();
}}).start();
int exitcode=process.waitFor();
System.out.println("finish:"+exitcode);
这个演示稍微复杂了一些，如果你等待5秒，就会发现记事本自动关闭了，是的，这个就是destroy方法的作用，强制关闭调用的外部程序。
不用我解释了吧，这是非常有用的方法。
以上的部分已经足够你调用并控制你的外部应用了。如果需要更详细的信息，看javadoc文档吧。
最后的说明：ProcessBuilder这个1.5新增的类也可以完成同样的任务，Runtime就是调用了这个类。

London2012 2009-06-28 21:57 发表评论

你知道如何才算掌握Java（J2EE篇）吗?

London2012 — Tue, 16 Jun 2009 14:28:00 GMT

  PS：要求很高，可以说是精通了！


      时常看到一些人说掌握了Java，但是让他们用Java做一个实际的项目可能又困难重重，在这里，笔者根据自己的一点理解斗胆提出自己的一些对掌握Java这个说法的标准，当然对于新手，也可以提供一个需要学习哪些内容的参考。另外这个标准仅限于J2SE部分，J2EE部分的内容有时间再另说。
　　
　　1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。
　　
　　2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、HtmlConverter、jar、 java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。
　　
　　3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。
　　
　　4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：
　　
　　1）、java.lang包下的80％以上的类的功能的灵活运用。
　　
　　2）、java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer。
　　
　　3）、java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。
　　
　　4）、java.math包下的100％的内容。
　　
　　5）、java.net包下的60％以上的内容，对各个类的功能比较熟悉。
　　
　　6）、java.text包下的60％以上的内容，特别是各种格式化类。
　　
　　7）、熟练运用JDBC。
　　
　　8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java。
　　
　　9）、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。
　　
　　10）、Swing的基本内容，和AWT的要求类似。
　　
　　11）、XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。
　　
　　5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。
　　
　　6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。
　　
　　7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。
　　
　　8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。
　　
　　9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/SCHOLAR_II/archive/2009/03/07/3964852.aspx

London2012 2009-06-16 22:28 发表评论

java命名规则

London2012 — Mon, 15 Jun 2009 06:23:00 GMT

包名：

包名是全小写的名词，中间可以由点分隔开，例如：java.awt.event;

类名、接口名：

首字母大写，通常由多个单词合成一个类名，要求每个单词的首字母也要大写，

例如class HelloWorldApp;

方法名：

往往由多个单词合成，第一个单词通常为动词，首字母小写，中间的每个单词的首字母

都要大写，例如：balanceAccount， isButtonPressed;

变量名：

全小写，一般为名词，例如：length;

常量名：

基本数据类型的常量名为全大写，如果是由多个单词构成，可以用下划线隔开，

例如：int YEAR, int WEEK_OF_MONTH；

如果是对象类型的常量，则是大小写混合，由大写字母把单词隔开。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nailwl/archive/2009/06/14/4265377.aspx

London2012 2009-06-15 14:23 发表评论

JAVA 23设计模式一点就通

London2012 — Mon, 15 Jun 2009 06:01:00 GMT

一、创建型模式

　　FACTORY？人才市场：以往是要哪个人才，就找哪个人才，效率低，现在有了人才市场，我们只需直接去人才市场挑一个好了；

　　BUILDER？生产流水线：以前是手工业作坊式的人工单个单个的生产零件然后一步一步组装做，好比有了工业革命，现在都由生产流水线代替了。如要造丰田汽车，先制定汽车的构造如由车胎、方向盘、发动机组成。再以此构造标准生产丰田汽车的车胎、方向盘、发动机。然后进行组装。最后得到丰田汽车；

　　PROTOTYPE？印刷术的发明：以前只能临贴才能保持和别人的字迹基本相同，直从印刷技术发明，从而保证了复制得和原物一模一样；

　　SINGLETON？唯一：以前是商标满天飞，相同的商标难免造成侵权，直从有商标保护法后，就保证了不会再产生第家企业使用相同的商标；

　　二、结构型模式

　　ADAPTER？集众人之私，成一己之公：武当派张三丰会太极拳，少林派智空大师会金刚般若掌，如果他们两个都成为我的师傅，我就既会太极拳，又会金刚般若掌了；

　　DECORATOR？青出于蓝而胜于蓝：武当派张三丰会太极拳，是我师傅，他教会了我太极拳，但我自己还会点蒙古式摔交，张三丰却不会。于是我就成了DECORATOR模式的实现；

　　BRIDGE？白马非马：马之颜色有黑白，马之性别有公母。我们说"这是马"太抽象，说"这是黑色的公马"又太死板，只有将颜色与性别和马动态组合，"这是（黑色的或白色的）（公或母）马"才显得灵活而飘逸，如此bridge模式精髓得矣。

　　COMPOSITE？大家族：子又生孙，孙又生子，子子孙孙，无穷尽也，将众多纷杂的人口组织成一个按辈分排列的大家族即是此模式的实现；

　　FACADE？求同存异：高中毕业需读初中和高中，博士也需读初中和高中，因此国家将初中和高中普及成九年制义务教育；

　　FLYWEIGHT？一劳永逸：认识三千汉字，可以应付日常读书与写字，可见头脑中存在这个汉字库的重要；

　　PROXY？垂帘听政：犹如清朝康熙年间的四大府臣，很多权利不在皇帝手里，必须通过辅佐大臣去办；

　　三、行为模式

　　CHAIN OF RESPONSIBLEITY？租房：以前为了找房到处打听，效率低且找不到好的房源。现在有了房屋中介，于是向房屋中介提出租房请求，中介提供一个合适的房源，满意则不再请求，不满意继续看房，直到满意为止；

　　COMMAND？借刀杀人：以前是想杀谁就杀，但一段时间后领悟到，长此以往必将结仇太多，于是假手他人，挑拨他人之间的关系从而达到自己的目的；

　　INTERPRETER？文言文注释：一段文言文，将它翻译成白话文；

　　ITERATOR？赶尽杀绝：一个一个的搜索，绝不放掉一个；

　　MEDIATOR？三角债：本来千头万绪的债务关系，忽出来一中介，包揽其一切，于是三角关系变成了独立的三方找第四方中介的关系；

　　MEMENTO？有福同享：我有多少，你就有多少；

　　OBSERVER？看守者：一旦被看守者有什么异常情况，定会及时做出反应；

　　STATE？进出自由：如一扇门，能进能出，如果有很多人随时进进出出必定显得杂乱而安全，如今设一保安限制其进出，如此各人进出才显得规范；

　　STRATEGY？久病成良医：如人生病可以有各种症状，但经过长期摸索，就可以总结出感冒、肺病、肝炎等几种；

　　TEMPLATE METHOD？理论不一定要实践：教练的学生会游泳就行了，至于教练会不会则无关紧要；

　　VISITOR？依法治罪：因张三杀人要被处死，李四偷窃要被罚款。由此势必制定处罚制度，故制定法律写明杀人、放火、偷窃等罪要受什么处罚，经通过后须变动要小。今后有人犯罪不管是谁，按共条例处罚即是，这就是访问者模式诞生的全过程。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/xujianhua815926/archive/2005/09/19/484465.aspx

London2012 2009-06-15 14:01 发表评论

Java编程规则

London2012 — Mon, 15 Jun 2009 05:59:00 GMT

(1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如：
ThisIsAClassName
thisIsMethodOrFieldName
若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。
Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。

(2) 为了常规用途而创建一个类时，请采取“经典形式”，并包含对下述元素的定义：

equals()
hashCode()
toString()
clone()（implement Cloneable）
implement Serializable

(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。

(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。

(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。
(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：
■一个复杂的开关语句：考虑采用“多形”机制
■数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现
■许多成员变量在特征上有很大的差别：考虑使用几个类

(7) 让一切东西都尽可能地“私有”——private。可使库的某一部分“公共化”（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护。

(8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。

(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。

(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的“用内部类改进代码”）。

(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。

(12) 避免使用“魔术数字”，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。

(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常——如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。

(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize ()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。

(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。

(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。

(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象“造型”到数组里。

(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。

(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。

(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。

(21) 在现成类的基础上创建新类时，请首先选择“新建”或“创作”。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。

(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个“颜色”字段。

(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。

(24) 在Java 1.1 AWT中使用事件“适配器”时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示——只不过代码的工作就变得不正常了。

(25) 用合理的设计方案消除“伪功能”。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。

(26) 警惕“分析瘫痪”。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入“死逻辑”中。

(27) 警惕“过早优化”。首先让它运行起来，再考虑变得更快——但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。

(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。

(29) 如认为自己已进行了良好的分析、设计或者实施，那么请稍微更换一下思维角度。试试邀请一些外来人士——并不一定是专家，但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作，看看是否能找出你一度熟视无睹的问题。采取这种方式，往往能在最适合修改的阶段找出一些关键性的问题，避免产品发行后再解决问题而造成的金钱及精力方面的损失。

(30) 良好的设计能带来最大的回报。简言之，对于一个特定的问题，通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法，以后的工作就轻松多了，再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报（甚至无可估量）。而且由于自己倾注了大量心血，最终获得一个出色的设计方案，成功的快感也是令人心动的。坚持抵制草草完工的诱惑——那样做往往得不偿失。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/stevexk/archive/2006/02/25/609615.aspx

London2012 2009-06-15 13:59 发表评论

MyEclipse一些设置

London2012 — Mon, 15 Jun 2009 05:42:00 GMT

改变Eclipse或者MyEclipse新建文件的默认编码：

Eclipse的：
window-preferences-General-ContentType 的右边窗口，改成gbk也可以，utf-8也行。

MyEclipse的：
window-preferences-myEclipse-files and editors-jsp里面有encoding，改这里为ISO10646/UTF-8。

增强Eclipse ，MyEclipse 的代码自动提示功能

一般默认情况下，Eclipse ，MyEclipse 的代码提示功能是比Microsoft Visual Studio的差很多的，主要是Eclipse ，MyEclipse本身有很多选项是默认关闭的，要开发者自己去手动配置。如果开发者不清楚的话，就不知道Eclipse ，MyEclipse的代码提示功能一样能像Microsoft Visual Studio的代码提示功能一样强大。
先举个简单的例子说明问题所在，例如在Eclipse ，MyEclipse代码里面，打个foreach，switch等这些，是无法得到代码提示的（不信自己试试），其他的就更不用说了，而在Microsoft Visual Studio 里面是得到非常友好的代码提示的。实际上，Eclipse ，MyEclipse代码里面的代码提示功能默认的一般是点“.”，一般是有了点“.”，才会有代码提示。
原理：“Auto Activation triggers for java”这个选项就是指触发代码提示的选项，把“.” 改成“.abcdefghijklmnopqrstuvwxyz(,”就OK了，就是指遇到26个字母和.，（这些符号就触发代码提示功能了。

增强Eclipse ，MyEclipse 的代码提示功能，具体配置：
下面开始说步骤（注意本人用的 MyEclipse 6.0.1做讲解）：

1. 打开MyEclipse 6.0.1，然后“window”→“Preferences”；

2. 选择“java”，展开，“Editor”，选择“Content Assist”；

3. 选择“Content Assist”，然后看到右边，右边的“Auto-Activation”下面的“Auto Activation triggers for java”这个选项。其实就是指触发代码提示的就是“.”这个符号；

4. “Auto Activation triggers for java”这个选项，在“.”后加abc字母，方便后面的查找修改。然后“apply”，点击“OK”；

5. 然后，“File”→“Export”，在弹出的窗口中选择“Perferences”，点击“下一步”；

6. 选择导出文件路径，本人导出到桌面，输入“test”作为文件名，点击“保存”；

7. 在桌面找到刚在保存的文件“test.epf”,右键选择“用记事本打开”；

8. 可以看到很多配置MyEclipse 6.0.1的信息；

9. 按“ctrl + F”快捷键，输入“.abc”，点击“查找下一个”；

10. 查找到“.abc”的配置信息；

11. 把“.abc”改成“.abcdefghijklmnopqrstuvwxyz(,”，保存，关闭“test.epf”；

12. 回到MyEclipse 6.0.1界面，“File”→“Import”，在弹出的窗口中选择“Perferences”，点击 “下一步”，选择刚在已经修改的“test.epf”文件，点击“打开”，点击“Finish”。该步骤和上面的导出步骤类似；

13. 最后当然是进行代码测试了，随便新建一个工程，新建一个类。在代码输入switch，foreach等进行测试。你立即会发现，果然出了提示，而且无论是敲哪个字母都会有很多相关的提示了，很流畅，很方便。
顺便说一下，修改类名，接口名等以不同颜色高亮的，可以这样配置在“java”→“enditor”→ “syntac”，右边展开“java”→“classes”，勾上“Enable”这个选项，选择自己喜欢的颜色即可。
当然还有其他相关的颜色配置。具体就不说啦。其实，在“Preferences”这个东西，有很多可以配置的东西，使得MyEclipse 优化的，具体的就要各个人根据自己个人喜好去配置了。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/guojingjun144/archive/2009/06/15/4269310.aspx

London2012 2009-06-15 13:42 发表评论

ECLIPSE快捷键与插件

London2012 — Mon, 15 Jun 2009 05:39:00 GMT

(1）Ctrl+M------->切换窗口的大小
(2）Ctrl+Q------->跳到最后一次的编辑处
(3) Ctrl+1------->快速修复(最经典的快捷键,就不用多说了)
(4) Ctrl+3------->快速查找想要的工具,和所有匹配的东西(最经典的快捷键,就不用多说了)
(5) Ctrl+D------->删除当前行
(6) Ctrl+Q------->定位到最后编辑的地方
(7) Ctrl+L------->定位在某行 (对于程序超过100的人就有福音了)
(8) Ctrl+M------->最大化当前的Edit或View (再按则反之)
(9) Ctrl+/------->注释当前行,再按则取消注释
(10) Ctrl+O------>快速显示 OutLine
(11) Ctrl+T------>快速显示当前类的继承结构
(12) Ctrl+W------>关闭当前Editer
(13) Ctrl+K------>参照选中的Word快速定位到下一个
(14) Ctrl+E------>快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
(15) Ctrl+/------>(小键盘) 折叠当前类中的所有代码
(16) Ctrl+×----->(小键盘) 展开当前类中的所有代码
(17) Ctrl+Space-->代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
(18）Ctrl+Pgdw--->对于XML文件是切换代码和图示窗口
(19）Ctrl+I------>格式化激活的元素Format Active Elements。
     Ctrl+Shift+F----->格式化文件Format Document。
(20）Ctrl+S------>保存当前文件。
     Ctrl+Shift+S----->保存所有未保存的文件。
(21）Ctrl+/------>在代码窗口中是这种//~注释。
     Ctrl+Shift+/----->在代码窗口中是这种/*~*/注释，在JSP文件窗口中是。
(22）Ctrl+Space--->提示键入内容即Content Assist，此时要将输入法中Chinese(Simplified)IME-Ime/Nonlme Toggle的快捷键（用于切换英文和其他文字）改成其他的。
     Ctrl+Shift+Space-->提示信息即Context Information。
(23）Ctrl+D------->删除当前行。
(24) Ctrl+J------->正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
=============================Ctrl+*+*==============================
(25）Ctrl+Alt+I--->看Java文件中变量的相关信息
(26）Ctrl+PgUp---->对于代码窗口是打开“Show List”下拉框，在此下拉框里显示有最近曾打开的文件
(27）Ctrl+Shift+M->(先把光标放在需导入包的类名上) 作用是加Import语句。
     Ctrl+Shift+O->作用是缺少的Import语句被加入，多余的Import语句被删除。
(28) Ctrl+Alt+↓-->复制当前行到下一行(复制增加)
(29) Ctrl+Alt+↑-->复制当前行到上一行(复制增加)
(30) Ctrl+Shift+E->显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
(31) Ctrl+Shift+J->反向增量查找(和上条相同,只不过是从后往前查)
(32) Ctrl+Shift+F4->关闭所有打开的Editer
(33) Ctrl+Shift+X-->把当前选中的文本全部变为小写
(34) Ctrl+Shift+Y-->把当前选中的文本全部变为小写
(35) Ctrl+Shift+F-->格式化当前代码
(36) Ctrl+Shift+P-->定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)
=============================Alt+*===========================================
(1) Alt+↓--------->当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
(2) Alt+↑--------->当前行和上面一行交互位置(同上)
(3) Alt+←--------->前一个编辑的页面
(4) Alt+→---------> 下一个编辑的页面(当然是针对上面那条来说了)
(5) Alt+Enter------>显示当前选择资源(工程,or 文件 or文件)的属性
(8）Alt+Shift+O---->(或点击工具栏中的Toggle Mark Occurrences按钮) 当点击某个标记时可使本页面中其他地方的此标记黄色凸显，并且窗口的右边框会出现白色的方块，点击此方块会跳到此标记处。
=============================Alt+shift+*===================================
下面的快捷键是重构里面常用的,(注:一般重构的快捷键都是Alt+Shift开头的了)
(9) Alt+Shift+R----->重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
(10) Alt+Shift+M---->抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
(11) Alt+Shift+C---->修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
(12) Alt+Shift+L---->抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
(13) Alt+Shift+F---->把Class中的local变量变为field变量 (比较实用的功能)
(14) Alt+Shift+I---->合并变量(可能这样说有点不妥Inline)
(15) Alt+Shift+V---->移动函数和变量(不怎么常用)
(16) Alt+Shift+Z---->重构的后悔药(Undo)
=============================Shif键=============================
(1) Shift+Enter----->在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
(2) Shift+Ctrl+Enter-> 在当前行插入空行(原理同上条)
=============================F键===============================
（3）
F2-->当鼠标放在一个标记处出现Tooltip时候按F2则把鼠标移开时Tooltip还会显示即Show Tooltip Description。
F3-->跳到声明或定义的地方。
F5-->单步调试进入函数内部。
F6-->单步调试不进入函数内部，如果装了金山词霸2006则要把“取词开关”的快捷键改成其他的。
F7-->由函数内部返回到调用处。
F8-->一直执行到下一个断点。
（14）双击窗口的左边框可以加断点。
(26）右击窗口的左边框即加断点的地方选Show Line Numbers可以加行号。

============================ Eclipse插件介绍与下载============================
1.Eclipse下载
EMF,GEF - Graphical Editor Framework,UML2,VE - Visual Editor都在这里下载
http://www.eclipse.org/downloads/index.php

1.lomboz J2EE插件,开发JSP,EJB
http://forge.objectweb.org/projects/lomboz

1.MyEclipse J2EE开发插件，支持SERVLET/JSP/EJB/数据库操纵等
http://www.myeclipseide.com

2.Properties Editor 编辑java的属性文件，并可以自动存盘为Unicode格式
http://propedit.sourceforge.jp/index_en.html

3.Colorer Take 为上百种类型的文件按语法着色
http://colorer.sourceforge.net/

4.XMLBuddy 编辑xml文件
http://www.xmlbuddy.com

5.Code Folding 加入多种代码折叠功能（比eclipse自带的更多）
http://www.coffee-bytes.com/servlet/PlatformSupport

5.jseclipse 支持JRE1.4
http://www.interaktonline.com/Products/Eclipse/JSEclipse/Try-Download/

6.Easy Explorer 从eclipse中访问选定文件、目录所在的文件夹
http://easystruts.sourceforge.net/

7.Fat Jar 打包插件，可以方便的完成各种打包任务，可以包含外部的包等
http://fjep.sourceforge.net/

8.RegEx Test 测试正则表达式
http://brosinski.com/stephan/archives/000028.php

9.JasperAssistant 报表插件（强，要钱的）
http://www.jasperassistant.com/

10.Jigloo GUI Builder ＪＡＶＡ的ＧＵＩ编辑插件
http://cloudgarden.com/jigloo/

11.Profiler 性能跟踪、测量工具，能跟踪、测量ＢＳ程序
http://sourceforge.net/projects/eclipsecolorer/

12.AdvanQas 提供对if/else等条件语句的提示和快捷帮助（自动更改结构等）
http://eclipsecolorer.sourceforge.net/advanqas/index.html

13.Log4E Log4j插件，提供各种和Log4j相关的任务，如为方法、类添加一个logger等
http://log4e.jayefem.de/index.php/Main_Page

14.VSSPlugin VSS插件
http://sourceforge.net/projects/vssplugin

15.Implementors 提供跳转到一个方法的实现类，而不是接中的功能（实用!）
http://eclipse-tools.sourceforge.net/implementors/

16.Call Hierarchy 显示一个方法的调用层次（被哪些方法调，调了哪些方法）
http://eclipse-tools.sourceforge.net/call-hierarchy/index.html

17.EclipseTidy 检查和格式化HTML/XML文件
http://eclipsetidy.sourceforge.net/

18.Checkclipse 检查代码的风格、写法是否符合规范
http://www.mvmsoft.de/content/plugins/checkclipse/checkclipse.htm

19.Hibernate Synchronizer Hibernate插件，自动映射等
http://www.binamics.com/hibernatesync/

20.VeloEclipse Velocity插件
http://propsorter.sourceforge.net/

21.EditorList 方便的列出所有打开的Editor
http://editorlist.sourceforge.net/

22.MemoryManager 内存占用率的监视
http://cloudgarden.com/memorymanager/

23.swt-designer java的GUI插件
http://www.swt-designer.com/

24.TomcatPlugin 支持Tomcat插件
http://www.sysdeo.com/eclipse/tomcatPlugin.html

25.XML Viewer
http://tabaquismo.freehosting.net/ignacio/eclipse/xmlview/index.html

26.quantum 数据库插件
http://quantum.sourceforge.net/

27.Dbedit 数据库插件
http://sourceforge.net/projects/dbedit

28.clay.core 可视化的数据库插件
http://www.azzurri.jp/en/software/index.jsp
http://www.azzurri.jp/eclipse/plugins

29.hiberclipse hibernate插件
http://hiberclipse.sourceforge.net
http://www.binamics.com/hibernatesync

30.struts-console Struts插件
http://www.jamesholmes.com/struts/console/

31.easystruts Struts插件
http://easystruts.sourceforge.net

32.veloedit Velocity插件
http://veloedit.sourceforge.net/

33.jalopy 代码整理插件
http://jalopy.sourceforge.net/

34.JDepend 包关系分析
http://andrei.gmxhome.de/jdepend4eclipse/links.html

35.Spring IDE Spring插件
http://springide-eclip.sourceforge.net/updatesite/

36.doclipse 可以产生xdoclet 的代码提示
http://beust.com/doclipse/

Eclipse插件大全下载
这里有比较全的eclipse插件下载，E文不错的可以去看看，应该能找到你需要的东西。
http://www.eclipse-plugins.info/eclipse/plugins.jsp;jsessionid=474944821E463102785EFCB59F941256

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/dsj188/archive/2009/06/15/4270124.aspx

London2012 2009-06-15 13:39 发表评论

java入门

London2012 — Mon, 15 Jun 2009 05:36:00 GMT

Java Learning Path （一）、工具篇

一、 JDK (Java Development Kit)

JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。

1、 JDK的下载和安装
JDK又叫做J2SE（Java2 SDK Standard Edition），可以从Sun的Java网站上下载到，http://java.sun.com/j2se/downloads.html 或 http://www.bt285.cn ，JDK当前最新的版本是J2SDK1.4.2，建议下载该版本的JDK，下载页面在这里：http://java.sun.com/j2se/1.4.2/download.html 或 http://www.bt285.cn 。

下载好的JDK是一个可执行安装程序，默认安装完毕后会在C:\Program Files\Java\目录下安装一套JRE（供浏览器来使用），在C:\j2sdk1.4.2下安装一套JDK（也包括一套JRE）。然后我们需要在环境变量PATH的最前面增加java的路径C:\j2sdk1.4.2\bin。这样JDK就安装好了。

2、 JDK的命令工具
JDK的最重要命令行工具：
java：启动JVM执行class
javac： Java编译器
jar： Java打包工具
javadoc： Java文档生成器
这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。

二、 JDK Documentation

Documentation在JDK的下载页面也有下载连接，建议同时下载Documentation。Documentation是最最重要的编程手册，涵盖了整个Java所有方面的内容的描述。可以这样说，学习Java编程，大部分时间都是花在看这个Documentation上面的。我是随身携带的，写Java代码的时候，随时查看，须臾不离手。

三、应用服务器(App Server)

App Server是运行Java企业组件的平台，构成了应用软件的主要运行环境。当前主流的App Server是BEA公司的Weblogic Server和IBM公司的Websphere以及免费的Jboss，选择其中一个进行学习就可以了，个人推荐Weblogic，因为它的体系结构更加干净，开发和部署更加方便，是Java企业软件开发人员首选的开发平台。下面简要介绍几种常用的App Server：

1、 Tomcat
Tomcat严格意义上并不是一个真正的App Server，它只是一个可以支持运行Serlvet/JSP的Web容器，不过Tomcat也扩展了一些App Server的功能，如JNDI，数据库连接池，用户事务处理等等。Tomcat被非常广泛的应用在中小规模的Java Web应用中，因此本文做一点下载、安装和配置Tomcat的介绍：

Tomcat是Apache组织下Jakarta项目下的一个子项目，它的主网站是：http://jakarta.apache.org/tomcat/ 或 http://www.5a520.cn，Tomcat最新版本是Tomcat4.1.27，软件下载的连接是：http://www.apache.org/dist/jakarta/tomcat-4/binaries/ 或 http://www.5a520.cn。

下载Tomcat既可以直接下载zip包，也可以下载exe安装包（个人建议zip更干净些），不管哪种情况，下载完毕安装好以后（zip直接解压缩就可以了）。需要设置两个环境变量：

JAVA_HOME=C:\j2sdk1.4.2
CATALINA_HOME=D:\tomcat4 (你的Tomcat安装目录

这样就安装好了，启动Tomcat运行CATALINA_HOME\bin\startup.bat，关闭Tomcat运行shutdown.bat脚本。Tomcat启动以后，默认使用8080端口，因此可以用浏览器访问http://localhost:8080来测试Tomcat是否正常启动。

Tomcat提供了两个Web界面的管理工具，URL分别是：
http://localhost:8080/admin/index.jsp
http://localhost:8080/manager/html
在启用这两个管理工具之前，先需要手工配置一下管理员用户和口令。用一个文本工具打开CATALINA_HOME\conf\tomcat-users.xml这个文件，加入如下几行：

这样用户“robbin”就具备了超级管理员权限。重新启动Tomcat以后，你就可以使用该用户来登陆如上的两个管理工具，通过Web方式进行Tomcat的配置和管理了。

2、 BEA Weblogic
Weblogic可以到BEA的网站上免费注册之后下载到最新的Weblogic8.1企业版，License可以免费使用1年时间，其实这已经完全足够了。Weblogic的下载连接：http://commerce.bea.com/index.jsp，Weblogic的在线文档：http://edocs.bea.com/ 。

3、 IBM Webshpere
Websphere同样可以下载到免费的试用版本，到IBM的developerWorks网站可以看到Websphere试用产品的下载和相关的Websphere的资料，developerWorks中文网站的连接是：http://www-900.ibm.com/developerWorks/cn/wsdd/ ，Websphere的下载连接：http://www7b.software.ibm.com/wsdd/downloads/WASsupport.html 。http://www.feng123.com

4、 Jboss
Jboss是免费开源的App Server，可以免费的从Jboss网站下载：http://www.jboss.org/index.html，然而Jboss的文档是不免费，需要花钱购买，所以为我们学习Jboss设置了一定的障碍。在Jdon上有几篇不错的Jboss配置文档，可以用来参考：http://www.jdon.com/idea.html

四、 Java应用的运行环境

Java的应用可以简单分为以下几个方面：

1、 Java的桌面应用
桌面应用一般仅仅需要JRE的支持就足够了。

2、 Java Web应用
Java的Web应用至少需要安装JDK和一个web容器（例如Tomcat），以及一个多用户数据库，Web应用至少分为三层：
Browser层：浏览器显示用户页面
Web层：运行Servlet/JSP
DB层：后端数据库，向Java程序提供数据访问服务

3、 Java企业级应用
企业级应用比较复杂，可以扩展到n层，最简单情况会分为4层：
Browser层：浏览器显示用户页面
Client层：Java客户端图形程序（或者嵌入式设备的程序）直接和Web层或者EJB层交互
Web层：运行Servlet/JSP
EJB层：运行EJB，完成业务逻辑运算
DB层：后端数据库，向Java程序提供数据访问服务

4、 Java嵌入式应用
Java嵌入式应用是一个方兴未艾的领域，从事嵌入式开发，需要从Sun下载J2ME开发包，J2ME包含了嵌入式设备专用虚拟机KVM，和普通的JDK中包含的JVM有所不同。另外还需要到特定的嵌入式厂商那里下载模拟器。

Java Learning Path（二）、书籍篇

学习一门新的知识，不可能指望只看一本，或者两本书就能够完全掌握。需要有一个循序渐进的阅读过程。我推荐Oreilly出版的Java系列书籍。

在这里我只想补充一点看法，很多人学习Java是从《Thinking in Java》这本书入手的，但是我认为这本书是不适合初学者的。我认为正确的使用这本书的方法应该是作为辅助的读物。《Thinking in Java》并不是在完整的介绍Java的整个体系，而是一种跳跃式的写作方法，是一种类似tips的方法来对Java很多知识点进行了深入的分析和解释。

对于初学者来说，最好是找一本Java入门的书籍，但是比较完整的循序的介绍Java的语法，面向对象的特性，核心类库等等，在看这本书的同时，可以同步来看《Thinking in Java》，来加深对Java的理解和原理的运用，同时又可以完整的了解Java的整个体系。

对于Java的入门书籍，蔡学镛推荐的是Oreilly的《Exploring Java, 2nd Edition》或者《Java in a Nutshell,2nd Edition（针对C++背景）》，我并没有看过这两本书。其实我觉得电子工业出版社的《Java 2编程详解》或者《Java 2从入门到精通》就很不错。

在所有的Java书籍当中，其实最最有用的，并不是O'reilly的 Java Serials，真正最最有用处是JDK的Documentation！几乎你想获得的所有的知识在Documentation里面全部都有，其中最主要的部分当然是Java基础类库的API文档，是按照package来组织的，对于每一个class都有详细的解释，它的继承关系，是否实现了某个接口，通常用在哪些场合，还可以查到它所有的public的属性和方法，每个属性的解释，意义，每个方法的用途，调用的参数，参数的意义，返回值的类型，以及方法可能抛出的异常等等。可以这样来说，所有关于Java编程方面的书籍其实都不过是在用比较通俗易懂的语言，和良好的组织方式来介绍Documentation里面的某个package里面包含的一些类的用法而已。所以万变不离其宗，如果你有足够的能力来直接通过Documentation来学习Java的类库，那么基本上就不需要看其他的书籍了。除此之外，Documentation也是编程必备的手册，我的桌面上有三个Documentation的快捷方式，分别是J2SDK1.4.1的Documentation，Servlet2.3的Documentation和J2SDKEE1.3.1的Documentation。有了这个三个Documentation，什么其他的书籍都不需要了。

对于Java Web 编程来说，最核心的是要熟悉和掌握HTTP协议，这个就和Java无关了，在熟悉HTTP协议之后，就需要熟悉Java的实现HTTP协议的类库，也就是Servlet API，所以最重要的东西就是Servlet API。当然对于初学者而言，直接通过Servlet API来学习Web编程有很大的难度，我推荐O'reilly的《Java Server Pages 》这本书来学习Web 编程。

EJB的书籍当中，《Enterprise JavaBeans, 2nd Edition》是一本很不错的书， EJB的学习门槛是比较高，入门很难，但是这本书完全降低了学习的难度，特别重要的一点是，EJB的学习需要结合一种App Server的具体实现，所以在学习EJB的同时，必须同步的学习某种App Server，而这本书相关的出了三本书，分别是Weblogic6.1，Websphere4.0和JBoss3.0上面部署书中例子的实做。真是既有理论，又有实践。在学习EJB的同时，可以边看边做，EJB的学习会变得很轻松。

但是这本书也有一个问题，就是版本比较旧，主要讲EJB1.1规范和部分EJB2.0的规范。而Ed Roman写的《Mastering EJB 2.0》这本书完全是根据EJB2.0规范写的，深入浅出，覆盖了EJB编程的各个方面，并且还有很多编程经验tips，也是学习EJB非常推荐的书籍之一。

如果是结合Weblogic来学习J2EE的话，《J2EE应用与BEA Weblogic Server》绝对是首选读物，虽然是讲述的Weblogic6.0，仍然值得购买，这本书是BEA官方推荐的教材，作者也是BEA公司的工程师。现在中文版已经随处可见了。这本书结合Weblogic介绍了J2EE各个方面的技术在Weblogic平台上的开发和部署，实践指导意义非常强。

在掌握了Java平台基础知识和J2EE方面的知识以后，更进一步的是学习如何运用OO的方法进行软件的设计，那么就一定要学习“设计模式”。Sun公司出版了一本《J2EE核心模式》，是每个开发Java企业平台软件的架构师必备的书籍。这本书全面的介绍了J2EE体系架构的各种设计模式，是设计师的必读书籍。

Java Learning Path（三）过程篇

每个人的学习方法是不同的，一个人的方法不见得适合另一个人，我只能是谈自己的学习方法。因为我学习Java是完全自学的，从来没有问过别人，所以学习的过程基本上完全是自己摸索出来的。我也不知道这种方法是否是比较好的方法，只能给大家提供一点参考了。

学习Java的第一步是安装好JDK，写一个Hello World，? 其实JDK的学习没有那么简单，关于JDK有两个问题是很容易一直困扰Java程序员的地方：一个是CLASSPATH的问题，其实从原理上来说，是要搞清楚JRE的ClassLoader是如何加载Class的；另一个问题是package和import问题，如何来寻找类的路径问题。把这两个问题摸索清楚了，就扫除了学习Java和使用JDK的最大障碍。推荐看一下王森的《Java深度历险》，对这两个问题进行了深入的探讨。

第二步是学习Java的语法。Java的语法是类C++的，基本上主流的编程语言不是类C，就是类C++的，没有什么新东西，所以语法的学习，大概就是半天的时间足够了。唯一需要注意的是有几个不容易搞清楚的关键字的用法，public，protected，private，static，什么时候用，为什么要用，怎么用，这可能需要有人来指点一下，我当初是完全自己琢磨出来的，花了很久的时间。不过后来我看到《Thinking in Java》这本书上面是讲了这些概念的。

第三步是学习Java的面向对象的编程语言的特性的地方。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，我觉得这个过程需要花很长很长时间，因为学习Java之前没有C++的经验，只有C的经验，我是大概花了一个月左右吧，才彻底把这些概念都搞清楚，把书上面的例子反复的揣摩，修改，尝试，把那几章内容反复的看过来，看过去，看了不下5遍，才彻底领悟了。不过我想如果有C++经验的话，应该一两天时间足够了。那么在这个过程中，可以多看看《Thinking in Java》这本书，对面向对象的讲解非常透彻。可惜的是我学习的时候，并没有看到这本书，所以自己花了大量的时间，通过自己的尝试和揣摩来学会的。

第四步就是开始熟悉Java的类库。Java的基础类库其实就是JDK安装目录下面jre\lib\rt.jar这个包。学习基础类库就是学习rt.jar。基础类库里面的类非常非常多。据说有3000多个，我没有统计过。但是真正对于我们来说最核心的只有4个，分别是
java.lang.*;
java.io.*;
java.util.*;
java.sql.*;

这四个包的学习，每个包的学习都可以写成一本厚厚的教材，而O'reilly也确实是这样做的。我觉得如果时间比较紧，是不可能通过读四本书来学习。我觉得比较好的学习方法是这样的：
首先要通读整个package的框架，了解整个package的class，interface，exception的构成，最好是能够找到介绍整个包框架的文章。这些专门介绍包的书籍的前几章应该就是这些总体的框架内容介绍。

对包整体框架的把握并不是要熟悉每个类的用法，记住它有哪些属性，方法。想记也记不住的。而是要知道包有哪些方面的类构成的，这些类的用途是什么，最核心的几个类分别是完成什么功能的。我在给人培训的时候一般是一次课讲一个包，所以不可能详细的介绍每个类的用法，但是我反复强调，我给你们讲这些包的不是要告诉你们类的方法是怎么调用的，也不要求你们记住类的方法调用，而是要你们了解，Java给我们提供了哪些类，每个类是用在什么场合，当我遇到问题的时候，我知道哪个类，或者哪几个类的组合可以解决我的问题，That'all！，当我们具体写程序的时候，只要你知道该用哪个类来完成你的工作就足够了。编码的时候，具体的方法调用，是边写代码，边查Documentation，所有的东西都在Documentation里面，不要求你一定记住，实际你也记不住3000多个类的总共将近10万个方法调用。所以对每个包的总体框架的把握就变得极为重要。

第五步，通过上面的学习，如果学的比较扎实的话，就打好了Java的基础了，剩下要做的工作是扫清Documentation里面除了上面4个包之外的其他一些比较有用处的类。相信进展到这一步，Java的自学能力已经被培养出来了，可以到了直接学习Documentation的水平了。除了要做GUI编程之外，JDK里面其他会有用处的包是这些：
java.text.*;
java.net.*;
javax.naming.*;
这些包里面真正用的比较多的类其实很少，只有几个，所以不需要花很多时间。

第六步，Java Web 编程，Web编程的核心是HTTP协议，HTTP协议和Java无关，如果不熟悉HTTP协议的话，虽然也可以学好Servlet/JSP编程，但是达不到举一反三，一通百通的境界。所以HTTP协议的学习是必备的。如果熟悉了HTTP协议的话，又有了Java编程的良好的基础，学习Servlet/JSP简直易如反掌，我学习Servlet/JSP就用了不到一周的时间，然后就开始用JSP来做项目了。

在Servlet/JSP的学习中，重头仍然是Servlet Documentation。Servlet API最常用的类很少，花比较少的时间就可以掌握了。把这些类都看一遍，多写几个例子试试。Servlet/JSP编程本质就是在反复调用这些类来通过HTTP协议在Web Server和Brower之间交谈。另外对JSP，还需要熟悉几个常用JSP的标记，具体的写法记不住的话，临时查就是了。

此外Java Web编程学习的重点要放在Web Application的设计模式上，如何进行业务逻辑的分析，并且进行合理的设计，按照MVC设计模式的要求，运用Servlet和JSP分别完成不同的逻辑层，掌握如何在Servlet和JSP之间进行流程的控制和数据的共享，以及Web Application应该如何配置和部署。

第七步，J2EE编程
以上的学习过程如果是比较顺利的话，进行到这一步，难度又陡然提高。因为上面的知识内容都是只涉及一个方面，而像EJB，JMS，JTA等核心的J2EE规范往往是几种Java技术的综合运用的结晶，所以掌握起来难度比较大。

首先一定要学习好JNDI，JNDI是App Server定位服务器资源（EJB组件，Datasouce，JMS）查找方法，如果对JNDI不熟悉的话，EJB，JMS这些东西几乎学不下去。JNDI其实就是javax.naming.*这个包，运用起来很简单。难点在于服务器资源文件的配置。对于服务器资源文件的配置，就需要看看专门的文档规范了，比如web.xml的写法，ejb-jar.xml的写法等等。针对每种不同的App Server，还有自己的服务资源配置文件，也是需要熟悉的。

然后可以学习JTA，主要是要理解JTA对于事务的控制的方法，以及该在什么场合使用JTA。这里可以简单的举个例子，我们知道一般情况可以对于一个数据库连接进行事务控制(conn.setAutoCommit(false),....,conn.commit())，做为一个原子操作，但是假设我的业务需求是要把对两个不同数据库的操作做为一个原子操作，你能做的到吗？这时候只能用JTA了。假设操作过程是先往A数据库插一条记录，然后删除B数据库另一个记录，我们自己写代码是控制不了把整个操作做为一个原子操作的。用JTA的话，由App Server来完成控制。

在学习EJB之前要学习对象序列化和RMI，RMI是EJB的基础。接着学习JMS和EJB，对于EJB来说，最关键是要理解EJB是如何通过RMI来实现对远端对象的调用的，以及在什么情况下要用到EJB。

在学习完EJB，JMS这些东西之后，你可能会意识到要急不可待学习两个领域的知识，一个是UML，另一个是Design Pattern。Java企业软件的设计非常重视框架(Framework)的设计，一个好的软件框架是软件开发成功的必要条件。在这个时候，应该开始把学习的重点放在设计模式和框架的学习上，通过学习和实际的编程经验来掌握EJB的设计模式和J2EE的核心模式。

J2EE规范里面，除了EJB，JMS，JTA，Servlet/JSP，JDBC之外还有很多很多的企业技术，这里不一一进行介绍了。

另外还有一个最新领域Web Services。Web Services也完全没有任何新东西，它像是一种黏合剂，可以把不同的服务统一起来提供一个统一的调用接口，作为使用者来说，我只要获得服务提供者给我的WSDL（对服务的描述），就够了，我完全不知道服务器提供者提供的服务究竟是EJB组件，还是.Net组件，还是什么CORBA组件，还是其他的什么实现，我也不需要知道。Web Services最伟大的地方就在于通过统一的服务提供方式和调用方式，实现了整个Internet服务的共享，是一个非常令人激动的技术领域。Web Services好像目前还没有什么很好的书籍，但是可以通过在网络上面查资料的方式来学习。

Java Learning Path（四）方法篇

Java作为一门编程语言，最好的学习方法就是写代码。当你学习一个类以后，你就可以自己写个简单的例子程序来运行一下，看看有什么结果，然后再多调用几个类的方法，看看运行结果，这样非常直观的把类给学会了，而且记忆非常深刻。然后不应该满足把代码调通，你应该想想看如果我不这样写，换个方式，再试试行不行。记得哪个高人说过学习编程就是个破坏的过程，把书上的例子，自己学习Documentation编写的例子在运行通过以后，不断的尝试着用不同的方法实现，不断的尝试破坏代码的结构，看看它会有什么结果。通过这样的方式，你会很彻底的很精通的掌握Java。

举个例子，我们都编过Hello World

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World http://www.feng123.com ; }}

很多初学者不是很理解为什么main方法一定要这样来定义public static void main(String[] args)，能不能不这样写？包括我刚学习Java的时候也有这样的疑问。想知道答案吗？很简单，你把main改个名字运行一下，看看报什么错误，然后根据出错信息进行分析；把main的public取掉，在试试看，报什么错误；static去掉还能不能运行；不知道main方法是否一定要传一个String[]数组的，把String[]改掉，改成int[]，或者String试试看；不知道是否必须写args参数名称的，也可以把args改成别的名字，看看运行结果如何。

我当初学习Java的时候就是这样做的，把Hello World程序反复改了七八次，不断运行，分析运行结果，最后就彻底明白为什么了main方法是这样定义的了。

此外，我对于staic，public，private，Exception，try{ }catch {}finally{}等等等等一开始都不是很懂，都是把参考书上面的例子运行成功，然后就开始破坏它，不断的根据自己心里面的疑问来重新改写程序，看看能不能运行，运行出来是个什么样子，是否可以得到预期的结果。这样虽然比较费时间，不过一个例子程序这样反复破坏几次之后。我就对这个相关的知识彻底学通了。有时候甚至故意写一些错误的代码来运行，看看能否得到预期的运行错误。这样对于编程的掌握是及其深刻的。

其中特别值得一提的是JDK有一个非常棒的调试功能，-verbose
java –verbose
javac –verbose 以及其它很多JDK工具都有这个选项
-verbose 可以显示在命令执行的过程中，JVM都依次加载哪里Class，通过这些宝贵的调试信息，可以帮助我们分析出JVM在执行的过程中都干了些什么。

另外，自己在学习过程中，写的很多的这种破坏例程，应该有意识的分门别类的保存下来，在工作中积累的典型例程也应该定期整理，日积月累，自己就有了一个代码库了。遇到类似的问题，到代码库里面 Copy & Paste ，Search & Replace，就好了，极大提高了开发速度。最理想的情况是把一些通用的例程自己再抽象一层，形成一个通用的类库，封装好。那么可复用性就更强了。

所以我觉得其实不是特别需要例程的，自己写的破坏例程就是最好的例子，如果你实在对自己写的代码不放心的话，我强烈推荐你看看JDK基础类库的Java源代码。在JDK安装目录下面会有一个src.zip，解开来就可以完整的看到整个JDK基础类库，也就是rt.jar的Java源代码，你可以参考一下Sun是怎么写Java程序的，规范是什么样子的。我自己在学习Java的类库的时候，当有些地方理解的不是很清楚的时候，或者想更加清晰的理解运作的细节的时候，往往会打开相应的类的源代码，通过看源代码，所有的问题都会一扫而空。

Java Learning Path（五）资源篇

1、 http://java.sun.com/ (英文)
Sun的Java网站，是一个应该经常去看的地方。不用多说。

2、http://www-900.ibm.com/developerWorks/cn/
IBM的developerWorks网站，英语好的直接去英文主站点看。这里不但是一个极好的面向对象的分析设计网站，也是Web Services，Java，Linux极好的网站。强烈推荐！！！

3、http://www.javaworld.com/ (英文)
关于Java很多新技术的讨论和新闻。想多了解Java的方方面面的应用，这里比较好。

4、http://dev2dev.bea.com.cn/index.jsp
BEA的开发者园地，BEA作为最重要的App Server厂商，有很多独到的技术，在Weblogic上做开发的朋友不容错过。

5、http://www.huihoo.com/
灰狐动力网站，一个专业的中间件网站，虽然不是专业的Java网站，但是在J2EE企业应用技术方面有深厚的造诣。

6、http://www.theserverside.com/ (英文)
TheServerSide是一个著名的专门面向Java Server端应用的网站。

7、http://www.javaresearch.org/
Java研究组织，有很多优秀的Java方面的文章和教程，特别是在JDO方面的文章比较丰富。

8、http://www.cnjsp.org/
JSP技术网站，有相当多的Java方面的文章和资源。

9、http://www.jdon.com/
Jdon论坛，是一个个人性质的中文J2EE专业技术论坛，在众多的Java的中文论坛中，Jdon一个是技术含量非常高，帖子质量非常好的论坛。

10、http://sourceforge.net/
SourgeForge是一个开放源代码软件的大本营，其中也有非常非常丰富的Java的开放源代码的著名的软件。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/OpenHero/archive/2006/08/08/1037831.aspx

London2012 2009-06-15 13:36 发表评论

BlogJava- oDiBo “开封菜”WWW.KFC.IM-随笔分类-J2SE

JDK1.5新特性之一----静态导入

可变参数列表-Java SE5新特性

java中产生随机数的两种方式

学习：socket

java调用外部程序的方法

你知道如何才算掌握Java（J2EE篇）吗?

java命名规则

JAVA 23设计模式一点就通

Java编程规则

MyEclipse一些设置

ECLIPSE快捷键与插件

java入门

BlogJava- oDiBo “开封菜”WWW.KFC.IM-随笔分类-J2SE