JAVA100例

你的名字 2022-06-14 01:53 183阅读 0赞

[JAVA100例]001、Hello,Java
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　public class HelloWorld {
    　　 public static void main(String[] args) {
    　　 System.out.println("Hello Java World!");
    　　 }
    　　 }
    　　[JAVA100例]002、Java流程控制
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　public class flowDemo{
    　　 public static void main(String[] arges){
    　　 int iPara1,iPara2,iEnd;
    　　 if(arges.length!=3)
    　　 {
    　　 System.out.println("USE :java flowDome parameter1 parameter2 circle");
    　　 System.out.println("parameter1 : 比较条件1，数字类型");
    　　 System.out.println("parameter2 : 比较条件2，数字类型");
    　　 System.out.println("circle ：循环次数");
    　　 System.out.println("ego:java flowDome 1 2 5");
    　　 return;
    　　 }else{
    　　 iPara1 = Integer.parseInt(arges[0]);
    　　 iPara2 = Integer.parseInt(arges[1]);
    　　 iEnd = Integer.parseInt(arges[2]);
    　　 }
    　　 //if语句
    　　 if(iPara2>iPara1)
    　　 {
    　　 System.out.println("if 条件满足！");
    　　 System.out.println("第2个数比第1个数大！");
    　　 }
    　　 else
    　　 {
    　　 System.out.println("if 条件不满足！");
    　　 System.out.println("第2个数比第1个数小！");
    　　 }
    　　 //for循环操作
    　　 for(int i=0;i　　 {
    　　 System.out.println("这是for 第"+i+"次循环");
    　　 }
    　　 //while循环操作
    　　 int i=0;
    　　 while(i　　 {
    　　 System.out.println("这是while 第"+i+"次循环");
    　　 i++;
    　　 }
    　　 //do-while循环操作
    　　 int j=0;
    　　 do
    　　 {
    　　 System.out.println("这是do-while 第"+j+"次循环");
    　　 j++;
    　　 }while(j　　 }
    　　 } 　
    　　[JAVA100例]003、数组数据操作
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　public class myArray{
    　　 //初始化数组变量
    　　 char[] cNum = {´1´,´2´,´3´,´4´,´5´,´6´,´7´,´8´,´9´,´0´};
    　　 char[] cStr = {´a´,´b´,´c´,´d´,´e´,´f´,´g´,´h´,
    　　 ´i´,´j´,´k´,´l´,´m´,´n´,´o´,´p´,
    　　 ´q´,´r´,´s´,´t´,´u´,´v´,´w´,´x´,´y´,´z´};
    　　 int[] iMonth = {31,28,31,30,31,30,31,31,30,31,30,31};
    　　 String[] sMail = {"@","."};
    　　/**
    　　 *
    方法说明：校验电子邮件
    　　 *
    输入参数：String sPara 被校验的电子邮件字符
    　　 *
    返回类型：boolean 如果校验的格式符合电子邮件格式返回true；否则返回false
    　　 */ 
    　　 public boolean isMail(String sPara){
    　　 for(int i=0;i　　 if(sPara.indexOf(sMail[i])==-1)
    　　 return false; 
    　　 }
    　　 return true;
    　　 }
    　　/**
    　　 *
    方法说明：判断是否是数字
    　　 *
    输入参数：String sPara。 需要判断的字符串
    　　 *
    返回类型：boolean。如果都是数字类型，返回true；否则返回false
    　　 */ 
    　　 public boolean isNumber(String sPara){
    　　 int iPLength = sPara.length();
    　　 for(int i=0;i　　 char cTemp = sPara.charAt(i);
    　　 boolean bTemp = false;
    　　 for(int j=0;j　　 if(cTemp==cNum[j]){
    　　 bTemp = true;
    　　 break;
    　　 }
    　　 }
    　　 if(!bTemp) return false; 
    　　 }
    　　 return true;
    　　 }
    　　/**
    　　 *
    方法说明：判断是否都是英文字符
    　　 *
    输入参数：String sPara。要检查的字符
    　　 *
    返回类型：boolean。如果都是字符返回true；反之为false
    　　 */ 
    　　 public boolean isString(String sPara){
    　　 int iPLength = sPara.length();
    　　 for(int i=0;i　　 char cTemp = sPara.charAt(i);
    　　 boolean bTemp = false;
    　　 for(int j=0;j　　 if(cTemp==cStr[j]){
    　　 bTemp = true;
    　　 break;
    　　 }
    　　 }
    　　 if(!bTemp) return false; 
    　　 }
    　　 return true;
    　　 }
    　　/**
    　　 *
    方法说明：判断是否是闰年
    　　 *
    输入参数：int iPara。要判断的年份
    　　 *
    返回类型：boolean。如果是闰年返回true，否则返回false
    　　 */ 
    　　 public boolean chickDay(int iPara){
    　　 return iPara%100==0&&iPara%4==0;
    　　 }
    　　/**
    　　 *
    方法说明：检查日期格式是否正确
    　　 *
    输入参数：String sPara。要检查的日期字符
    　　 *
    返回类型：int。0 日期格式正确，-1 月或这日不合要求， -2 年月日格式不正确 
    　　 */
    　　 public int chickData(String sPara){
    　　 boolean bTemp = false;
    　　 //所输入日期长度不正确
    　　 if(sPara.length()!=10) return -2;
    　　 //获取年
    　　 String sYear = sPara.substring(0,4);
    　　 //判断年是否为数字
    　　 if(!isNumber(sYear)) return -2;
    　　 //获取月份
    　　 String sMonth = sPara.substring(5,7);
    　　 //判断月份是否为数字
    　　 if(!isNumber(sMonth)) return -2;
    　　 //获取日
    　　 String sDay = sPara.substring(8,10);
    　　 //判断日是否为数字
    　　 if(!isNumber(sDay)) return -2;
    　　 //将年、月、日转换为数字
    　　 int iYear = Integer.parseInt(sYear);
    　　 int iMon = Integer.parseInt(sMonth);
    　　 int iDay = Integer.parseInt(sDay);
    　　 if(iMon>12) return -1;
    　　 //闰年二月处理
    　　 if(iMon==2&&chickDay(iYear)){
    　　 if(iDay>29) return 2;
    　　 }else{
    　　 if(iDay>iMonth[iMon-1]) return -1;
    　　 }
    　　 return 0;
    　　 }
    　　/**
    　　 *
    方法说明：主方法，测试用
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */ 
    　　 public static void main(String[] arges){
    　　 myArray mA = new myArray();
    　　 //校验邮件地址
    　　 boolean bMail = mA.isMail("tom@163.com");
    　　 System.out.println("1 bMail is "+bMail);
    　　 bMail = mA.isMail("tom@163com");
    　　 System.out.println("2 bMail is "+bMail);
    　　 //演示是否是数字
    　　 boolean bIsNum = mA.isNumber("1234");
    　　 System.out.println("1：bIsNum="+bIsNum);
    　　 bIsNum = mA.isNumber("123r4");
    　　 System.out.println("2：bIsNum="+bIsNum);
    　　 //演示是否是英文字符
    　　 boolean bIsStr = mA.isString("wer");
    　　 System.out.println("1：bIsStr="+bIsStr);
    　　 bIsStr = mA.isString("wer3");
    　　 System.out.println("2：bIsStr="+bIsStr);
    　　 //演示检查日期
    　　 int iIsTime = mA.chickData("2003-12-98");
    　　 System.out.println("1：iIsTime="+iIsTime);
    　　 iIsTime = mA.chickData("2003-111-08");
    　　 System.out.println("2：iIsTime="+iIsTime);
    　　 iIsTime = mA.chickData("2003-10-08");
    　　 System.out.println("3：iIsTime="+iIsTime);
    　　 iIsTime = mA.chickData("2000-02-30");
    　　 System.out.println("4：iIsTime="+iIsTime);
    　　 }
    　　 }
    　　
    　　　[JAVA100例]005、哈希表(Hashtable)和枚举器
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　public class RoleRight
    　　 {
    　　 private static Hashtable rightList = new Hashtable();
    　　/**
    　　 *
    方法说明：初始化数据
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void init()
    　　 {
    　　 String[] accRoleList = {"admin","satrap","manager","user","guest"};
    　　 String[] rightCodeList = {"10001","10011","10021","20011","24011"};
    　　 for(int i=0;i　　 {
    　　 rightList.put(accRoleList[i],rightCodeList[i]);
    　　 }
    　　 }
    　　/**
    　　 *
    方法说明：获取角色权限代码
    　　 *
    输入参数：String accRole 角色名称
    　　 *
    返回类型：String 权限代码
    　　 */
    　　 public String getRight(String accRole)
    　　 {
    　　 if(rightList.containsKey(accRole))
    　　 return (String)rightList.get(accRole);
    　　 else
    　　 return null;
    　　 }
    　　/**
    　　 *
    方法说明：添加角色和代码信息
    　　 *
    输入参数：String accRole 角色名称
    　　 *
    输入参数：String rightCode 角色权限代码 
    　　 *
    返回类型：void （无）
    　　 */
    　　 public void insert(String accRole,String rightCode)
    　　 {
    　　 rightList.put(accRole,rightCode);
    　　 }
    　　/**
    　　 *
    方法说明：删除角色权限
    　　 *
    输入参数：String accRole 角色名称
    　　 *
    返回类型：void（无）
    　　 */
    　　 public void delete(String accRole)
    　　 {
    　　 if(rightList.containsKey(accRole))
    　　 rightList.remove(accRole);
    　　 }
    　　/**
    　　 *
    方法说明：修改角色权限代码
    　　 *
    输入参数：String accRole 角色名称
    　　 *
    输入参数：String rightCode 角色权限代码 
    　　 *
    返回类型：void（无）
    　　 */
    　　 public void update(String accRole,String rightCode)
    　　 {
    　　 //this.delete(accRole);
    　　 this.insert(accRole,rightCode);
    　　 }
    　　/**
    　　 *
    方法说明：打印哈希表中角色和代码对应表
    　　 *
    输入参数：无
    　　 *
    返回类型：无
    　　 */
    　　 public void print()
    　　 {
    　　 Enumeration RLKey = rightList.keys();
    　　 while(RLKey.hasMoreElements())
    　　 {
    　　 String accRole = RLKey.nextElement().toString();
    　　 print(accRole+"="+this.getRight(accRole));
    　　 }
    　　 }
    　　/**
    　　 *
    方法说明：打印信息（过载）
    　　 *
    输入参数：Object oPara 打印的信息内容
    　　 *
    返回类型：无
    　　 */
    　　 public void print(Object oPara)
    　　 {
    　　 System.out.println(oPara);
    　　 }
    　　/**
    　　 *
    方法说明：主方法，
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] args)
    　　 {
    　　 RoleRight RR = new RoleRight();
    　　 RR.init();
    　　 RR.print();
    　　 RR.print("___________________________");
    　　 RR.insert("presider","10110");
    　　 RR.print();
    　　 RR.print("___________________________");
    　　 RR.update("presider","10100");
    　　 RR.print();
    　　 RR.print("___________________________");
    　　 RR.delete("presider");
    　　 RR.print();
    　　 } 
    　　 }//end:)~ 　
    　　[JAVA100例]006、类的继承
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　class tree
    　　{
    　　/**
    　　 *
    方法说明：树的树根
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void root()
    　　 {
    　　 String sSite = "土壤中";
    　　 String sFunction = "吸收养份";
    　　 print("位置："+sSite);
    　　 print("功能："+sFunction);
    　　 }
    　　/**
    　　 *
    方法说明：树的树干
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void bolo()
    　　 {
    　　 String sSite = "地面";
    　　 String sFunction = "传递养份";
    　　 print("位置："+sSite);
    　　 print("功能："+sFunction);
    　　 }
    　　/**
    　　 *
    方法说明：树的树枝
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void branch()
    　　 {
    　　 String sSite = "树干上";
    　　 String sFunction = "传递养份";
    　　 print("位置："+sSite);
    　　 print("功能："+sFunction);
    　　 }
    　　/**
    　　 *
    方法说明：树的叶子
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void leaf()
    　　 {
    　　 String sSite = "树梢";
    　　 String sFunction = "光合作用";
    　　 String sColor = "绿色";
    　　 print("位置："+sSite);
    　　 print("功能："+sFunction);
    　　 print("颜色："+sColor);
    　　 }
    　　/**
    　　 *
    方法说明：显示信息
    　　 *
    输入参数：Object oPara 显示的信息
    　　 *
    返回类型：
    　　 */
    　　 public void print(Object oPara)
    　　 {
    　　 System.out.println(oPara);
    　　 }
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] arges)
    　　 {
    　　 tree t = new tree();
    　　 t.print("描述一棵树：");
    　　 t.print("树根：");
    　　 t.root();
    　　 t.print("树干：");
    　　 t.bolo();
    　　 t.print("树枝：");
    　　 t.branch();
    　　 t.print("树叶：");
    　　 t.leaf();
    　　 }
    　　}
    　　/**
    　　 * 
    Title: 柳树参数
    
    
    　　 * 
    Description: 描述柳树的参数
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: 
    
    
    　　 * @author 杜江
    　　 * @version 1.0
    　　 */
    　　class osier extends tree
    　　{
    　　 /**
    　　 *
    方法说明：过载树的树叶
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void leaf()
    　　 {
    　　 super.leaf();
    　　 String sShape = "长形";
    　　 super.print("形状："+sShape);
    　　 }
    　　 /**
    　　 *
    方法说明：扩展树的花
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void flower()
    　　 {
    　　 print("哈哈，柳树没有花！！");
    　　 }
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] args)
    　　 {
    　　 osier o = new osier();
    　　 o.print("柳树树根：");
    　　 o.root();
    　　 o.print("柳树树干：");
    　　 o.bolo();
    　　 o.print("柳树树枝：");
    　　 o.branch();
    　　 o.print("柳树树叶：");
    　　 o.leaf();
    　　 o.print("柳树花：");
    　　 o.flower();
    　　 }
    　　}
    　　
    　　　[JAVA100例]009、异常的捕获和实现自己的异常类
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　/**
    　　 * 
    Title: 捕获异常和实现自己的异常类
    
    
    　　 * 
    Description: 通过继承Exception类来实现自己的异常类。并使用try－catch来捕获这个异常。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: 
    
    
    　　 * @version 1.0
    　　 */
    　　class MyException extends Exception {
    　　 public MyException() {}
    　　 public MyException(String msg) {
    　　 super(msg);
    　　 }
    　　 public MyException(String msg, int x) {
    　　 super(msg);
    　　 i = x;
    　　 }
    　　 public int val() { return i; }
    　　 private int i;
    　　}
    　　
    　　
    　　
    　　public class DemoException {
    　　/**
    　　 *
    方法说明：使用MyException类中默认的构造器
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void a() throws MyException {
    　　 System.out.println(
    　　 "Throwing MyException from a()");
    　　 throw new MyException();
    　　 }
    　　/**
    　　 *
    方法说明：使用MyException类中带信息的构造器
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void b() throws MyException {
    　　 System.out.println(
    　　 "Throwing MyException from b()");
    　　 throw new MyException("Originated in b()");
    　　 }
    　　/**
    　　 *
    方法说明：使用了MyException中有编码的构造器
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void c() throws MyException {
    　　 System.out.println(
    　　 "Throwing MyException from c()");
    　　 throw new MyException(
    　　 "Originated in c()", 47);
    　　 }
    　　 public static void main(String[] args) {
    　　 try {
    　　 a();
    　　 } catch(MyException e) {
    　　 e.getMessage();
    　　 }
    　　 try {
    　　 b();
    　　 } catch(MyException e) {
    　　 e.toString();
    　　 }
    　　 try {
    　　 c();
    　　 } catch(MyException e) {
    　　 e.printStackTrace();
    　　 System.out.println("error code: " + e.val());
    　　 }
    　　 }
    　　} //end :)
    　　
    　　　[JAVA100例]044、多线程服务器：每个人都有份
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　// 文件名：moreServer.java
    　　import java.io.*;
    　　import java.net.*;
    　　import java.util.*;
    　　/**
    　　 * 
    Title: 多线程服务器
    
    
    　　 * 
    Description: 本实例使用多线程实现多服务功能。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: 
    
    
    　　 * @version 1.0
    　　 */
    　　class moreServer
    　　{
    　　 public static void main (String [] args) throws IOException
    　　 {
    　　 System.out.println ("Server starting...\n"); 
    　　 //使用8000端口提供服务
    　　 ServerSocket server = new ServerSocket (8000);
    　　 while (true)
    　　 {
    　　 //阻塞，直到有客户连接
    　　 Socket sk = server.accept ();
    　　 System.out.println ("Accepting Connection...\n");
    　　 //启动服务线程
    　　 new ServerThread (sk).start ();
    　　 }
    　　 }
    　　}
    　　//使用线程，为多个客户端服务
    　　class ServerThread extends Thread
    　　{
    　　 private Socket sk;
    　　 
    　　 ServerThread (Socket sk)
    　　 {
    　　 this.sk = sk;
    　　 }
    　　//线程运行实体
    　　 public void run ()
    　　 {
    　　 BufferedReader in = null;
    　　 PrintWriter out = null;
    　　 try{
    　　 InputStreamReader isr;
    　　 isr = new InputStreamReader (sk.getInputStream ());
    　　 in = new BufferedReader (isr);
    　　 out = new PrintWriter (
    　　 new BufferedWriter(
    　　 new OutputStreamWriter(
    　　 sk.getOutputStream ())), true);
    　　
    　　
    　　
    　　 while(true){
    　　 //接收来自客户端的请求，根据不同的命令返回不同的信息。
    　　 String cmd = in.readLine ();
    　　 System.out.println(cmd);
    　　 if (cmd == null)
    　　 break;
    　　 cmd = cmd.toUpperCase ();
    　　 if (cmd.startsWith ("BYE")){
    　　 out.println ("BYE");
    　　 break;
    　　 }else{
    　　 out.println ("你好，我是服务器！");
    　　 }
    　　 }
    　　 }catch (IOException e)
    　　 {
    　　 System.out.println (e.toString ());
    　　 }
    　　 finally
    　　 {
    　　 System.out.println ("Closing Connection...\n");
    　　 //最后释放资源
    　　 try{
    　　 if (in != null)
    　　 in.close ();
    　　 if (out != null)
    　　 out.close ();
    　　 if (sk != null)
    　　 sk.close ();
    　　 }
    　　 catch (IOException e)
    　　 {
    　　 System.out.println("close err"+e);
    　　 }
    　　 }
    　　 }
    　　}
    　　
    　　
    　　
    　　 
    　　
    　　
    　　
    　　 
    　　
    　　
    　　
    　　//文件名：SocketClient.java
    　　import java.io.*;
    　　import java.net.*; 
    　　class SocketThreadClient extends Thread
    　　{
    　　 public static int count = 0;
    　　//构造器，实现服务
    　　 public SocketThreadClient (InetAddress addr)
    　　 {
    　　 count++;
    　　 BufferedReader in = null;
    　　 PrintWriter out = null;
    　　 Socket sk = null;
    　　 try{
    　　 //使用8000端口
    　　 sk = new Socket (addr, 8000);
    　　 InputStreamReader isr;
    　　 isr = new InputStreamReader (sk.getInputStream ());
    　　 in = new BufferedReader (isr);
    　　 //建立输出
    　　 out = new PrintWriter (
    　　 new BufferedWriter(
    　　 new OutputStreamWriter(
    　　 sk.getOutputStream ())), true);
    　　 //向服务器发送请求
    　　 System.out.println("count:"+count);
    　　 out.println ("Hello");
    　　 System.out.println (in.readLine ());
    　　 out.println ("BYE");
    　　 System.out.println (in.readLine ());
    　　
    　　
    　　
    　　 }
    　　 catch (IOException e)
    　　 {
    　　 System.out.println (e.toString ());
    　　 }
    　　 finally
    　　 {
    　　 out.println("END");
    　　 //释放资源
    　　 try
    　　 {
    　　 if (in != null)
    　　 in.close ();
    　　 if (out != null)
    　　 out.close ();
    　　 if (sk != null)
    　　 sk.close ();
    　　 }
    　　 catch (IOException e)
    　　 {
    　　 }
    　　 }
    　　 }
    　　}
    　　//客户端
    　　public class SocketClient{
    　　 public static void main(String[] args) throws IOException,InterruptedException
    　　 {
    　　 InetAddress addr = InetAddress.getByName(null);
    　　 for(int i=0;i<10;i++)
    　　 new SocketThreadClient(addr);
    　　 Thread.currentThread().sleep(1000);
    　　 } 
    　　}
    　　
    　　
    　　　[JAVA100例]058、调用存储过程
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　import java.sql.*;
    　　
    　　
    　　
    　　/**
    　　 * 
    Title: JDBC连接数据库
    
    
    　　 * 
    Description: 本实例演示如何使用JDBC连接Oracle数据库，并演示添加数据和查询数据。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: JDBCSTMConn.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class JDBCSTMConn{
    　　 private static String url="";
    　　 private static String username="";
    　　 private static String password="";
    　　/**
    　　 *
    方法说明：获得数据连接
    　　 *
    输入参数：
    　　 *
    返回类型：Connection 连接对象
    　　 */ 
    　　 public Connection conn(){
    　　 try {
    　　 //加载JDBC驱动
    　　 Class.forName("oracle.jdbc.driver.OracleDriver");
    　　 //创建数据库连接
    　　 Connection con = DriverManager.getConnection(url, username, password);
    　　 return con;
    　　 }catch(ClassNotFoundException cnf){
    　　 System.out.println("driver not find:"+cnf);
    　　 return null;
    　　 }catch(SQLException sqle){
    　　 System.out.println("can´t connection db:"+sqle);
    　　 return null;
    　　 } catch (Exception e) {
    　　 System.out.println("Failed to load JDBC/ODBC driver.");
    　　 return null;
    　　 }
    　　 }
    　　/**
    　　 *
    方法说明：调用存储过程，察看数据结果
    　　 *
    输入参数：Connection con 数据库连接
    　　 *
    输入参数：String sql 要执行的SQL语句
    　　 *
    返回类型：
    　　 */
    　　 public void execute(Connection con){
    　　 CallableStatement toesUp = null; 
    　　 try { 
    　　 con.setAutoCommit(false); 
    　　 //调用存储过程
    　　 toesUp = con.prepareCall("{call p_test(?)}"); 
    　　 //传递参数给存储过程
    　　 toesUp.setInt(1, 6);
    　　 //执行存储过程
    　　 toesUp.executeQuery();
    　　
    　　
    　　
    　　 Statement stmt = con.createStatement();
    　　 ResultSet rs = (ResultSet) stmt.executeQuery("SELECT * FROM TEST"); 
    　　 while (rs.next()) { 
    　　 String ID = rs.getString(1); 
    　　 String NAME = rs.getString(2); 
    　　 System.out.println(ID+ " " +NAME);
    　　 } 
    　　 rs.close(); 
    　　 } catch (SQLException e) { 
    　　 System.out.println(e);
    　　 try{
    　　 toesUp.close(); 
    　　 con.close();
    　　 }catch(Exception es){System.out.println(es);} 
    　　 }
    　　 }
    　　
    　　
    　　
    　　/**
    　　 *
    方法说明：实例演示
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void demo(){
    　　 try{
    　　 JDBCSTMConn oc = new JDBCSTMConn();
    　　 Connection conn = oc.conn();
    　　 oc.execute(conn);
    　　 conn.close();
    　　 }catch(SQLException se){
    　　 System.out.println(se);
    　　 }catch(Exception e){
    　　 System.out.println(e);
    　　 }
    　　 
    　　 }
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] arg){
    　　 if(arg.length!=3){
    　　 System.out.println("use: java JDBCSTMConn url username password");
    　　 return;
    　　 }
    　　 JDBCSTMConn oc = new JDBCSTMConn();
    　　 oc.url = arg[0];
    　　 oc.username=arg[1];
    　　 oc.password=arg[2];
    　　 oc.demo();
    　　 }
    　　} 
    　　
    　　　[JAVA100例]059、事务处理
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　import java.sql.*;
    　　/**
    　　 * 
    Title: JDBC连接数据库
    
    
    　　 * 
    Description: 本实例演示如何使用JDBC连接Oracle数据库，并演示添加数据和查询数据。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: JDBCConnCommit.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class JDBCConnCommit{
    　　 private static String url="";
    　　 private static String username="";
    　　 private static String password="";
    　　/**
    　　 *
    方法说明：获得数据连接
    　　 *
    输入参数：
    　　 *
    返回类型：Connection 连接对象
    　　 */ 
    　　 public Connection conn(){
    　　 try {
    　　 //加载JDBC驱动
    　　 Class.forName("oracle.jdbc.driver.OracleDriver");
    　　 //创建数据库连接
    　　 Connection con = DriverManager.getConnection(url, username, password);
    　　 return con;
    　　 }catch(ClassNotFoundException cnf){
    　　 System.out.println("driver not find:"+cnf);
    　　 return null;
    　　 }catch(SQLException sqle){
    　　 System.out.println("can´t connection db:"+sqle);
    　　 return null;
    　　 } catch (Exception e) {
    　　 System.out.println("Failed to load JDBC/ODBC driver.");
    　　 return null;
    　　 }
    　　 }
    　　
    　　
    　　
    　　/**
    　　 *
    方法说明：执行查询SQL语句
    　　 *
    输入参数：Connection con 数据库连接
    　　 *
    输入参数：String sql 要执行的SQL语句
    　　 *
    返回类型：
    　　 */
    　　 public void query(Connection con, String sql) throws SQLException,Exception {
    　　 try{
    　　 if(con==null){
    　　 throw new Exception("database connection can´t use!");
    　　 }
    　　 if(sql==null) throw new Exception("check your parameter: ´sql´! don´t input null!");
    　　 //声明语句
    　　 Statement stmt = con.createStatement();
    　　 //执行查询
    　　 ResultSet rs = stmt.executeQuery(sql); 
    　　 ResultSetMetaData rmeta = rs.getMetaData();
    　　 //获得数据字段个数
    　　 int numColumns = rmeta.getColumnCount();
    　　 while(rs.next())
    　　 {
    　　 for(int i = 0;i< numColumns;i++)
    　　 {
    　　 String sTemp = rs.getString(i+1);
    　　 System.out.print(sTemp+" ");
    　　 }
    　　 System.out.println(""); 
    　　 }
    　　 rs.close();
    　　 stmt.close();
    　　 }catch(Exception e){
    　　 System.out.println("query error: sql = "+sql);
    　　 System.out.println("query error:"+e);
    　　 throw new SQLException("query error");
    　　 }
    　　 }
    　　/**
    　　 *
    方法说明：执行插入、更新、删除等没有返回结果集的SQL语句
    　　 *
    输入参数：Connection con 数据库连接
    　　 *
    输入参数：String sql 要执行的SQL语句
    　　 *
    返回类型：
    　　 */
    　　 public void execute(Connection con, String sql) throws SQLException {
    　　 try{
    　　 if(con==null) return;
    　　 Statement stmt = con.createStatement();
    　　 int i = stmt.executeUpdate(sql); 
    　　 System.out.println("update row:"+i);
    　　 stmt.close();
    　　 }catch(Exception e){
    　　 System.out.println("execute error: sql = "+sql);
    　　 System.out.println(e);
    　　 throw new SQLException("execute error");
    　　 }
    　　 }
    　　
    　　
    　　
    　　/**
    　　 *
    方法说明：实例演示
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void demo(){
    　　 JDBCConnCommit oc = new JDBCConnCommit();
    　　 Connection conn = oc.conn();
    　　 try{
    　　 conn.setAutoCommit( false );
    　　 String sql = "";
    　　 for(int i=0;i<4;i++){
    　　 sql = "insert into TBL_USER(id,name,password)values(seq_user.nextval,´tom´,´haorenpingan´)";
    　　 oc.execute(conn,sql);
    　　 }
    　　 sql = "select * from TBL_USER where name=´tom´ order by id";
    　　 oc.query(conn,sql);
    　　 sql = "delete from TBL_USER where name=´tom´";
    　　 oc.execute(conn,sql);
    　　 conn.commit();
    　　 }catch(SQLException se){
    　　 try{
    　　 conn.rollback(); 
    　　 }catch(Exception e){
    　　 }
    　　 System.out.println(se);
    　　 }catch(Exception e){ 
    　　 System.out.println(e);
    　　 }finally
    　　 { 
    　　 try{
    　　 conn.close();
    　　 }catch(SQLException e){}
    　　 }
    　　 
    　　 }
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] arg){
    　　 if(arg.length!=3){
    　　 System.out.println("use: java JDBCConnCommit url username password");
    　　 return;
    　　 }
    　　 JDBCConnCommit oc = new JDBCConnCommit();
    　　 oc.url = arg[0];
    　　 oc.username=arg[1];
    　　 oc.password=arg[2];
    　　 oc.demo();
    　　 }
    　　} 
    　　[JAVA100例]060、继承Thread
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　/**
    　　 * 
    Title: 继承Thread，实现线程
    
    
    　　 * 
    Description: 通过继承Thread类，实现其run方法，实现自己的线程
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: oneThread.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class oneThread extends Thread {
    　　/**
    　　 *
    方法说明：构造器，本类没有使用
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　public oneThread() {
    　　 
    　　 }
    　　/**
    　　 *
    方法说明：继承Thread类必须实现的方法，当调用start方法时运行本方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run() {
    　　 System.out.println("...............oneThread begining................");
    　　 int flag = 0;
    　　 while(true) {
    　　 if(flag==20){
    　　 System.out.println("\n...............oneThread end............. ");
    　　 break;
    　　 }
    　　 for(int i=0;i　　 System.out.print("*");
    　　 System.out.println("");
    　　 flag++;
    　　 try{
    　　 //睡眠0.1秒
    　　 sleep(100);
    　　 }catch(Exception e){
    　　 } 
    　　 }
    　　 }
    　　/**
    　　 *
    方法说明：主方法。启动本线程
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String args[]) {
    　　 new oneThread().start();
    　　 }
    　　}
    　　[JAVA100例]061、实现Runnable
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　/**
    　　 * 
    Title: 实现Runnable接口，获得线程。
    
    
    　　 * 
    Description: 通过实现Runnable接口来获得自己的线程（t2）。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: twothread.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class twothread implements Runnable {
    　　/**
    　　 *
    方法说明：构造器。实际线程，并启动这个线程。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 twothread() { 
    　　 //获取当前的线程
    　　 Thread t1 =Thread.currentThread(); 
    　　 t1.setName("The first main thread"); 
    　　 System.out.println("The running thread:" + t1); 
    　　 //通过将本类（Runnable接口）和名称构造一个线程
    　　 Thread t2 = new Thread(this,"the second thread"); 
    　　 System.out.println("creat another thread"); 
    　　 //启动线程
    　　 t2.start(); 
    　　 try { 
    　　 System.out.println("first thread will sleep"); 
    　　 Thread.sleep(3000); 
    　　 }catch (InterruptedException e) {
    　　 System.out.println("first thread has wrong"); 
    　　 } 
    　　 System.out.println("first thread exit"); 
    　　 } 
    　　/**
    　　 *
    方法说明：线程主体。实现run方法。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run() { 
    　　 try { 
    　　 for (int i=0;i<5;i++) { 
    　　 System.out.println("Sleep time for thread 2:"+i); 
    　　 Thread.sleep(1000); 
    　　 }
    　　 } catch (InterruptedException e) {
    　　 System.out.println("thread has wrong"); 
    　　 }
    　　 System.out.println("second thread exit"); 
    　　 } 
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String args[]) { 
    　　 new twothread(); 
    　　 } 
    　　} 　
    　　[JAVA100例]062、多线程
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　/**
    　　 * 
    Title: 创建多线程
    
    
    　　 * 
    Description: 使用构造器，创建多线程。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: multiThread.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class multiThread 
    　　{ 
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main (String [] args){ 
    　　 new multiThread();
    　　 }
    　　/**
    　　 *
    方法说明：构造器。构造多个线程，并启动它们。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 multiThread(){
    　　 for (int i = 0; i < 5; i++){
    　　 System.out.println("Creating thread "+i);
    　　 innThread mt = new innThread (i); 
    　　 mt.start (); 
    　　 }
    　　 }
    　　/**
    　　 *
    类说明：内部类通过继承Thread实现线程 
    　　 *
    类描述：通过构造器参数，区别不同的线程
    　　 */ 
    　　 class innThread extends Thread 
    　　 { 
    　　 int count;
    　　 innThread(int i){
    　　 count=i;
    　　 }
    　　/**
    　　 *
    方法说明：内部类线程主体，继承Thread必须实现的方法。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run () 
    　　 { 
    　　 System.out.println("now "+count+" thread is beginning..... ");
    　　 try{
    　　 sleep(10-count);
    　　 }catch(Exception e){
    　　 System.out.println(e);
    　　 }
    　　 System.out.println("\n"+count+" thread is end!");
    　　 } 
    　　 } 
    　　} 　
    　　[JAVA100例]063、线程群组
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　/**
    　　 * 
    Title: 线程组群
    
    
    　　 * 
    Description: 通过线程组管理下面的多个线程。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: myThreadgroup.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class myThreadgroup extends Thread {
    　　 public static int flag=1;
    　　 ThreadGroup tgA;
    　　 ThreadGroup tgB;
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] args){
    　　 myThreadgroup dt = new myThreadgroup();
    　　 //声明线程组A
    　　 dt.tgA = new ThreadGroup("A");
    　　 //声明线程组B
    　　 dt.tgB = new ThreadGroup("B");
    　　 for(int i=1;i<3;i++)
    　　 new thread1(dt.tgA,i*1000,"one"+i);
    　　 for(int i=1;i<3;i++)
    　　 new thread1(dt.tgB,1000,"two"+i);
    　　 //启动本线程和所有线程组
    　　 dt.start();
    　　 }
    　　/**
    　　 *
    方法说明：覆盖run方法，控制线程组
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run(){
    　　 try{
    　　 this.sleep(5000);
    　　 this.tgB.checkAccess();
    　　 //停止线程组B，
    　　 this.tgB.stop();
    　　 System.out.println("**************tgB stop!***********************");
    　　 this.sleep(1000);
    　　 //检查线程组A是否可以更改
    　　 this.tgA.checkAccess();
    　　 //停止线程组A
    　　 this.tgA.stop();
    　　 System.out.println("**************tgA stop!***********************");
    　　 
    　　 }catch(SecurityException es){
    　　 System.out.println("**"+es);
    　　 }catch(Exception e){
    　　 System.out.println("::"+e);
    　　 }
    　　 }
    　　}
    　　/**
    　　 * 
    Title: 线程类
    
    
    　　 * 
    Description: 通过构造器的参数，实现不同的线程
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: thread1.java
    
    
    　　 * @author 杜江
    　　 * @version 1.0
    　　 */
    　　class thread1 extends Thread {
    　　 int pauseTime;
    　　 String name;
    　　 public thread1(ThreadGroup g,int x, String n) {
    　　 super(g,n);
    　　 pauseTime = x;
    　　 name = n;
    　　 start();
    　　 }
    　　/**
    　　 *
    方法说明：必须覆盖的方法。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run () 
    　　 {
    　　 while(true) {
    　　 try {
    　　 System.out.print(name+"::::");
    　　 this.getThreadGroup().list();//获取线程组信息
    　　 Thread.sleep(pauseTime);
    　　 } catch(Exception e) {
    　　 System.out.println(e);
    　　 }
    　　 }
    　　 }
    　　}
    　　[JAVA100例]064、线程间通讯
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　/**
    　　 * 
    Title: 线程间合作
    
    
    　　 * 
    Description: 本实例使用二个线程共同合作绘制一个实体三角。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: mainThread.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class mainThread{
    　　 public static int flag = 0;
    　　 int count = 10;
    　　/**
    　　 *
    方法说明：主方法
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public static void main(String[] arg){
    　　 new mainThread();
    　　 }
    　　/**
    　　 *
    方法说明：构造器，启动两个子线程。
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 mainThread(){
    　　 thread1 t1 = new mainThread.thread1(this.count);
    　　 thread2 t2 = new mainThread.thread2(this.count);
    　　 //启动两线程
    　　 t1.start();
    　　 t2.start();
    　　 //让线程一首先工作。
    　　 flag = 1;
    　　 }
    　　/**
    　　 *
    类说明：内部类，继承了Thread，
    　　 *
    类描述：实现了在输出每行前面的空格。
    　　 */
    　　 class thread1 extends Thread{
    　　 int count1 = 0; 
    　　 thread1(int i){
    　　 count1 = i;
    　　 }
    　　 public void run(){
    　　 
    　　 while(true){
    　　 if(count1<=0) break;
    　　 if(mainThread.flag==1){
    　　 
    　　 for(int i=0;i　　 System.out.print(" ");
    　　 }
    　　 count1--;
    　　 mainThread.flag=2;
    　　 }
    　　 }
    　　 }
    　　 }
    　　/**
    　　 *
    类说明：内部类，继承了Thread，
    　　 *
    类描述：实现了在输出每行第“*”号。并提供换行。
    　　 */
    　　 class thread2 extends Thread{
    　　 int count2 = 0; 
    　　 thread2(int i){
    　　 count2 = i;
    　　 }
    　　 public void run(){
    　　 int count = 0;
    　　 while(true){
    　　 if(count>=count2) break;
    　　 if(mainThread.flag==2){
    　　 for(int i=0;i<(count*2+1);i++){
    　　 System.out.print("*");
    　　 }
    　　 System.out.print("\n");
    　　 count++;
    　　 mainThread.flag=1;
    　　 }
    　　 }
    　　 }
    　　 } 
    　　} 　
    　　[JAVA100例]065、线程同步
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　/**
    　　 * 
    Title: 线程同步
    
    
    　　 * 
    Description: 通过使用同步锁实现对共享数据的操作
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: SyThreadDemo.java
    
    
    　　 * @version 1.0
    　　 */
    　　/**
    　　 *
    类说明：主程序
    　　 *
    功能描述：构造两个线程，并启动它们
    　　 */
    　　public class SyThreadDemo 
    　　{ 
    　　 public static void main (String [] args) 
    　　 { 
    　　 trade ft = new trade (); 
    　　 addThread tt1 = new addThread (ft, "add"); 
    　　 decThread tt2 = new decThread (ft, "dec"); 
    　　 tt1.start (); 
    　　 tt2.start (); 
    　　 } 
    　　}
    　　/**
    　　 *
    类说明：同步类
    　　 *
    功能描述：保存共享数据，
    　　 */
    　　class trade 
    　　{ 
    　　 private String transName; 
    　　 private double amount; 
    　　/**
    　　 *
    方法说明：更新数据
    　　 *
    输入参数：String transName 操作名称
    　　 *
    输入参数：double amount 资金数量
    　　 *
    返回类型：
    　　 */
    　　 synchronized void update (String transName, double amount) 
    　　 { 
    　　 this.transName = transName; 
    　　 this.amount = amount; 
    　　 System.out.println (this.transName + " " + this.amount); 
    　　 } 
    　　} 
    　　/**
    　　 *
    类说明：添加资金
    　　 *
    功能描述：单线程，调用trade.update（）方法，修改数据
    　　 */
    　　class addThread extends Thread 
    　　{ 
    　　 private trade ft; 
    　　 addThread (trade ft, String name) 
    　　 { 
    　　 super (name);
    　　 this.ft = ft; 
    　　 } 
    　　 public void run () 
    　　 { 
    　　 for (int i = 0; i < 10; i++) 
    　　 ft.update ("add", 2000.0); 
    　　 } 
    　　} 
    　　/**
    　　 *
    类说明：减少资金
    　　 *
    功能描述：单线程，调用trade.update（）方法，修改数据
    　　 */
    　　class decThread extends Thread 
    　　{ 
    　　 private trade fd; 
    　　 decThread (trade fd, String name) 
    　　 { 
    　　 super (name);
    　　 this.fd = fd; 
    　　 } 
    　　/**
    　　 *
    方法说明：线程主体
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 public void run () 
    　　 { 
    　　 for (int i = 0; i < 10; i++) 
    　　 fd.update ("dec", -2000.0); 
    　　
    　　
    　　
    　　 } 
    　　} 
    　　[JAVA100例]066、线程控制
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　/**
    　　 * 
    Title: 线程控制
    
    
    　　 * 
    Description: 实现对线程的控制，中断、挂起、恢复、停止
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: threadCtrl.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class threadCtrl{
    　　 public static void main(String [] main){
    　　 new threadCtrl();
    　　 }
    　　/**
    　　 *
    方法说明：构造器，控制其它线程
    　　 *
    输入参数：
    　　 *
    返回类型：
    　　 */
    　　 threadCtrl(){
    　　 try{
    　　 Thread tm = Thread.currentThread();
    　　 threadchild td = new threadchild();
    　　 td.start();
    　　 tm.sleep(500);
    　　 System.out.println("interrupt child thread");
    　　 td.interrupt();
    　　
    　　
    　　
    　　 System.out.println("let child thread wait!");
    　　 //td.wait();
    　　 //td.suspend();
    　　 tm.sleep(1000);
    　　
    　　
    　　
    　　 System.out.println("let child thread working");
    　　 td.fauxresume();
    　　 //td.resume();
    　　 tm.sleep(1000);
    　　 td.runflag = false;
    　　 System.out.println("main over..............");
    　　 }catch(InterruptedException ie){
    　　 System.out.println("inter main::"+ie);
    　　 }catch(Exception e){
    　　 System.out.println("main::"+e);
    　　 }
    　　 }
    　　
    　　
    　　
    　　}
    　　/**
    　　 *
    类说明：被控线程类
    　　 */
    　　 class threadchild extends Thread {
    　　 boolean runflag = true;
    　　 boolean suspended = true;
    　　 threadchild(){
    　　 }
    　　 public synchronized void fauxresume(){
    　　 suspended = false;
    　　 notify();
    　　 } 
    　　 public void run(){
    　　 while(runflag){
    　　 System.out.println("I am working..............");
    　　 try{
    　　 sleep(1000);
    　　 }catch(InterruptedException e){
    　　 System.out.println("sleep::"+e);
    　　 }
    　　 synchronized(this){
    　　 try{
    　　 if(suspended)
    　　 wait();
    　　 }catch(InterruptedException e){
    　　 System.out.println("wait::"+e);
    　　 }
    　　 }
    　　 }
    　　 System.out.println("thread over...........");
    　　 }
    　　 }
    　　
    　　　[JAVA100例]067、线程优先级
    　　
    　　--------------------------------------------------------------------------------
    　　
    　　
    　　import java.util.*;
    　　/**
    　　 * 
    Title: 提高线程优先级
    
    
    　　 * 
    Description: 通过修改线程的优先级，是线程获得优先处理。
    
    
    　　 * 
    Copyright: Copyright (c) 2003
    
    
    　　 * 
    Filename: upPRIThread.java
    
    
    　　 * @version 1.0
    　　 */
    　　public class upPRIThread {
    　　 //主方法
    　　 public static void main(String[] args) throws Exception {
    　　 Thread1 t1 = new Thread1();
    　　 t1.start();
    　　 Thread2 t2 = new Thread2();
    　　 t2.start();
    　　 t1.setPriority(Thread.MIN_PRIORITY);
    　　 t2.setPriority(Thread.MIN_PRIORITY);
    　　 new Thread().sleep(105);
    　　 t2.setPriority(Thread.MAX_PRIORITY);
    　　 new Thread().sleep(10500);
    　　 }
    　　 //类说明：线程1，不更改优先级
    　　 static class Thread1 extends Thread {
    　　 public void run(){
    　　 while(true){
    　　 try {
    　　 Thread.sleep(100);
    　　 } 
    　　 catch (Exception e){
    　　 e.printStackTrace();
    　　 }
    　　 System.out.println("我是线程111");
    　　 }
    　　 }
    　　 }
    　　 //类说明：线程2，提高优先级
    　　 static class Thread2 extends Thread {
    　　
    　　
    　　
    　　 public void run(){
    　　 while(true){
    　　 try {
    　　 Thread.sleep(100);
    　　 } 
    　　 catch (Exception e){
    　　 e.printStackTrace();
    　　 }
    　　 System.out.println("我是线程222.........................");
    　　 }
    　　 }
    　　 }
    　　}