用JAVA实现动画,汉诺塔,和冒泡排序
汉诺塔 java 程序
汉诺塔java 程序import java.awt.*;import java.awt.event.*;import javax.swing.*;public class AutoMoveDisc extends JDialog implements ActionListener{ int amountOfDisc=3;TowerPoint [] pointA,pointB,pointC;char [] towerName;Container con;StringBuffer moveStep;JTextArea showStep;JButton bStart,bStop,bContinue,bClose;Timer time;int i=0,number=0;AutoMoveDisc(Container con){setModal(true);setTitle("自动演示搬盘子过程");this.con=con;moveStep=new StringBuffer();time=new Timer(1000,this);time.setInitialDelay(10);showStep=new JTextArea(10,12);bStart=new JButton("演示");bStop=new JButton("暂停");bContinue=new JButton("继续");bClose=new JButton("关闭");bStart.addActionListener(this);bStop.addActionListener(this);bContinue.addActionListener(this);bClose.addActionListener(this);JPanel south=new JPanel();south.setLayout(new FlowLayout());south.add(bStart);south.add(bStop);south.add(bContinue);south.add(bClose);add(new JScrollPane(showStep),BorderLayout.CENTER);add(south,BorderLayout.SOUTH);setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);towerName=new char[3];addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){time.stop();setVisible(false);}});}public void setPointA(TowerPoint [] pointA){this.pointA=pointA;}public void setPointB(TowerPoint [] pointB){this.pointB=pointB;}public void setPointC(TowerPoint [] pointC){this.pointC=pointC;}public void setTowerName(char name[]){if(name[0]==name[1]||name[0]==name[2]||name[1]==name[2]){towerName[0]='A';towerName[1]='B';towerName[2]='C';}elsetowerName=name;}public void setAmountOfDisc(int n){amountOfDisc=n;}public void actionPerformed(ActionEvent e) {if(e.getSource()==time){number++;char cStart,cEnd;if(i<=moveStep.length()-2){cStart=moveStep.charAt(i);cEnd=moveStep.charAt(i+1);showStep.append("("+number+")从"+cStart+"座搬一个盘子到"+cEnd+"座\n");autoMoveDisc(cStart,cEnd);}i=i+2;if(i>=moveStep.length()-1){time.stop();}}else if(e.getSource()==bStart){if(moveStep.length()==0){if(time.isRunning()==false){i=0;moveStep=new StringBuffer();setMoveStep(amountOfDisc,towerName[0],towerName[1],towerName[2]);number=0;time.start();}}}else if(e.getSource()==bStop){if(time.isRunning()==true)time.stop();}else if(e.getSource()==bContinue){if(time.isRunning()==false)time.restart();}else if(e.getSource()==bClose){time.stop();setVisible(false);}}private void setMoveStep(int amountOfDisc,char one,char two,char three){ if(amountOfDisc==1){moveStep.append(one);moveStep.append(three);}else{setMoveStep(amountOfDisc-1,one,three,two);moveStep.append(one);moveStep.append(three);setMoveStep(amountOfDisc-1,two,one,three);}}private void autoMoveDisc(char cStart,char cEnd){Disc disc=null;if(cStart==towerName[0]){for(int i=0;i<pointA.length;i++){if(pointA[i].isHaveDisc()==true){disc=pointA[i].getDiscOnPoint();pointA[i].setHaveDisc(false);break;}}}if(cStart==towerName[1]){for(int i=0;i<pointB.length;i++){if(pointB[i].isHaveDisc()==true){disc=pointB[i].getDiscOnPoint();pointB[i].setHaveDisc(false);break;}}}if(cStart==towerName[2]){for(int i=0;i<pointC.length;i++){if(pointC[i].isHaveDisc()==true){disc=pointC[i].getDiscOnPoint();pointC[i].setHaveDisc(false);break;}}}TowerPoint endPoint=null;int i=0;if(cEnd==towerName[0]){for(i=0;i<pointA.length;i++){if(pointA[i].isHaveDisc()==true){if(i>0){endPoint=pointA[i-1];break;}else if(i==0)break;}}if(i==pointA.length)endPoint=pointA[pointA.length-1];}if(cEnd==towerName[1]){for(i=0;i<pointB.length;i++){if(pointB[i].isHaveDisc()==true){if(i>0){endPoint=pointB[i-1];break;}else if(i==0)break;}}if(i==pointB.length)endPoint=pointB[pointB.length-1];}if(cEnd==towerName[2]){for(i=0;i<pointC.length;i++){if(pointC[i].isHaveDisc()==true){if(i>0){endPoint=pointC[i-1];break;}else if(i==0)break;}}if(i==pointC.length)endPoint=pointC[pointC.length-1];}if(endPoint!=null&&disc!=null){endPoint.putDisc(disc,con);endPoint.setHaveDisc(true);}}}import javax.swing.*;import java.awt.*;public class Disc extends JButton{int number;TowerPoint point;Disc(){setBackground(Color.cyan);}public void setNumber(int n){number=n;}public int getNumber(){return number;}public void setPoint(TowerPoint p){point=p;}public TowerPoint getPoint(){return point;}}import java.awt.event.*;import java.awt.*;public class HandleMouse implements MouseListener,MouseMotionListener { TowerPoint [] pointA,pointB,pointC;TowerPoint startPoint=null,endPoint=null;int leftX,leftY,x0,y0;boolean move=false,countTime=false;Container con;HandleMouse(Container con){this.con=con;}public void setPointA(TowerPoint [] pointA){this.pointA=pointA;}public void setPointB(TowerPoint [] pointB){this.pointB=pointB;}public void setPointC(TowerPoint [] pointC){this.pointC=pointC;}public void mousePressed(MouseEvent e){move=false;Disc disc=null;disc=(Disc)e.getSource();startPoint=disc.getPoint();x0=e.getX();y0=e.getY();int m=0;for(int i=0;i<pointA.length;i++){if(pointA[i].equals(startPoint)){m=i;if(m>0&&(pointA[m-1].isHaveDisc()==false)){move=true;break;}else if(m==0){move=true;break;}}}for(int i=0;i<pointB.length;i++){if(pointB[i].equals(startPoint)){m=i;if(m>0&&(pointB[m-1].isHaveDisc()==false)){move=true;break;}else if(m==0){move=true;break;}}}for(int i=0;i<pointC.length;i++){if(pointC[i].equals(startPoint)){m=i;if(m>0&&(pointC[m-1].isHaveDisc()==false)){move=true;break;}else if(m==0){move=true;break;}}}}public void mouseMoved(MouseEvent e){}public void mouseDragged(MouseEvent e){Disc disc=null;disc=(Disc)e.getSource();leftX=disc.getBounds().x;leftY=disc.getBounds().y;int x=e.getX();int y=e.getY();leftX=leftX+x;leftY=leftY+y;if(move==true)disc.setLocation(leftX-x0,leftY-y0);}public void mouseReleased(MouseEvent e){Disc disc=null;disc=(Disc)e.getSource();Rectangle rect=disc.getBounds();boolean location=false;int x=-1,y=-1;for(int i=0;i<pointA.length;i++){x=pointA[i].getX();y=pointA[i].getY();if(rect.contains(x,y)){endPoint=pointA[i];if(i==pointA.length-1&&endPoint.isHaveDisc()==false){location=true;break;}else if(i<pointA.length-1&&pointA[i+1].isHaveDisc()==true&&endPoint.isHaveDisc()==false&&pointA[i+1].getDiscOnPoint().getNumber()>disc.getNumber()){location=true;break;}}}for(int i=0;i<pointB.length;i++){x=pointB[i].getX();y=pointB[i].getY();if(rect.contains(x,y)){endPoint=pointB[i];if(i==pointB.length-1&&endPoint.isHaveDisc()==false){location=true;break;}else if(i<pointB.length-1&&pointB[i+1].isHaveDisc()==true&&endPoint.isHaveDisc()==false&&pointB[i+1].getDiscOnPoint().getNumber()>disc.getNumber()){location=true;break;}}}for(int i=0;i<pointC.length;i++){x=pointC[i].getX();y=pointC[i].getY();if(rect.contains(x,y)){endPoint=pointC[i];if(i==pointC.length-1&&endPoint.isHaveDisc()==false){location=true;break;}else if(i<pointC.length-1&&pointC[i+1].isHaveDisc()==true&&endPoint.isHaveDisc()==false&&pointC[i+1].getDiscOnPoint().getNumber()>disc.getNumber()){location=true;break;}}}if(endPoint!=null&&location==true){endPoint.putDisc(disc,con);startPoint.setHaveDisc(false);}elsestartPoint.putDisc(disc,con);}public void mouseEntered(MouseEvent e){}public void mouseExited(MouseEvent e){}public void mouseClicked(MouseEvent e){}}import javax.swing.*;import java.awt.*;import java.awt.event.*;public class HannoiWindow extends JFrame implements ActionListener{ Tower tower=null;int amountOfDisc=3;char []towerName={'A','B','C'};JMenuBar bar;JMenu menuGrade;JMenuItem oneGradeItem,twoGradeItem,threeGradeItem;JButton renew=null;JButton autoButton=null;JPanel center=new JPanel();HannoiWindow(){tower=new Tower(towerName);tower.setAmountOfDisc(amountOfDisc);tower.setMaxDiscWidth(120);tower.setMinDiscWidth(50);tower.setDiscHeight(16);tower.putDiscOnTower();add(tower,BorderLayout.CENTER);bar=new JMenuBar();menuGrade=new JMenu("选择级别");oneGradeItem=new JMenuItem("初级");twoGradeItem=new JMenuItem("中级");threeGradeItem=new JMenuItem("高级");menuGrade.add(oneGradeItem);menuGrade.add(twoGradeItem);menuGrade.add(threeGradeItem);bar.add(menuGrade);setJMenuBar(bar);oneGradeItem.addActionListener(this);twoGradeItem.addActionListener(this);threeGradeItem.addActionListener(this);renew=new JButton("重新开始");renew.addActionListener(this);autoButton=new JButton("自动演示");autoButton.addActionListener(this);JPanel north=new JPanel();north.add(renew);north.add(autoButton);String mess="将全部盘子从"+towerName[0]+"座搬运到"+towerName[1]+ "座或"+towerName[2]+"座";JLabel hintMess=new JLabel(mess,JLabel.CENTER);north.add(hintMess);add(north,BorderLayout.NORTH);setResizable(false);setVisible(true);setBounds(60,60,460,410);validate();setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}public void actionPerformed(ActionEvent e){if(e.getSource()==oneGradeItem){amountOfDisc=3;tower.setAmountOfDisc(amountOfDisc);tower.putDiscOnTower();}else if(e.getSource()==twoGradeItem){amountOfDisc=4;tower.setAmountOfDisc(amountOfDisc);tower.putDiscOnTower();}else if(e.getSource()==threeGradeItem){amountOfDisc=5;tower.setAmountOfDisc(amountOfDisc);tower.putDiscOnTower();}else if(e.getSource()==renew){tower.setAmountOfDisc(amountOfDisc);tower.putDiscOnTower();}else if(e.getSource()==autoButton){tower.setAmountOfDisc(amountOfDisc);tower.putDiscOnTower();int x=this.getBounds().x+this.getBounds().width;int y=this.getBounds().y;tower.getAutoMoveDisc().setLocation(x,y);tower.getAutoMoveDisc().setSize(280,this.getBounds().height);tower.getAutoMoveDisc().setVisible(true);}validate();}public static void main(String args[]){new HannoiWindow();}}import javax.swing.*;import java.awt.*;public class Tower extends JPanel{int amountOfDisc=3;Disc [] disc;int maxDiscWidth,minDiscWidth,discHeight;char [] towerName;TowerPoint [] pointA,pointB,pointC;HandleMouse handleMouse;AutoMoveDisc autoMoveDisc;Tower(char [] towerName){handleMouse=new HandleMouse(this);this.towerName=towerName;setLayout(null);setBackground(new Color(200,226,226));}public void setAmountOfDisc(int number){if(number<=1)amountOfDisc=1;elseamountOfDisc=number;}public void setMaxDiscWidth(int m){maxDiscWidth=m;}public void setMinDiscWidth(int m){minDiscWidth=m;}public void setDiscHeight(int h){discHeight=h;}public AutoMoveDisc getAutoMoveDisc(){return autoMoveDisc;}public void putDiscOnTower(){removeDisk();int n=(maxDiscWidth-minDiscWidth)/amountOfDisc;disc=new Disc[amountOfDisc];for(int i=0;i<disc.length;i++){disc[i]=new Disc();disc[i].setNumber(i);int diskwidth=minDiscWidth+i*n;disc[i].setSize(diskwidth,discHeight);disc[i].addMouseListener(handleMouse);disc[i].addMouseMotionListener(handleMouse);}pointA=new TowerPoint[amountOfDisc];pointB=new TowerPoint[amountOfDisc];pointC=new TowerPoint[amountOfDisc];int vertialDistance=discHeight;for(ii<pointA.nt i=0;length;i++){pointA[i]=new TowerPoint(maxDiscWidth,100+vertialDistance);vertialDistance=vertialDistance+discHeight;}vertialDistance=discHeight;for(int i=0;i<pointB.length;i++){pointB[i]=new TowerPoint(2*maxDiscWidth,100+vertialDistance);vertialDistance=vertialDistance+discHeight;}vertialDistance=discHeight;for(int i=0;i<pointC.length;i++){pointC[i]=new TowerPoint(3*maxDiscWidth,100+vertialDistance);vertialDistance=vertialDistance+discHeight;}for(int i=0;i<pointA.length;i++){pointA[i].putDisc(disc[i],this);}handleMouse.setPointA(pointA);handleMouse.setPointB(pointB);handleMouse.setPointC(pointC);autoMoveDisc=new AutoMoveDisc(this);autoMoveDisc.setTowerName(towerName);autoMoveDisc.setAmountOfDisc(amountOfDisc);autoMoveDisc.setPointA(pointA);autoMoveDisc.setPointB(pointB);autoMoveDisc.setPointC(pointC);validate();repaint();}public void removeDisk(){if(pointA!=null){for(int i=0;i<pointA.length;i++){pointA[i].removeDisc(pointA[i].getDiscOnPoint(),this);pointB[i].removeDisc(pointB[i].getDiscOnPoint(),this);pointC[i].removeDisc(pointC[i].getDiscOnPoint(),this);}}}public void paintComponent(Graphics g){super.paintComponent(g);int x1,y1,x2,y2;x1=pointA[0].getX();y1=pointA[0].getY()-discHeight/2;x2=pointA[amountOfDisc-1].getX();y2=pointA[amountOfDisc-1].getY()+discHeight/2;g.drawLine(x1,y1,x2,y2);x1=pointB[0].getX();y1=pointB[0].getY()-discHeight/2;x2=pointB[amountOfDisc-1].getX();y2=pointB[amountOfDisc-1].getY()+discHeight/2;g.drawLine(x1,y1,x2,y2);x1=pointC[0].getX();y1=pointC[0].getY()-discHeight/2;x2=pointC[amountOfDisc-1].getX();y2=pointC[amountOfDisc-1].getY()+discHeight/2;g.drawLine(x1,y1,x2,y2);g.setColor(Color.blue);x1=pointA[amountOfDisc-1].getX()-maxDiscWidth/2;y1=pointA[amountOfDisc-1].getY()+discHeight/2;x2=pointC[amountOfDisc-1].getX()+maxDiscWidth/2;y2=pointC[amountOfDisc-1].getY()+discHeight/2;int length=x2-x1,height=6;g.fillRect(x1,y1,length,height);int size=5;for(int i=0;i<pointA.length;i++){g.fillOval(pointA[i].getX()-size/2,pointA[i].getY()-size/2,size,size);g.fillOval(pointB[i].getX()-size/2,pointB[i].getY()-size/2,size,size);g.fillOval(pointC[i].getX()-size/2,pointC[i].getY()-size/2,size,size);}g.drawString(towerName[0]+"座",pointA[amountOfDisc-1].getX(),pointA[amountOfDisc-1].getY()+50);g.drawString(towerName[1]+"座",pointB[amountOfDisc-1].getX(),pointB[amountOfDisc-1].getY()+50);g.drawString(towerName[2]+"座",pointC[amountOfDisc-1].getX(),pointC[amountOfDisc-1].getY()+50);}}import java.awt.*;public class TowerPoint{int x,y;boolean haveDisc;Disc disc=null;public TowerPoint(int x,int y){this.x=x;this.y=y;}public boolean isHaveDisc(){return haveDisc;}public void setHaveDisc(boolean boo){haveDisc=boo;}public int getX(){return x;}public int getY(){return y;}public boolean equals(TowerPoint p){if(p.getX()==this.getX()&&p.getY()==this.getY())return true;elsereturn false;}public void putDisc(Component com,Container con){ disc=(Disc)com;con.setLayout(null);con.add(disc);int w=disc.getBounds().width;int h=disc.getBounds().height;disc.setBounds(x-w/2,y-h/2,w,h);haveDisc=true;disc.setPoint(this);con.validate();}public Disc getDiscOnPoint(){return disc;}public void removeDisc(Component com,Container con){ if(com!=null)con.remove(com);con.validate();}}。
汉诺塔游戏-----用C++编的
#ifndef HANIO_H_#define HANIO_Hclass Stack{private:enum{ MAX=50 };int m_node[MAX];int m_top;int m_size;int m_index;public:Stack();~Stack() { };bool Isfull() { return m_top==MAX-1 ;}; //堆栈满则返回TRUE bool Isempty() { return m_top==-1;}; //堆栈空则返回TRUE int Top() { return m_top; };int TopValue() { return m_node[m_top];};int GetDataFromIndex(int i) { return m_node[i]; };int GetIndex() { return m_index; } ;void SetIndex(int index) { m_index = index; };int Size() { return m_top+1; };bool Push(int data);bool Pop(int * pData);int MoveToNext();void OutPrint();};class Hanio{Stack m_stack[3];int m_num; //盘数int m_steps; //移动次数int m_times; //完成所用时间void print(char ch,int n);public:Hanio(int num=3);~Hanio() {};void GameStart();bool MoveFromTo(int x,int y); //从x号盘移动到y号盘void DrawPaletes(char ch='*'); //打印3个堆的盘子bool IsFinished() ; //结束返回TURE;int Solve(char from,char to,char auxiliary,int n); //求解其解法路径};#endif//hanio.cpp#include "hanio.h"#include <iostream>#include<cstdlib>#include<cstring>#include<cctype>#include<windows.h>Stack::Stack(){m_top=-1;m_index=m_top;for(int i=0;i<MAX;i++)m_node[i]=0;}bool Stack::Push(int data){if(Isfull())return false;m_top++;m_node[m_top]=data;m_index=m_top;return true;}bool Stack::Pop(int *pData){if(Isempty())return false;*pData=m_node[m_top];m_node[m_top]=0;m_top--;m_index=m_top;return true;}int Stack::MoveToNext(){int temp=m_index;m_index--;return m_node[temp];}void Stack::OutPrint(){if(m_top!=-1){for(int i=0;i<=m_top;i++)std::cout<<"["<<m_node[i]<<"]";}}///////////////////////////////////////Hanio::Hanio(int num){m_num=num;m_steps=0;m_times=0;for(int i=num;i>=1;i--)m_stack[0].Push(i);//m_stack[0].OutPrint();}void Hanio::print(char ch,int n){for(int i=1;i<=n;i++)std::cout<<ch;}void Hanio::DrawPaletes(char ch){int max;max=m_stack[0].Size()>m_stack[1].Size() ? m_stack[0].Size() : m_stack[1].Size();max=m_stack[2].Size()>max ? m_stack[2].Size() : max;//std::cout<<"Max:"<<max<<std::endl;m_stack[0].SetIndex(max-1);m_stack[1].SetIndex(max-1);m_stack[2].SetIndex(max-1);for(int i=1;i<=max;i++){int data1=m_stack[0].MoveToNext();int data2=m_stack[1].MoveToNext();int data3=m_stack[2].MoveToNext();if(data1==0)print(' ',20);else{print(' ',10-data1);print(ch,2*data1);print(' ',10-data1);}if(data2==0)print(' ',20);else{print(' ',10-data2);print(ch,2*data2);print(' ',10-data2);}if(data3==0)print(' ',20);else{print(' ',10-data3);print(ch,2*data3);print(' ',10-data1);}std::cout<<std::endl;}}bool Hanio::MoveFromTo(int x,int y){m_steps++; //计算所走的步数if(m_stack[x].Isempty()){std::cout<<x<<" pallete is empty ! continue !"<<std::endl; std::cin.get();return false;}if(m_stack[y].Isempty()){int data;m_stack[x].Pop(&data);m_stack[y].Push(data);return true;}else{if(m_stack[x].TopValue()>m_stack[y].TopValue()){std::cout<<"The board can't move from "<<x<<" plate to " <<y<<" plate!"<<std::endl;std::cin.get();return false;}else{int data;m_stack[x].Pop(&data);m_stack[y].Push(data);return true;}}}bool Hanio::IsFinished(){return m_stack[2].Top()==m_num-1;}void Hanio::GameStart(){using namespace std;UINT StartTime=::GetTickCount();UINT EndTime;while(1){system("cls");print('-',80);cout<<"steps: "<<m_steps; print(' ',20);cout<<"Used time: "<<m_times<<endl;print('-',80);cout<<endl; cout<<endl; print(' ',10); cout<<"A";print(' ',19); cout<<"B"; print(' ',19);cout<<"C"<<endl<<endl;Hanio::DrawPaletes();cout<<endl; cout<<endl;print('-',80);//测试游戏是否结束if(Hanio::IsFinished()){cout<<"你好强呀!从今天开始,维护世界和平的任务就交给你那!"<<endl;cin.get();break;}//输入命令并左相应的处理char szCommand[50];cout<<">>";cin.getline(szCommand,50);if(stricmp(szCommand,"QUIT")==0 || stricmp(szCommand,"Q")==0)break;if(stricmp(szCommand,"HELP")==0 || stricmp(szCommand,"H")==0){cout<<" 本游戏说明:"<<endl;cout<<" 该游戏由DAVID用C++编程,花费了一个多下午的时间呢!!!,由命令行来控制铁饼的移动:"<<endl;cout<<" QUIT / Q : 退出程序"<<endl;cout<<" HELP / H : 查看该说明"<<endl;cout<<" XY : X,Y的取值为A,B,C,意思时把X木桩最上面的铁饼移到Y 木桩"<<endl;cout<<" SOLVE / S : 显示求解该问题(移动铁饼)的最优路径..."<<endl; cin.get();}char ch1=toupper(szCommand[0]);char ch2=toupper(szCommand[1]);if( ch1=='A' && ch2=='B')Hanio::MoveFromTo(0,1);else if ( ch1=='A' && ch2=='C')MoveFromTo(0,2);else if ( ch1=='B' && ch2=='A')MoveFromTo(1,0);else if ( ch1=='B' && ch2=='C')MoveFromTo(1,2);else if ( ch1=='C' && ch2=='A')MoveFromTo(2,0);else if ( ch1=='C' && ch2=='B')MoveFromTo(2,1);else{cout<<"Bad command !"<<endl;cin.get();}//统计游戏所用时间EndTime=GetTickCount();m_times=(EndTime-StartTime)/1000;}}int Hanio::Solve(char from,char to,char auxiliary,int n) {if(n==1)return 0;}//main.cpp#include<iostream>#include"hanio.h"#include<cstdlib>using namespace std;int StartPicture();//返回选择的盘数int main(){int number;number=StartPicture();Hanio hanio(number);hanio.GameStart();return 0;}void print(char ch,int n){for(int i=1;i<=n;i++)std::cout<<ch;}int StartPicture(){using namespace std;int number;system("cls");system("color fc");print(' ',20);print('-',25);cout<<endl;print(' ',20);cout<<" Hanio(汉诺塔)"<<endl;print(' ',20);print('-',25);cout<<endl;print(' ',40);print('-',5);cout<<"By David"<<endl;print('=',80);cout<<" 相传在某一座古庙中有3根木桩,有24个铁盘由小到大放置在一根木柱上,庙中流传者一个传说:\"如果能把24个铁盘, 从一根木桩移动到另一个木桩,且必须遵守如下规则:"<<endl;cout<<endl;print(' ',5);cout<<"1. 每天只能动一个盘,而且只能从最上面的铁盘开始搬动."<<endl; print(' ',5);cout<<"2. 必须维持较小的铁盘在上方的原则"<<endl;cout<<endl;cout<<"这两个原则,则当24个铁盘完全般到另一个木桩时,世界就回永久和平!!"<<endl;cout<<"游戏的玩法可以在命令行中输入HELP查看"<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<"再此输入你要搬的铁盘数(建议在1--10值间,太多回花费很长时间的)"<<endl;print('=',80);cout<<">>";cin>>number;cin.get();system("cls");return number;}。
java多态练习题
java多态练习题Java多态练习题Java是一种面向对象的编程语言,其中的多态性是其最重要的特性之一。
通过多态,我们可以实现代码的灵活性和可扩展性。
在这篇文章中,我们将通过一些练习题来加深对Java多态性的理解。
练习一:动物的多态假设有一个动物类Animal,它有一个方法叫做makeSound(),用于输出动物的叫声。
现在我们派生出了两个子类Dog和Cat,它们分别重写了makeSound()方法,分别输出"汪汪汪"和"喵喵喵"。
现在我们创建一个Animal类型的数组,数组中存放了不同的动物对象,包括Dog和Cat。
我们遍历数组,调用每个动物对象的makeSound()方法,观察输出结果。
代码示例:```javaclass Animal {public void makeSound() {System.out.println("动物发出叫声");}}class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("汪汪汪");}}class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("喵喵喵");}}public class PolymorphismExample {public static void main(String[] args) { Animal[] animals = new Animal[3]; animals[0] = new Dog();animals[1] = new Cat();animals[2] = new Dog();for (Animal animal : animals) {animal.makeSound();}}}```运行结果:```汪汪汪喵喵喵汪汪汪```通过这个练习题,我们可以看到多态的作用。
Java面试题合集Java中的排序算法
Java面试题合集Java中的排序算法Java面试题合集——Java中的排序算法排序算法是计算机科学中的基本算法之一,而在Java编程语言中,也提供了多种排序算法的实现。
掌握常见的排序算法是Java开发者面试时的重要考点之一。
本文将介绍Java中一些常用的排序算法,并对它们的原理、应用场景和性能进行讨论。
一、冒泡排序(Bubble Sort)冒泡排序是一种简单但效率较低的排序算法,它的基本思想是通过不断交换相邻元素的位置,将较大或较小的元素逐渐“冒泡”到数组的一端。
具体实现如下:```javapublic static void bubbleSort(int[] arr) {int n = arr.length;for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}```冒泡排序的时间复杂度为O(n^2),因此对于大规模数据的排序效率较低。
但它的实现简单,对于小规模数据或基本有序的数据仍然具有一定优势。
二、选择排序(Selection Sort)选择排序是一种简单但效率较低的排序算法,它每次从待排序的元素中选择最小(或最大)的元素放到已排序的部分末尾。
通过不断选择并交换元素,实现整个数组的排序。
具体实现如下:```javapublic static void selectionSort(int[] arr) {int n = arr.length;for (int i = 0; i < n - 1; i++) {int minIndex = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}}```选择排序的时间复杂度同样为O(n^2),虽然在大规模数据的排序中效率较低,但由于每次只需交换一次元素,因此相对于冒泡排序而言,选择排序的性能略高。
课堂作业(模块1:Java编程逻辑).doc
课堂作业模块1 Java编程逻辑【第1课】【作业1】编写一个Java程序,在控制台上输出如下两行信息:Hello,World!Hello,Java!考核点1:了解一个Java程序的启动位置(即程序入口)。
考核点2:掌握基本输出语句:System.out.println(字符串)【第2课】【作业1】从键盘输入3个整数a、b、c,计算a+b*c的结果后输出,验证计算结果是否遵循运算符的优先级顺序。
考核点1:使用Scanner类获取键盘输入。
考核点2:基本运算符及其优先级顺序。
【作业2】从键盘输入1个实数r,计算以r为半径的圆的面积并输出结果,要求将π定义为符号常量。
考核点:符号常量的基本用法。
【第3课】【作业1】从键盘输入3个整数,比较大小后输出最大者。
考核点:if-else语句的运用。
【作业2】从键盘输入一个3位数,判断其是否为水仙花数。
所谓“水仙花数”是指一个三位整数,其各位数字立方和等于该数本身。
例如:153=13+53+33,所以153是一个水仙花数。
考核点:基本数学运算符和逻辑运算符的用法。
【第4课】【作业1】从键盘输入3个整数,比较大小后按由小到大的顺序输出。
考核点:if-else语句嵌套运用。
【作业2】从键盘输入一个年份和一个月份,输出此月份有多少天(考虑闰二月的情况)。
考核点:使用switch-case多分支语句。
【第5课】【作业1】从键盘输入一个正整数,判断其是否为素数。
素数指只有1和它本身两个因子的整数。
考核点:基本循环语句的用法。
【作业2】输出100-999之间的全部水仙花数。
考核点:基本循环语句的用法。
【作业3】从键盘输入一个正整数,判断并输出该正整数是几位数。
考核点1:基本循环语句的用法。
考核点2:分离一个整数各个位数字的方法。
【第6课】【作业1】编写一个Java程序,输出如下图案,图案的行数由键盘输入。
(1)观察图案中行、列及星星个数之间的关系。
(2)扩展练习,输出如下图案,图案的行数由键盘输入。
Java实现冒泡排序
Java实现冒泡排序问题描述利⽤冒泡排序把⼀列数组按从⼩到⼤或从⼤到⼩排序(⼀)、冒泡排序思想以从⼩到⼤为例:1、第⼀轮的冒泡,从第⼀个数开始,与相邻的第⼆个数相⽐,若第⼀个数更⼤,则交换⼀⼆的位置,反之不动,结束后进⾏⼆三位置两个数的⽐较,同理如此反复,直到把最⼤的⼀个数排到最后⼀个位置。
2、进⾏第⼆轮的冒泡,依旧从第⼀个数开始,依次⽐较当前的⼀⼆、⼆三······位置的数,直到把第⼆⼤的数排到倒数第⼆位。
3、如此循环进⾏,直到所有数按从⼩到⼤排列。
(⼆)、问题分析1.输⼊数组根据⽤户输⼊的进⾏排序的数字数量n,建⽴⼀个长度为n的数组public static void main (String[] args){int n,m;Scanner sc = new Scanner(System.in);System.out.println("请输⼊你想排序的数量n");n=sc.nextInt();int [] arrary = new int[n];System.out.println("请输⼊"+n+"个数,并⽤空格隔开");for(int i=0;i<arrary.length;i++){arrary[i]=sc.nextInt();}2.输⼊如何排序设置两条路径:m=1为从⼩到⼤,m=2为从⼤到⼩,m=其他提醒⽤户重新输⼊System.out.println("请问你想:1.从⼩到⼤ 2.从⼤到⼩排序?");m=sc.nextInt();while (m!=1 && m!=2 ){System.out.println("输⼊有误请再次输⼊");m = sc.nextInt();continue;}3.排序算法(1)数组长度 arrary.length 也就是⽤户输⼊的 n(2)j 表⽰第 j+1 轮排序,这⾥⾯n-1轮排序就已⾜够(3)k 表⽰第 k+1 个位置,arrary[k] 表⽰第 k+1 个位置的数(4)由于每⼀轮都能确定⼀个最⼤数排在最后,所以每⼀轮进⾏⽐较的数都会少⼀个,⽐较的次数也会少⼀个,所以是k<arrary.length-1-j(5)较⼤数与较⼩数交换位置的经典算法:若a>b; 则c=a; a=b; b=c;(6)从⼤到⼩排序只需把 arrary[k]>arrary[k+1] 换成 arrary[k]<arrary[k+1] 即可(7)选择进⾏何种排序,在 if 语句的判断框⾥加上此时m应该等于的值(8)因为要先选择进⾏何种排序,才能进⾏排序,所以把 m==1 放在 arrary[k]>arrary[k+1] 前⾯,且⽤短板与 && ,这样更易于理解(如果m≠1,则直接进⾏else if 的语句)(9)也可以 m==1 & arrary[k]>arrary[k+1] 或 arrary[k]>arrary[k+1] & m==1,但不能 arrary[k]<arrary[k+1] && m==2。
java模拟面试题目(3篇)
第1篇一、Java基础知识1. 请简述Java语言的特点。
2. 什么是Java虚拟机(JVM)?它有什么作用?3. 什么是Java的内存模型?请解释Java内存模型中的几个关键概念:堆、栈、方法区、程序计数器、本地方法栈。
4. 什么是Java中的反射机制?请举例说明反射在Java中的应用。
5. 什么是Java中的泛型?请解释泛型的原理和作用。
6. 请简述Java中的四种访问控制符:public、protected、default、private。
7. 什么是Java中的继承和多态?请举例说明继承和多态在实际开发中的应用。
8. 什么是Java中的封装?请举例说明封装在实际开发中的应用。
9. 什么是Java中的接口和抽象类?它们之间有什么区别?10. 什么是Java中的异常处理?请解释try-catch-finally语句的执行顺序。
二、Java集合框架1. 请列举Java集合框架中的常用集合类及其特点。
2. 请简述ArrayList、LinkedList、HashMap、HashSet的区别。
3. 什么是Java中的泛型集合?请举例说明泛型集合的应用。
4. 什么是Java中的迭代器(Iterator)和枚举器(Enum)?请比较它们的区别。
5. 什么是Java中的List、Set、Map的遍历方法?6. 请解释Java中的ArrayList和LinkedList的内部实现原理。
7. 什么是Java中的HashMap的扩容机制?8. 什么是Java中的HashSet的内部实现原理?9. 请解释Java中的线程安全集合类,如CopyOnWriteArrayList、ConcurrentHashMap。
三、Java多线程与并发1. 什么是Java中的线程?请解释线程的创建、调度和同步。
2. 请简述Java中的线程状态,如新建、就绪、运行、阻塞、等待、超时等待、终止。
3. 什么是Java中的同步机制?请解释synchronized关键字的作用。
每一趟都能选出一个元素放到其最终位置上,并且不稳定
每一趟都能选出一个元素放到其最终位置上,并且不稳定冒泡排序:每一趟能选出一个元素放到其最终位置上,并且不稳定----------------------------------冒泡排序是一种比较简单的排序算法,它的基本思想是:通过重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
## 一、冒泡排序的原理冒泡排序是一种交换排序,它的工作原理如下:1. 比较相邻的元素。
如果第一个比第二个大,就交换他们两个;2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;3. 针对所有的元素重复以上的步骤,除了最后一个;4. 重复步骤1~3,直到排序完成。
## 二、冒泡排序的实现方式冒泡排序可以有多种实现方式,其中常用的有三种:1. 普通冒泡排序2. 改进冒泡排序3. 快速冒泡排序### 1. 普通冒泡排序冒泡排序最早发明是在1956年,由两位数学家F. W. Watson和A.M. Sorton发明。
它是一种简单而原始的排序方式,它采用相邻元素两两对比的方式,如果前者大于后者,就将两者交换位置,直到整个数列都有序为止。
它的基本原理如上文所述,具体实现代码如下所示:```pythondef bubble_sort(list):# 获取list的长度length = len(list)# 外层循环表示总共要循环length-1轮for i in range(length-1):# 内层循环表示每一轮要循环length-i-1次for j in range(length-i-1):if list[j] > list[j+1]:list[j], list[j+1] = list[j+1], list[j]```### 2. 改进冒泡排序在原始的冒泡排序中,如果待排序数列中存在大量已经有序的数列时,冒泡排序依然会执行大量的无用功,而“改进冒泡排序”就是为了解决这一问题而出现的。
20个java案例
20个java案例以下是20个Java案例,涵盖了不同的主题和功能。
每个案例都有一个简要的描述和示例代码。
1. 计算两个数的和。
描述,编写一个程序,计算两个整数的和并输出结果。
示例代码:java.int num1 = 10;int num2 = 5;int sum = num1 + num2;System.out.println("两个数的和为," + sum);2. 判断一个数是否为偶数。
描述,编写一个程序,判断一个整数是否为偶数,并输出结果。
示例代码:java.int num = 6;if (num % 2 == 0) {。
System.out.println(num + "是偶数。
");} else {。
System.out.println(num + "不是偶数。
");}。
3. 求一个数的阶乘。
描述,编写一个程序,计算一个正整数的阶乘,并输出结果。
示例代码:java.int num = 5;int factorial = 1;for (int i = 1; i <= num; i++) {。
factorial = i;}。
System.out.println(num + "的阶乘为," + factorial);4. 判断一个字符串是否为回文字符串。
描述,编写一个程序,判断一个字符串是否为回文字符串,并输出结果。
示例代码:java.String str = "level";boolean isPalindrome = true;for (int i = 0; i < str.length() / 2; i++) {。
if (str.charAt(i) != str.charAt(str.length() 1 i)) {。
isPalindrome = false;break;}。
java冒泡排序简单写法
java冒泡排序简单写法冒泡排序是一种简单的排序算法,它重复地遍历待排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
以下是Java实现冒泡排序的简单写法:Javapublic class BubbleSort {public static void bubbleSort(int[] arr) {int n = arr.length;for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {// 交换arr[j] 和arr[j+1]int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}public static void main(String[] args) {int[] arr = {64, 34, 25, 12, 22, 11, 90};bubbleSort(arr);System.out.println("Sorted array: ");for (int i=0; i<arr.length; ++i) {System.out.print(arr[i] + " ");}}}这段代码首先定义了一个名为bubbleSort的方法,该方法接收一个整数数组作为参数。
然后,该方法使用两个嵌套的for循环来遍历数组,比较相邻的元素,并在必要时交换它们。
这个过程重复进行,直到整个数组被排序。
最后,main方法创建了一个未排序的数组,调用bubbleSort方法对其进行排序,然后打印出排序后的数组。
java_swing面试题目(3篇)
第1篇一、Java Swing基本概念1. 什么是Java Swing?答:Java Swing是一种用于创建图形用户界面的库,它是Java语言的一个扩展,允许开发者创建具有丰富视觉效果的桌面应用程序。
2. Swing的组件有哪些?答:Swing组件包括基本组件(如按钮、标签、文本框等)、容器组件(如面板、窗口、滚动条等)、特殊组件(如树、表格等)。
3. Swing与AWT的区别是什么?答:Swing是基于Java的,而AWT是基于本地平台的。
Swing组件在不同平台上表现一致,而AWT组件在不同平台上可能有所不同。
Swing运行速度较慢,但提供了更多功能和更好的用户体验。
二、Swing基本组件1. 如何创建一个按钮,并设置其文本和字体?答:使用JButton类创建按钮,并设置其文本和字体。
```javaJButton button = new JButton("按钮");button.setFont(new Font("宋体", Font.PLAIN, 12));```2. 如何获取并设置文本框中的文本?答:使用JTextField类创建文本框,并通过getText()和setText()方法获取和设置文本。
```javaJTextField textField = new JTextField();String text = textField.getText(); // 获取文本textField.setText("新文本"); // 设置文本```3. 如何使用单选按钮(JRadioButton)实现多选?答:使用JRadioButton类创建单选按钮,并使用ButtonGroup类将它们分组。
```javaJRadioButton radioButton1 = new JRadioButton("选项1");JRadioButton radioButton2 = new JRadioButton("选项2");ButtonGroup buttonGroup = new ButtonGroup();buttonGroup.add(radioButton1);buttonGroup.add(radioButton2);```4. 如何使用复选框(JCheckBox)实现多选?答:使用JCheckBox类创建复选框,它们之间互不影响。
Java基础上机题
一、类和对象基础题(共13题)1.编写一个Java应用程序,该程序中有3个类:Lader、Circle和主类A。
具体要求如下:Lader类具有类型为double的上底、下底、高、面积属性,具有返回面积的功能,包括一个构造方法对上底、下底、高进行初始化。
Circle类具有类型为double的半径、周长和面积属性,具有返回周长、面积的功能,包括一个构造方法对半径进行初始化。
主类A用来测试类Lader和类Circle的功能。
2.按要求编写Java应用程序:(1)编写西游记人物类(XiYouJiRenWu)其中属性有:身高(height),名字(name),武器(weapon)方法有:显示名字(printName),显示武器(printWeapon)(2)在主类的main方法中创建二个对象:zhuBaJie,sunWuKong。
并分别为他们的两个属性(name,weapon)赋值,最后分别调用printName,printWeapon方法显示二个对象的属性值。
8.编写Java应用程序。
首先定义一个描述银行账户的Account类,包括成员变量“账号”和“存款余额”,成员方法有“存款”、“取款”和“余额查询”。
其次,编写一个主类,在主类中测试Account类的功能。
9.编写Java应用程序。
首先,定义一个时钟类——Clock,它包括三个int型成员变量分别表示时、分、秒,一个构造方法用于对三个成员变量(时、分、秒)进行初始化,还有一个成员方法show()用于显示时钟对象的时间。
其次,再定义一个主类——TestClass,在主类的main方法中创建多个时钟类的对象,使用这些对象调用方法show()来显示时钟的时间。
10.编写Java应用程序。
首先,定义描述学生的类——Student,包括学号(int)、姓名(String)、年龄(int)等属性;二个方法:Student(intstuNo,Stringname,intage) 用于对对象的初始化,outPut()用于输出学生信息。
scratch 冒泡排序编程题
【主题】Scratch 冒泡排序编程题【内容】1. 什么是冒泡排序?冒泡排序是一种简单的排序算法,它重复地遍历要排序的列表,比较相邻的两个元素,如果它们的顺序错误就把它们交换过来。
重复这个过程直到整个列表都排好序。
2. 冒泡排序的原理冒泡排序的原理很简单,就是不断地比较相邻的两个元素,如果顺序不对就交换它们的位置,直到整个列表都排好序为止。
冒泡排序的核心是比较和交换两个操作,它通过多次遍历列表来实现排序。
这个过程就好像冒泡一样,较大的元素就像气泡一样不断地向上浮,而较小的元素就像水中的气泡一样不断地向下沉,最终整个列表就排好序了。
3. 冒泡排序的实现步骤冒泡排序的实现步骤可以分为以下几个部分:3.1 第一步:比较相邻的元素从列表的第一个元素开始,依次和它的后一个元素进行比较。
3.2 第二步:交换元素的位置如果相邻的两个元素顺序不对,就交换它们的位置。
3.3 第三步:重复上述步骤重复上述两个步骤,直到整个列表都排好序为止。
4. Scratch 冒泡排序的编程实现Scratch 是一种简单易学的编程语言,非常适合初学者学习编程。
下面就以Scratch 为例,介绍如何实现冒泡排序的编程。
4.1 创建一个列表在Scratch 中创建一个列表,假设这个列表中包含了一些数字,我们希望对这些数字进行排序。
4.2 编写冒泡排序的算法在Scratch 的舞台中,使用图形化编程块来编写冒泡排序的算法。
需要使用循环块来遍历列表中的元素,然后使用比较和交换的块来实现冒泡排序的逻辑。
4.3 测试冒泡排序的结果一旦编写好了冒泡排序的算法,就可以对列表中的元素进行排序,并查看排序结果是否符合预期。
5. 冒泡排序的时间复杂度冒泡排序是一种简单但是效率不高的排序算法,它的时间复杂度为O(n^2),其中n表示列表的长度。
在实际应用中,冒泡排序并不适合对大规模数据进行排序,但是对于小规模数据来说,冒泡排序还是一种简单易懂的排序算法。
java练习题库
Java练习题库一、基础知识篇1.1 变量与数据类型1. 定义一个整型变量并赋值为10。
2. 声明一个浮点型变量并初始化为3.14。
3. 创建一个字符变量并赋值为'A'。
4. 使用字符串类型声明并初始化一个变量,内容为"Hello World"。
1.2 运算符5. 计算5 + 3 2的值。
6. 判断下列表达式的结果:10 > 5 && 8 < 6。
7. 编写一个程序,实现两个整数的交换。
8. 使用三元运算符判断一个数是奇数还是偶数。
1.3 控制结构9. 编写一个for循环,输出1到10的整数。
10. 使用while循环计算1到100的和。
11. 根据分数判断学生等级(优秀、良好、及格、不及格)。
12. 编写一个switch语句,根据月份输出对应的天数。
二、面向对象篇2.1 类与对象13. 创建一个名为Person的类,包含姓名和年龄属性。
14. 为Person类添加一个方法,用于打印个人信息。
15. 编写一个构造方法,为Person类初始化姓名和年龄。
16. 创建一个Student类,继承自Person类,并添加一个成绩属性。
2.2 封装、继承与多态17. 将Person类的姓名和年龄属性设置为私有,并提供对应的get和set方法。
18. 在Student类中重写toString方法,输出学生信息。
19. 定义一个接口Animal,包含一个方法eat()。
20. 创建两个类Cat和Dog,实现Animal接口,并分别实现eat()方法。
2.3 异常处理21. 编写一个程序,捕获并处理数组越界异常。
22. 创建一个自定义异常类MyException,并在适当的时候抛出异常。
23. 使用trycatchfinally结构编写一个读取文件的程序。
三、高级特性篇3.1 集合框架24. 使用ArrayList存储并遍历一组字符串。
25. 创建一个HashMap,存储学生姓名和成绩,并遍历输出。
汉诺塔动画演示课件
汉诺塔的规则和玩法
01
02
03
04
05
规则:汉诺塔的规则是 要求将所有的圆盘从起 始柱子移到目标柱子上, 移动过程中必须遵循以 下三个原 则
1. 每次只能移动一个圆 盘;
2. 圆盘只能放在比它大 3. 圆盘只能放在空柱子
的圆盘上;
上。
玩法:汉诺塔的玩法是 从起始柱子开始,按照 规则将圆盘逐个移到目 标柱子上。在移动过程 中,需要不断地将圆盘 进行分解和组合,以找 到最优的移动方案。
03
人工智能与机器学习
汉诺塔问题可以作为人工智能和机器学习领域的基准测试案例,用于评
估和优化算法和模型的性能。
在物理学中的应用
力学与运动学
汉诺塔问题涉及到物体的运动和相互作用,可以用来解释和演示力学和运动学的基本原理,如牛顿运 动定律、动量守恒定律等。
光学与视觉
汉诺塔问题中的不同颜色和形状的盘子可以用来模拟光线和颜色的传播和反射,可以用来解释和演示 光学和视觉的基本原理。
效地降低时间复杂度,提高求解效率。
优化二:使用遗传算法求解
总结词
遗传算法是一种基于生物进化原理的优化算法,可以用于求解组合优化问题。
详细描述
遗传算法是一种基于生物进化原理的优化算法,它通过模拟生物进化过程中的基因选择、交叉和变异等过程来寻 找最优解。在汉诺塔问题中,我们可以使用遗传算法来求解。首先,我们定义一个表示汉诺塔问题的染色体,然 后通过模拟选择、交叉和变异等过程来不断优化染色体的适应度,最终得到最优解。
02
汉诺塔动画演示
演示一:移动三个盘子
总结词:通过演示,展示汉诺塔问题最简单的情形,即只 有三个盘子需要移动。
详细描述
1. 起始状态:三个盘子叠在一起,放在第一个柱子上。
Java课程设计指导书
《Java程序设计》课程设计指导书2013-2014学年第二学期计科11级学生计算机学院2013-12一、课程设计目的1、复习、巩固所学过的Java语言基础知识,进一步加深对Java语言的理解和掌握;2、课程设计为学生提供了一个既动手又动脑,独立实践的机会,将课本上的理论知识和实际有机的结合起来,锻炼学生分析、解决实际问题的能力,提高学生适应实际、实践编程的能力。
3、培养学生在项目开发中团队合作精神、创新意识及能力。
二、课程设计要求1、对系统进行功能模块分析、控制模块分析正确,符合课题要求,实现相应功能;可以加以其它功能或修饰,使程序更加完善、合理;2、系统设计要实用,编程简练、可用、功能全面;3、说明书、流程图要清楚;4、记录设计情况(备查,也为编写设计说明书作好准备);5、要求采用模块化程序设计方法及锯齿型的标准代码书写格式,要求上机调试通过并按设计报告格式书写报告;6、要求标识符命名遵循命名规范,代码多加注释;注意各种可能遇到的异常处理,注重提高程序运行效率;7、图形界面要符合日常软件使用规范来设计菜单和界面。
8、上交内容:打印课程设计报告一份(按格式书写)、源程序文件。
每人给学习委员上传含报告和代码的压缩包,文件名形如"张三.rar"(学号加姓名组成),由课代表刻录。
三、课程设计题目●设计题目知识点:程序控制语句编程设计题目1.1编写程序从键盘输入10个整数,找出最大、最小的整数并输出。
设计题目1.2输入某一个班级学生的Java程序设计期末考试成绩,以-1作为结束标记:(1)统计班级学生中,不及格、及格、中等、良好、优秀的人数;(2)求该班级学生这门课的考试平均分数。
设计题目1.3某地刑侦大队对涉及六个嫌疑人的一桩疑案进行分析:1A、B至少有一人作案;A、E、F三人中至少有两人参与作案;A、D不可能是同案犯;B、C或同时作案,或与本案无关;C、D中有且仅有一人作案;如果D没有参与作案,则E也不可能参与作案。
java小球点击动画课程设计
java小球点击动画课程设计一、课程目标知识目标:1. 学生能理解Java编程中面向对象的基本概念,掌握类的定义、对象的使用和小球的运动模型。
2. 学生能够运用Java中的事件处理机制,实现对小球的点击事件监听。
3. 学生能够理解并实现小球动画中的坐标更新和画面重绘原理。
技能目标:1. 学生能够独立编写Java程序,创建具有点击动画效果的小球。
2. 学生通过实践,掌握Java中线程的使用,实现小球的连续运动。
3. 学生能够运用所学知识,进行程序调试和优化,提高动画的执行效率和响应速度。
情感态度价值观目标:1. 学生通过本课程的学习,培养解决问题的能力和团队合作精神。
2. 学生在创作过程中,体验编程的乐趣,提高对编程学科的兴趣和热情。
3. 学生通过课程实践,培养耐心、细心和勇于尝试的良好品质。
课程性质:本课程为实践性较强的Java编程课程,结合小球点击动画的制作,帮助学生将理论知识应用于实际编程中。
学生特点:学生处于初中或高中年级,具备一定的Java编程基础,对动画制作和游戏开发有较高的兴趣。
教学要求:教师应注重培养学生的动手能力,引导学生主动探究问题,通过实例讲解和操作演示,帮助学生掌握课程内容。
在教学过程中,关注学生的个体差异,提供有针对性的指导。
同时,注重评估学生的实际操作能力,确保课程目标的达成。
二、教学内容1. 面向对象编程基础:- 类的定义与对象的使用。
- 成员变量和方法的创建与调用。
2. Java图形用户界面(GUI):- JFrame窗口的创建与设置。
- 组件的添加与布局。
3. 事件处理机制:- 鼠标点击事件的监听与处理。
- 响应事件的方法编写。
4. 小球运动模型:- 坐标系的建立与坐标更新。
- 小球移动逻辑的实现。
5. 线程控制:- 线程的创建与启动。
- 线程同步与通信。
6. 动画实现:- paintComponent方法的重写与画面重绘。
- 动画刷新速率的控制。
7. 程序调试与优化:- 代码逻辑检查与调试技巧。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
} } } 二:实现动画的播放 实现素材中的动画显示。 import java.awt.*; import java.applet.Applet; import java.awt.event.*; public class myimg extends Applet { Image[] myImage; int totalimages=10; int currentimage=0;
public class maopao extends Applet implements ActionListener{ Button sortbtn=new Button("排序"); int[] my_array={13,02,25,07,28,23,12}; int[][] LW=new int[8][7]; long ATime; long t1,t2; public void init() { add(sortbtn); sortbtn.addActionListener(this); } public void paint(Graphics g) { for(int i=0;i<LW.length;i++) for(int j=0;j<LW[i].length;j++) g.drawString(Integer.toString(LW[i][j]),10+30*j,40+20*i);//打印 g.drawString(("计算时间是:"+ATime),600,100);//打印 } public void actionPerformed(ActionEvent e) { if(e.getSource()==sortbtn)//点击按钮 {
currentimage=0; }
public void paint(Graphics g) { g.drawImage(myImage[currentimage],0,0,150,240,this); currentimage=++currentimage%totalimages; try{
Thread.sleep(150); } catch(InterruptedException e) {
t1=System.currentTimeMillis(); for(int i=0;i<my_array.length;i++)
LW[0][1]=my_array[i]; SortProcedure(); repaint(); } }
void SortProcedure() {
int pass,i,temp,exchangeCnt; for(pass=0;pass<my_array.length;pass++) {
应用技术学院
实验报告
专 业: 07 网络工程(2)班 学 号: ****** 姓 名: ***** 指导老师: 胡祝华
一 实验内容 一 :冒泡排序 1 实现{13,02,25,07,28,23,12} 序列从小到大的排序。并演示出每一趟的排序过程。 2 求出你所写的算法所消耗的系统时间。 二:实现动画的播放
public void init() {
myImage=new Image[totalimages]; for(int i=1;i<=totalimages;i++)myImage[i-1]=getImage(getDocumentBase(),"JPG\\A"+i+".jpg"); }
public void start() {
实现素材中的动画显示。 1. 用递归实现 3 层 hanoi(汉诺塔)程序。并用图形界面演示整个过程。
二 实验目的 掌握一种基本的数据结构算法; 掌握简单图形用户界面处理方法;
三 实验详细步骤及实验结果 1 实现{13,02,25,07,28,23,12} 序列从小到大的排序。并演示出每一趟的排序过程。 2 求出你所写的算法所消耗的系统时间。 import java.applet.Applet; import java.awt.*; import java.awt.event.*;
exchangeCnt=0; for(i=0;i<my_array.length-pass-1;i++) {
if(my_array[i]>my_array[i+1]) {
temp=my_array[i]; my_array[i]=my_array[i+1]; my_array[i+1]=temp; exchangeCnt++; } } for(i=0;i<my_array.length;i++) LW[pass+1][i]=my_array[i]; if(exchangeCnt==0) return; t2=System.currentTimeMillis(); ATime=t2-t1;
} public static void move(int n,char from,char to){
System.out.println(" 把第 "+n+" 个 " +" 从 " + from +" 到 "+ to); }
}
四 本次实验总结
showStatus(e.toString()); } repaint(); } } 3 用递归实现 3 层 hanoi(汉诺塔)程序。并用图形界面演示整个过程。 public class Hanoi{ public static void main(String[] args){ moveAll(4,'A','B','C'); //有四个盘子的汉诺塔 }