abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。
接口：没有提供任何具体实现，可以说是一个极度抽象的类，他允许你创建一个能够被向上转型为不止一种基类型的类，以此来实现多重继承。
抽象类：包含一种或多种抽象方法的类，且可以提供具体的实现。定义抽象类后，其他类可以对他进行扩充并且通过实现其中的抽象方法，使用抽象类具体话。
Java中的接口和抽象类的区别：接口中没有属性，而且所有的方法都是抽象的，而抽象类可以有属性，而且可以有抽象方法，也可以有实现的方法。但两者都不能被实例话。
使用的时候，一个类可以继承多个接口，但只能继承一个抽象类。
一、理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。
二、从语法定义层面看abstract class和interface
在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。使用abstract class的方式定义Demo抽象类的方式如下：

abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝

使用interface的方式定义Demo抽象类的方式如下：

interface Demo {
void method1();
void method2();
…
}

在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。
从编程的角度来看，abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。
首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。
其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会 增加一些复杂性，有时会造成很大的麻烦。
在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。
同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule，one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。
三、从设计理念层面看abstract class和interface
上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本文将从另一个层面：abstract class和interface所反映出的设计理念，来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概念的本质所在。
前面已经提到过，abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。
考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：

abstract class Door {
abstract void open();
abstract void close()；
}

使用interface方式定义Door：

interface Door {
void open();
void close();
}

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。
如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。
解决方案一：
简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door {
abstract void open();
abstract void close()；
abstract void alarm();
}

或者

interface Door {
void open();
void close();
void alarm();
}

那么具有报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或者

