kermart

Eclipse版本、插件介绍

Eclipse IDE for Java EE Developers 应该是Eclipse的platform加上WTP插件，用来java企业级开发的

Eclipse IDE for C/C++ Developers 是Eclipse的platform加上CDT插件，用来做C和C++开发的

Eclipse for RCP/Plug-in Developers 是Eclipse的SDK，主要用来插件开发

Eclipse Classic 就是原来的Eclipse，是Eclipse的基本版，还是主要用来开发java

Eclipse的功能是通过插件来实现的，下面了解主要插件的功能。

JDT（Java Development Tools）：Java设计工具。
PDT：用于开发PHP语言的工具。
C/C++ IDE：用于设计C/C++项目。
PDE（Plugin Development Environment）：插件设计环境，用于设计自定义插件。
Platform：Eclipse的核心运行平台。
EMF（Eclipse Modeling Framework）：Eclipse模型框架。
GEF（Graphical Editor Framework）：图形编辑框架，用于辅助图形设计。
UML2：UML编辑器。

WTP(Web Tools Platform )：是一个开发J2EE Web应用程序的工具集。WTP包含以下工具：
     * 一个源码编辑器可以用来编辑HTML, Javascript, CSS, JSP, SQL, XML, DTD, XSD, 和WSDL。
     * 一个图形编辑器用来编辑XSD与WSDL。
     * J2EE项目构建器和一个J2EE向导工具。
     * 一个Web服务创建向导和管理器，和WS-I 测试工具。
     * 一个数据库访问，查询工具等。
　 WTP由两个子项目构成:WST(Web标准工具集) 与JST(J2EE标准工具集)
VE（Visual Editor）：可视化图形编辑组件，用于提供AWT/SWT/Swing的图形编辑。
J2EE Standard Tools：用于设计J2EE应用程序的插件。
WST-Web Standards Tools：用于设计Web应用程序的插件。
Eclipse Test and Performance Tools Platform：用于调试，单元测试和测试项目的插件。
Business Intelligence and Reporting Tools（BIRT）：商业智能和商业报表开发插件，它包括ChartEngine（图形引擎）、Report Framework（报表框架）、Runtime ENV（运行时环境）。
AJDT-AspectJ Development Tools：用于开发AOP（面向方面编程）的开发Eclipse插件。
AspectJ：用于开发AOP的开发环境。
CME（Concern Manipulation Environment）：用于开发AOP的一组可视化工具插件。

posted @ 2012-07-26 14:32 kermart 阅读(303) | 评论 (0) | 编辑 收藏

分层Pane结构与Swing组件高级特性的实现

其实有了这张图，加上图形系统中Z-order的概念，就不难理解并实现上面提到的特性。Z-order概念和图形学中Z深度是一致的。离观察点近的物体总是会遮挡离观察点远的物体。物体所在法平面离观察点的距离就是所谓Z深度。Swing中通过先画出Z-order远（小）的组件，再画Z-order近（大）的组件的方法实现组件之间的遮挡关系。每个组件所在平面的都有一个数字描述其位置，这个位置同三维坐标系中的Z轴类似，离观察者越近，坐标越大：

　　Swing的顶层容器都包含有一个JRootPane，该JRootPane是一切Swing组件起点。JRootPane中包含了一个JLayeredPane和一个GlassPane。GlassPane和JLayeredPane都是充满JRootPane的。GlassPane缺省情况下是不可见的，因此我们看到都是JLayeredPane。GlassPane如果是可见的，它Z-order大于任何其他组件，因此它会覆盖住整个窗口，使得所有的鼠标事件都被它截获。另外通常可见情况下它是透明的，因此你能仍然看到JLayeredPane上面的一切，但是JLayeredPane上面的组件都得不到鼠标事件。
GlassPane这个奇怪的组件主要是用来实现Drag & Drop以及跨组件渲染用的。NetBeans和Eclipse中哪种常见的Docking Frame的实现就和这种组件相关。这些工程、文件、源代码的窗口其实不过是普通的Swing组件，它们本身并不能实现这种拖拽功能。鼠标在它们上面标题栏区域按下之后，标题栏组件会检测到这种事件，经过粘连性判断后，如果发现这些鼠标事件目的是拖拽窗口，这种Docking系统就会将拖拽区域（即所谓的ClientArea)的GlassPane设置为可见，于是下面的一些列拖拽鼠标事件就被这个GlassPane所接管了过去。GlassPane是覆盖于应用程序ClientArea的透明组件，它处理这些事件时计算出当前鼠标位置所蕴含着的拖拽动作，并根据这些动作画出相应的焦点矩形。NetBeans的Docking Framework一个拖拽过程如下图所示.注意GlassPane是背景透明的，所以可以在上面画背景透明的焦点矩形：

