通过实例可以更好的了解java

19-例子10
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
class 售票员
{int 五元钱的个数=2,十元钱的个数=0,二十元钱的个数=0; String s=null;
  public synchronized void  售票规则(int money)
  { if(money==5)      //如果使用该方法的线程传递的参数是5,就不用等待。
      { 五元钱的个数=五元钱的个数+1; 
        s= "给您入场卷"+"  您的钱正好";
         Example19_10.text.append("\n"+s);
      }
    else if(money==20)           
      { while(五元钱的个数<3)
           { try {wait();}     //如果使用该方法的线程传递的参数是20须等待。
            catch(InterruptedException e){}
           }
          五元钱的个数=五元钱的个数-3;
          二十元钱的个数=二十元钱的个数+1;
          s="给您入场卷"+"  您给我20，找您15元";
           Example19_10.text.append("\n"+s);
       }
    notifyAll();
   }  
}
public class Example19_10 extends Applet implements Runnable
{ 售票员 王小姐;
  Thread 张平,李明;  //创建两个线程。
  static TextArea text; 
 public void init()
  {张平=new Thread(this);李明=new Thread(this);
   text=new TextArea(10,30);add(text);
   王小姐=new 售票员(); 
  } 
 public void start()
  {张平.start();李明.start(); }
 public void run()
  { if(Thread.currentThread()==张平)
      {王小姐.售票规则(20);
      }
    else if(Thread.currentThread()==李明)
      {王小姐.售票规则(5);
      }
  }   
}




19-例子11
import java.awt.event.*;
import java.awt.*;import java.util.Date;
class Example19_11 extends Frame implements Runnable,ActionListener
{ Thread thread=null; TextArea text=null;
  Button b_start=new Button("Start"),b_stop=new Button("Stop");
Example19_11()
  {thread=new Thread(this);
   text=new TextArea();add(text,"Center");
   Panel p=new Panel();p.add(b_start);p.add(b_stop); 
   b_start.addActionListener(this);
   b_stop.addActionListener(this) ;
   add(p,"North");setVisible(true);
   setSize(500,500);pack();setSize(500,500);
   setResizable(false);                     //让窗口的大小不能被调整。
    addWindowListener(new WindowAdapter()
      {public void windowClosing(WindowEvent e)
        {System.exit(0);
        }
      });
  }
 public void actionPerformed(ActionEvent e)
 { if(e.getSource()==b_start)
  {try {thread.start();}
    catch(Exception e1)
    {text.setText("在线程没有结束run方法之前，不赞成让线程再调用start方法");
    }  
  }
 else if(e.getSource()==b_stop)
   {thread.interrupt();
   }
 }
 public void run()
 {  while(true)
    {text.append("\n"+new Date());
      try{thread.sleep(1000);}
      catch(InterruptedException ee)
      {text.setText("我被消灭");return;//结束run语句,消灭该线程。
      }
    } 
 }
 public static void main(String args[])
 {Example19_11 tt=new Example19_11();
 }
} 



19-例子12 

import java.awt.*;import java.awt.event.*;import java.applet.*;
public class JieLi extends Applet implements Runnable,ActionListener
{ Button b=new Button("go");TextField text=null;
  Thread 发令员,运动员_1,运动员_2;
  int x=10;//线程运动的起始位置。
  Graphics mypen=null; 
  public void init()
  { b.addActionListener(this);
    text=new TextField(20);
    发令员=new Thread(this);
    运动员_1=new Thread(this);
    运动员_2=new Thread(this);
    add(b);add(text);
    mypen=getGraphics();
  }
 public void start()
  { 发令员.start();
  }
public void actionPerformed(ActionEvent e)
  { 发令员.interrupt();//点击按扭结束发令员的生命。
  }

 public void run()
  { if(Thread.currentThread()==发令员)
     { while(true)
        { text.setText("准备跑... ...");text.setText("......");
           try {发令员.sleep(30);
               }
           catch(InterruptedException e)
               {//点击按扭结束生命，并让运动员_1开始跑。
text.setText("跑");
                运动员_1.start(); break; 
               }  
        }
     }
    if(Thread.currentThread()==运动员_1)
     { while(true)
        {   x=x+1;
            mypen.setColor(Color.blue);
            mypen.clearRect(10,80,99,100);//显示线程运动的动画。  
            mypen.fillRect(x,85,5,5); 
            try  {
                  运动员_1.sleep(10);
                 }
            catch(InterruptedException e)
                 {         //通知运动员_2开始跑，运动员_1结束生命： 
运动员_2.start(); return;
}
            if(x>=100) 
                {运动员_1.interrupt();//运动员_1当跑到100米处时结束生命。
                }

        }
     } 
     if(Thread.currentThread()==运动员_2)
     { while(true)
        {   x=x+1;
            mypen.setColor(Color.red);
            mypen.clearRect(105,80,150,100);//显示线程运动的动画。 
            mypen.fillRect(x+5,85,7,7); 
            try  {
                  运动员_2.sleep(10);
                 }
            catch(InterruptedException e)
                 {text.setText("到达终点"); return; 
                 }
            if(x>=200)             //运动员_2跑到200米处时结束生命。
                {运动员_2.interrupt();
                }

        }
    }
  }  
}



