很不错的一个汉诺塔演示动画（Java版本）

最新推荐文章于 2021-03-11 09:35:41 发布
最新推荐文章于 2021-03-11 09:35:41 发布
阅读量2.4k 收藏 10
点赞数 3
分类专栏： Java JDK解读 文章标签： awt java Java JAVA swing Swing 动画 汉诺塔 
/**
 * 盘子类
 * @author Sking
 */
package component.Animation.HannoiTower;

import java.awt.*;

public class Disk extends Button {
	int number;
	boolean 上方有盘 = false;

	/**
	 *Disk类的构造方法
	 * @param number 盘子号
	 * @param con HannoiTower对象
	 */
	public Disk(int number, HannoiTower con) {
		this.number = number;
		setBackground(Color.blue);
		addMouseMotionListener(con);//添鼠标移动事件监听器
		addMouseListener(con);//添加鼠标监听器
	}

	/**
	 * 检测当前盘子上方是否有盘子
	 * @return true表示当前盘子上方有盘子
	 */
	public boolean get上方有盘() {
		return 上方有盘;
	}

	/**
	 * 设置当前盘子上方是否含有盘子
	 * @param b 设置值
	 */
	public void set上方有盘(boolean b) {
		上方有盘 = b;
	}

	/**
	 * 获取当前盘子号
	 * @return 盘子号 
	 */
	public int getNumber() {
		return number;
	}
}


 

package component.Animation.HannoiTower;
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;
     int lefty=point[盘子数目-1].getY();
     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);
     g.drawString(""+towerName[1]+"塔",point[2*盘子数目-1].getX(),point[盘子数目-1].getY()+30);
     g.drawString(""+towerName[2]+"塔",point[3*盘子数目-1].getX(),point[盘子数目-1].getY()+30);

     g.drawString("将全部盘子从"+towerName[0]+"塔搬运到"+towerName[1]+"塔或"+towerName[2]+"塔",
                  point[盘子数目-1].getX(),point[盘子数目-1].getY()+80);
   }
  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);
      }
    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])
      {
         for(int i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }
      }
     if(塔名==towerName[1])
      {
         for(int i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }
      }
      if(塔名==towerName[2])
      {
         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;
  }
}


 

/**
 * 塔类
 * @author Sking
 */
package component.Animation.HannoiTower;

import java.awt.*;
import java.awt.event.*;

public class Tower extends Frame implements ActionListener, Runnable {
	HannoiTower tower = null;
	Button renew, auto = null;
	char towerName[] = { 'A', 'B', 'C' };
	int 盘子数目, 盘宽, 盘高;
	Thread thread;
	TextArea 信息条 = null;

	public Tower() {
		thread = new Thread(this);
		盘子数目 = 5;
		盘宽 = 80;
		盘高 = 18;
		信息条 = new TextArea(12, 12);
		信息条.setText(null);
		tower = new HannoiTower(盘子数目, 盘宽, 盘高, towerName, 信息条);
		renew = new Button("重新开始");
		auto = new Button("自动演示搬盘子");
		renew.addActionListener(this);
		auto.addActionListener(this);
		add(tower, BorderLayout.CENTER);
		add(renew, BorderLayout.SOUTH);
		add(auto, BorderLayout.NORTH);
		add(信息条, BorderLayout.EAST);
		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		setVisible(true);
		setBounds(60, 20, 670, 540);
		validate();
	}

	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == renew) {
			if (!(thread.isAlive())) {
				this.remove(tower);
				信息条.setText(null);
				tower = new HannoiTower(盘子数目, 盘宽, 盘高, towerName, 信息条);
				add(tower, BorderLayout.CENTER);
				validate();
			} else {
			}
		}
		if (e.getSource() == auto) {
			if (!(thread.isAlive())) {
				thread = new Thread(this);
			}
			try {

				thread.start();
			} catch (Exception eee) {
			}

		}
	}

	public void run() {
		this.remove(tower);
		信息条.setText(null);
		tower = new HannoiTower(盘子数目, 盘宽, 盘高, towerName, 信息条);
		add(tower, BorderLayout.CENTER);
		validate();
		tower.自动演示搬运盘子(盘子数目, towerName[0], towerName[1], towerName[2]);
	}

	public static void main(String args[]) {
		new Tower();
	}
}


 