　　JLayeredPane是实现弹出式窗口或类似Pallete浮动窗口的主要组件。如同它的名字一样，它将自己的内部结构也分成许多亚层。在使用它的add(Component, Object)方法加入组件时，第二个参数是一个Integer值，这个值决定了加入的层。这个值相当于前面所说的Z-order值。目前主要有下面几个预定义值：

public final static Integer DEFAULT_LAYER = new Integer(0);

这层加入的缺省层。
　　public final static Integer PALETTE_LAYER = new Integer(100);

这层是定义Palette窗口的层。那种浮动选项窗口属于这一层。
　　public final static Integer MODAL_LAYER = new Integer(200);

这层是模态对话框的层。这个模态对话框应该是指JInternalFrame的模态对话框，而不是JDialog。
　　public final static Integer POPUP_LAYER = new Integer(300);

这层是菜单、下拉框窗口、Tooltip等窗口浮动的层。
　　public final static Integer DRAG_LAYER = new Integer(400);

这一层是拖拽层，组件可以在这一层被托拽。

　　public final static Integer FRAME_CONTENT_LAYER = new Integer(-30000);

这一层是ContentPane和MenuBar所在的层。注意它非常小，前面所有层的组件都会覆盖这一层的组件。我们知道ContentPane是所有应用程序组件所在的地方。

　　JLayeredPane直接包含有ContentPane组件。应用程序如果定了MenuBar，JLayeredPane还包含MenuBar。注意JLayeredPane本身没有布局管理器，它对组件的布局是由它的父容器JRootPane的布局管理器RootLayout来完成的。简单来说，所在层数值小的组件有可能被高层组件所覆盖。Swing将不同类型的组件放置在不同层面上，就实现了文章一开始提到的特性：菜单、浮动窗口、下拉框窗口和Tooltip等。当然这些窗口有可能不是JLayeredPane上的轻量级Swing组件，当它们的边界超过顶层容器的窗口时，这些窗口的就变成了重量级AWT窗口。这在上一篇文章《如何混排Swing和AWT组件》中已经提到过。

　　下面是这些Pane组件之间的树状包含关系图：

　　本文的目的是讲述Swing的这种组件层次结构，并不是讲述如何使用JLayeredPane和GlassPane来实现某中特殊的功能。如果需要学习如何使用它们实现某些特殊效果，Java Tutorial的Swing部分提供了详尽的编程资料。Java Tutorial的Swing部分编程在：

http://java.sun.com/docs/books/tutorial/uiswing/index.html

　　如何使用RootPane、GlassPane和JLayeredPane分别见下面的章节：

http://java.sun.com/docs/books/tutorial/uiswing/components/rootpane.html

http://java.sun.com/docs/books/tutorial/uiswing/components/layeredpane.html

posted @ 2012-07-26 11:21 kermart 阅读(1234) | 评论 (0) | 编辑 收藏

NetBeans中自动生成JFrame的布局管理器

   默认添加的面板（JPanel)等容器也都是用了自由布局GroupLayout方式。

    这将导致我们自己在代码中动态添加的组件无法显示在窗体上，因此需要手工重设容器的布局方式。（对需要动态添加的组件，可以先画一个面板，重设布局，再在面板上添加自己的组件。）（即重新弹出一个窗口）

     NetBeans对GridBagLayout提供了可定制的布局，对GridLayout，BorderLayout,FlowLayout也有比较好的支持。绝对布局，需要NetBeans的包支持，不建议使用。

     对BoxLayout支持不够好，不可调间隙。自由布局和NULL布局，不会自动适应窗体变化。

     由于GridBagLayout布局在改变窗体大小的时候，可以基本保持原形，建议在NetBeans中设计窗体时使用GridBagLayout布局，也可以结合GridLayout,BorderLayout,FlowLayout进行布局

posted @ 2012-07-26 11:02 kermart 阅读(1775) | 评论 (0) | 编辑 收藏

Freemarker

FreeMarker是一个模板引擎，一个基于模板生成文本输出的通用工具，使用纯Java编写

FreeMarker被设计用来生成HTML Web页面，特别是基于MVC模式的应用程序

虽然FreeMarker具有一些编程的能力，但通常由Java程序准备要显示的数据，由FreeMarker生成页面，通过模板显示准备的数据

FreeMarker不是一个Web应用框架，而适合作为Web应用框架一个组件

FreeMarker与容器无关，因为它并不知道HTTP或Servlet；FreeMarker同样可以应用于非Web应用程序环境

FreeMarker更适合作为Model2框架（如Struts）的视图组件，你也可以在模板中使用JSP标记库

FreeMarker是免费的

