大部分选项使用yes即可修复（权限、帐户等）

※ Cygwin 安裝方式：

參考： http://www2.cyut.edu.tw/~s9154610/cygwin.html

※ 在 WinXP 的 Cygwin 上安裝 ssh 伺服器：

1. Cygwin 必要安裝的兩個套件：OpenSSH、cygrunsrv

2. 修改 WinXP 的環境變數：

WinXP：桌面 > 我的電腦(右健) > 內容 > 進階 > 環境變數

修改環境變數：path 增加 c:\cygwin\bin
增加環境變數：CYGWIN=ntsec tty

3. Cygwin 設定 OpenSSH：

$ssh-host-config
Should privilege separation be used? (yes/no) ：yes
Should this script create a local user 'sshd' on this machine? (yes/no) ：yes
Do you want to install sshd as service? (yes/no) ：yes
Default is "ntsec" . CYGWIN=ntsec tty

4. 手動啟動及關閉 OpenSSH 服務：

$net start sshd
$net stop sshd

※ 如何讓 WinXP 在 Cygwin 中運行 crontab 服務？

1. Cygwin 必要安裝的兩個套件：cron、cygrunsrv

2. 設定環境：讓 WinXP上安裝了系統服務 cron 且開機即可啟動。

$cygrunsrv -I cron -p /usr/sbin/cron -a -D

3. 啟動服務：

$cygrunsrv -S cron

同樣也可使用 $net start/stop 來手動開關 cron 服務

$net start cron
$net stop cron

4. 可進行測試，如下內容：

$crontab -e

与 动 态 类 载 入 有 关 的 系 统 类
---- 为 支 持 动 态 类 载 入 机 制， 在 系 统 类 组java.lang 中 提 供 了 两 个 类：Class 类 和ClassLoader 类。

---- 1、 类java.lang.Class。 在Java 虚 拟 机 中， 每 一 个 类 或 接 口 都 是 由Class 类 来 操 纵 的， 它 不 能 被 显 式 的 实 例 化， 必 须 用 其 他 方 法 来 获 取Class 类 的 对 象。 动 态 类 载 入 机 制 的 关 键 一 步 在 于 如 何 获 得 指 定 类 的Class 类 型 的 对 象。 相 关 方 法 主 要 有：

---- public static Class forName(String className)

---- 这 是 一 个 静 态 方 法， 它 获 取 指 定 名 字 的 类 的Class 类 型 对 象， 类 名 可 以 是 象"sun.applet.Applet" 这 样 的 字 符 串， 但 不 能 带 有 路 径 或 网 络 地 址 等 信 息。 这 是 从 本 地 系 统 中 动 态 载 入 类 的 最 方 便 的 办 法。

---- public Object newInstance()

---- 这 是 最 重 要 的 一 个 方 法， 它 建 立 由Class 类 型 对 象 描 述 的 指 定 类 的 实 例。

---- 下 面 是 一 个 用forName() 和newInstance() 方 法 实 现 动 态 类 载 入 的 代 码，share 类 包 含 一 个 接 口， 详 细 内 容 将 在 第 三 部 分 中 解 释。

try{
//根据类名建立Class类型的对象。
Class cc =Class.forName("类名"))；
//建立被载入类类的实例并强制类型转换，
值赋给share类型的变量。
share oo=（（share）cc）.newInstance();
//调用该类的方法进行工作。
}
catch (Exception ex){
//如果发生例外，则进行相应处理。
};

---- 2、 类java.lang.ClassLoader。 这 是 一 个 抽 象 类， 如 果 打 算 运 用 它， 必 须 继 承 它 并 重 写 它 的loadClass() 方 法。 其 主 要 方 法 有：

---- protected ClassLoader();

---- 这 是 一 个 建 构 元， 可 以 用 它 建 立 一 个ClassLoader 类 的 实 例。 注 意 继 承 这 个 类 的 类 必 须 重 写 这 个 方 法， 而 不 能 使 用 缺 省 的 建 构 元。

