hannoitower.java

程序简明清晰

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class HannoiTower extends JPanel implements MouseListener,MouseMotionListener  //用接口实现多重继承
{
   TowerPoint point[];         //定义各变量                                 
   int x,y;                                                     
   boolean move=false;                                         
   Disk   盘子[];                                              
   int startX,startY;                                          
   int startI ;                                                
   int 盘子数目=0;
   int width,height;                                           
   char towerName[]={'A','B','C'};                            
   TextArea 信息条=null;                                      

   public  HannoiTower(int number,int w,int h,char[] name,TextArea text)  //构造方法
   {
        towerName=name;          //初始化各变量
        盘子数目=number;
        width=w;
        height=h;
        信息条=text;
        setLayout(null);
        addMouseListener(this);
        addMouseMotionListener(this);
        盘子= new Disk[盘子数目];    //为数组元素开辟空间
        point=new TowerPoint[3*盘子数目];                         
         int space=20;  
        for(int i=0;i<盘子数目;i++)     //为盘子的大小、位置开辟空间                          
          {
            point[i]=new TowerPoint(40+width,100+space,false); 
            space=space+height;
          }
        space=20;
        for(int i=盘子数目;i<2*盘子数目;i++)                        
          {
            point[i]=new TowerPoint(160+width,100+space,false);
            space=space+height;
          }
        space=20;
        for(int i=2*盘子数目;i<3*盘子数目;i++)                     
          {
            point[i]=new TowerPoint(280+width,100+space,false);
            space=space+height;
          }
       int tempWidth=width;                                      
       int sub=(int)(tempWidth*0.2);
       for(int i=盘子数目-1;i>=0;i--)                            
          {
             盘子[i]=new Disk(i,this);      //为数组开辟空间
             盘子[i].setSize(tempWidth,height);  //引用对象的方法                 
             tempWidth=tempWidth-sub;
          }
        for(int i=0;i<盘子数目;i++)                             
          {
            point[i].放置盘子(盘子[i],this);  //所放盘子位置
            if(i>=1)
            盘子[i].set上方有盘(true);   //判断是否有盘子
          }
    }
  public void paintComponent(Graphics g)     //盘子的绘制                
   {
     super.paintComponent(g);
     g.drawLine(point[0].getX(),point[0].getY(),    //盘子的边线       
                point[盘子数目-1].getX(),point[盘子数目-1].getY());     
     g.drawLine(point[盘子数目].getX(),point[盘子数目].getY(),
                point[2*盘子数目-1].getX(),point[2*盘子数目-1].getY()); 
     g.drawLine(point[2*盘子数目].getX(),point[2*盘子数目].getY(),
                point[3*盘子数目-1].getX(),point[3*盘子数目-1].getY()); 
     g.drawLine(point[盘子数目-1].getX()-width,point[盘子数目-1].getY(),
               point[3*盘子数目-1].getX()+width,point[3*盘子数目-1].getY()); 
     int leftx=point[盘子数目-1].getX()-width;   //盘子在X方向的位置
     int lefty=point[盘子数目-1].getY();         //盘子在Y方向的位置
     int w=(point[3*盘子数目-1].getX()+width)-(point[盘子数目-1].getX()-width);  //盘子宽度
     int h=height/2;           //盘子高度
     g.setColor(Color.orange);      //矩形颜色
     g.fillRect(leftx,lefty,w,h);  //矩形位置
     
     g.setColor(Color.red);   //点的颜色
     int size=4;
     for(int i=0;i<3*盘子数目;i++)                                    
       {
         g.fillOval(point[i].getX()-size/2,point[i].getY()-size/2,size,size);   //点的位置
       }
     g.drawString(""+towerName[0]+"塔",point[盘子数目-1].getX(),point[盘子数目-1].getY()+30);    //塔A
     g.drawString(""+towerName[1]+"塔",point[2*盘子数目-1].getX(),point[盘子数目-1].getY()+30);  //塔B
     g.drawString(""+towerName[2]+"塔",point[3*盘子数目-1].getX(),point[盘子数目-1].getY()+30);  //塔C
     
     g.drawString("将全部盘子从"+towerName[0]+"塔搬运到"+towerName[1]+"塔或"+towerName[2]+"塔",
                  point[盘子数目-1].getX(),point[盘子数目-1].getY()+80);     //将盘子搬到塔B或塔C   
   } 
  public void mousePressed(MouseEvent e)  //鼠标单击时
  { 
    Disk  盘子=null;         
    Rectangle rect=null;     //初始化矩形
    if(e.getSource()==this)                                 
        move=false;
    if(move==false)
      if(e.getSource() instanceof Disk)  
       {
         盘子=(Disk)e.getSource();                        
         startX=盘子.getBounds().x;                         
         startY=盘子.getBounds().y;     
         
          rect=盘子.getBounds();
          for(int i=0;i<3*盘子数目;i++)   
            {
               int x=point[i].getX();
               int y=point[i].getY();
                  if(rect.contains(x,y))
                   {                   
                     startI=i;                            
                     break;
                   }
            }
       }
  } 
 public void mouseMoved(MouseEvent e)    
  { 
  }
 public void mouseDragged(MouseEvent e)  //鼠标拖动盘子时
  {
 
    Disk disk=null;
       if(e.getSource() instanceof Disk)
         {
           disk=(Disk)e.getSource();     //返回触发此事件的对象                   
           move=true; 
           
           e=SwingUtilities.convertMouseEvent(disk,e,this); 
         }
    
       if(e.getSource()==this)
        {
          if(move&&disk!=null)
           {
            x=e.getX(); 
            y=e.getY();
            if(disk.get上方有盘()==false)
               disk.setLocation(x-disk.getWidth()/2,y-disk.getHeight()/2);
           }
        }
 }
 public void mouseReleased(MouseEvent e)   //鼠标释放盘子时
  { 
    Disk disk=null;
    move=false;
    Rectangle rect=null;
    if(e.getSource() instanceof Disk)  //测试它左边的对象是否是它右边的类的实例
      {
        disk=(Disk)e.getSource();                            
        rect=disk.getBounds();
         
        e=SwingUtilities.convertMouseEvent(disk,e,this);  //Swing 实用方法的集合  
      }
    if(e.getSource()==this)
     {
        boolean containTowerPoint=false;
        int x=0,y=0;
        int endI=0;
        if(disk!=null)
         { 
          for(int i=0;i<3*盘子数目;i++)
            {
                x=point[i].getX();
                y=point[i].getY();
                if(rect.contains(x,y))
                   { 
                     containTowerPoint=true;
                     endI=i;
                     break;
                  }
            }
         }
        if(disk!=null&&containTowerPoint)
         {
         
           if(point[endI].是否有盘子()==true)        
             { 
               disk.setLocation(startX,startY);                        
             } 
          else
             {
 
                if(endI==盘子数目-1||endI==2*盘子数目-1||endI==3*盘子数目-1)  
                 { 
                  point[endI].放置盘子(disk,this);                       
                  
                  if(startI!=盘子数目-1&&startI!=2*盘子数目-1&&startI!=3*盘子数目-1)
                    {
                     (point[startI+1].获取盘子()).set上方有盘(false);
                     point[startI].set有盘子(false);     
                    }
                  else
                    {
                       point[startI].set有盘子(false);  
                    } 
                 } 
                else 
                 { 
                   if(point[endI+1].是否有盘子()==true)
                    {
                      Disk tempDisk=point[endI+1].获取盘子();
                      if((tempDisk.getNumber()-disk.getNumber())>=1)
                       {
                        point[endI].放置盘子(disk,this);                
                         if(startI!=盘子数目-1&&startI!=2*盘子数目-1&&startI!=3*盘子数目-1)
                          {
                            (point[startI+1].获取盘子()).set上方有盘(false);
                             point[startI].set有盘子(false); 
                             tempDisk.set上方有盘(true);   
                          }
                         else
                          {
                             point[startI].set有盘子(false); 
                             tempDisk.set上方有盘(true); 
                          } 
                       }
                      else
                       {
                         disk.setLocation(startX,startY); 
                       }
                    }
                   else
                    {
                      disk.setLocation(startX,startY);                   
                    }
                 } 
            }
        
                
        }
     if(disk!=null&&!containTowerPoint)        
        {        
          disk.setLocation(startX,startY);
        }
     } 
  }
 public void mouseEntered(MouseEvent e)
  {
  }
 public void mouseExited(MouseEvent e)
  { 
  }
 public void mouseClicked(MouseEvent e)
  { 
  }
 
 public void 自动演示搬运盘子(int 盘子数,char one,char two,char three)  //点击自动演示按钮后
  {
     if(盘子数==1)
       {
         信息条.append(""+one+" 到: "+three+"塔\n"); //文本框中文字的显示
         Disk disk=在塔中获取最上面的盘子(one);      
         int startI=在塔中获取最上面盘子的位置(one);
         int endI=在塔中获取最上面盘子的上方位置(three);                 
         if(disk!=null)
           {
             point[endI].放置盘子(disk,this);
             point[startI].set有盘子(false);
              try{
                  Thread.sleep(1000);      //将当前线程阻塞指定的毫秒数
                 
                 }
              catch(Exception ee)
                 {
                 }
           }
        }
      else
        {
          自动演示搬运盘子(盘子数-1,one,three,two); //移动一个盘子后
	  信息条.append(""+one+" 到: "+three+"塔\n");
          Disk disk=在塔中获取最上面的盘子(one);  
          int startI=在塔中获取最上面盘子的位置(one);
          int endI=在塔中获取最上面盘子的上方位置(three);                 
          if(disk!=null)
            {
             point[endI].放置盘子(disk,this);
             point[startI].set有盘子(false);
             try {
                  Thread.sleep(1000);                       
                 }
              catch(Exception ee)
                 {
                 }
            } 
	  自动演示搬运盘子(盘子数-1,two,one,three);
        }
  }
 public Disk 在塔中获取最上面的盘子(char 塔名)  //获取上面盘子
  {
    Disk disk=null;
    if(塔名==towerName[0])           //判断塔A
      {
         for(int i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
     if(塔名==towerName[1])           //判断塔B
      {
         for(int i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
      if(塔名==towerName[2])         //判断塔C
      {
         for(int i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
   return disk;
  } 
 public int 在塔中获取最上面盘子的上方位置(char 塔名)  //上面盘子的上方位置
  {
    int position=0;
    if(塔名==towerName[0])
      {  
         int i=0;
         for(i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);   //返回两个整数中较大的一个
                 break;
               }
           } 
         if(i==盘子数目)
           {
             position=盘子数目-1;
           } 
      }
     if(塔名==towerName[1])
      {  
          int i=0;
         for(i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);
                 break;
               }
           } 
          if(i==2*盘子数目)
           {
             position=2*盘子数目-1;
           }  
      }
      if(塔名==towerName[2])
      {
         int i=0;
         for(i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);
                 break;
               }
           }  
          if(i==3*盘子数目)
           {
             position=3*盘子数目-1;
           }  
      }
    return position;
  } 
  public int 在塔中获取最上面盘子的位置(char 塔名)
  {
    int position=0;
    if(塔名==towerName[0])
      {  
         int i=0;
         for(i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           } 
         if(i==盘子数目)
           {
             position=盘子数目-1;
           } 
      }
     if(塔名==towerName[1])
      {  
          int i=0;
         for(i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           } 
          if(i==2*盘子数目)
           {
             position=2*盘子数目-1;
           }  
      }
      if(塔名==towerName[2])
      {
         int i=0;
         for(i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           }  
          if(i==3*盘子数目)
           {
             position=3*盘子数目-1;
           }  
      }
    return position;
  } 
}