而且你还可以通过Eclipse的插件来编辑FreeMarker，经过验证，FreeMarker 最好的 Eclipse 编辑插件是 JBoss Tools。

FreeMarker特性

1、通用目标

能够生成各种文本：HTML、XML、RTF、Java源代码等等

易于嵌入到你的产品中：轻量级；不需要Servlet环境

插件式模板载入器：可以从任何源载入模板，如本地文件、数据库等等

你可以按你所需生成文本：保存到本地文件；作为Email发送；从Web应用程序发送它返回给Web浏览器

2、强大的模板语言

所有常用的指令：include、if/elseif/else、循环结构

在模板中创建和改变变量

几乎在任何地方都可以使用复杂表达式来指定值

命名的宏，可以具有位置参数和嵌套内容

名字空间有助于建立和维护可重用的宏库，或者将一个大工程分成模块，而不必担心名字冲突

输出转换块：在嵌套模板片段生成输出时，转换HTML转义、压缩、语法高亮等等；你可以定义自己的转换

3、通用数据模型

FreeMarker不是直接反射到Java对象，Java对象通过插件式对象封装，以变量方式在模板中显示

你可以使用抽象（接口）方式表示对象（JavaBean、XML文档、SQL查询结果集等等），告诉模板开发者使用方法，使其不受技术细节的打扰

4、为Web准备

在模板语言中内建处理典型Web相关任务（如HTML转义）的结构

能够集成到Model2 Web应用框架中作为JSP的替代

支持JSP标记库

为MVC模式设计：分离可视化设计和应用程序逻辑；分离页面设计员和程序员

5、智能的国际化和本地化

字符集智能化（内部使用UNICODE）

数字格式本地化敏感

日期和时间格式本地化敏感

非US字符集可以用作标识（如变量名）

多种不同语言的相同模板

6、强大的XML处理能力

<#recurse> 和<#visit>指令（2.3版本）用于递归遍历XML树

在模板中清楚和直觉的访问XML对象模型

posted @ 2012-07-20 11:46 kermart 阅读(965) | 评论 (0) | 编辑 收藏

java 中的 各种变量、代码块执行时机

前言：这属于 java 的基础知识，你可以不了解，也可以不拿它当一回事，代码也一样能敲的顺畅；这是很久之前，我从 C++ 转 java 刚入门那会的看法，那会我坚持自己的理念：
    重实践，讲运用，轻理论。当然，对同一样事物，在不同阶段也会有不一样的看法，这理念在某个时段已经不适合我，早就被抛弃了。不扯淡了，直接进入主题。

java 中的变量大致分为 成员变量 和 局部变量 两大类。

成员变量：
    在类体里面定义的变量称为成员变量；
    如果该成员变量有 static 关键字修饰，则该成员变量称为 静态变量 或 类变量；
    如果该成员变量没有 static 关键字修饰，则该成员变量被称为 非静态变量 或 实例变量。

局部变量：
    形参、方法内定义的变量、代码块中定义的变量，都属于局部变量。

类变量 （静态变量）
    1. 可以向前引用
    2. 变量属于类本身
    3. 类变量不依赖类的实例，类变量只在初始化时候在栈内存中被分配一次空间，无论类的实例被创建几次，都不再为类变量分配空间
    4. 通过类的任意一个实例来访问类变量，底层都将将其转为通过类本身来访问类变量，它们的效果是一样的
    5. 一旦类变量的值被改变，通过类或类的任意一个实例来访问类变量，得到的都将是被改变后的值
    6. 将在类的初始化之前初始化

实例变量（非静态变量）
    1. 不能向前引用，如果向前引用，则称为非法向前引用，这是不允许的
    2. 变量属于类的实例对象
    3. 随着类的实例被创建而分配内存空间

非静态代码块
    直接由 { } 包起来的代码，称为非静态代码块

静态代码块
    直接由 static { } 包起来的代码，称为静态代码块

类变量（静态变量）、实例变量（非静态变量）、静态代码块、非静态代码块 的初始化时机
    由 static 关键字修饰的（如：类变量[静态变量]、静态代码块）将在类被初始化创建实例对象之前被初始化，而且是按顺序从上到下依次被执行；
    没有 static 关键字修饰的（如：实例变量[非静态变量]、非静态代码块）初始化实际上是会被提取到类的构造器中被执行的，但是会比类构造器中的
    代码块优先执行到，其也是按顺序从上到下依次被执行。

- 以上是本人在翻完 PDF 后的个人笔记和理解以及见解，不见得百分百对，以下附上本人测试示例代码，会更有说服性