---- protected abstract Class loadClass(String name, boolean resolve)

---- 载 入 指 定 的 类 数 据， 建 立Class 类 型 的 对 象 并 根 据 需 要 解 析 它。 这 是 一 个 抽 象 方 法， 大 家 必 须 在 自 己 的 子 类 中 重 写 这 个 方 法， 重 写 的 规 则 可 以 参 考 第 三 部 分 的 例 子。

---- protected final Class defineClass(byte data[], int offset, int length)

---- 将 字 节 数 组 中 的 数 据 定 义 为Class 类 型 的 对 象， 字 节 数 组 的 格 式 由 虚 拟 机 规 定。

---- protected final Class findSystemClass(String name)

---- 根 据 指 定 的 类 名 载 入 类， 它 会 自 动 在 当 前 目 录 和 环 境 变 量"CLASSPATH" 指 定 的 路 径 中 寻 找， 如 果 找 不 到， 则 会 抛 出ClassNotFoundException 例 外。

---- protected final void resolveClass(Class c)

---- 通 过 载 入 与 指 定 的 类 相 关 的 所 有 类 来 解 析 这 个 类， 这 必 须 在 类 被 使 用 之 前 完 成。

扩 充ClasslLader 类 以 实 现 动 态 类 载 入
---- 理 解 动 态 类 载 入 机 制 的 最 好 办 法 是 通 过 例 子， 下 面 这 个 完 整 的 例 子 由 四 个 类 组 成， 分 别 解 释 如 下：

---- 1、MyClassLoader 类 是ClassLoader 类 的 子 类， 它 重 写 了loadClass 方 法， 实 现 了 将 网 络 上 用URL 地 址 指 定 的 类 动 态 载 入， 取 得 它 的Class 类 型 对 象 的 功 能。 读 者 可 根 据 自 己 载 入 类 的 具 体 方 式 改 写 下 面 的 代 码。

import java.io.*;
import java.util.*;
import java.net.*;

public class MyClassLoader extends ClassLoader {
//定义哈希表（Hashtable）类型的变量，
用于保存被载入的类数据。
Hashtable loadedClasses;

public MyClassLoader() {
loadedClasses = new Hashtable();
}

public synchronized Class loadClass(String className,
boolean resolve) throws ClassNotFoundException {
Class newClass;
byte[] classData;

//检查要载入的类数据是否已经被保存在哈希表中。
newClass = (Class) loadedClasses.get(className);
//如果类数据已经存在且resolve值为true，则解析它。
if (newClass != null){
if (resolve)
resolveClass(newClass);
return newClass;
}

---- /* 首 先 试 图 从 本 地 系 统 类 组 中 载 入 指 定 类。 这 是 必 须 的， 因 为 虚 拟 机 将 这 个 类 载 入 后， 在 解 析 和 执 行 它 时 所 用 到 的 任 何 其 他 类， 如java.lang.System 类 等， 均 不 再 使 用 虚 拟 机 的 类 载 入 器， 而 是 调 用 我 们 自 制 的 类 载 入 器 来 加 载。*/

try {
newClass = findSystemClass(className);
return newClass;
} catch (ClassNotFoundException e) {
System.out.println(className+" is not a system class!");
}

//如果不是系统类，
则试图从网络中指定的URL地址载入类。
try {
//用自定义方法载入类数据，
存放于字节数组classData中。
classData = getClassData(className);
//由字节数组所包含的数据建立一个class类型的对象。
newClass = defineClass(classData, 0, classData.length);
if (newClass == null)
throw new ClassNotFoundException(className);
} catch (Exception e) {
throw new ClassNotFoundException(className);
}

//如果类被正确载入，
则将类数据保存在哈希表中，以备再次使用。
loadedClasses.put(className, newClass);
//如果resolve值为true，则解析类数据。
if (resolve){
resolveClass(newClass);
}
return newClass;
}
//这个方法从网络中载入类数据。
protected byte[] getClassData(String className)
throws IOException {
byte[] data;
int length;
try {
//从网络中采用URL类的方法
载入指定URL地址的类的数据。
URL url = new URL(className.endsWith(".class") ?
className : className + ".class");
URLConnection connection = url.openConnection();
InputStream inputStream = connection.getInputStream();
length = connection.getContentLength();

data = new byte[length];
inputStream.read(data);
inputStream.close();
return data;
} catch(Exception e) {
throw new IOException(className);
}
}
}

