查看: 1641|回复: 0

[Java代码] Java编程实现的模拟行星运动示例

发表于 2018-5-4 08:00:02

本文实例讲述了java编程实现的模拟行星运动。分享给大家供大家参考,具体如下:

期待了很久的java语言程序设计也拉下了帷幕,在几个月的时间里基本掌握了java的简单用法,学习了java的主要基础知识,面向对象思想,多线程并发控制,swing界面设计,动画制作等,最后结课了也打算制作一个课程设计能够尽可能多的涵盖所学知识,将其进行串联,因此考虑实现了一个简单的模拟行星运动的小软件,主要思路如下:

利用动画实现行星运动的模拟,主面板里有一个中心行星,同时绘制了椭圆轨道,有一颗运动的行星围绕着中心行星运动。同时右下角设置的有四个按钮,即“Start”、“Pause”、“accelerate”和“decelerate”分别可以使行星运动、暂停、加速、减速。

一、类的设计:

Star继承自JPanel。Star类是行星的基类,所有运动的行星都是继承自Star类。内部draw()方法主要绘制了一个实心圆形,目的是在每次绘制时,可以保证中心行星始终显示。paintComponent()方法重写了JPanel的绘制方法,目的是保证继承自Star类的Stars类的实例对象可以绘制出自己的行星。如下:

  1. package Star;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import javax.swing.JPanel;
  5. public class Star extends JPanel{
  6. /**
  7. * 基本的行星类
  8. */
  9. private static final long serialVersionUID = 1L;
  10. int x,y;
  11. int width,height;
  12. public Star() {
  13. width = 10;
  14. height = 10;
  15. }
  16. public Star(int x, int y){
  17. this.x = x;
  18. this.y = y;
  19. width = 10;
  20. height = 10;
  21. }
  22. public void draw(Graphics g){
  23. g.setColor(Color.blue);
  24. g.fillOval(x, y, width, height);
  25. }
  26. protected void paintComponent(Graphics g){
  27. super.paintComponent(g);
  28. g.fillOval(x, y, width, height);
  29. }
  30. }
复制代码

Stars类继承自Star类,是对Star类的进一步细化,表示运动的行星。Stars类中的alfa表示运动行星的运动起始角度,speed表示运动速度,可对其进行修改。Long,Short分别表示椭圆轨迹的长轴与短轴。center表示其实例化对象的中心行星。paintComponent()函数重写了paintComponent(),内部引用了父类的draw()函数,并且根据Long,,Short绘制了椭圆轨道,Long、Short由实例化对象调用构造方法来决定。move()函数描述了x,y的变化方程,即围绕着椭圆轨道变化,同时规定了alfa的变化方式。start()函数表示线程开始,pause()函数表示线程暂停,accelerate()函数表示对行星的加速操作,decelerate()函数表示对行星减速的操作。

Pthread类目的是控制线程,即通过对Pthread类的实例化可以控制行星的开始运动,暂停运动,加速,减速。Pthread类继承自Thread类,且包含于Starts类中,因而,PThread类不能被定义为共有类。PThread类提供了run()方法,不断调用repaint()方法,对画面进行重新绘制。setsuspend()方法利用改变boolean变量对线程进行暂停操作(调用notifyall()方法)。因为Pthread类是Starts的内部类,所以之后Starts类中将生成一个PThread类的对象,并且利用该对象,对线程进行操作。

