java编写弹跳的小球
java弹球游戏代码_Java实现简单的弹球游戏
java弹球游戏代码_Java实现简单的弹球游戏本⽂实例为⼤家分享了Java实现简单的弹球游戏的具体代码,供⼤家参考,具体内容如下该程序主要是⽤于对java图形化界⾯编程进⾏联系,程序实现全部采⽤的是AWT包下的类。
程序仅做参考,供学习使⽤。
import java.awt.Canvas;import java.awt.Color;import java.awt.Dimension;import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.swing.Timer;public class PinBallGame {//创建窗⼝对象private Frame frame = new Frame("弹球游戏");//桌⾯宽度private final int TABLE_WTDTH = 300;//桌⾯⾼度private final int TABLE_HEIGHT = 400;//球拍的⾼度和宽度private final int RACKET_WIDTH = 60;private final int RACKET_HETGHT = 20;//⼩球的⼤⼩private final int BALL_SIZE = 16;//定义变量,记录⼩球的坐标private int ballX = 120;private int ballY = 20;//定义变量,记录⼩球在x和y⽅向上分别移动的速度private int speedY = 10;private int speedX = 5;//定义变量,记录球拍的坐标private int racketX = 120;private final int racketY = 340;//定义变量,标识当前游戏是否已结束private boolean isOver = false;//声明⼀个定时器private Timer timer;//⾃定义⼀个类,继承Canvas,充当画布@SuppressWarnings("serial")private class MyCanvas extends Canvas{@Overridepublic void paint(Graphics g) {//TODO 在这⾥绘制内容if (isOver) {//游戏结束g.setColor(Color.BLUE);g.setFont(new Font("Times",Font.BOLD,30));g.drawString("游戏结束!", 50, 200);}else{//游戏中//绘制⼩球g.setColor(Color.RED);g.fillOval(ballX, ballY, BALL_SIZE, BALL_SIZE);//绘制球拍g.setColor(Color.PINK);g.fillRect(racketX, racketY, RACKET_WIDTH, RACKET_HETGHT); }}}//创建绘画区域MyCanvas drawArea = new MyCanvas();public void init() {//组装视图,游戏逻辑的控制//完成球拍坐标的变化KeyListener listener = new KeyAdapter() {@Overridepublic void keyPressed(KeyEvent e) {//获取当前按下的键int keyCode = e.getKeyCode();if (keyCode == KeyEvent.VK_LEFT) {//0) {racketX -= 10;}}if (keyCode == KeyEvent.VK_RIGHT) {//-> 应该向右移动if (racketX =(TABLE_WTDTH-BALL_SIZE)) {speedX = -speedX;}if (ballY <= 0 || (ballY > racketY-BALL_SIZE && ballX>racketX && ballX < racketX+RACKET_WIDTH)) { speedY = -speedY;}if (ballY > racketY-BALL_SIZE && (ballX < racketX || ballX > racketX+RACKET_WIDTH)) {//当前⼩球超出了球拍的范围,游戏结束//停⽌定时器timer.stop();//修改游戏是否结束的标记isOver = true;//重绘界⾯drawArea.repaint();}//更新⼩球的坐标,重绘界⾯ballX += speedX;ballY += speedY;//重绘界⾯drawArea.repaint();}};timer = new Timer(100, task);timer.start();drawArea.setPreferredSize(new Dimension(TABLE_WTDTH,TABLE_HEIGHT)); frame.add(drawArea);//设置frame最佳⼤⼩,并可视frame.pack();frame.setVisible(true);frame.setLocationRelativeTo(null);frame.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent e) {System.exit(0);}});}public static void main(String[] args) {new PinBallGame().init();}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持脚本之家。
java设计报告
天津大学电气自动化与信息工程学院学院JAVA课程设计报告班级15通信工程姓名刘华宾学号对随机数的研究设计1:活蹦乱跳的小球一、题目简介创建一个应用程序,调用awt包产生一个可视化界面,界面分为四个区域,每个区域分别产生10个颜色相同的小球,位置随机,四个区域小球颜色不同。
二、代码实现import java .awt.*;public class XiaoQiu{public static void main(String args[]){Frame w = new Frame("活蹦乱跳的小球");w.setSize(1024,768); //设置窗体大小w.setBackground(Color.BLACK);w.show();}1.首先用记事本创建一个名叫XiaoQiu的主类,使用awt包中的类Frame生成一个对象名为w的窗体,窗体名为“闪烁的小球”,设置窗体大小为1024*768,背景为黑色。
2.另建一个名为MyPanel的类,此类继承自Panel类,并将此画布放进窗体。
调用paint方法画出3条白线作为边界。
g.setColor(Color.WHITE);g.fillOval((int)(Math.random()*206),(int)(Math.random()*768 ),50, 50);3.在第一区域画出第一个实心的随机圆,调用fillOval方法。
其x坐标先调用方法random产生一个0到1的随机数再乘第一区域最大x坐标206,并将其转为整形。
一开始将206乘在了外面,(int)(Math.random())*206,产生的小球只能贴着界面的左边,因为先取整,x就变为了0,再乘任何数都是0。
同理y坐标写成(int)(Math.random()*768),通过for语句循环增加小球个数。
4.在第二区域画出实心圆。
由于想x,y为具体数值,不是带状区域,一开始写成了g.fillOval((int)((Math.random()*462),(int) (Math.random()*768),50,50),确实在第二区域产生了绿色的小球,但第一区域也混有绿色小球,经过很多次尝试,终于想出一种方法:先在第一区域随机产生一定数量的小球,然后通过增加x坐标的值将其平移到第二区域。
Java基于swing实现的弹球游戏代码
Java基于swing实现的弹球游戏代码这篇文章主要介绍了Java基于swing实现的弹球游戏代码,包含了窗体界面设计与游戏的逻辑功能处理,具有不错的参考借鉴价值,需要的朋友可以参考下本文实例讲述了Java基于swing实现的弹球游戏代码。
分享给大家供大家参考。
主要功能代码如下:复制代码代码如下:package Game;import java.awt.Graphics;import java.awt.Insets;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.util.ArrayList;import java.util.Random;import javax.swing.ButtonGroup;import javax.swing.JMenu;import javax.swing.JMenuBar;import javax.swing.JMenuItem;import javax.swing.JOptionPane;import javax.swing.JRadioButtonMenuItem;/*** 游戏界面类** @author Administrator**/public class Game extends javax.swing.JFrame {private static final long serialVersionUID = 1L;private static Game UI;private Graphics g;private Listener ml;public javax.swing.JLabel text_field;public javax.swing.JProgressBar pBar;private String command;public ArrayList<MyThread> list = new ArrayList<MyThread>(); private javax.swing.JToggleButton button;public static void main(String args[]) {UI = new Game();UI.initUI();}/*** 初始化窗体的方法*/public void initUI() {// 设置标题this.setTitle("是高手就坚持10s");// 设置大小this.setSize(610, 635);// 设置关闭是退出程序this.setDefaultCloseOperation(3);// 设置打开窗体时在屏幕中间显示this.setLocationRelativeTo(null);// 设置窗体的流式布局管理器this.setLayout(new java.awt.FlowLayout());// 设置窗体背景颜色this.getContentPane().setBackground(java.awt.Color.black);// 创建文本标签对象text_field = new javax.swing.JLabel();javax.swing.JLabel lable = new javax.swing.JLabel("时间 :"); // 设置文本标签前景颜色lable.setForeground(java.awt.Color.red);text_field.setForeground(java.awt.Color.red);// 创建进度条对象pBar = new javax.swing.JProgressBar(0, 330);// 创建按钮对象button = new javax.swing.JToggleButton();button.setMargin(new Insets(0, 0, 0, 0));button.setIcon(new javax.swing.ImageIcon("images/Pause.gif")); button.setActionCommand("暂停");// 通过匿名内部类来创建动作监听器java.awt.event.ActionListener button_listener = new java.awt.event.ActionListener() {public void actionPerformed(ActionEvent e) {String com = e.getActionCommand();if (com.equals("暂停")) {button.setMargin(new Insets(0, 0, 0, 0));button.setIcon(newjavax.swing.ImageIcon("images/start.gif"));button.setActionCommand("继续");for (int i = 0; i < list.size(); i++) {list.get(i).PauseThread();}}if (com.equals("继续")) {button.setMargin(new Insets(0, 0, 0, 0));button.setIcon(newjavax.swing.ImageIcon("images/Pause.gif"));button.setActionCommand("暂停");for (int i = 0; i < list.size(); i++) {list.get(i).ContinueThread();}}}};button.addActionListener(button_listener); this.add(button);this.add(lable);this.add(pBar);this.add(text_field);// 的到菜单条JMenuBar bar = creatMenuBar();// 为窗体设置菜单条this.setJMenuBar(bar);// 设置窗体的可见性this.setVisible(true);}/*** 创建菜单条的方法** @return*/public JMenuBar creatMenuBar() {// 创建菜单条对象JMenuBar bar = new JMenuBar();// 创建菜单对象JMenu menu_menu = new JMenu("菜单"); JMenu difficulty_menu = new JMenu("难度"); JMenu help_menu = new JMenu("帮助");// 创建菜单选项对象JMenuItem star_item = new JMenuItem("开始");JMenuItem exit_item = new JMenuItem("退出");JMenuItem help_item = new JMenuItem("游戏说明");JMenuItem about_item = new JMenuItem("关于");// 创建单选选项JRadioButtonMenuItem easy_item = new JRadioButtonMenuItem( "简单");JRadioButtonMenuItem middle_item = new JRadioButtonMenuItem( "中等");JRadioButtonMenuItem hard_item = new JRadioButtonMenuItem( "困难");// 创建一个按钮组ButtonGroup group = new ButtonGroup();// 将单选按钮添加到按钮组中group.add(easy_item);group.add(middle_item);group.add(hard_item);// 将单选按钮添加到菜单中difficulty_menu.add(easy_item);difficulty_menu.add(middle_item);difficulty_menu.add(hard_item);// 通过匿名内部类来创建动作监听器ActionListener listener = new ActionListener() {public void actionPerformed(ActionEvent e) { command = e.getActionCommand();// 如果选择开始,则创建线程对象if (command.equals("开始") && list.size() == 0) { creatBall(20, 1);}// 如果选择退出按钮,则退出程序if (command.equals("退出")) {System.exit(0);}// 如果选择简单按钮if (command.equals("简单") && list.size() == 0) { creatBall(20, 1);}// 如果选择中等按钮if (command.equals("中等") && list.size() == 0) { creatBall(50, 2);}if (command.equals("困难") && list.size() == 0) { creatBall(40, 2);}if (command.equals("游戏说明")) {JOptionPane.showMessageDialog(null, "移动鼠标,用挡板接球,如果接不住,就算输了……\n游戏可以选择难度,包括简单、中等、困难");}if (command.equals("关于")) {JOptionPane.showMessageDialog(null,"这是一个用Java编写的小游戏……\n制作人:沈冠军\n时间:2010年8月\n 版权所有,翻版必究~");}}};// 添加动作监听器star_item.addActionListener(listener);exit_item.addActionListener(listener);easy_item.addActionListener(listener);middle_item.addActionListener(listener);hard_item.addActionListener(listener);help_item.addActionListener(listener);about_item.addActionListener(listener);// 将菜单选项对象添加到菜单对象上menu_menu.add(star_item);menu_menu.add(exit_item);help_menu.add(help_item);help_menu.add(about_item);// 将菜单对象添加到菜单条上bar.add(menu_menu);bar.add(difficulty_menu);bar.add(help_menu);// 返回菜单条对象return bar;}/*** 创建线程对象的方法** @param speed* :速度**/public void creatBall(int speed, int num) { Random ran = new Random();if (ml == null) {g = UI.getGraphics();ml = new Listener(g);UI.addMouseListener(ml);UI.addMouseMotionListener(ml);}for (int i = 0; i < num; i++) {int x = ran.nextInt(600) + 10;int y = ran.nextInt(300) + 100;MyThread th = new MyThread(g, ml, UI, x, y, speed); list.add(th);h.start();}}/*** 得到命令的方法*/public String getCommand() {return command;}}复制代码代码如下:package Game;import java.awt.Color;import java.awt.Graphics;import java.awt.event.MouseAdapter;import java.awt.event.MouseEvent; /*** 鼠标监听器的类** @author Administrator**/public class Listener extends MouseAdapter { private Graphics g;private int x = 5, y = 620;private int width = 100, height = 10;public Listener(Graphics g) {this.g = g;}public void mouseMoved(MouseEvent e) {// 设置画布对象颜色synchronized (this.g) {g.setColor(Color.black);g.fillRect(x, y, width, height);x = e.getX();g.setColor(java.awt.Color.green);g.fillRect(x, y, width, height);}}/*** 得到x的方法** @return:x*/public int getX() {return x;} }。
java编写弹跳的小球
java编写弹跳的小球import java.awt.*;import java.awt.event.*;import javax.swing.*;//可以不是public 类public class jxiaoqiu extends JFrame implements ActionListener,Runnable{Thread thread;JButton startButton,threadButton,stopButton;boolean flag=true;JPanel canvas;static final int WIDTH=15,HEIGHT=15;//居然是WIDTH写错了int x=0,y=0,dx=2,dy=2;public jxiaoqiu(){setTitle("线程对比实验,重画模式");addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});//Container contentPane=getContentPane();//完全没有必要啊canvas=new JPanel();canvas.setBackground(new Color(120,220,250));//contentPane.add(canvas,"Center");//不是BorderLayout.CENTER?add(canvas,BorderLayout.CENTER);//contentPane.add(can)JPanel p=new JPanel();startButton=new JButton("不使用线程");startButton.addActionListener(this);p.add(startButton);threadButton=new JButton("使用线程");threadButton.addActionListener(this);p.add(threadButton);stopButton=new JButton("停止");stopButton.addActionListener(this);p.add(stopButton);//contentPane.add(p,"South");add(p,"South");//add(p,BorderLayout.SOUTH);是正规的setSize(300,200);setVisible(true);}public void actionPerformed(ActionEvent e){if(e.getSource()==startButton){bounce();}else if(e.getSource()==threadButton){start();}else {stop();}}public void move(boolean yn){Graphics g=canvas.getGraphics();g.setColor(canvas.getBackground());//画图的组建使用的方法:设置背景色g.fillOval(x,y,WIDTH,HEIGHT);//擦出之前的小球,否则是画线了Dimension d=canvas.getSize();if(x<0){x=0;dx=-dx;}if(y<0){y=0;dy=-dy;}if(x+WIDTH>d.width){x=d.width-WIDTH;dx=-dx;}//去掉WIDTH,越界后不回来if(y+HEIGHT>d.height){y=d.height-HEIGHT;dy=-dy;}x+=dx;y+=dy;g.setColor(Color.red);//设背景色为红色g.fillOval(x,y,WIDTH,HEIGHT);//画小球if(yn=true){try{thread.sleep(20);}catch(InterruptedException e){} }else {double z=0.371;for(int k=0;k<99999;k++){z=4*z*(1-z);}}}public void start(){flag=true;thread=new Thread(this); thread.start();}public void run(){while(flag){move(true);}}public void stop(){flag=false;}public void bounce(){int i=0;while(flag &&i<1000){move(flag);i++;}}public static void main(String args[]){ new jxiaoqiu();}}。
Java程序设计实验报告2(弹球游戏)参考模板
《Java语言程序设计》课程设计实习报告题目:班级:学号:姓名:同组人员:指导老师:张彬一、实验目的1、掌握Swing图形用户界面编程以及事件处理等,掌握java绘图技术。
2、掌握多线程编程的基本原理,能使用Runnable、ExecutorService等接口进行线程的创建、启动等工作。
3、培养独立查找资料,并解决问题的能力。
二、实验任务1、设计并编程实现弹球游戏:用户能通过GUI组件指定生成小球的数量,每个小球将从随机的位置出现,并具有随机颜色,随机速度以及随机的运动方向,小球沿初始方向匀速运动,当碰到窗口边缘时,小球将依据受力原理改变运动方向(可简化考虑,受力只改变小球的运动方向,小球仍按照初始速度匀速运动,且不考虑小球之间的碰撞)。
鼠标在界面中显示为方块状,玩家需按住鼠标来回移动以避开运动的小球及屏幕四周,如果鼠标碰到任一小球或者窗口四周,则游戏结束。
程序需提供计时功能,并最终显示玩家能坚持多少秒。
2、程序要求:(1)具备相应界面,并通过事件编程,实现相应的GUI组件功能。
(2)使用多线程技术,在程序窗口区域绘制小球,并以线程控制小球的移动,实现动画效果。
(3)实现鼠标与屏幕四周,以及与小球的碰撞检测。
三、开发工具与平台1.开发工具:Eclipse默认是一个和Jbuilder类似的Java开发工具,但它不仅仅只是Java开发工具,只要装上相应的插件,eclipse也可作为其它语言的开发工具。
如C/C++插件(CDT)。
2.开发平台:JDK1.5四、设计思路1.界面设计(1)制作一个简单的面板JFrame,文件保存为bollFrame.java其中为一public的类bollFrame,其构造方法为:bollFrame(int n){super();setTitle("我的弹球小游戏");setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();//得到电脑屏幕大小setSize(450,450);setLocation((dimension.width-game.getWidth())/2-250,(dimension.height-game.getHeight())/2-250);//设置面板显示基中;this.n = n;myBollPanel = new bollPanel(n);//构造一个画板;add(myBollPanel);//将画板放入JFramecreateMenu();//创建菜单;setJMenuBar(bar);}(2)构造画板类,文件保存为bollPanel.java其构造函数如下:bollPanel(int n){this.n = n;// executorThread = Executors.newCachedThreadPool();//创建线程池;mouse = new mouseThread(mxNow,myNow,groupThread,this);//启动鼠标线程;this.setIsOver(false);//游戏开始线程条件的判断;for(int i =0 ;i<n;++i){myBollThread =new bollThread(this);groupThread.add(myBollThread);//executorThread.execute(myBollThread);//小球线程加入线程池;}addMouseListener(this);addMouseMotionListener(this);}Paint()方法如下构造:public void paint(Graphics g){if(!this.getIsOver()) //如果游戏还没结束;{super.paint(g);//清除原先的图像g.setColor(Color.RED);g.setFont(new Font("宋体",Font.BOLD+Font.ITALIC,15));g.drawString("你已坚持:"+getT()+"S", 15, 15);//计时器的显示;for(int i = 0;i<n;++i){//画出每个线程球int xNow =groupThread.get(i).getxNow();int yNow = groupThread.get(i).getyNow();g.setColor(groupThread.get(i).getColor());g.fillOval(xNow,yNow,30,30);if(xNow>(getWidth()-23)||xNow<0){//碰到左右边界;groupThread.get(i).dx = -groupThread.get(i).dx;}if(yNow>(getHeight()-23)||yNow<0){//碰到上下边界;groupThread.get(i).dy = -groupThread.get(i).dy;}groupThread.get(i).setxNow(xNow+groupThread.get(i).getdx());// 设置下一个位置;groupThread.get(i).setyNow(yNow+groupThread.get(i).getdy());}}if(isMouse){g.drawImage(new ImageIcon("boll.gif").getImage(), mxNow, myNow, 40,40, this);//鼠标的图像;}}//end paint();总体界面如下:2.逻辑设计(1).首先,我们考虑到多个小球的运动,实质上是多线程的使用,n个小球我们就同时启动n个线程去控制每个小球的运动。
java小球自由落体反弹代码 -回复
java小球自由落体反弹代码-回复如何使用Java编写一个模拟小球自由落体和反弹的程序?[java小球自由落体反弹代码]在这篇文章中,我将向你展示如何使用Java编写一个简单的程序来模拟小球的自由落体和反弹过程。
我们将使用基本的物理原理和Java编程语言的特性来实现这一模拟效果。
步骤1:创建Java项目和类首先,我们需要创建一个新的Java项目。
在项目中创建一个名为"BallSimulation"的主类,并添加一个名为"Main"的主函数。
public class BallSimulation {public static void main(String[] args) {这里将是我们程序的主体逻辑}}步骤2:定义小球的属性和初始状态在主函数内部的主体逻辑之前,我们需要定义小球的属性和初始状态。
我们需要考虑小球的位置、速度和重力加速度等因素。
public static final double GRAVITY = 9.8; 重力加速度,单位为m/s ²public static final double INITIAL_HEIGHT = 100.0; 小球的初始高度,单位为mpublic static final double COEFFICIENT_OF_RESTITUTION = 0.8; 反弹系数double position = INITIAL_HEIGHT; 小球的初始位置,即初始高度double velocity = 0.0; 小球的初始速度,初始为0在上述代码中,我们定义了重力加速度(9.8 m/s²),小球的初始高度(100.0 m)和反弹系数(0.8)。
然后,我们定义了小球的初始位置和速度,这里使用了双精度浮点数类型。
步骤3:编写小球的模拟逻辑现在,我们可以开始编写小球模拟的主体逻辑了。
我们将使用一个循环来模拟小球自由落体和反弹的过程。
反弹小球小游戏编程实现
反弹小球小游戏编程实现反弹小球是一款经典的小游戏,在游戏中玩家需要控制一个平台,通过移动平台使小球不断反弹,并击碎墙壁上的砖块。
在这篇文章中,我将为大家介绍如何使用编程语言来实现这个有趣的小游戏。
一、游戏背景反弹小球游戏的背景是一个封闭空间,并在空间内布置了多行多列的砖块墙壁。
玩家需要通过移动平台来控制小球的反弹轨迹,让小球击碎尽可能多的砖块,并避免小球落地。
二、游戏规则1. 游戏开始时,小球会从一个初始位置开始运动,玩家需要通过键盘或触摸屏等方式控制平台的移动方向,以控制小球的反弹轨迹。
2. 小球与平台接触时会改变运动方向,玩家可以通过调整平台的位置来控制小球的反弹角度与速度。
3. 小球与砖块碰撞时,砖块会被击碎。
玩家的目标是通过小球的反弹来击碎尽可能多的砖块。
4. 如果小球未能击碎足够数量的砖块并落地,则游戏结束。
5. 游戏设置了计分规则,玩家每击碎一个砖块,得到一定的得分,玩家可以通过得分来评估自己在游戏中的表现。
三、编程实现为了实现反弹小球游戏,我们可以选择使用面向对象编程语言,如Python或Java。
下面我以Python为例,介绍游戏的实现过程。
首先,我们需要导入相关的游戏库,如Pygame。
Pygame是一个用于开发2D游戏的Python库,具有简单易用,跨平台等特点。
接下来,我们可以定义游戏的窗口大小、砖块的尺寸、小球的半径等基本参数,以及小球和平台的初始位置、速度等属性。
然后,我们可以创建游戏窗口,并在窗口中绘制砖块、小球和平台。
接着,我们需要编写游戏的主循环,用于处理玩家的输入、更新游戏对象的状态、检测碰撞等操作。
在主循环中,可以使用条件判断来判断游戏是否结束,以及小球与平台、小球与砖块之间是否发生碰撞。
最后,我们可以在游戏中添加一些音效、动画效果等来增加游戏的趣味性和可玩性。
四、总结通过以上的步骤,我们可以实现一个简单的反弹小球小游戏。
在编程过程中,我们需要熟悉游戏的规则和逻辑,并运用相关的编程知识来实现各种功能。
绘制随机小球来回弹动java代码
Java小球碰撞代码绘制小球随机位置,随机颜色(自概念颜色)来回碰撞。
那个代码只有上下左右四个方向,因此反弹也是固定的45°角。
第一是概念小球(Ball类)package picture;import java.awt.Color;import java.awt.Graphics;public class Ball {private int x,y;//分清概念是左上角极点坐标仍是圆心点坐标(圆心坐标)private int rSize;//半径private Color color;private int speed;private int orientation;private BallPanel panel;//取得小球所属的面板public static final int RIGHT_DOWN=0;public static final int RIGHT_ON=1;public static final int LEFT_DOWN=2;public static final int LEFT_ON=3;public Ball(){}public Ball(int x, int y, int rSize, Color color, int speed, int orientation) {super();this.x = x;this.y = y;this.rSize = rSize;this.color = color;this.speed = speed;this.orientation = orientation;}public void draw(Graphics g){g.setColor(color);g.fillArc(x-rSize, y-rSize/*左上角定点坐标*/, 2*rSize, 2*rSize, 0, 360);}//概念小球绘画的逻辑public void move(){//小球处在不同方向时移动所改变的坐标值switch(orientation){case RIGHT_DOWN:x+=speed;y+=speed;if(x+rSize >=panel.getWidth()){this.orientation = LEFT_DOWN;}if(y+rSize >=panel.getHeight()){this.orientation = RIGHT_ON;}break;case RIGHT_ON:x+=speed;y-=speed;if(x+rSize >=panel.getWidth()){this.orientation = LEFT_ON;}if(y-rSize <= 0 ){this.orientation = RIGHT_DOWN;}break;case LEFT_DOWN:x-=speed;y+=speed;if(x-rSize <= 0 ){this.orientation = RIGHT_DOWN;}if(y+rSize <=panel.getHeight()){this.orientation = LEFT_ON;}break;case LEFT_ON:x-=speed;y-=speed;if(x-rSize <= 0 ){this.orientation = RIGHT_ON;}if(y-rSize <= 0){this.orientation = LEFT_DOWN;}break;}/*碰着边界事件处置*/}public int getX() {return x;}public void setX(int x) {this.x = x;}public int getY() {return y;}public void setY(int y) {this.y = y;}public int getrSize() {return rSize;}public void setrSize(int rSize) { this.rSize = rSize;}public Color getColor() {return color;}public void setColor(Color color) {this.color = color;}public int getSpeed() {return speed;}public void setSpeed(int speed) {this.speed = speed;}public int getOrientation() {return orientation;}public void setOrientation(int orientation) {this.orientation = orientation;}public BallPanel getPanel() {return panel;}public void setPanel(BallPanel panel) { this.panel = panel;}}然后是小球的面板(BallPanel)package picture;import java.awt.Color;import java.awt.Graphics;import javax.swing.JPanel;public class BallPanel extends JPanel{private int x = 0,y = 0;//构造函数提早挪用startRun不适合private Ball[]balls;private Color[]cs = {Color.red,Color.blue,Color.green,Color.cyan,Color.yellow,C olor.gray,Color.orange};public BallPanel(){this.setBackground(Color.WHITE);balls = new Ball[10];for(int i = 0 ;i<balls.length;i++){balls[i] = new Ball((int)(Math.random()*800),(int)(Math.random()*600),(int)(Math.random()*20)+10,cs[(int)(Math.random()*cs.length)],(int)(Math.random()*10)+1,(int)(Math.random()*4));balls[i].setPanel(this);}}public void paint(Graphics g){super.paint(g);for(int i=0;i<balls.length;i++){balls[i].draw(g);}}public void startRun(){new Thread(){public void run(){while(true){for(int i = 0;i<balls.length;i++){balls[i].move();}repaint();//从头画屏幕try {Thread.sleep(2);//画完以后睡一会再循环} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}.start();}}那个地址我需要提示一下,ball类里面关于小球方向的操纵判定,我是能够依照不同的概念。
java实现简单的弹球游戏
java实现简单的弹球游戏弹球游戏实现原理: 隔⼀定时间(⼩于1秒)重新绘制图像,因为Graphics类是⼀个抽象类,创建⼦类的时候需要把所有涉及的⽅法都得重写,所以这⾥使⽤的是创建Canvas的⼦类,只需要重写它的paint()⽅法来实现。
这⾥我们⽤了键盘监听事件、Timer类等。
游戏说明: 该弹球游戏中的⼩球会随着时间增加速度且速度最多是横向速度和垂直速度为10。
当⼩球的y坐标(垂直坐标)⼤于球拍的y坐标(垂直坐标)即判断游戏结束。
控制台显⽰的是⼩球的x⽅向的速度和y⽅向的速度。
import java.awt.*;import java.util.Random;import javax.swing.Timer;import java.awt.event.*;public class PinBall{private Frame f=new Frame("弹球游戏");Random rand=new Random();//桌⾯的宽度以及⾼度private final int TABLE_WIDTH=300;private final int TABLE_HEIGHT=400;//球拍的宽度以及⾼度以及⽔平位置、垂直位置private final int RACKET_WIDTH=60;private final int RACKET_HEIGHT=20;private int racketX=rand.nextInt(24)*10;private int racketY=300;//⼩球的⼤⼩、运⾏速度、坐标private final int BALL_SIZE=16;private int ySpeed=1;private double xyRate=1;private int xSpeed=(int)(xyRate*ySpeed);private int ballX=rand.nextInt(284);private int ballY=1;//创建画布private MyCanvas tableArea=new MyCanvas();//定义时间类Timer timer;//游戏是否结束的旗标private boolean isLose=false;//设置游戏等级private int time_times=1;public void init(){tableArea.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));f.add(tableArea);//定义键盘监听器KeyAdapter keyProcessor=new KeyAdapter(){public void keyPressed(KeyEvent ke){if(ke.getKeyCode()==KeyEvent.VK_LEFT){if(racketX>0)racketX-=10;}if(ke.getKeyCode()==KeyEvent.VK_RIGHT){if(racketX<TABLE_WIDTH-RACKET_WIDTH)racketX+=10;}}};f.addKeyListener(keyProcessor);//tableArea.addKeyListener(keyProcessor);ActionListener taskPerformer=evt->{//⼩球碰到左边框或右边框if(ballX<=0||ballX>=TABLE_WIDTH-BALL_SIZE){xSpeed=-xSpeed;}if(ballY>racketY-BALL_SIZE&&(ballX<racketX||ballX>racketX+RACKET_WIDTH-BALL_SIZE)){timer.stop();isLose=true;tableArea.repaint();}else if(ballY<=0||(ballY>=racketY-BALL_SIZE&&ballX>racketX&&ballX<=racketX+RACKET_WIDTH)){ySpeed=-ySpeed;}ballY+=ySpeed;ballX+=xSpeed;tableArea.repaint();if((xSpeed<10&&xSpeed>-10)&&(ySpeed<10&&ySpeed>-10)){time_times++;}if(time_times==10){if(xSpeed>0){xSpeed++;}else{xSpeed--;}if(ySpeed>0){ySpeed++;}else{ySpeed--;}time_times-=10;System.out.println(xSpeed+" "+ySpeed);}};timer=new Timer(100,taskPerformer);timer.start();f.pack();f.setVisible(true);}class MyCanvas extends Canvas{public void paint(Graphics g){if(isLose){g.setColor(new Color(255,0,0));g.setFont(new Font("Times",Font.BOLD,30));g.drawString("游戏结束",50,200);}else{g.setColor(new Color(240,240,80));g.fillOval(ballX,ballY,BALL_SIZE,BALL_SIZE);g.setColor(new Color(80,80,200));g.fillRect(racketX,racketY,RACKET_WIDTH,RACKET_HEIGHT); }}}public static void main(String[] args){new PinBall().init();}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
java线程实验报告—反弹球
《Java程序设计》实验报告班级:学号:姓名:1.题目(一). 编写Applet程序,其中包含一个滚动的字符串,字符串从左到右运动,当所有的字符都从屏幕的右边消失后,字符串重新从左边出现并继续向右移动。
(二). 编写一个Applet内部显示一个蓝色反弹球的程序,通过一个事件使该球开始运动,在该球撞击Applet边框时,它应从边框弹回并以相反的方向运动。
2.目的和要求(1)掌握实现线程有两种方法:1.实现Ruannable接口 2.继承Thread类(2)学会线程的创建,run()方法的调用,在stop()方法中终止线程。
3.源程序实验(二)源程序:import java.awt.*;import java.applet.*;public class Thread2 extends Applet implements Runnable{int X, Y;public Thread2() {}Thread m_Draw = null;public void init(){m_Draw = new Thread(this);}public void paint(Graphics g){g.setColor(Color.pink);g.fillOval(X,Y, 20, 20);}public void start(){m_Draw.start();try{Thread.sleep(50);}catch(InterruptedException e){}}public void stop(){if(m_Draw.isAlive())m_Draw.stop();}public void run(){int dx=(int)(Math.random()*10)%2+3;int dy=(int)(Math.random()*10)%2+3;try{while(true){X = X + dx;Y = Y + dy;if (Y > getHeight() - 40 || Y < 0) dy = -dy;if (X > getWidth() - 40 || X < 0) dx = -dx;repaint();Thread.sleep(100);}}catch(InterruptedException e){}}}4.数据结果实验(一)结果:实验(二)数据:5.实验心得与体会。
基于Java多线程的弹球游戏程序
• 18•Java 程序设计语言提供了用户使用的多任务并发执行的能力的支持。
处在可执行状态中的应用程序称为进程。
线程是比进程更小的执行单元,一个进程可以分为若干个线程,形成多条执行路线,完成多项操作。
弹球游戏程序应用Java 多线程,完成不同颜色、不同运行速度、不同大小的弹球,每个弹球的运动由一个各自独立的线程控制。
在多线程教学中,为了能够更好地实现教学目标以及教学工作的开展。
通过弹球游戏图形化编程,降低编程难度,减少挫折感、激发学生的学习积极性。
1 引言弹球游戏程序应用Java 语言提供的多线程支持,在程序中完成多种弹球的实现。
通过形象的图形化编程,降低编程难度,减少挫折感、激发学生的学习积极性,并且能更好地实现教学目标的设计以及教学工作的开展。
2 弹球游戏的实现弹球游戏的实现的主要功能:左上9球:从左上方弹出9个颜色随机、大小速度相同、间隔时间90-590ms 的小球;右上单球:从右上方弹出1个颜色、大小、速度随机的小球;左下7彩球:从左下方弹出7个大小、速度、间隔时间相同的7彩小球;右下9球:从右下方弹出9个颜色、大小、速度、间隔时间相同的小球;梦幻9球:产生9个颜色、发球位置、大小、速度随机的小球;昨夜星辰:产生9个发球位置、大小、速度随机的白色小球;其他说明:弹球线程数量为运动小球数量,当线程数量超过200,建议不要再增加弹球数量,窗口标题显示运动小球数量,小球弹出后,大约1min 自动消失。
多线程弹球的实现: class Ball extends Thread { private Color color;private int xsize = 10;//弹球大小 private int ysize= 10; private int x = 0;//弹球位置 private int y = 0;private int dx = 2;//弹球移动步长 private int dy = 2; private Graphics g;// 设置标题要用到private Bounce b;基于Java多线程的弹球游戏程序福建船政交通职业学院信息与智慧交通学院 林恒建public Ball(Bounce b, Color co) { color = co; this.b = b;g = canvas.getGraphics();}//画出弹球public void drawD() {g.setColor(color);g.setXORMode(canvas.getBackground()); g.fillOval(x, y, xsize, YSIZE);}public void draw() { g.setColor(color);g.fillOval(x, y, xsize, ysize);g.setXORMode(canvas.getBackground());}//按步长移动弹球,在窗体边界回弹public void move() { g.fillOval(x, y, xsize, ysize); x += dx; y += dy;if (x < 0) {x = 0; dx = -dx; }// 只在每次事件发生时重新计算窗体内画布的宽和高canvasWidth ,canvasHeight// 让运动更流畅。
弹跳的小球java课程设计
弹跳的小球java课程设计。
一、课程目标知识目标:1. 学生能理解Java编程中面向对象的基本概念,包括类、对象、属性和方法的定义与使用。
2. 学生能够掌握Java中的基本图形绘制方法,以及如何使用事件监听器处理用户的交互。
3. 学生能够理解动画实现的基本原理,包括帧率和时间间隔的处理。
技能目标:1. 学生能够独立编写一个简单的Java程序,实现弹跳小球的动画效果。
2. 学生能够运用所学知识,设计和优化程序结构,使小球弹跳逻辑清晰,代码可读性强。
3. 学生能够通过调试程序,解决基本的编程错误,提高问题解决能力。
情感态度价值观目标:1. 学生通过编程实践,培养逻辑思维能力和解决问题的耐心。
2. 学生在学习过程中,体会到编程带来的成就感,激发对计算机科学的兴趣和热情。
3. 学生能够在团队协作中发挥个人优势,学会分享与交流,培养合作精神。
课程性质:本课程为信息技术课程,旨在通过具体的编程实践活动,让学生掌握Java编程的基本知识,培养其编程能力和创新思维。
学生特点:考虑到学生年级特点,他们对编程有一定的好奇心,但可能缺乏实际操作经验,因此课程设计需循序渐进,注重实践操作。
教学要求:教学中应注重理论与实践相结合,鼓励学生动手实践,注重个体差异,提供个性化指导,确保每位学生都能达到课程设定的学习目标。
二、教学内容1. 面向对象编程基础:- 类的定义与使用- 对象的创建与操作- 属性的定义与访问- 方法的定义与调用2. Java图形用户界面(GUI)编程:- JFrame窗口的创建与设置- 组件的添加与布局- 事件监听器与事件处理- 基本图形绘制方法3. 动画实现原理:- 帧率的概念与设置- 时间间隔控制- 位置与运动轨迹的计算- 动画的刷新与更新4. 弹跳小球项目实践:- 设计小球类及其属性、方法- 实现小球移动与弹跳逻辑- 处理边界碰撞与响应- 优化代码结构与性能教学内容依据课程目标进行选择和组织,注重科学性和系统性。
java课程设计——红色小弹球
JA V A课程设计报告题目红色小球反弹程序院系信工院班级14计本1学号**********姓名赵佳目录摘要 (3)1、概述 (4)1.1题目简介 (4)1.2功能分析 (4)1.3功能实现 (4)1.3.1颜色选择功能的实现 (4)1.3.2速度选择功能的实现 (4)1.3.3小球出现的位置的功能实现 (5)1.3.4开始/添加功能的实现 (5)1.3.5暂停功能的实现 (5)1.3.5清除功能的实现 (6)2、程序的分析与设计 (7)2.1程序分析 (7)2.2程序设计 (7)2.2.1main方法用于程序测试 (7)2.2.2小球运动线程 (7)2.2.3小球的画板 (8)2.2.4添加小球 (8)2.2.5绘制画板 (8)2.2.6小球类 (9)2.2.7获取小球的形状 (9)2.2.8获取小球的颜色 (9)3、系统实现 (10)3.1实现代码 (10)3.2测试结果 (10)4、总结 (12)附录2 (15)摘要JA V A是目前最流行的软件开发语言之一,称为网络上的“世界语”。
JA V A 适合开发基于多媒体、与平台无关、用面向对象的方法进行的基于Internet、Intranet、Extranet的Applet和应用程序。
它具有简单高效、面向对象、不依赖机器结构的特点,支持多线程、分布和并发机制。
用JA V A开发的应用软件在可移植性、健壮性、安全性等方面大大优于已存在的其他编程语言。
JA V A是一门包含多种知识的学科,提供了丰富的类库,能最大限度地利用网络。
JA V A可广泛用于面向对象的事件描述、处理面向对象的企业型的应用开发,还应用于Internet 系统管理、Web页面设计、Internet可视化软件开发等方面。
在学习的过程中我学到了许多以前没有学到的概念和新鲜资讯。
运用这些知识可以完成老师交给我的课程设计任务。
1、概述1.1题目简介用java语言,使用Eclipse工具来进行编辑运行一个简单红色反弹球程序。
Java实力弹弹球实现代码
Java实⼒弹弹球实现代码先看看效果图:直接上代码了。
微调按钮加画布画⼏个圆,再实现监听。
package cn.hncu.threadDemo.thread2;import java.awt.Canvas;import java.awt.Color;import java.awt.Graphics;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.FocusEvent;import java.awt.event.FocusListener;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JSpinner;import javax.swing.Timer;import javax.swing.event.ChangeEvent;import javax.swing.event.ChangeListener;public class BallsJFrame extends JFrame implements ChangeListener{private BallsCanvas ball;private JSpinner spinner;public BallsJFrame(){super("弹弹球");this.setBounds(300, 200, 400, 300);this.setDefaultCloseOperation(EXIT_ON_CLOSE);Color colors[] = {Color.red,Color.green,Color.blue,Color.magenta,Color.cyan};ball = new BallsCanvas(colors,100);this.getContentPane().add(ball);//默认是CENTER位置JPanel panel = new JPanel();this.getContentPane().add(panel,"South");panel.add(new JLabel("Delay"));spinner = new JSpinner();spinner.setValue(100);panel.add(spinner);spinner.addChangeListener(this);this.setVisible(true);}@Overridepublic void stateChanged(ChangeEvent e) {int value = Integer.parseInt(""+spinner.getValue());ball.setDelay(value);}public static void main(String[] args) {new BallsJFrame();}}class BallsCanvas extends Canvas implements ActionListener, FocusListener{private Ball balls[];//存放所有的球private Timer timer;//javax.swing.Timerpublic BallsCanvas(Color colors[] ,int delay){this.balls = new Ball[colors.length];for(int i=0,x=40;i<colors.length;i++,x+=20){this.balls[i] = new Ball(x,x,colors[i]);}//让当前画布监听焦点事件this.addFocusListener(this);timer = new Timer(delay,this);timer.start();}public void setDelay(int delay){timer.setDelay(delay);}@Overridepublic void paint(Graphics g) {for(int i=0;i<this.balls.length;i++){g.setColor(balls[i].color);//让每个球的坐标变化⼀下---(x坐标)balls[i].x = balls[i].left ? balls[i].x-10:balls[i].x+10; //当球碰壁时,更改球的⽅向if(balls[i].x<=0||balls[i].x>=this.getWidth()-24){balls[i].left = !balls[i].left;//切换⽅向}//让每个球的坐标变化⼀下---(y坐标)balls[i].y = balls[i].up ? balls[i].y-10:balls[i].y+10; //当球碰壁时,更改球的⽅向if(balls[i].y<=0||balls[i].y>=this.getHeight()-22){ balls[i].up = !balls[i].up;//切换⽅向}g.fillOval(balls[i].x, balls[i].y, 20, 20);}}@Overridepublic void actionPerformed(ActionEvent e) {//System.out.println("aaa");repaint();//刷新画布.调⽤paint(Graphics g)}@Overridepublic void focusGained(FocusEvent e) {timer.stop();}@Overridepublic void focusLost(FocusEvent e) {timer.restart();}private static class Ball{int x,y;boolean up,left;Color color;public Ball(int x, int y, Color color) {this.x = x;this.y = y;this.color = color;up = left = false;}}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
java递归算法计算小球落地回弹的距离
java递归算法计算小球落地回弹的距离小球落地回弹的距离是一个经典的物理问题,也是计算机科学中常用的递归算法案例之一。
在这篇文章中,我们将探讨使用Java编写递归算法来计算小球落地回弹的距离。
让我们来理解一下问题的背景和假设条件。
假设有一个小球从某个高度自由落下,每次落地后都会以固定的弹力反弹回去。
我们需要计算小球在经过一定次数的落地和反弹后,最终停下来的位置。
为了简化问题,我们假设小球的高度和弹力都是理想的,没有空气阻力等因素的影响。
我们需要考虑的是小球每次反弹后的高度变化情况。
在每次落地和反弹后,小球的高度都会发生变化。
假设小球在第一次落地前的初始高度为H,落地后反弹到的高度为h,反弹系数为b(0 < b < 1)。
那么,我们可以得到以下关系式:h = b * H其中,h表示小球每次反弹后的高度,H表示小球的初始高度。
根据这个关系式,我们可以发现,小球在每次反弹后的高度都是上一次的高度乘以反弹系数。
接下来,我们可以定义一个递归函数来计算小球在经过n次反弹后的高度。
假设这个函数为calculateDistance,函数的输入参数包括初始高度H、反弹系数b和反弹次数n。
在函数的实现中,我们首先需要判断递归终止的条件。
当反弹次数n为0时,表示小球已经停下来了,此时返回初始高度H。
如果反弹次数n大于0,我们可以通过递归调用calculateDistance 函数来计算小球在经过n-1次反弹后的高度,然后将该高度乘以反弹系数b,即可得到小球在经过n次反弹后的高度。
下面是使用Java编写的递归算法的代码示例:```javapublic class BallDistanceCalculator {public static double calculateDistance(double initialHeight, double bounceFactor, int bounceTimes) {// 递归终止条件if (bounceTimes == 0) {return initialHeight;}// 递归调用计算小球在经过n-1次反弹后的高度double previousHeight = calculateDistance(initialHeight, bounceFactor, bounceTimes - 1);// 计算小球在经过n次反弹后的高度double currentHeight = previousHeight * bounceFactor;return currentHeight;}public static void main(String[] args) {double initialHeight = 100.0; // 初始高度double bounceFactor = 0.8; // 反弹系数int bounceTimes = 5; // 反弹次数double distance = calculateDistance(initialHeight, bounceFactor, bounceTimes);System.out.println("小球在经过" + bounceTimes + "次反弹后的距离为:" + distance);}}```在上述代码中,我们定义了一个名为BallDistanceCalculator的类,其中包含了一个静态方法calculateDistance来计算小球的距离。
用java实现跳动的小球示例代码
⽤java实现跳动的⼩球⽰例代码实现效果为⼀个⼩球接触左右侧时,会反向的运动。
import javafx.application.Application;import javafx.event.ActionEvent;import javafx.event.EventHandler;import javafx.scene.Group;import javafx.scene.Scene;import javafx.scene.control.Button;import javafx.scene.paint.Color;import javafx.scene.shape.Ellipse;import javafx.stage.Stage;import java.util.Timer;import java.util.TimerTask;public class BallMove extends Application {//x记录⼩球的横坐标,默认值为初始位置static int x = 200;//e为⼩球static Ellipse e = new Ellipse();//temp记录⼩球的移动情况:当temp为left时,左移;temp为right时,右移static String temp = "left";//创建计时器static Timer t = new Timer();//创建记录器,当多次点击过“确定”按钮后,只有第⼀次点击有效static boolean record = true;public static void main(String[] args) {launch(args);}public void start(Stage s) {//创建Group⾯板Group root = new Group();//创建场景Scene scene = new Scene(root, 400, 250, Color.WHITE);//创建按钮Button start = new Button("开始");Button stop = new Button("停⽌");//创造⼀个⼩球e.setCenterX(x);e.setCenterY(90);e.setRadiusX(50);e.setRadiusY(50);e.setFill(Color.RED);//放置开始按钮start.setLayoutX(100);start.setLayoutY(180);//放置停⽌按钮stop.setLayoutX(250);stop.setLayoutY(180);//为开始按钮添加事件start.setOnAction(new EventHandler<ActionEvent>() {public void handle(ActionEvent event) {System.out.println("开始按钮被触发");if(record==true) {t = new Timer();t.schedule(new TimerTask() {public void run() {e.setFill( Color.rgb((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));//⼩球的半径为50,场景的宽度为400,那么⼩球横坐标达到50或者350时,转向移动if (x < 50) { temp = "right"; }if (x > 350) { temp = "left"; }if (temp.equals("left")) { e.setCenterX(x -= 5);} else { e.setCenterX(x += 5); }}}, 0, 25);}//“开始"按钮被点击且事件被触发,record=false;record=false;}});//为停⽌按钮添加事件stop.setOnAction(new EventHandler<ActionEvent>() {public void handle(ActionEvent event) {System.out.println("停⽌按钮被触发");record = true;t.cancel();}});root.getChildren().add(e);root.getChildren().add(start);root.getChildren().add(stop);s.setTitle("移动⼩球");s.setScene(scene);s.show();}}我还做了⼀个升级版,扩展到上下左右⼀起移动,代码如下import javafx.application.Application;import javafx.scene.Group;import javafx.scene.Scene;import javafx.scene.control.Button;import javafx.scene.paint.Color;import javafx.scene.shape.Ellipse;import javafx.scene.shape.Line;import javafx.stage.Stage;import java.util.Timer;import java.util.TimerTask;public class BallMove2 extends Application {//x记录⼩球的横坐标,默认值为初始位置static int x = 200;//y记录⼩球的纵坐标,默认值为初始位置static int y = 90;//distance_x记录⼩球每次横向移动的距离,取1到4之间的随机数static double distance_x = Math.random()*4+1;//distance_y记录⼩球每次纵向移动的距离,由于每次移动的距离为5,由distance_x可求出distance_y static double distance_y = Math.sqrt(25-distance_x*distance_x);//e为⼩球static Ellipse e = new Ellipse();//temp1记录⼩球的横向移动情况:当temp为left时,左移;temp为right时,右移static String temp1 = "left";//temp2记录⼩球的纵向移动情况:当temp为up时,上移;temp为down时,下移static String temp2 = "down";//创建计时器static Timer t = new Timer();//创建记录器,当多次点击过“确定”按钮后,只有第⼀次点击有效static boolean record_start = true;static boolean record_stop = false;public static void main(String[] args) {launch(args);}public void start(Stage s) {/*System.out.println(distance_x+"***"+distance_y);*///创建Grooup⾯板Group root = new Group();//创建场景Scene scene = new Scene(root, 400, 250, Color.WHITE);//创建按钮Button start = new Button("开始");Button stop = new Button("停⽌");//创建⼀条分割线,分割⼩球和按钮Line l = new Line();//放置线条l.setStartX(0);l.setStartY(160);l.setEndY(160);l.setEndX(400);//放置⼩球e.setCenterX(x);e.setCenterY(y);e.setRadiusX(20);e.setRadiusY(20);e.setFill(Color.RED);//放置开始按钮start.setLayoutX(100);start.setLayoutY(190);//放置停⽌按钮stop.setLayoutX(250);stop.setLayoutY(190);//为开始按钮添加事件start.setOnAction(event -> {/*创建⼀个⼩球随机⾓度移动的思路:假设⼩球每次移动的距离为5,当横坐标或者纵坐标其中⼀个确定时,另外可以根据三⾓函数求出现在可以⽤随机函数,令横坐标为1到4之间随机的数字,那么横坐标也可以由此求出如何验证每次⾓度不同?当点击“停⽌”按钮之后,再次点击“停⽌”按钮即可重置⼩球位置和移动的⾓度* */if(record_start) {t = new Timer();t.schedule(new TimerTask() {public void run() {//随机取颜⾊,just have a fun//e.setFill( Color.rgb((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));//⼩球的半径为20,场景的宽度为400,那么⼩球横坐标达到20或者380时,转向移动if (x < 20) { temp1 = "right"; }if (x > 380) { temp1 = "left"; }//⼩球的半径为20,场景的⾼度为160,那么⼩球纵坐标达到20或者140时,转向移动if (y < 20) { temp2 = "up";}if (y > 140) { temp2 = "down"; }if (temp1.equals("left")) { e.setCenterX(x -= distance_x);} else { e.setCenterX(x += distance_x); }if (temp2.equals("down")) { e.setCenterY(y -= distance_y);} else { e.setCenterY(y += distance_y); }}}, 0, 20);}//“开始"按钮被点击且事件被触发,record=false;record_start = false;record_stop = false;});//为停⽌按钮添加事件stop.setOnAction(event -> {/*System.out.println("停⽌按钮被触发");*///当第⼆次点击"停⽌"时,⼩球重置if(record_stop){//重置横向和纵向移动的距离distance_x = Math.random()*4+1;distance_y = Math.sqrt(25-distance_x*distance_x);//重置⼩球的位置e.setCenterX(x = 200);e.setCenterY(y = 90);record_stop = false;}record_stop = true;record_start = true;t.cancel();});root.getChildren().addAll(start,stop,l,e);s.setTitle("弹跳⼩球");s.setScene(scene);s.show();}}以上代码设置了个彩蛋,不知道你能不能找到!总结到此这篇关于⽤java实现跳动的⼩球⽰例代码的⽂章就介绍到这了,更多相关java 跳动的⼩球内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。
java小球自由落体反弹代码
java小球自由落体反弹代码好的,在 Java 中实现小球自由落体反弹,可以使用`java.util.Random`类来生成随机数以模拟小球的初始位置和速度,并使用`Thread.sleep`方法来控制小球的运动速度。
以下为示例代码:```javaimport java.awt.Color;import java.awt.Graphics;import java.util.Random;public class Ball {// 小球半径private static final int BALL_RADIUS = 10;// 小球颜色private static final Color BALL_COLOR = Color.RED;// 小球初始位置 x 坐标private int x;// 小球初始位置 y 坐标private int y;// 小球速度 x 方向private int vx;// 小球速度 y 方向private int vy;public Ball() {// 随机生成小球初始位置x = (int) (Math.random() * 800);y = (int) (Math.random() * 600);// 随机生成小球初始速度vx = (int) (Math.random() * 10) - 5;vy = (int) (Math.random() * 10) - 5;public void move() {x += vx;y += vy;// 如果小球超出边界,反弹if (x < 0 || x > 800 - BALL_RADIUS) {vx = -vx;}if (y < 0 || y > 600 - BALL_RADIUS) {vy = -vy;}}public void draw(Graphics g) {g.setColor(BALL_COLOR);g.fillOval(x, y, BALL_RADIUS * 2, BALL_RADIUS * 2); }public static void main(String[] args) {Ball ball = new Ball();// 创建绘图窗口Graphics g = createGraphics();while (true) {ball.move();ball.draw(g);// 控制小球运动速度try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}}public static Graphics createGraphics() {// 获取窗口对象javax.swing.JFrame frame = new javax.swing.JFrame("自由落体");frame.setSize(800, 600);frame.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);frame.setVisible(true);// 获取绘图上下文return frame.getGraphics();}}```在上述代码中,首先创建了一个`Ball`类,用于表示小球的属性和行为。
求小球反弹高度,及落地过程中经过的路程~~~java代码
求⼩球反弹⾼度,及落地过程中经过的路程~~~java代码总结:这种思想,不是⼀想就突然出现在脑海⾥的
package com.c2;
//题⽬:⼀球从100⽶⾼度⾃由落下,每次落地后反跳回原⾼度的⼀半;
//再落下,求它在第10次落地时,共经过多少⽶?第10次反弹多⾼?
//总结:这⾥的关键在于反弹⾼度,第⼀次反弹后,再弹起来绝对不会是100⽶⾼,第⼆次反弹50⽶,落地后
//50⽶,再反弹只有⼀半了25⽶,在落地,也是25⽶,然后弹起来只有12.5⽶……………………
//不要想的过于复杂,累计求和。
看起来很简单,如果是⼀道数学应⽤题,结果会怎样呢?⼆元⼀次⽅程式吗??
public class Oll {
public static void main(String[] args) {
double h=100;
double s=100;//代表第⼀次的⾼度,s
for(int i=0;i<10;i++){
h=h/2;//反弹的⾼度
s+=h*2;//经过的⽶数
}
System.out.println("反弹⾼度:"+h/2);
System.out.println("共经过多少⽶:"+s);
}
}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
import java.awt.event.*;
import javax.swing.*;
//可以不是public 类
public class jxiaoqiu extends JFrame implements ActionListener,Runnable{
if(y<0){y=0;dy=-dy;}
if(x+WIDTH>d.width){x=d.width-WIDTH;dx=-dx;}//去掉WIDTH,越界后不回来
if(y+HEIGHT>d.height){y=d.height-HEIGHT;dy=-dy;}
x+=dx;y+=dy;
g.setColor(Color.red);//设背景色为红色
p.add(startButton);
threadButton=new JButton("使用线程");
threadButton.addActionListener(this);
p.add(threadButton);
stopButton=new JButton("停止");
stopButton.addActionListener(this);
if(e.getSource()==startButton){
bounce();
}
else if(e.getSource()==threadButton){
start();
}
else {
stop();
}
}
public void move(boolean yn){
Graphics g=canvas.getGraphics();
z=4*z*(1-z);
}
}
}
public void start(){
flag=true;
thread=new Thread(this);
thread.start();
}
public void run(){
while(flag){
move(true);
}
}
public void stop(){
p.add(stopButton);
//contentPane.add(p,"South");
add(p,"South");//add(p,BorderLayout.SOUTH);是正规的
setSize(300,200);
setVisible(true);
}
public void actionPerformed(ActionEvent e){
Thread thread;
JButton startButton,threadButton,stopButton;
boolean flag=true;
JPanel canvas;
static final int WIDTH=15,HEIGHT=15;//居然是WIDTH写错了
int x=0,y=0,dx=2,dy=2;
public jxiaoqiu(){
setTitle("线程对比实验,重画模式");
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
//Container contentPane=getContentPane();//完全没有必要啊
canvas=new JPanel();
canvas.setBackground(new Color(120,220,250));
//contentPane.add(canvas,"Center");//不是BorderLayout.CENTER?
flag=false;
} Βιβλιοθήκη public void bounce(){
int i=0;
while(flag &&i<1000){
move(flag);
i++;
}
}
public static void main(String args[]){
new jxiaoqiu();
}
g.fillOval(x,y,WIDTH,HEIGHT);//画小球
if(yn=true){
try{
thread.sleep(20);
}
catch(InterruptedException e){}
}
else {
double z=0.371;
for(int k=0;k<99999;k++){
add(canvas,BorderLayout.CENTER);
//contentPane.add(can)
JPanel p=new JPanel();
startButton=new JButton("不使用线程");
startButton.addActionListener(this);
g.setColor(canvas.getBackground());//画图的组建使用的方法:设置背景色
g.fillOval(x,y,WIDTH,HEIGHT);//擦出之前的小球,否则是画线了
Dimension d=canvas.getSize();
if(x<0){x=0;dx=-dx;}
}