---- 2、 由 于Java 是 强 类 型 检 查 语 言， 通 过 网 络 载 入 后 的 类 被 实 例 化 后 只 是 一 个Object 类 型 的 对 象， 虚 拟 机 并 不 知 道 它 包 含 那 些 方 法， 应 从 哪 个 方 法 开 始 执 行。 因 此， 可 以 被 动 态 载 入 的 类 必 须 继 承 某 一 个 抽 象 类 或 实 现 某 一 个 接 口， 因 为 父 类 只 能 有 一 个， 所 以 通 常 用 实 现 特 定 接 口 的 办 法。 下 面 的 代 码 定 义 了 一 个 接 口 类share 和 它 的 方 法start()。

public interface share {
public void start(String[] option);
}

---- 3、TestClassLoader 类 通 过 使 用MyClassLoader 类 的loadClass() 方 法， 将 指 定URL 地 址 的 类 载 入 并 在 本 地 系 统 执 行 它， 实 现 了 类 的 动 态 载 入。 注 意 在 执 行 被 载 入 类 的 方 法 前 一 定 要 将 它 进 行 强 制 数 据 类 型 转 换。

public class TestClassLoader {
public static void main(String[] args){
MyClassLoader ll = new MyClassLoader();
Class cc;
Object oo;
String ss = "http://kyzser.ydxx/classLoader/Tested.class";

if (args.length != 0) ss = args[0];
try {
System.out.println("Loading class "+ss+"...");
//使用重写的方法loadClass()载入类数据。
cc = ll.loadClass(ss);
System.out.println("Creat instance...");
//创建Object类型的类实例。
oo = cc.newInstance();
System.out.println("Call start() method...");
//强制类型转换并执行被载入类中的方法。
((share) oo).start(args);
}catch (Exception e) {
System.out.println("Caught exception : "+e);
}
}
}

---- 4、Tested 类 很 简 单， 可 以 将 它 放 在 任 何WEB 服 务 器 上， 但 应 注 意 能 动 态 载 入 且 被 执 行 的 类， 一 定 要 实 现 预 先 定 义 的 接 口 中 的 方 法。 下 面 的 例 子 实 现 了 接 口share 的start 方 法。

public class Tested implements share{
public void start(String[] option){
//填写程序代码。
}
}

动 态 类 载 入 机 制 的 几 点 应 用
---- 1、 开 发 分 布 式 应 用。 这 对 开 发 远 程 的 客 户 端 应 用 程 序 最 有 用， 客 户 端 仅 需 要 安 装 一 些 基 本 的 系 统 和 一 个 能 实 现 动 态 类 载 入 机 制 的 类， 需 要 本 地 系 统 不 存 在 的 功 能 时， 仅 需 要 从 网 络 动 态 载 入 并 执 行 相 应 类 即 可 获 得 特 定 功 能。 因 为 客 户 端 所 使 用 的 总 是 软 件 的 最 新 版 本， 所 以 不 再 存 在 软 件 的 升 级 和 维 护 问 题， 即 实 现 了 所 谓 的" 零 管 理" 模 式。

