public class MyThread_1 extends Thread
{
public void run()
{
//some code 
}
}

public class MyThread_2 implements Runnable
{
public void run()
{
//some code 
}
}

new MyThread_1().start()

new Thread(new MyThread_2()).start()

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
new Thread(new MyThread()).start(); 
}
} 

new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//赋予最高优先级
t1.start();
t2.start();
t3.start();
}
} 

public class MyThread implements Runnable
{ 
public void run()
{ 
try
{
int sleepTime=(int)(Math.random()*100);//产生随机数字，
Thread.currentThread().sleep(sleepTime);//让其休眠一定时间，时间又上面sleepTime决定
//public static void sleep(long millis)throw InterruptedException （API）
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于线程在休眠可能被中断，所以调用sleep方法的时候需要捕捉异常
{
ie.printStackTrace();
} 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}

public static void main(String[] args)
{
/***************************************
ThreadGroup(String name) 
ThreadGroup(ThreadGroup parent, String name) 
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}

class BlankSaving //储蓄账户
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向银行存入了 [￥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向银行取走了 [￥"+i+"]");
if(money<0)
System.out.println("余额不足！"); 
}
public int showMoney()
{
return money;
}
} 


class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;



}
public static void oper(String name,BlankSaving bs)
{



if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{



for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
} 
}
public class BankTest 
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}



}

class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{ 
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}

“ 异 常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 在 用 传统 的 语 言 编 程 时， 程 序 员 只 能 通 过 函 数 的 返 回 值 来 发 出错 误 信 息。 这 易 于 导 致 很 多 错 误， 因 为 在 很 多 情 况 下 需 要知 道 错 误 产 生 的 内 部 细 节。 通 常， 用 全 局 变 量errno来 存 储“ 异 常” 的 类 型。 这 容 易 导 致 误 用， 因 为 一 个errno的 值 有 可 能在 被 处 理 ?reg; 前 被 另 外 的 错 误 覆 盖 掉。 即 使 最 优 美 的C语言 程 序， 为 了 处 理“ 异 常” 情 况， 也 常 求 助 于goto语 句。 Java对“ 异 常” 的 处 理 是 面 向 对 象 的。 一 个Java的Exception是 一 个 描 述“ 异 常” 情 况 的 对 象。 当 出 现“ 异 常” 情 况 时， 一 个Exception对象 就 产 生 了， 并 放 到 产 生 这 个“ 异 常” 的 成 员 函 数 里。

8.1 基础

Java的“ 异 常” 处 理 是 通 过5个 关 键 词 来 实 现 的：try, catch, throw, throws和finally。 用try 来 执 行 一 段 程 序， 如 果 出 现“ 异常”， 系 统 抛 出（throws?copy; 一 个“ 异 常”， 你 可 以 通 过 它 的类 型 来 捕 捉（catch?copy; 它， 或 最 后（finally?copy; 由 缺 省 处理 器 来 处 理。 下 面 是“ 异 常” 处 理 程 序 的 基 本 形 式：

try { //程 序 块 } catch (ExceptionType1 e) { // 对ExceptionType1的处 理 } catch (ExceptionType2 e) { // 对ExceptionType2的 处 理 throw(e); //再 抛 出 这 个“ 异 常” } finally { }

8.2 "异 常” 的 类 型

在“ 异 常” 类 层 次 的 最 上 层 有 一 个 单 独 的 类 叫 做Throwable。这 个 类 用 来 表 示 所 有 的“ 异 常” 情 况。 每 个“ 异 常” 类 型 都是Throwable的 子 类。Throwable有 两 个 直 接 的 子 类。 一 类 是Exception，是 用 户 程 序 能 够 捕 捉 到 的“ 异 常” 情 况。 我 们 将 通 过 产 生它 的 子 类 来 创 建 自 己 的“ 异 常”。 另 一 类 是Error， 它 定 义 了那 ?copy; 通 常 无 法 捕 捉 到 的“ 异 常”。 要 谨 慎 使 用Error子 类，因 为 它 们 通 常 会 导 致 灾 难 性 的 失 败。 在Exception中 有 一 个 子类RuntimeException， 它 是 程 序 运 行 时 自 动 地 对 某 ?copy; 错 误作 出 反 应 而 产 生 的。

8.3 不 捕 捉“ 异 常”

“ 异 常” 对 象 是Java在 运 行 时 对 某 ?copy;“ 异 常” 情 况 作出 反 应 而 产 生 的。 例 如， 下 面 这 个 小 程 序 包 含 一 个 整 数 被0除的“ 异 常”。

class Exc0 { public static void main(String args[]) { int d = 0; int a = 42/d; } }

当Java执 行 这 个 除 法 时， 由 于 分 母 是0， 就 会 构 造 一 个“ 异常” 对 象 来 使 程 序 停 下 来 并 处 理 这 个 错 误 情 况， 在 运 行 时“ 抛 出”（throw?copy; 这 个“ 异 常”。 说“ 抛 出” 是 因 为 它 象 一个 滚 烫 的 马 铃 薯， 你 必 须 把 它 抓 住 并 立 即 处 理。 程 序 流 将会 在 除 号 操 作 符 处 被 打 断， 然 后 检 查 当 前 的 调 用 堆 栈 来查 找“ 异 常”。 一 个“ 异 常” 处 理 器 是 用 来 立 即 处 理“ 异 常” 情 况 的。 在 这 个 例 子 里， 我 们 没 有 编 一 个“ 异 常” 处 理 器，所 以 缺 省 的 处 理 器 就 发 挥 作 用 了。 缺 省 的 处 理 器 打 印Exception的字 符 ?reg; 值 和 发 生 “ 异 常” 的 地 点。 下 面 是 我 们 的 小 例子 的 输 出。

C:\>java Exc0 java.lang.arithmeticException: / by zero at Exc0.main(Exc0.java:4)

8.4 try与catch

通 常 我 们 希 望 自 己 来 处 理“ 异 常” 并 继 续 运 行。 可 以 用try来指 定 一 块 预 防 所 有“ 异 常” 的 的 程 序。 紧 跟 在try程 序 后 面，应 包 含 一 个catch子 句 来 指 定 你 想 要 捕 捉 的“ 异 常” 的 类 型。例 如， 下 面 的 例 子 是 在 前 面 的 例 子 的 基础上 构 造 的， 但 它包 含 一 个try程 序 块 和 一 个catch子 句。

class exc1 { public static void main(string args[]) { try { int d = 0; int a = 42 / d; } catch (arithmeticexception e) { system.out.println("division by zero"); } } }

catch子 句 的 目 标 是 解 决“ 异 常” 情 况， 把 一 ?copy; 变 量 设到 合 理 的 状 态， 并 象 没 有 出 错 一 样 继 续 运 行。 如 果 一 个 子程 序 不 处 理 某 个“ 异 常”， 则 返 到 上 一 级 处 理， 直 到 最 外一 级。

8.5 多 个catch子 句

在 某 ?copy; 情 况 下， 同 一 段 程 序 可 能 产 生 不 止 一 种“ 异常” 情 况。 你 可 以 放 置 多 个catch子 句， 其 中 每 一 种“ 异 常” 类 型 都 将 被 检 查， 第 一 个 与 ?reg; 匹 配 的 就 会 被 执 行。 如果 一 个 类 和 其 子 类 都 有 的 话， 应 把 子 类 放 在 前 面， 否 则 将永 远 不 会 到 达 子 类。 下 面 是 一 个 有 两 个catch子 句 的 程 序 的例 子。

class MultiCatch { public static void main(String args[]) { try { int a = args.length; System.out.println("a = " + a); int b = 42/a; int c[] = {1}; c[42] = 99; } catch(ArithmeticException e) { System.out.println("div by 0: " + e); } catch(ArrayIndexOutOfBoundsException e) { system.out.println("array index oob: " + e); } } }

如 果 在 程 序 运 行 时 不 跟 参 数， 将 会 引 起 一 个0做 除 数 的“ 异 常”， 因 为a的 值 为0。 如 果 我 们 提 ?copy; 一 个 命 令 行 参 数，将 不 会 产 生 这 个“ 异 常”， 因 为a的 值 大 于0。 但 会 引 起 一 个 ArrayIndexOutOfBoundexception的“ 异 常”， 因 为 整 型 数 组c的 长 度是1， 却 给c[42]赋 值。 下 面 是 以 上 两 种 情 况 的 运 行 结 果。

C:\>java MultiCatch a = 0 div by 0: java.lang.arithmeticexception: / by zero C:\>java MutiCatch 1 a = 1 array index oob: java.lang.ArrayIndexOutOfBoundsException:42

8.6 try语 句 的 嵌 套

你 可 以 在 一 个 成 员 函 数 调 用 的 外 面 写 一 个try语 句， 在 这个 成 员 函 数 内 部， 写 另 一 个try语 句 保 护 其 他 代 码。 每 当 遇到 一 个try语 句，“ 异 常” 的 框 架 就 放 到 堆 栈 上 面， 直 到 所 有的try语 句 都 完 成。 如 果 下 一 级 的try语 句 没 有 对 某 种“ 异 常” 进 行 处 理， 堆 栈 就 会 展 开， 直 到 遇 到 有 处 理 这 种“ 异 常” 的try语 句。 下 面 是 一 个try语 句 嵌 套 的 例 子。

class MultiNest { static void procedure() { try { int c[] = { 1 }: c[42] = 99; } catch(ArrayIndexOutOfBoundsexception e) { System.out.println("array index oob: " + e); } } public static void main(String args[]) { try { int a = args.length; system.out.println("a = " + a); int b = 42/a; procedure(); } catch(arithmeticException e) { System.out.println("div by 0: " + e); } } }

成 员 函 数procedure里 有 自 己 的try/catch控 制， 所 以main不 用 去处 理 ArrayIndexOutOfBoundsException。

8.7 throw语 句

throw语 句 用 来 明 确 地 抛 出 一 个“ 异 常”。 首 先， 你 必 须 得到 一 个Throwable的 实 例 的 控 制 柄， 通 过 参 数 传 到catch子 句， 或者 用new操 作 符 来 创 建 一 个。 下 面 是throw语 句 的 通 常 形 式。

throw ThrowableInstance;

程 序 会 在throw语 句 后 立 即 终 止， 它 后 面 的 语 句 执 行 不 到，然 后 在 包 含 它 的 所 有try块 中 从 里 向 外 寻 找 含 有 与 其 匹 配的catch子 句 的try块。 下 面 是 一 个 含 有throw语 句 的 例 子。

class ThrowDemo { static void demoproc() { try { throw new NullPointerException("de3mo"); } catch(NullPointerException e) { System.out.println("caught inside demoproc"); throw e; } } public static void main(String args[]) { try { demoproc(); } catch(NullPointerException e) { system.out.println("recaught: " + e); } } }

8.8 throws语 句

throws用 来 标 明 一 个 成 员 函 数 可 能 抛 出 的 各 种“ 异 常”。对 大 多 数Exception子 类 来 说，Java 编 译 器 会 强 迫 你 声 明 在 一个 成 员 函 数 中 抛 出 的“ 异 常” 的 类 型。 如 果“ 异 常” 的 类 型是Error或 RuntimeException， 或 它 们 的 子 类， 这 个 规 则 不 起 作 用，因 为 这 ?copy; 在 程 序 的 正 常 部 分 中 是 不 期 待 出 现 的。 如 果你 想 明 确 地 抛 出 一 个RuntimeException， 你 必 须 用throws语 句 来声 明 它 的 类 型。 这 就 重 新 定 义 了 成 员 函 数 的 定 义 语 法：

type method-name(arg-list) throws exception-list { }

下 面 是 一 段 程 序， 它 抛 出 了 一 个“ 异 常”， 但 既 没 有 捕捉 它， 也 没 有 用throws来 声 明。 这 在 编 译 时 将 不 会 通 过。

class ThrowsDemo1 { static void procedure( ) [ System.out.println("inside procedure"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { procedure( ); } }

为 了 让 这 个 例 子 编 译 过 去， 我 们 需 要 声 明 成 员 函 数procedure抛出 了IllegalAccessException， 并 且 在 调 用 它 的 成 员 函 数main里 捕捉 它。 下 面 是 正 确 的 例 子：

class ThrowsDemo { static void procedure( ) throws IllegalAccessException { System.out.println("inside procedure"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { try { procedure( ); } catch (IllegalAccessException e) { System.out.println("caught " + e); } } }

下 面 是 输 出 结 果：

C:\>java ThrowsDemo inside procedure caught java.lang.IllegalAccessException: demo

8.9 finally

当 一 个“ 异 常” 被 抛 出 时， 程 序 的 执 行 就 不 再 是 线 性 的，跳 过 某 ?copy; 行， 甚 至 会 由 于 没 有 与 ?reg; 匹 配 的catch子 句而 过 早 地 返 回。 有 时 确 保 一 段 代 码 不 管 发 生 什 么“ 异 常” 都 被 执 行 到 是 必 要 的， 关 键 词finally就 是 用 来 标 识 这 样 一段 代 码 的。 即 使 你 没 有catch子 句，finally程 序 块 也 会 在 执 行 try程 序 块 后 的 程 序 ?reg; 前 执 行。 每 个try语 句 都 需 要 至 少一 个 与 ?reg; 相 配 的catch子 句 或finally子 句。 一 个 成 员 函 数 返回 到 调 用 它 的 成 员 函 数， 或 者 通 过 一 个 没 捕 捉 到 的“ 异 常”，或 者 通 过 一 个 明 确 的return语 句，finally子 句 总 是 恰 好 在 成 员函 数 返 回 前 执 行。 下 面 是 一 个 例 子， 它 有 几 个 成 员 函 数，每 个 成 员 函 数 用 不 同 的 途 径 退 出， 但 执 行 了finally子 句。

class FinallyDemo { static void procA( ) { try { System.out.println("inside procA"); throw new RuntimeException("demo"); } finally { System.out.println("procA's finally"); } } static void procB( ) { try { System.out.println("inside procB"); return; } finally { System.out.println("procB's finally"); } } public static void main(String args[]) { try { procA( ); } catch (Exception e); procB( ); } }

下 面 是 这 个 例 子 的 运 行 结 果：

C:\>java FinallyDemo inside procA procA's finally inside procB procB's finally

本 章 小 结

1. “ 异 常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 2. 在“ 异 常” 类 ?次 的 最 上 层 的 类 叫Throwable， 它 有 两 个 直 接 的 子类：Exception和Error。 3. Java的“ 异 常” 处 理 通 过5个 关 键 词 来 实现：try，catch，throw，throws和finally。

java日期格式转换测试