19-例子13
 
import java.awt.*;import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;import java.applet.*;
public class Clock extends Applet implements Runnable
{   Thread 时针=null,分针=null,秒针=null;//用来表示时针,分针和秒针的线程.
     //表示时针,分针,秒针端点的整型变量:
     int hour_a,hour_b,munite_a,munite_b,second_a,second_b;
     //用来获取当前时间的整型变量:
     int hour=0,munite=0,second=0;
     //用来绘制时针,分针和秒针的Grapghics对象:
     Graphics g_second=null,g_munite=null,g_hour=null;
     //用来存放表盘刻度的数组,供指针走动时使用:
     double point_x[]=new double[61], point_y[]=new double[61] ;
     //用来存放表盘刻度的数组,供绘制表盘使用:
     double scaled_x[]=new double[61], scaled_y[]=new double[61] ;
    //用来判断小程序是否重新开始的变量:
      int start_count=0;
   public void init()
   { g_hour=this.getGraphics();   g_hour.setColor(Color.cyan);
     g_second=this.getGraphics(); g_second.setColor(Color.red); 
     g_munite=this.getGraphics(); g_munite.setColor(Color.blue);
     g_second.translate(200,200); //进行坐标系变换,将新坐标系的原点设在(200,200)处.
     g_munite.translate(200,200);
     g_hour.translate(200,200);
     point_x[0]=0;point_y[0]=-120; //各个时针十二点处的位置坐标(按新坐标系的坐标).
     scaled_x[0]=0;scaled_y[0]=-140; //十二点处的刻度位置坐标(按新坐标系的坐标).
     double jiaodu=6*Math.PI/180;
     //表盘分割成60分,将分割点处的坐标存放在数组中:
     for(int i=0;i<60;i++)
        { point_x[i+1]=point_x[i]*Math.cos(jiaodu)-Math.sin(jiaodu)*point_y[i];
          point_y[i+1]=point_y[i]*Math.cos(jiaodu)+ point_x[i]*Math.sin(jiaodu);
        }
    point_x[60]=0;point_y[60]=-120; //十二点处各个时针的位置坐标(按新坐标系的坐标).
    //表盘分割成60分,将分割点处的坐标存放在数组中:
     for(int i=0;i<60;i++)
        { scaled_x[i+1]=scaled_x[i]*Math.cos(jiaodu)-Math.sin(jiaodu)*scaled_y[i];
          scaled_y[i+1]=scaled_y[i]*Math.cos(jiaodu)+scaled_x[i]*Math.sin(jiaodu);
        }
     scaled_x[60]=0; scaled_y[60]=-140; //十二点处刻度位置坐标(按新坐标系的坐标).
   }
   public void start()
   { //每当小程序重新开始时,首先消灭线程,然后重新开始创建线程.
     if(start_count>=1)
     {秒针.interrupt();分针.interrupt();时针.interrupt();
     }
     秒针=new Thread(this);
     分针=new Thread(this);
     时针=new Thread(this);
     秒针.start();
     分针.start();
     时针.start(); 
     start_count++;if(start_count>=2) start_count=1; 
   }
 