---- 2、 对.class 文 件 加 密。 由 于Java 的 字 节 码（bytecode） 容 易 被 反 编 译， 大 部 分 开 发Java 应 用 程 序 的 公 司 均 担 心 自 己 的 成 果 被 别 人 不 劳 而 获。 其 实 可 以 将 类 文 件 进 行 适 当 的 加 密 处 理， 执 行 时 使 用 自 己 的 类 载 入 器 进 行 相 应 的 解 密， 就 可 以 解 决 这 个 问 题。

---- 3、 使 第 三 方 开 发 者 易 于 扩 展 你 的 应 用。 从 前 面 可 知， 所 有 可 以 被 你 的 类 载 入 器 动 态 载 入 并 被 执 行 的 类， 必 须 继 承 你 定 义 的 类 或 实 现 你 定 义 的 接 口， 这 样， 你 可 以 制 订 一 些 规 则， 使 其 他 开 发 者 不 必 了 解 你 的 应 用 程 序 也 可 以 扩 充 功 能。

---- 当 然， 有 利 必 有 弊， 在 网 络 中 使 用 动 态 类 载 入 的 主 要 缺 陷 在 于 安 全 性， 很 难 保 证 不 载 入 不 怀 好 意 的 代 码， 这 个 问 题 要 靠Java 的 安 全 管 理 器 和 适 当 的 加 密 算 法 来 解 决， 已 超 出 本 文 的 讨 论 范 围。

Unix 的使用者就輕鬆多了，光是 shell，你就有很多選擇可以使用，你可以用骨灰級的 Bourn Shell (sh)、C Shell (csh)，也可以選 Korn shell (ksh)、Z Shell (zsh)、tcsh、bash (Bourn Again Shell)...，甚至還有 Perl、PHP...這些版本的 shell 可供選擇。教材來說，市面上有的最多的是 bash/sh 這一對兄弟的書，但是 csh/tcsh 這對兄弟的書也不少，你可以找出一堆這方面的書籍來學習，連網路上都有一堆這方面的教學文件，連中文的教學資料都有一大堆，全都不用錢。

就自動化而言，Unix 上早就有 at command，Windows 上的版本還是從 Unix 上 port 過去的。還有一套更好用的系統 ─ cron，更是目前的網管人員必須會的工具。簡單、易學、強大，是 cron 最大的特徵，要學會它，大概花你一個晚上就行了。

到了 Windows 2000/XP/2003 時，微軟終於又發揮把系統功能簡化成：你傻瓜、它聰明的境界，把 at 用 控制台→排定的工作 加以 GUI 簡化。但是最好的選擇仍是使用傳統的 DOS shell 或 VBscript shell 來寫作的腳本程式比較容易操控。如果我早已熟悉 Unix 下的 shell script 寫作，想讓 Cygwin 和它搭配，仍是有一段路要走的^[2]。更重要的是它是系統管理專家最不信任的 GUI 介面，所以熟悉 Unix 的朋友，當看到 Cygwin 時，常常會想，是否能讓 Cygwin 也能執行 cron 呢？答案是肯定的，而且還不難呢。

首先我們先來聊聊怎麼安裝。先確認你是否事先已經不小心安裝過 cron 了，有三種確認方法：

第一種最笨，最直接，直接執行 setup.exe。

第二種方法是執行 Cygwin ，輸入
$ ls /usr/sbin/cron

如果出現的是：
ls: /usr/sbin/cron: No such file or directory

那麼就是沒有安裝，否則就會出現 cron 這個檔案。

第三種方法是在 Cygwin 中，輸入
$ ls /etc/setup | grep cron

如果空無一物，那就沒裝，不然就會出現 cron.lst.gz。這個第三種方法最正式，因為 /etc/setup 儲存的就是已安裝軟體的一些套件資料，你所有安裝過的套件在這裡都找得到它的 .lst.gz 檔。