package component.Animation.HannoiTower;
public class TowerPoint
{
   int x,y;
   boolean 有盘子;
   Disk 盘子=null;
   HannoiTower con=null;
   public TowerPoint(int x,int y,boolean boo)
   {
      this.x=x;
      this.y=y;
      有盘子=boo;
   }
  public boolean 是否有盘子()
  {
    return 有盘子;
  }
  public void set有盘子(boolean boo)
  {
    有盘子=boo;
  }

  public int getX()
  {
    return x;
  }
  public int getY()
  {
    return y;
  }
  public void 放置盘子(Disk 盘子,HannoiTower con)
  {
     this.con=con;
     con.setLayout(null);
     this.盘子=盘子;
     con.add(盘子);
     int w=盘子.getBounds().width;
     int h=盘子.getBounds().height;
     盘子.setBounds(x-w/2,y-h/2,w,h);
     有盘子=true;
     con.validate();
  }
  public Disk 获取盘子()
  {
     return 盘子;
  }
}


 

originalIntention
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 图片运动轨迹_Java如何让多个图片都按照一定轨迹下落
weixin_33042659的博客
02-13 851
展开全部图片62616964757a686964616fe78988e69d8331333431346439的位移(下落),可以通过修改图片的x,y坐标来实现, 在Swing/Html中,我们可以使用Timer定时(比如每隔100毫秒)去修改图片的x,y坐标即可实现,多个图片都按照一定的轨迹移动,那都按照自己的轨迹的算法,去定时修改x,y坐标即可.JavaFX是java先进的图形界面框架, 里面有...
汉诺塔 Java 简单实现小程序
steven_cici的博客
10-07 505
算法描述： 汉诺塔主要是有三个塔座X，Y，Z，要求将三个大小不同，依小到大编号为1，2…n的圆盘从A移动到塔座Z上，要求 （1）：每次只能移动一个圆盘 （2）：圆盘可以插到X，Y，Z中任一塔座上 （3）：任何时候不能将一个较大的圆盘压在较小的圆盘之上 程序实现逻辑： 汉诺塔的算法就3个步骤： 【1】把a上的n-1个盘通过c移动到b。 【2】把a上的最下面的盘移到c。 【3】因为n-1个盘全在b上了...
基于Java实现的Hannoi汉诺塔自动演示程序
qq_38474871的博客
07-18 894
1 设计要求设计GUI界面的Hannoi塔。汉诺塔中有三个座，名字分别为A，B，C。初始状态时A塔上有3个大小不等的盘子，这些盘子从座底到座顶按着大小顺序依次摆放在A座上。用户可以用鼠标选中盘子，然后通过拖动鼠标来移动盘子。释放鼠标来放置该盘子。程序要求用户在移动盘子的过程中，不允许吧大盘子放置在小盘子的上面，用户最终要完成的是把A座上的全部盘子移动到B座...
swingAnimation:一个java swing画布实现动画的小例子 加入了鼠标与键盘监听
05-15
swingAnimation 一个java swing实现动画的小例子 加入了鼠标与键盘监听 完成功能为 在画布中右几个运动的空心小球，小球运动方向速度随机生成 小球碰撞墙壁会反弹 但是小球与小球间的碰撞未检测 按下键盘空格键会停止运动 鼠标点击小球，对应小球会变为实心小球
汉诺塔：动画过程绘制实现
清玄逸梦
11-13 8928
Tower of Hanoi 状态空间算法 动画绘制实现 C语言
Java Swing模拟水波纹扩散效果动画
xidajiancun
11-03 627
基于Java语言模拟水波纹运动效果，分为两种方法，一种采用简单的叠加计算 不使用sine函数模拟水波纹，好处是计算量小，另外一种采用sine函数来计算 水波纹扩展，计算量大，但是效果比较真实。 第一种简单的叠加效果水波模拟，是很多简单的2D游戏中会用的，关键是计 算水波的迁移，然后剩以能量衰减因子。Java实现的代码如下： for(y=1; y&lt;waveWidth-1; y...
精灵说科技 java,Java动画动画(精灵)
weixin_39897015的博客
03-11 146
您好我有一个问题：当我运行此代码时,我得到这个：在一些java论坛上他们说我需要添加Graphics2DObject.clearRect(x1,y1,x2,y2);(其中`x1和y1是图像的坐标,x2 y2是图像的宽度高度.)当我将它添加到代码中时我得到：代码(附加功能)：主要：import java.awt.*;import javax.swing.*;public class Main {pu...
java实现汉诺塔演示及手动操作汉诺塔
05-31
汉诺塔是一个经典的递归问题，...通过阅读代码，我们可以看到如何将理论的汉诺塔算法与Java GUI编程结合在一起，实现了一个交互式的汉诺塔游戏。这对于学习Java编程、递归算法以及图形用户界面设计都是很好的实践案例。
hannuo.rar_汉诺塔_汉诺塔演示
09-21
在"汉诺塔的图形演示"中，很可能包含了一个交互式的程序或者动画，用于直观展示这个过程。用户可能可以通过该程序动态观察圆盘的移动，理解递归算法如何应用于实际问题中。"www.pudn.com.txt"可能是提供下载资源或更...
hnt.rar_hnt_汉诺塔演示_演示 程序 运行 过程
09-23
在Java中实现汉诺塔演示程序，你需要创建一个主类，包含一个主方法，以及一个用于处理递归的`hanoi`方法。主方法负责初始化并调用`hanoi`，而`hanoi`方法则根据递归规则移动圆盘。此外，为了增加可视化效果，程序...
Java课程设计 飞机大战 源项目文件及实验报告
07-12
Java课程设计 飞机大战 源项目文件及实验报告，本课程设计通过代码实现将理论知识和具体实践相结合，巩固提高了对JAVA的相关方法与概念的理解，进一步加强了学生的发散思维及动手能力，加强了学生对计算机及软件工程的进一步了解。
java 3d 人体行走模拟程序
03-08
java 3d 人体行走模拟程序 主要运用TransformGroup,Behavior
flash小游戏汉诺塔-Flash文档类资源
07-01
这是一个关于汉诺塔的flash小游戏，适合做各种设计
java汉诺塔动画实现
03-08
汉诺塔游戏是一种经典的递归问题，...总之，这个Java汉诺塔动画项目提供了一个很好的实践平台，可以帮助我们巩固递归、对象导向编程和GUI设计的概念。通过深入研究和改进这个项目，我们可以进一步提升自己的编程技能。
java动态演示汉诺塔
11-06
汉诺塔是一个经典的递归问题，它源自印度的一个古老传说，涉及将一组盘子从一根柱子移动到另一根柱子，遵循特定的规则。...对于想要提升Java GUI编程和递归算法理解的开发者来说，这是一个很好的学习资源。
Java图片百叶窗_经典代码收藏之——百叶窗特效的Java实现 | 学步园
weixin_30958737的博客
03-02 355
import javax.swing.*;import java.awt.*;import java.awt.Event;import javax.swing.event.*;import java.awt.image.BufferedImage;class TransitionTabbedPane extends JTabbedPaneimplements ChangeListener, Run...
关于Java swing双缓存实现消除闪烁
青春的光与影
11-02 5571
这几天一直纠结游戏界面的淡入淡出怎么实现。之前终于了解可以用AlphaComposite修改图片的alpha值，加以延时可以实现淡入淡出，但界面闪得很厉害。   之前做图形编程的时候也知道，这是图片没有绘制完成然后显示到屏幕的原因。什么意思呢？就比方说一个运动的小球，实现的效果是先画小球，然后擦除，然后在新位置重绘小球。显然，擦除是不应该被显示到屏幕上的。小球到重绘的时候再显示到屏幕才是。曾经用
java swing 抽屉_使用Java Swing滑动抽屉动画
weixin_29543187的博客
02-13 359
小编典典根据要实现的目标，您可以采用多种可能的方法。基本方法是简单地绘制图形和摆动Timer这样您就可以简单地更新一个变量，该变量将作为绘制大小的基础，例如…import java.awt.BorderLayout;import java.awt.Color;import java.awt.Dimension;import java.awt.EventQueue;import java.awt.G...
java swing 抽屉,使用Java Swing滑动抽屉动画
weixin_34846784的博客
02-13 171
I am new to swing and designing an interface using java swing. I want a drawer to pull out with sliding animation on a button click. Firstly, is it possible to do so and if yes, how do I do it. Thank ...
汉诺塔游戏动画演示 java代码
最新发布
05-02
而在实现汉诺塔游戏的过程中，Java语言被广泛应用，下面介绍一下Java实现汉诺塔游戏动画演示的代码。 在Java中实现汉诺塔游戏动画演示的关键其实就是利用递归的思想来求解游戏。具体实现步骤如下： 1. 定义汉诺塔...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值