class AlarmDoor implements Door ｛
void open() { … }
void close() { … }
void alarm() { … }
｝

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。
解决方案二：
既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。
显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。
如果两个概念都使用interface方式来定义，那么就反映出两个问题：
1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？
2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。
如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door {
abstract void open();
abstract void close()；
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。
abstract class和interface是Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会

WebServices 是部署在WEB上的组件和对象!
  它具有以下几点特征:
   1. 高度的耦合性.就是移植性还不错,相互依赖不强 .
   2. 高度的集成性.
   3. 完好的封状性. 就是我们只可以看到他想让你看到的东西 呵呵!
   4. 使用标准协议规范.

对synchronized(this)的一些理解
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用.

全面认识JAVA
作者：unknown 更新时间：2005-04-07
作SCJP培训已经有一段时间了，到我这学习的有在校的大学生，也有在职的开发人员。通常这些学员此前都对Java已有一些了解，但普遍对Java缺乏总体的认识。于是学员总是问，Java应该怎么学？Java能做什么？什么是Applet？什么是Servlet、Jsp、EJB?还有Webspere、Weblogic又是做什么的等等。之所以学员会有这些疑问，是因为大家普遍对Java相关概念听说的太多而了解的又相对少的缘故。 学通Java语言需要一个过程，所有Java相关的概念都会在学习的过程中逐渐变得清昕。这个过程的开始就是要先学会标准的Java技术(J2SE)，然后是学Java的简单Web运用，然后分布式运用,再以后对Java的移动技术运用就很容易理解了。 以下是Java标准技术的一些要点： 一、Java的跨平台性，即一次编译到处运行 简单地说Java的跨平台性就是指，编译后的Java程序可直接在不同的平台上运行而不用重新编译，这一特性使得Java随着Web应用的普及而迅速普及起来。而Java的跨平台性是如何实现的呢？这就要理解Java虚拟机和字节码的概念。 　　实际上，编译后的Java代码并不是传统的二进制代码（如Windows下的.exe文件），而是Java字节码，这种字节码文件是不能直接在操作系统上执行的。要想在一个操作系统上运行一个Java程序必须有一个中间环节来负责将Java字节码解释成二进制码，这个中间环节就是Java虚拟机（简称JVM)。由于目前大多数操作系统已经实现了JVM，所以Java轻松实现跨平台性。 　　二、面象对象技术 　　Java全面支持面象对象技术，这体现在Class（类）是Java程序构成的基本单元，一个Java程序通常由许多Class组成，而且这些Class还会有一定的继承关系，Java支持Class的单继承，从而使类之间的继承关系更明确。继承的结果产生类的多态性，类的多态本质上讲就是可以用父类的引用访问继承类的实现（子类对象），类的这种多态性最终形成了组件对象模型的基础，即通过接口（父类）访问实现（子类）。 　　三、Java中的I/O操作 　　Java中以字节流（InputStream和OutputStream)、节符流（Reader和Writer)来分别读写二进制数据和字符数据，使用非常简单有效。Java类库中的File类不仅提供文件操作而且还包含文件夹操作，如下面这几行代码可以列出C盘根目录下的所有文件： File f=new File("c://"); String [] m_dir= f.list(); for(int i=0;i<m_dir.length;i++) System.out.println(m_dir[i]); 四、Java中的图形及事件处理 可以用awt包或swing包的Java类来进行大部分的Java图形界面设计，下面的几行代码将产生一个200*200像素的窗体： Frame f=new Frame("Welcome"); f.setSize(200,200); f.setVisible(true); 默认情况下，Frame窗体的关闭按钮不起作用，这也是Java初学者迷惑的地方。为了使用户按下关闭按钮时能关闭Frame窗体，需要让这个窗体响应一个WindowEvent事件，具体的做法就是给这个窗体添加一个事件监听器对象，这个事件监听器就是WindowListener接口的实现。在上面的代码中插入如下代码就可以关闭窗体： f.addWindowListener(new WindowAdapter(){ ??public void windowClosing(WindowEvent e){ System.exit(0); ??} } 这里用到一个无名内部类，无名内部类是Java中内部类的一种灵活运用方式。 五、Java中线程及同步控制 线程概念的引入是为了实现并行处理，从而提高程序的效率。Java中的线程实现非常简单，可以用两种方式来创建线程，一种是实现Runnable接口，另一种是继承Thread类重写run()方法。两种方式唯一的不同就是前者保留了继承一个类的可能（因为Java只支持类的单继承，但接口没有此限制）。 　　永远都用start()方法来启动一个线程，线程类中的run()可以被直接调用，但决不是启动一个线程，二者有着本质的区别。 　　用同步控制关键字synchronized来保护线程敏感数据，synchronized块中的内容可以保证同一时刻只能被一个线程访问，所以其中的数据是线程安全的。 　　用Object类中的wait()和notify()方法可以实现线程间交互，但要记住wait()和notify()方法只有发生在同一个对象上才能真正实现线程间交互。被某一对象wait()方法阻塞的线程需要另外一个调用了同一对象notify()的线程干预才能恢复运行。notify()方法一次唤醒一个被wait()方法阻塞的线程，notifyAll()方法可以一次唤醒所有被wait()方法阻塞的线程。 　　六、Java本地方法（native方法）的实现 　　Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。 　　可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤： 　　１、在Java中声明native()方法，然后编译； 　　２、用javah产生一个.h文件； 　　３、写一个.cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）； 　　４、将第三步的.cpp文件编译成动态链接库文件； 　　５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。 　　上述所提及的一些Java技术具有一定的普遍性，它们基本上是在Java各个方面的运用中都需要掌握的术。实际上Java的运用非常广泛，而且每个方面都需要遵循不同的规范。以下是对Java应用的简要介绍。 （一）理解Java SDK的三个版本： Java SDK Micro Edition (J2ME) 用于开发掌上电脑、手机等移动通信设备上使用的应用程序。并不是所有的移动设备都支持Java，只有具备J2ME运行环境（JVM+J2ME API)的设备才能运行Java程序。J2ME的集成开发工具（通常都有带有一些访真器）有 Sun 的J2ME Wireless Toolkit 、IBM的Visul Age Micro Edition 等。 Java SDK Standard Edition（J2SE) 主要用于开发一般台式机应用程序。我们平时所说的JDK就指J2SE，而我们学Java就是从学习J2SE开始的。 Java SDK Enterprise Edition (J2EE) 用于开发分布式的企业级大型应用程序。其中的核心是Entetprise Java Beans（EJB，分布式Java组件）的开发。 （二）Java小程序 （Applet) Java小程序是一个继承了Applet类并重写了init()、paint()、stop()等方法的的Java类，它被布署在Web服务器（如IIS）上，当客户端请求Web页时，浏览器从Web服务器上将其下载到本地客户端，然后，浏览器创建该Applet类的实例并调用其init()方法，从安全角度考虑，Applet没有访问本地文件的权限。由于Applet是被浏览器执行的，所以Applet不需要一个main()方法。实际上，除了Java Application之外，所有其它Java应用都不需要一个main()方法。 （三）服务器端Java小程序 （Servlet） Servlet也是一个Java类，和Applet形成对比，Servlet是运行于服务器端的Java小程序，而且Servlet需要一个单独的Web服务器（如Tomcat）做容器。除此之外，Servlet中用到的一些类（如HttpServlet)并不包含在J2SE API中，所以需要将Servlet.jar（在Tomcat的common\lib文件夹下）加到环境变量中去。下面是一个简单的Servlet例子： public class Myservlet extends HttpServlet{ ??public void doGet(HttpServletRequest request,HttpServletResponse response) { ??try{ response.setContentType("text/html"); PrintWriter out=response.getWriter(); out.println("<html>"); out.println("<body>"); out.println("Hello world"); out.println("</body>"); out.println("</html>"); ??}catch(IOException e){} } } 将这个Class文件编译后放至Tomcat\webapps\examples\WEB-INF\classes下，然后在浏览器地址栏里输入http://127.0.0.1:8080/examples/servlet/Myservlet即可看到 Hello world出现在浏览器中。 （四）Java Server Page （JSP） 同Servlet相似的是，JSP运行于Web服务器端，并且也需要Tomcat之类的容器。不同的是，由于JSP是将Java代码嵌在html标记里（同ASP一样用<% ...%>)，JSP的界面设计同后台开发人员的工作可以有效分离。可以想像让开发人员用Servlet写一个花捎的Web页面有多困难，所以JSP+Servlet混合Web应用是比较理想的选择。 看起来JSP同ASP的实现机制大同小异，其实也存在着本质的区别。所有的ASP页面都是解释运行的，而JSP页在第一次被请求时会被编译，再以后的客户请求都是直接运行服务器上的.class文件（在Tomcat的Work文件夹下），所以JSP要比ASP速度上快许多。 （五）Java Beans Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。 （六）Enterprise Java Beans （EJB） Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。 这种模型很像COM+管理器，其实EJB容器正是起到COM+管理器的作用，只是EJB组件相对COM组件来说更易用、更安全。 总的说来，Java作为面象对象技术的一个代表，在当今商业应用中更容易开发出高效的、多层的分布式应用程序，而且，由于Java技术有很强的健壮性和易用性，加上同UML应用的结合，开发一个商业应用软件的周期会大大缩短，所以Java会有不错的前景。