本文需要的是 cron 和 cygrunsrv 這兩個套件。如果之前你曾經參考 在 Windows 上安裝 sshd，那麼應該已經裝過 cygrunsrv 。至於 cron 套件的安裝過程，請先參考 新增 Cygwin 上的軟體 ─ 以安裝 joe 和 rxvt 為例 一文，在 Cygwin 上安裝新軟體的方法是相同的。當出現如下圖的 Select Packages 對話方塊時，請按下 Admin 類別前的 + 號，把它打開，如下圖點選安裝 cron，也順便確認一下位在其下的 cygrunsrv 是否要升級，若要，請在此刻順便把它裝起來，不過這個動作應該是不用勞駕你動手，setup 程式會自動將它加上去。

由於 cron 本身是 Unix daemon，是需要在機器開機時，就立刻執行。在 在 Windows 上安裝 sshd 一文中，我曾經談過這需要使用 cygrunsrv 這個工具。使用這個工具，可以讓你的程式^[3]以 Windows 的 service^[4] 形式在 Windows 啟動時自動啟動，就宛若 Unix 上的 daemon 一樣。如果你想要知道 cygrunsrv 這個工具如何使用，請在 Cygwin 下輸入：

$ cygrunsrv --help

所以，我們必須先執行 sygrunsrv。我建議的執行參數是：

$ cygrunsrv --install cron --desc 'Cygwin cron daemon' --path /usr/sbin/cron.exe --args -D

你可以自行到 控制台→系統管理工具→服務，打開 服務 對話方塊，去確認是否有 cron 這項服務出現，然後看它是否已 啟動，也確認一下 啟動類型 是不是 自動。如果你想讓 啟動類型 使用 手動 類型，那麼執行的參數請再加上 --type manual 這項。我介紹一下上面命令的參數所代表的意義。--install 項目是 服務 的真正名稱，將來你要手動執行 服務 時，就是直接打這個名字。--desc 就是在 服務 對話方塊中 描述 這一列會顯示的內容，所以可有可無。只是要注意，如果文字間有空白字元，記得要用單引號括起來。--path 是真正要執行的程式命令。請注意，程式的路徑要用完整的，不能參考 $PATH。--args 就是你執行的命令它本身要帶的參數。在這裏，因為我們要讓 cron 成為 deamon 在背景寂靜執行，所以需要用到 cron -D 這樣的命令，因此要把 -D 這樣的參數放到 --args 項目中。我再補充一下 --disp 這個參數，這個參數指的是在 服務 對話方塊中 名稱 這一列會顯示的內容。但是，它只是顯示出來的名稱，並非 服務 本身真正的名字，所以在使用 net start ... 、net stop ... 這些有關 服務 的指令時不是用這個名稱，而是在 --install 後指定的那個真的的名字。但是如果不喜歡在 服務 對話方塊中 名稱 這一列只看到呆呆的 cron 這個字，那麼你可以使用 --disp 這個參數，比如說 --disp 'Cygwin cron' ，在 服務 對話方塊中 名稱 這一列列出來的就會變成 Cygwin cron，這樣看起來是不是清楚很多？

如果你想把 cron 服務除掉，那麼可以輸入：

$ cygrunsrv --remove cron

這樣不難吧。

剛才你在 服務 對話方塊中應該看到 cron 目前的狀態應該是空白的，也就是停止的。要啟動 cron，可以直接在 服務 對話方塊中，點選 cron 該列後，到上方工具列中按下 啟動服務 的圖示，它是一個黑色向右的三角形，和 CD 唱盤、錄音機上的 Play 鍵一樣。你也可以在 Cygwin 中輸入下列之一的命令，一樣可以啟動 cron service：

$ cygrunsrv -- start cron 或者

$ net start cron

停止它是：

$ cygrunsrv -- stop cron 或者

$ net stop cron

在之前 在 Windows 上安裝 sshd 一文中應該就看過相同的方法啟動 sshd。要確定它執行了沒，可以在 Cygwin 中執行：

$ ps -ef | grep cron
SYSTEM 4068 3724 ? 18:53:55 /usr/sbin/cron

或者