设计如下:

  1. package Star;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. public class Stars extends Star{
  5. /**
  6. * 运动的行星
  7. */
  8. private static final long serialVersionUID = 1L;
  9. double alfa ;
  10. double speed ;
  11. Star center;
  12. int Long ; //长轴
  13. int Short;//短轴
  14. public Stars(int Px,int Py,Star center){
  15. super(Px,Py);
  16. this.center = center;
  17. Long = (Px - center.x)*2;
  18. Short = (Py - center.y)*2;
  19. this.setOpaque(true);
  20. // move();
  21. alfa = 0;
  22. speed = 0.001;
  23. }
  24. protected void paintComponent(Graphics g){
  25. super.paintComponent(g);
  26. center.draw(g);//画出中心点
  27. move();
  28. g.setColor(Color.GREEN);
  29. g.drawOval(center.x-Long/2, center.y-Short/2, Long, Short);
  30. }
  31. public void move(){
  32. x = center.x + (int)(Long/2*Math.cos(alfa));
  33. y = center.y + (int)(Short/2*Math.sin(alfa));
  34. //沿椭圆轨迹运行
  35. alfa += speed;
  36. //角度不断变化
  37. }
  38. class PThread extends Thread{
  39. //重画线程类
  40. private boolean suspend = true;
  41. private String control = "";
  42. public void run(){
  43. while(true){
  44. synchronized (control) {
  45. if(suspend){
  46. //move();
  47. repaint();
  48. }
  49. }
  50. }
  51. }
  52. public void setsuspend(boolean s){
  53. //设置线程暂停方法
  54. if (!suspend) {
  55. synchronized (control) {
  56. control.notifyAll();
  57. }
  58. }
  59. this.suspend = s;
  60. }
  61. }
  62. public PThread pt = new PThread();
  63. public void start(){
  64. pt.setsuspend(true);
  65. pt.start();
  66. }
  67. public void pause(){
  68. pt.setsuspend(false);
  69. }
  70. public void accelerate(){
  71. //加速的方法
  72. if(speed > 0){
  73. //角度每次加速0.0002
  74. speed += 0.0002;
  75. }
  76. else
  77. speed = 0.001;
  78. }
  79. public void decelerate(){
  80. //减速的方法
  81. if(speed > 0){
  82. speed -= 0.0002;
  83. //角度每次减速0.0002
  84. }
  85. //若减速到0,则不能继续减速,另速度为0,停止运动
  86. else speed = 0;
  87. }
  88. }
复制代码

StarFrame类是本程序的启动面板,通过实例化该类,生成主程序界面,并且将行星部件,按钮,标签添加进面板。内部的getPanel()方法对两个按钮进行了设置,并且返回一个JPanel(将四个按钮添加进该JPanel中)。getLabel()方法返回一个文字描述的JLabel。Center对象是Star类的实例化,p1是Stars类的实例化,分别表示中心行星与环绕行星。jb1,jb2,jb3,jb4分别是行星的启动,暂停,加速,减速的控制按钮。image表示界面背景图,LayeredPanel是界面的层次面板,方便背景图的设置。jp,jl是设置背景图的部件。设计如下:

  1. package Star;
  2. import java.awt.BorderLayout;
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import java.awt.event.ActionEvent;
  6. import java.awt.event.ActionListener;
  7. import javax.swing.ImageIcon;
  8. import javax.swing.JButton;
  9. import javax.swing.JFrame;
  10. import javax.swing.JLabel;
  11. import javax.swing.JLayeredPane;
  12. import javax.swing.JPanel;
  13. public class StarFrame extends JFrame{
  14. /**
  15. *行星模拟启动面板
  16. */
  17. private static final long serialVersionUID = 1L;
  18. Star center = new Star(300,200);//定义中心行星
  19. Stars p1 = new Stars(300+230,200+130,center);//环绕中心的行星
  20. Stars p2 = new Stars(300+230+20,200+130+20,p1);
  21. JButton jb1 = new JButton("start");
  22. JButton jb2 = new JButton("pause");
  23. JButton jb3 = new JButton("accelerate");
  24. JButton jb4 = new JButton("decelerate");
  25. ImageIcon image=new ImageIcon("timg.jpg");//背景图,利用相对路径定义
  26. JLayeredPane layeredPane; //定义一个层次面板,用于放置背景图片
  27. JPanel jp;
  28. JLabel jl;
  29. public StarFrame(){
  30. //为p1设置位置,与大小
  31. p1.setBounds(40,40,600,400);
  32. // p2.setBounds(40,40,600,400);
  33. //定义背景图,将背景图放于JLabel中,将JLabel放于JPanel中
  34. layeredPane = new JLayeredPane();
  35. jp = new JPanel();
  36. jp.setBounds(0,0,image.getIconWidth(),image.getIconHeight());
  37. jl=new JLabel(image);
  38. jp.add(jl);
  39. //将jp放到最底层。
  40. layeredPane.add(jp,JLayeredPane.DEFAULT_LAYER);
  41. //将jb放到高一层的地方
  42. layeredPane.add(p1,JLayeredPane.MODAL_LAYER);
  43. // layeredPane.add(p2,JLayeredPane.MODAL_LAYER);
  44. layeredPane.add(getPanel(),JLayeredPane.MODAL_LAYER);
  45. layeredPane.add(getLabel(),JLayeredPane.MODAL_LAYER);
  46. //分别为jb1、jb2、jb3、jb4设置相关动作
  47. jb1.addActionListener(new ActionListener(){
  48. public void actionPerformed(ActionEvent e) {
  49. // TODO Auto-generated method stub
  50. p1.start();
  51. }
  52. }
  53. );
  54. jb2.addActionListener(new ActionListener(){
  55. public void actionPerformed(ActionEvent e) {
  56. // TODO Auto-generated method stub
  57. p1.pause();
  58. }
  59. });
  60. jb3.addActionListener(new ActionListener(){
  61. public void actionPerformed(ActionEvent e) {
  62. // TODO Auto-generated method stub
  63. p1.accelerate();
  64. }
  65. });
  66. jb4.addActionListener(new ActionListener(){
  67. public void actionPerformed(ActionEvent e) {
  68. // TODO Auto-generated method stub
  69. p1.decelerate();
  70. }
  71. });
  72. this.setLayeredPane(layeredPane);
  73. this.setTitle("Star");
  74. this.setBounds(100,100,1000, 600);
  75. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  76. this.setVisible(true);
  77. }
  78. private JPanel getPanel(){
  79. //返回定义的四个按钮
  80. JPanel jp = new JPanel();
  81. jp.add(jb1);
  82. jp.add(jb2);
  83. jp.add(jb3);
  84. jp.add(jb4);
  85. jp.setBounds(750,450,200,70);
  86. return jp;
  87. }
  88. private JPanel getLabel(){
  89. //返回文字描述
  90. JLabel jl = new JLabel("行星模拟");
  91. jl.setForeground(Color.RED);//设置字体颜色
  92. jl.setFont(new Font("Dialog",0,20));//设置字体
  93. JPanel jp = new JPanel();
  94. jp.add(jl,BorderLayout.CENTER);
  95. jp.setBounds(800,0,150,40);
  96. return jp;
  97. }
  98. public static void main(String[] args) {
  99. @SuppressWarnings("unused")
  100. StarFrame f = new StarFrame();
  101. }
  102. }