   public void stop()
   {秒针.interrupt();分针.interrupt();时针.interrupt();
   }
   public void paint(Graphics g)
   {  //每当小程序重新绘制自己时,重新开始创建线程:
          this.start();
         //绘制表盘的外观:
         g.drawOval(50,50,300,300);//表盘的外圈.
         g.translate(200,200);
        //绘制表盘上的小刻度和大刻度:
        for(int i=0;i<60;i++)
           { if(i%5==0)
                { g.setColor(Color.red);
                  g.fillOval((int) scaled_x[i],(int) scaled_y[i],8,8);
                }
             else
               g.fillOval((int) scaled_x[i],(int) scaled_y[i],3,3);
           }
        
  }
  public void run()
  { //获取本地时间:
    Date date=new Date();
    String s=date.toString();
    hour=Integer.parseInt(s.substring(11,13));  
    munite=Integer.parseInt(s.substring(14,16));
    second=Integer.parseInt(s.substring(17,19));    
    
    if(Thread.currentThread()==秒针)
      {     
            second_a=(int)point_x[second];second_b=(int)point_y[second];
            g_second.drawLine(0,0,second_a,second_b); //秒针的初始位置.
            g_second.drawString("秒",second_a,second_b);
            int i=second;
          while(true)  //秒针开始行走,每一秒走6度.
            {
             try{秒针.sleep(1000);
                  Color c=getBackground();
                  g_second.setColor(c);
                  g_second.drawLine(0,0,second_a,second_b);//用背景色清除前一秒时的秒针.
                  g_second.drawString("秒",second_a,second_b);
                  //如果这时秒针与分针重合,恢复分针的显示:
                  if((second_a==munite_a)&&(second_b==munite_b))
                   { g_munite.drawLine(0,0,munite_a,munite_b);
                     g_munite.drawString("分",munite_a,munite_b);
                   } 
                  //如果这时秒针与时针重合,恢复时针的显示:
                  if((second_a==hour_a)&&(second_b==hour_b))
                   { g_hour.drawLine(0,0,hour_a,hour_b);
                    g_hour.drawString("时",hour_a,hour_b);
                   } 
                 }
             catch(InterruptedException e)
                 { Color c=getBackground();g_second.setColor(c);
                  g_second.drawLine(0,0,second_a,second_b);//用背景色清除秒针.
                  g_second.drawString("秒",second_a,second_b);
                  return;
                 }
             //秒针向前走一个单位: 
             second_a=(int)point_x[(i+1)%60];
             second_b=(int)point_y[(i+1)%60];//每一秒走6度(一个单位格).
             g_second.setColor(Color.red); 
             g_second.drawLine(0,0,second_a,second_b);   //绘制新的秒针.
             g_second.drawString("秒",second_a,second_b);
             i++;
           }
      }  
    if(Thread.currentThread()==分针)
      {  
          munite_a=(int)point_x[munite];munite_b=(int)point_y[munite];
          g_munite.drawLine(0,0,munite_a,munite_b);//分针的初始位置.
          g_munite.drawString("分",munite_a,munite_b);
          int i=munite;
          while(true)
           {     //第一次,过60-second秒就前进一分钟,以后每过60秒前进一分钟
                 try{分针.sleep(1000*60-second*1000);second=0;
                  Color c=getBackground();
                  g_munite.setColor(c);
                  g_munite.drawLine(0,0,munite_a,munite_b);//用背景色清除前一分钟时的分针.
                  g_munite.drawString("分",munite_a,munite_b);
                  //如果这时分针与时针重合,恢复时针的显示:
                   if((hour_a==munite_a)&&(hour_b==munite_b))
                   { g_hour.drawLine(0,0,hour_a,hour_b);
                     g_hour.drawString("时",hour_a,hour_b);
                   } 
                 }
            catch(InterruptedException e)
                 {return;
                 } 
                //分针向前走一个单位:
                munite_a=(int)point_x[(i+1)%60];
                munite_b=(int)point_y[(i+1)%60];//分针每分钟走6度(一个单位格).
                g_munite.setColor(Color.blue);
                g_munite.drawLine(0,0,munite_a,munite_b);//绘制新的分针.
                g_munite.drawString("分",munite_a,munite_b);
                i++;   second=0;         
           }
      } 
    if(Thread.currentThread()==时针)
      {     int h=hour%12;
            hour_a=(int)point_x[h*5+munite/12];hour_b=(int)point_y[h*5+munite/12];  
            int i= h*5+munite/12;      
            g_hour.drawLine(0,0,hour_a,hour_b);
            g_hour.drawString("时",hour_a,hour_b);
          while(true)
           {   //第一次,过12-munite%12分钟就前进一个刻度,以后每过12分钟前进一个刻度.          
             try{时针.sleep(1000*60*12-1000*60*(munite%12)-second*1000);munite=0;
                 Color c=getBackground();
                 g_hour.setColor(c);
                 g_hour.drawLine(0,0,hour_a,hour_b);// 用背景色清除前12分钟时的时针. 
                 g_hour.drawString("时",hour_a,hour_b);
                }
             catch(InterruptedException e)
                {return;
                } 
              hour_a=(int)point_x[(i+1)%60];
              hour_b=(int)point_y[(i+1)%60];//时针每12分走6度(一个单位格)
              g_hour.setColor(Color.cyan);
              g_hour.drawLine(0,0,hour_a,hour_b);//绘制新的时针.
              g_hour.drawString("时",hour_a,hour_b);
              i++; munite=0;
           }
      }   
 } 
}