$ ps -a | grep cron
4068 3724 4068 3920 ? 18 18:53:55 /usr/sbin/cron

如果出現這樣，那就是執行起來了。要確定工作是否正確，你可以先加入一條工作：

$ crontab -e

* * * * * /usr/bin/date >> /tmp/hahaha

上面這一條是代表每一分鐘 cron 執行一次 date 指令，顯示當時的時間，然後把該時間加到 /tmp/hahaha 這個檔的後面。你可以在幾分鐘後自行用 cat /tmp/hahaha，看看是否正常執行。

$ cat /tmp/hahaha
Fri Apr 14 20:19:00 2006
Fri Apr 14 20:20:00 2006
Fri Apr 14 20:21:00 2006
Fri Apr 14 20:22:00 2006

如果你對 cron 不熟悉，請參考 Newbie: Intro to cron，該文相當詳細的一步一步解說得極為清楚，是很好的教學文件。

(1)Ctrl+Space

说明:内容助理。提供对方法,变量,参数,javadoc等得提示,应运在多种场合,总之需要提示的时候可先按此快捷键。

注:默认Ctrl+Space，注意输入法的切换设置与此设置冲突

(2)Ctrl+Shift+Space

说明:变量提示

(3)Ctrl+/

说明:添加/消除//注释,在eclipse2.0中,消除注释为Ctrl+\

(4)Ctrl+Shift+/

说明:添加/* */注释

(5)Ctrl+Shift+\

说明:消除/* */注释

(6)Ctrl+Shift+F

说明:自动格式化代码

(7)Ctrl+1

说明:批量修改源代码中的变量名,此外还可用在catch块上.

(8)Ctril+F6

说明:界面切换

(9)Ctril+Shift+M

说明:查找所需要得包

(10)Ctril+Shift+O

说明:自动引入所需要得包

(11)Ctrl+Alt+S

说明:源代码得快捷菜单。其中的Generate getters and setters 和 Surround with try/catch
block比较常用.建议把它们添加为快捷键

2. 快捷键列表

编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+？Alt+Shift+?Ctrl+Shift+Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y

查看
作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-

窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-

导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L

搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G

文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓

文件
作用域 功能 快捷键
全局 保存 Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N

项目
作用域 功能 快捷键
全局 全部构建 Ctrl+B

源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+\
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。也可以使用Ctrl+1自动修正。

运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U

重构
作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y

public class myTask
extends java.util.TimerTask {
String jobName;
private int i;
public void run() { //run in interface Runnable
System.out.println(jobName);
}

public myTask(String jobName) {
this.jobName = jobName;
}
}

//doTask.java

import java.util.*;
import java.io.*;

public class doTask {
private java.util.Timer timer;
private java.util.TimerTask task;
public doTask(java.util.TimerTask task) {
this.timer = new Timer();
this.task = task;
}
public void start(int delay, int internal) {
timer.schedule(task, delay * 1000, internal * 1000);//利用timer.schedule方法
}

public static void main(String[] args) {
java.util.TimerTask task1 = new myTask(" Job 1");
java.util.TimerTask task2= new myTask("Job 2");
doTask pt = new doTask(task1);
pt.start(1,3);
doTask pt2 = new doTask(task2);
pt2.start(1,1);
}

}

这是在一定的间隔时间执行重复的任务，java.util.Timer可以很简单的帮你实现。当然你也可以用多线程来实现。下面是用java.util.Timer来实现这个功能。

例子二：
//文件TimerUse
package src;

import java.util.*;
import java.io.*;

public class TimerUse
{
public static void main(String[] args)
{
PickTask pt = new PickTask();
pt.start(1,3);
}
}
//文件PickTask
package src;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