复制代码

运行效果:

二、对象:

因为java是面向对象的语言,当然不能像c语言一样,仅仅靠函数实现,课设里岂能没有对象?

主要对象:

对象center,即中心行星

对象p1,即环绕行星

对象pt,即负责控制线程的对象

对象f,即程序启动面板

三、对象之间的关系(交互)

p1与center的关系:Star类是行星的基类,继承自JPanel,其内部定义了基本的半径与坐标,其实例化对象center即是运动行星的中心行星。而继承自Star的Stars类表示运动行星,是其进一步的细化,因此其实例化对象p1表示运动的行星1,且围绕着center运动,同时center作为参数传递给p1的构造方法,完成二者交互。对象p1与center便是这样的关系。实例化对象center后,便会在指定坐标下绘制实心圆形,center对象的x,y坐标不会变化。而对象p1在实现绘制实心圆形的基础上,又根据center的坐标绘制了指定长轴,短轴的椭圆轨道,同时其内部实现了Thread类,不中断的执行线程。相互的继承关系,使得center和p1可以互不干扰的绘制图形,值得一提的是,在Stras类中的paintComponent()方法中,仍需要调用center对象的draw()方法,因为线程开始时会调用repaint()方法,如果不实现center的draw()方法,那么最终结果将不会显示中心行星。

pt与p1的关系:PThread类继承自Thread类,定义了run()方法,通过其实例化对象p1,可以调用start()方法启动线程,而PThread类在Starts类内部,因而通过p1内的方法可以控制线程,即控制其速度,加速减速,控制其运行与否。

f与各对象的关系:StarFrame继承自JFrame,其实例化对象f将各对象添加进绘画布里,制作了界面,并控制了每个部件的大小、位置,是程序运行的关键。

四、面向对象的理解:

万物皆对象,有些同学问我到底什么才是对象,我回答说有new的都是对象,对象便是类的实例化,本程序中,可以通过对Stars类进行实例化从而创造出无数多个行星(理论上是的),但是内部函数的实现有些问题难以解决,主要便在paintComponent()方法的重写上,再次创建对象后,便会再次重写该方法,于是会出现不可避免的问题,也是无法解决的一个遗憾!

更多java相关内容感兴趣的读者可查看本站专题:《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。



回复

使用道具 举报