Java学习过程的一些重点
Java学习过程的一些重点 　　主要说说Java的几大块吧，无法说得很细，因为其实每一块拿出来都能说很多，我就说一下这几块学习的时候的重点或者应该注意的东西。 数值类型： 　　虽然是面向对象的语言，但是在使用上数值类型还是必不可少的，如果在C的学习中已经掌握了C的数值计算和转换规则，那我想这里应该没有什么问题，只有两点需要注意：1、14.0这样的浮点常量被认为是double型，只有加上f后缀才是float型的；2、整数常量说起来被认为是int型，但是在编译时，可以认为编译器将其看作能表示该数的最小数值，因此byte b = 100;不会报错。 引用类型： 　　我也是从C/C++转过来的，其实所谓引用类型在C++中已有体现，就是传参的时候有一种引用类型，从C来考虑，它就是一个指针，只不过，我们不能对它进行指针上的硬操作。所以这里的重点是：1、Java里所有的对象都是在堆中生成的，所以需要类似指针的东西指向它，那就是引用；2、我们通过引用操作的是引用所指向的对象，除了赋值操作外，应该就没有什么操作是针对引用本身的了，这一点是C的指针与Java的引用区别所在。 类和对象： 　　这是一个大块，有很多东西，不展开讲了，就说几个重点：1、类方法、类属性与成员方法、成员属性在加载、初始化、使用上的异同；2、在构造函数中，this()和super()的用法；3、子类的加载过程、初始化过程和构造过程；4、方法的重载和覆写；5、覆写所引出的多态问题。(注意：多态之应用在方法上，对属性没有作用) 函数调用的参数传递： 　　如果把引用类型所记录的地址值，就看作是引用类型变量的值的话，那么，Java的所有方法调用的时候，都是采用的值传递??数值类型传数值，引用类型传地址。 IO流： 　　与C比起来，Java的输入输出，尤其是输入是非常麻烦的，也许是因为出于面向对象的考虑吧？不知道。Java提供了很多的IO流，但是我们并不必将各种IO都搞清楚，我们只需要了解字节流与字符流各有什么功能，字符流是如何在字节流之上构造的，几乎所有的字符流构造的时候都是建立在一个已有的字节流的基础上的，并且它的这种设计使得我们可以像套管子一样，将IO流一节一节套起来，直到得到我们想使用的IO对象(例：BufferedReader的使用)。在我们以后使用的时候，我们可以再去查API，我觉得主要要看的几个类是：FileReader、FileWriter、BufferedReader，再配合上System.out对象，对于文本的输入、输出来说，就足够用了，至于其他的，我觉得不考试的话，没有必要看那么多，用的时候再看了。(我使用Java一年半来，基本上就在使用BufferedReader和System.out) 容器： 　　个人认为，这是Java编程的一大利器，我最爱用的类是：ArrayList(List)作为可变长数组、HashMap(Map)用来建立查找表，Set我很少用，只在HashMap的使用中连带用过一些。通过对这两个类的熟悉，能够将List、Set和Map三大类的基本用法掌握。另外它的几个辅助类要掌握：Iterator和Collections。Collections类提供容器的一些通用工具，比如排序。而说到排序，就牵扯出了比较器：Comparator。能够熟练使用Comparator类，可以让你为自己的需求和自己的类定制排序方案。 AWT和SWING： 　　个人认为，Java在图形界面的制作上有着非常好的封装性，我以前曾经试图学过MFC，MFC在生成图形界面的时候会帮助你生成一些代码，然后让你在这些代码的指定位置添加代码以实现功能，我这个人有个习惯，如果让我看到了一些东西，那么我不搞清除为什么这么写，就不会往下走，看到那许多代码，自然就想弄清楚那些是什么，结果引出来好多知识，后来我才知道其中有些是调用WinAPI，结果我到现在还是不会用MFC。这里并不是贬低MFC，我相信MFC有其过人之处，只不过个人认为它的封装性做得不好，暴露出了太多东西，也许能够提高灵活性，不过，可能我跟它无缘:(。在这方面Java就做得不错，给你一个类，你用就是了，它将图形界面的低层实现隐藏的很好，将其作为一个对象给你，而你只需要在这个对象上修修改改，挺方便的。 　　作为初学者，我觉得AWT的重点在于它的几个Listener的用法，还有布局格式，然后就是那许多的Component的用处和用法。(不过，我觉得，等到用的时候再去找合适的Component进行学习应该也不算太迟 ^_^) 　　不过，因为我个人使用的原因，所以至今AWT和SWING都用得很少，所以这方面也就不便多说了，抱歉。写这些并不是告诉大家怎么解决问题，因为每一个都有很多可写，只是希望能给初学者一点参考，希望能够帮助初学者们有的放矢地看书。

JBuilder 9 常见快捷键
1.工作区: (显隐) 项目面板：ctrl + Alt + p (Project) 设计面板: ctrl + Alt + c (content) 结构面板: ctrl + Alt + s (Structure) 信息面板: ctrl + Alt + M (Message) 状态面板: ctrl + Alt + Z 2.主面板:(代码面板和设计面板) 激活代码模块: ctrl + J (@1) 参数提示信息的激活: ctrl + shift + H 打开查询、替换窗口: ctrl + F 类的查询: ctrl + - 3.F 键的用法 F1: 帮助快捷 F4: 运行多行 F5: 加入断点 F7: 当遇到方法时会运行方法内的代码 F8: 逐步运行代码 F12: 代码面板和设计面板切换 4. Shift 键的用法 添加多个相同组件： 按shift键在选项上选取组件，把组件添加到窗口即可 调整组件间间隔和对齐： 假设有组件JPanel 1/2/3;(要达到3个组件宽度相同，组件间隔相等，并且都是依据JPanel1左对齐),按shift键，用鼠标选中需要调整的组件，(第一个选中的组件是其他的基准)然后右键。 5: codeInsight 和 Codetemplates MemberInsight -- 根据当前的代码提示可用的类成员或方法(说明) ParameterInsight -- 提示当前的方法需要使用的参数 SymbolInsigh -- 查看当前的变量、方法或者类的愿代码。 MemberInsight: ctrl + space 或 ctrl + H ParameterInsight: ctrl + shift + space 或 ctrl + shift + H SymbolInsight: ctrl + Enter 或 Alt + shift + H ClassInsight : ctrl + alt + space 或 ctrl + alt + H 注： (@1)：使用代码功能：(ctrl + J) 1、 在想要输入代码的位置输入代码摸板名，然后按 ctrl + J(开发人员可以用主菜单上的Tools/Editor/Templates命令来查看代码摸板的名字) 2、把光标定位于想要输入代码的位置，然后按ctrl + J

1.得到当前程序文件的绝对路径：this.getClass().getResource(this.getClass().getName()+".java").getPath()

关于软件优化,硬件升级方面的:

至强64位双CPU
2G内存 DDR2 533

tomcat5.5默认配置
java5.0默认配置
mysql5.0默认配置

带宽为10M独享.
如何改变软件方面的配置要求。优化方面的资料。硬件方面要升级哪些？ 以达到支持大约在线用户为最高2000人。

处理：
       2000 人在线，每秒钟请求数应该在几百次或者更低些的程度，并发数不会超过100(平均10妙请求一次)，使用普通的 PC 机，每秒钟也能够处理上百次的请求；
       缓存优化：解决性能问题首先想到的就是缓存，在 Web 应用中有很多缓存的方式，可以缓存到 Web 层的 servletContext 中，也可以缓存到业务层中，甚至可以在数据库中建立冗余。而生成静态页面是一种极端的做法，一般来说会增加复杂性，同时可能会对灵活性和可维护性造成很大伤害。缓存的要点在于命中率，命中率低的东西不应该缓存，除非对内存的价格不做考虑。总结起来设计上就两句话，使用 N 层结构，合理缓存。根据程序的需要，适当是使用缓存机制；
       程序进行优化方法，比如：每次查找部分记录，而不是全部查出来，这样既可以减轻服务器的负担，也可以减少网络传输量； 对于系统中的数据库连接一定要进行妥善的处理； 对需要用 scrchrnozied 的地方要用，但是有些地方可以不用同步化的，这个对速度影响也很大；从代码入手，优化程序，在数据持久化上进行改进，采用成熟的库访问对象（Data Access Object）设计模式也会节省你的服务器开销。
       硬件升级：硬件方面还不行，硬盘最好搞阵列，还可以再来一个服务器，弄个负载均衡，由两个服务器来处理用户的请求，apache必然是要用到的，他将挡在tomcat前处理http请求。
       注意：在硬件足够强大的时候，将 web 与 db 分两台服务器来做，只会降低效率，因为网络编组的成本要比本地内存中的复制高几个数量级。同样道理，负载均衡也只会导致更复杂的结构，会引起更多的问题，并产生更低于下的效率。将一个应用分布于多台机器的唯一理由，就是由于一台机器根本顶不住，不得不分。
       环境优化：调Tomcat、JVM的Heap大小等参数做一些优化， Tomcat的虚拟内存管理有最大值限制，可以并发运行多个Tomcat来均衡负载，tomcat5.5默认配置  ==>改了JAVA_OPTS没有？开大内存 既java_opts= -Xms1024m -Xmx1024m ；  java5.0默认配置    ==>升级一下到最大的小版本6.0 升级处理
      系统内存测试：
     （1）自己测试：参考tomcat,jvm,mysql优化方面的资料。测试如下操作出错：
C:\>java -Xms536870932 -Xmx536870912
Error occurred during initialization of VM
Incompatible initial and maximum heap sizes specified至强64位双CPU，原则上面来说64位的CPU应当可以用到无限大的内存了，也还是理论上的了。可以java -Xmx2000M -version这样一路加上去试试看你的可以加到多大。
     （2）工具测试：  压力测试：对应用系统进行性能采样于监控，（Wily有一套产品可以在运行期进行调优，但我没有用过），我用的P6Spy，加MS的那个压力测试工具，也有D用LoadRunner来跑一跑，在SQL语句这个地方有太多的名堂可做了。
       建议软件方面：
       a、软件配置 Apache2.2.0 + mod_ajp + jrockit-R26.0.0-jdk1.5.0_04+  Tomcat5.5.15 (启多个)+apr1.2.2 .
       b、内存建议4g以上 。 tomcat的内存参数使用 set JAVA_OPTS=%JAVA_OPTS%-Xms1024m -Xmx1024m  (内存2g的话，建议set JAVA_OPTS=%JAVA_OPTS%-Xms512m -Xmx512m).
      c、tomcat5.5版本的性能已经大幅度提高了。

     
   

今天遇到个以前使用Struts没有注意的地方。
现象：
   在actionForward配置文件里面定义
   <forward name="success" path="/Catalog.jsp" redirect="true"/>

   当在提交页面里面request.setAttbriute("msg","处理成功");
   提交后在Catalog.jsp 用request.getAttbriute("msg");居然为空，原因是设置了redirect="true"

下例举例说明了redirect属性的用法：

<forward name="success" path="/Catalog.jsp" redirect="true"/>

如果 redirect=true, URL 建立如 / contextPath / path 因为 HttpServletResponse.sendRedirect(…) 中解释 URL 采用 ”/” 开头相对于 servlet 容器根目录。

如果 redirect=false, URI 建立如 / path 因为 ServletContext.getRequestDisptacher(…) 采用虚拟目录相关 URL 。

繁重