public class PickTask
{
private Timer timer;

public PickTask(){
timer = new Timer();
}

private TimerTask task = new TimerTask()
{
public void run(){

try{
BufferedReader br = new BufferedReader(new FileReader("ming.txt"));
String data = null;
while((data=br.readLine())!=null){
System.out.println(data);
}
}
catch(FileNotFoundException e){
System.out.println("can not find the file");
}
catch(IOException e){
e.printStackTrace();
}
}
};

public void start(int delay,int internal )
{
timer.schedule(task,delay*5000,internal*1000);
}
}

（1）方法选择。

一，使用高级的线程API，包括：
1.如果想重复的调用某个任务，或者想在一定延迟之后进行某项工作，推荐使用java.util.Timer和java.util.TimerTask组合；
2.如果想写一个GUI程序，推荐使用java.swing.Timer；
3.类SwingWorker用于后台线程。

二，继承java.lang.Thread类。

三，实现Runnabl接口。

（2）方法介绍。

1.使用java.util.Timer 和 java.util.TimerTask。

Timer类构造器有：
Timer() ; // 默认
Timer( boolean isDaemon ) ; // 是否是daemon线程
用法：
用一个类（MyTask）继承TimerTask，把要执行的任务放在该类的run方法中，然后创建一个Timer对象（新线程）：
Timer timer = new Timer();
并拟定计划：
timer.schedule( new MyTask() , delayedTimeInMillisecond ); // 用于延迟一定时间后执行
timer.schedule( new MyTask() , time ); // 用于在给定的时间点执行，time是Date类的一个实例
timer.schedule( new MyTask(), initialDelay, interval ) // 用于重复执行
终止线程的方法：
　　timer.cancel();
　　当只剩下daemon线程时
　　当MyTaskd的run()执行完时，去除所有对timer的引用
　　System.exit(0);　　//　所有的线程都终止

２.继承Thread类并覆盖run()方法

没什么好说的，但是要记得start()哦～
Thread的构造器有：
Thread( threadName );
Thread( runnableObject , threadName );

３.实现Runnable接口

方法就是实现一个Runnable的类，并把实例传给Thread类的构造器，以创建新的线程。如：
public class MyTask implements Runnable {
private int index;
public MyTask( int index ) { this.index = index; }
public void run() {
System.out.prinln( " Task " + index + " is running." );
}
public static void main( String[] args ) {
for( int i=0; i<100; i++ )
new Thread( new MyTask(i), String.valueOf(i) ).start();
}
}

有的时候我们需要每隔一段时间去执行某个任务，在Java中提供了Timer and TimerTask来完成这个任务，本文提供一个应用程序的源代码告诉你如何使用这两个类。

Timer和TimerTask的方法很少，使用起来也非常方便。希望如果遇到问题参考一下API doc，里面写的很清楚。TimerTask是个抽象类，他扩展了Object并实现了Runnable接口，因此你必须在自己的Task中实现public void run()方法。这也就是我们需要执行的具体任务。Timer实际上是用来控制Task的，他提供的主要方法是重载的schedule()方法。我们这里将使用schedule(TimerTask task,long time,long internal)方法来说明如何使用它。

使用Java中的Timer和TimerTask
-------------------------
下面直接提供应用程序的源代码，有得时候感觉说的太多，对初学者作用并不是很大。但是当把代码给他们看了以后，很容易就接受了。下面我要完成的任务就是每隔3秒钟从一个文件中把内容读出来并打印到控制台，文件的内容如下：
ming.txt
hello world
beijing
basketball
java
c/c++
这里涉及到一些IO的知识，但并不复杂。我们使用BufferedReader从文件里面读取内容，一行一行的读取，代码如下：

try
{
BufferedReader br = new BufferedReader(new FileReader("ming.txt"));
String data = null;
while((data=br.readLine())!=null)
{
System.out.println(data);
}
}
catch(FileNotFoundException e)
{
System.out.println("can not find the file");
}
catch(IOException e)
{
e.printStackTrace();
}
在主程序中我们启动timer让他开始执行读取文件的工作。整个程序的内容如下
import java.util.*;
import java.io.*;

public class Tim