示例代码

 1
 2/**
 3 * -----------------------------------------
 4 * @文件: Statical.java
 5 * @作者: fancy
 6 * @邮箱: fancydeepin@yeah.net
 7 * @时间: 2012-7-9
 8 * @描述: TEST
 9 * -----------------------------------------
10 */
11public class Statical {
12
13 /**
14     * 静态代码块
15     * 类变量(静态变量)可以向前引用(即：先引用,再定义)
16     */
17    static {
18        name = "fancydeepin"; // name 的定义在使用之后
19        System.out.println("--->  静态代码块被执行   <---");
20    }
21 /**
22     * 类变量(静态变量)在类的初始化之前初始化,无论类的实例将被创建多少个
23     * 类变量(静态变量)都将只在初始化时候在栈内存上分配一次空间
24     * 凡 static 修饰的,都将按位置被顺序执行，所以，
25     * name 的值最终输出 fancy 而不是上面的 fancydeepin
26     */
27    public static String name = "fancy"; //类变量(静态变量)
28    private String mail = "myEmail"; //实例变量(非静态变量)，定义时指定初始值，会比在构造器赋予值更早执行
29    
30    public Statical() {
31        mail = "fancydeepin@yeah.net";
32        System.out.println("---> 构造器代码块被执行 <---");
33    }
34 /**
35     * 非静态代码块
36     * 实际上，非静态代码块在类初始化创建实例时，将会被提取到类的构造器中，
37     * 但是，非静态代码块会比构造器中的代码块优先被执行
38     * 所以，mail 最终输出的是类构造器中给定的值，也就是 fancydeepin@yeah.net
39     * 而不是 1525336367@qq.com，更不是 myEmail
40     */
41    {
42        mail = "1525336367@qq.com";
43        System.out.println("---> 非静态代码块被执行 <---");
44    }
45    
46    // getting and setting 
47

测试类示例代码

 1
 2      /**
 3         * 类变量(静态变量)在类被初始化创建实例之前被初始化
 4         */
 5        System.out.println("-----------------> @1 <----------------");
 6        System.out.println("name --->> " + Statical.name); // @1
 7        System.out.println("-----------------> @1 <----------------");
 8       /**
 9         * 创建类的实例对象
10         */
11        System.out.println("-----------------> @6 <----------------");
12        Statical statical = new Statical(); // @6
13        System.out.println("-----------------> @6 <----------------");
14        /**
15         * 通过实例来访问类变量,底层将转化成通过类本身来访问类变量
16         */
17        System.out.println("-----------------> @2 <----------------");
18        System.out.println("name --->> " + statical.name); // @2
19        System.out.println("-----------------> @2 <----------------");
20       /**
21         * 如果类变量的值被改变,再访问类变量,将得到被改变后的值
22         */
23        Statical.name = "fancydeepin";
24        
25        System.out.println("-----------------> @3 <----------------");
26        System.out.println("name --->> " + statical.name); // @3
27        System.out.println("-----------------> @3 <----------------");
28        
29        System.out.println("-----------------> @4 <----------------");
30        System.out.println("name --->> " + Statical.name); // @4
31        System.out.println("-----------------> @4 <----------------");
32       /**
33         * 非静态代码块 和 构造器 被执行的时机
34         */
35        System.out.println("-----------------> @5 <----------------");
36        System.out.println("mail --->> " + statical.getMail()); // @5
37        System.out.println("-----------------> @5 <----------------");
38

后台输出结果

-----------------> @1 <----------------
--->  静态代码块被执行   <---
name --->> fancy
-----------------> @1 <----------------

-----------------> @6 <----------------
---> 非静态代码块被执行 <---
---> 构造器代码块被执行 <---
-----------------> @6 <----------------

-----------------> @2 <----------------
name --->> fancy
-----------------> @2 <----------------

-----------------> @3 <----------------
name --->> fancydeepin
-----------------> @3 <----------------

-----------------> @4 <----------------
name --->> fancydeepin
-----------------> @4 <----------------

-----------------> @5 <----------------
mail  --->> fancydeepin@yeah.net
-----------------> @5 <----------------

为了能更好的看出后台的输出是哪一行代码执行的结果，我用了 @和数字来做了标记，希望大家不要看晕了哈 ^_^
最后针对输出结果简单说一下：
@1 说明，静态（类变量、静态代码块）属于类本身，不依赖于类的实例
@6 说明，在创建类的实例对象的时候，非静态代码块比构造器代码块更早的执行
@3 4 说明，当类变量的值改变后，再通过类或类的实例来访问类变量，得到的将是被改变后的值
@5 说明，非静态（实例变量、非静态代码块）的地位是相等的，它们将按顺序被执行，但会比构造器中的代码块更早的执行

posted @ 2012-07-10 13:00 kermart 阅读(1356) | 评论 (0) | 编辑 收藏