《Java零基础实战》配套代码

  • 更新时间:
  • 9484人关注
  • 点击下载

给大家带来的是《Java零基础实战》配套代码,介绍了关于Java、Java零基础、Java实战、Java方面的内容,本书是由人民邮电出版社出版,已被217人关注,由热心网友冉柔煦 提供,目前本书在Java类综合评分为:7.8分

资源详情相关推荐
《《Java零基础实战》配套代码》封面
  • 出版社:人民邮电出版社
  • 作者:宁楠
  • 大小:103.44 KB
  • 类别:Java
  • 热度:331
  • 零基础学Java(第4版)
  • 零基础学Java(第5版)
  • 零基础Java学习笔记
  • Java项目开发实战入门
  • 编辑推荐

    1.通俗易懂 久经教学考验的Java入门教程,巧用类比式讲解,核心概念轻松掌握; 
    2.快速上手 实践为主,理论相辅,让零基础的新手也可以快速掌握Java编程; 
    3.示例丰富 近300段代码示例让理论落地,5大项目实战贯穿核心技能点; 
    4.精巧实用 内容经过反复推敲,源自研发一线的经年积累,强化编程实操技巧; 
    5.良师相伴 读者专属QQ群,作者在线答疑解惑,重磅学习资料实时放送; 
    6.拓展学习 作者秘制的配套教程和Java核心面试题答疑,与本书无缝衔接。

    内容简介

    Java是一门经典的面向对象的编程语言,具有很强的通用性、平台可移植性和安全性,并且一直在编程语言排行榜上稳居前列。本书旨在通过浅显易懂的语言,讲清Java的特性,帮助读者掌握面向对象编程的核心思想;同时,通过丰富实用的代码示例,帮助读者快速上手,轻松掌握Java语言。 
    本书分11章,带领读者从零开始认识Java,了解Java,会用并且用好Java。书中不仅对Java的运行机制、体系结构和基本的安装配置进行了讲解,还对面向对象编程的思想进行了深刻的剖析和总结,同时作者以丰富的代码示例演示了基本的Java编程。除此之外,本书还对Java的集合框架、多线程、实用类、IO流、反射机制和Web编程等进行了讲解,让读者在掌握基本编程技巧的基础上,进一步探索Java的强大功能。 
    本书由Java开发老手编写,汇集了丰富的实践经验和实用的编程思想,非常适合想入门Java的新手学习,也适合用作计算机相关专业的辅助教程,其他非科班出身的想学习Java编程的读者也可以参考学习。

    作者简介

    宁楠,Java开发工程师,拥有多年软件研发、系统架构经验,历任开发工程师、项目经理、技术总监。热爱技术交流和知识分享,在多个平台输出技术博客、图文课程和视频课程,公众号原创博主、知识星球嘉宾、慕课网讲师、Git Chat认证作者,对Java编程有着丰富的经验和独到的见解。

    目录

    • 第 1部分 Java基础 n
    • 第 1章 Java初体验 2 n
    • 1.1 Java概述 2 n
    • 1.1.1 什么是Java 2 n
    • 1.1.2 Java的运行机制 4 n
    • 1.1.3 Java三大体系 5 n
    • 1.2 搭建Java开发环境 6 n
    • 1.2.1 安装配置Java10 6 n
    • 1.2.2 Java程序开发步骤 11 n
    • 1.3 小结 13 n
    • 第 2章 Java入门 14 n
    • 2.1 开发第 一个Java程序 14 n
    • 2.1.1 使用Eclipse开发程序 14 n
    • 2.1.2 编码规范 21 n
    • 2.1.3 注释 24 n
    • 2.1.4 关键字 27 n
    • 2.2 变量 29 n
    • 2.2.1 什么是变量 29 n
    • 2.2.2 如何使用变量 30 n
    • 2.3 基本数据类型 32 n
    • 2.4 数据类型转换 33 n
    • 2.4.1 自动转换 33 n
    • 2.4.2 强制转换 35 n
    • 2.5 运算符 36 n
    • 2.5.1 赋值运算符 36 n
    • 2.5.2 基本算术运算符 37 n
    • 2.5.3 复合算术运算符 40 n
    • 2.5.4 关系运算符 41 n
    • 2.5.5 逻辑运算符 43 n
    • 2.5.6 条件运算符 46 n
    • 2.5.7 位运算符 47 n
    • 2.6 小结 50 n
    • 第3章 Java进阶 51 n
    • 3.1 流程控制 51 n
    • 3.1.1 if-else 51 n
    • 3.1.2 多重if 53 n
    • 3.1.3 if嵌套 55 n
    • 3.1.4 switch-case 56 n
    • 3.2 循环 58 n
    • 3.2.1 while循环 58 n
    • 3.2.2 do-while循环 61 n
    • 3.2.3 for循环 63 n
    • 3.2.4 while、do-while和 n
    • for这3种循环的区别 64 n
    • 3.2.5 双重循环 65 n
    • 3.2.6 终止循环 69 n
    • 3.3 数组 70 n
    • 3.3.1 什么是数组 70 n
    • 3.3.2 数组的基本要素 71 n
    • 3.3.3 如何使用数组 71 n
    • 3.3.4 数组的常用操作及 n
    • 方法 74 n
    • 3.3.5 二维数组 78 n
    • 3.4 综合练习 80 n
    • 3.5 小结 86 n
    • 第 2部分 Java面向对象 n
    • 第4章 面向对象基础 88 n
    • 4.1 什么是面向对象 88 n
    • 4.2 类与对象 89 n
    • 4.2.1 类与对象的关系 89 n
    • 4.2.2 定义类 90 n
    • 4.2.3 构造函数 91 n
    • 4.2.4 创建对象 92 n
    • 4.2.5 使用对象 93 n
    • 4.2.6 this关键字 93 n
    • 4.2.7 方法重载 94 n
    • 4.2.8 成员变量和局部变量 95 n
    • 4.3 封装 98 n
    • 4.3.1 什么是封装 98 n
    • 4.3.2 封装的步骤 99 n
    • 4.3.3 static关键字 101 n
    • 4.4 继承 105 n
    • 4.4.1 什么是继承 105 n
    • 4.4.2 子类访问父类 106 n
    • 4.4.3 子类访问权限 109 n
    • 4.4.4 方法重写 111 n
    • 4.4.5 方法重写VS方法重载 114 n
    • 4.5 多态 114 n
    • 4.5.1 什么是多态 114 n
    • 4.5.2 多态的使用 117 n
    • 4.5.3 抽象方法和抽象类 119 n
    • 4.6 小结 122 n
    • 第5章 面向对象进阶 123 n
    • 5.1 Object类 123 n
    • 5.1.1 认识Object类 123 n
    • 5.1.2 重写Object类的方法 125 n
    • 5.2 包装类 131 n
    • 5.2.1 什么是包装类 131 n
    • 5.2.2 装箱与拆箱 132 n
    • 5.3 接口 135 n
    • 5.3.1 什么是接口 135 n
    • 5.3.2 如何使用接口 136 n
    • 5.3.3 面向接口编程的 n
    • 实际应用 138 n
    • 5.4 异常 142 n
    • 5.4.1 什么是异常 142 n
    • 5.4.2 异常的使用 142 n
    • 5.4.3 异常类 146 n
    • 5.4.4 throw和throws 147 n
    • 5.4.5 自定义异常类 151 n
    • 5.5 综合练习 152 n
    • 5.6 小结 157 n
    • n
    • 第3部分 Java高级应用 n
    • 第6章 多线程 160 n
    • 6.1 进程与线程 160 n
    • 6.2 Java中线程的使用 163 n
    • 6.2.1 继承Thread类 163 n
    • 6.2.2 实现Runnable接口 165 n
    • 6.2.3 线程的状态 166 n
    • 6.3 线程调度 167 n
    • 6.3.1 线程休眠 167 n
    • 6.3.2 线程合并 169 n
    • 6.3.3 线程礼让 171 n
    • 6.3.4 线程中断 173 n
    • 6.4 线程同步 175 n
    • 6.4.1 线程同步的实现 175 n
    • 6.4.2 线程安全的单例模式 183 n
    • 6.4.3 死锁 187 n
    • 6.4.4 重入锁 189 n
    • 6.4.5 生产者消费者模式 194 n
    • 6.5 综合练习 196 n
    • 6.6 小结 198 n
    • 第7章 集合框架 199 n
    • 7.1 集合的概念 199 n
    • 7.2 Collection接口 200 n
    • 7.2.1 Collection接口的定义 200 n
    • 7.2.2 Collection的子接口 201 n
    • 7.3 List接口 201 n
    • 7.3.1 List接口的定义 201 n
    • 7.3.2 List接口的实现类 202 n
    • 7.4 Set接口 207 n
    • 7.4.1 Set接口的定义 207 n
    • 7.4.2 Set接口的实现类 208 n
    • 7.5 Map接口 214 n
    • 7.5.1 Map接口的定义 214 n
    • 7.5.2 Map接口的实现类 215 n
    • 7.6 Collections工具类 220 n
    • 7.7 泛型 222 n
    • 7.7.1 泛型的概念 222 n
    • 7.7.2 泛型的应用 224 n
    • 7.7.3 泛型通配符 226 n
    • 7.7.4 泛型上限和下限 227 n
    • 7.7.5 泛型接口 228 n
    • 7.8 综合练习 229 n
    • 7.9 小结 232 n
    • 第8章 实用类 233 n
    • 8.1 枚举 233 n
    • 8.2 Math 236 n
    • 8.3 Random 237 n
    • 8.4 String 238 n
    • 8.4.1 String实例化 238 n
    • 8.4.2 String常用方法 242 n
    • 8.5 StringBuffer 244 n
    • 8.6 日期类 246 n
    • 8.6.1 Date 246 n
    • 8.6.2 Calendar 248 n
    • 8.7 小结 249 n
    • 第9章 IO流 250 n
    • 9.1 File类 250 n
    • 9.2 字节流 251 n
    • 9.3 字符流 257 n
    • 9.4 处理流 265 n
    • 9.5 缓冲流 267 n
    • 9.5.1 输入缓冲流 268 n
    • 9.5.2 输出缓冲流 274 n
    • 9.6 序列化和反序列化 279 n
    • 9.6.1 序列化 279 n
    • 9.6.2 反序列化 280 n
    • 9.7 小结 281 n
    • n
    • 第4部分 底层扩展 n
    • 第 10章 反射 284 n
    • 10.1 Class类 284 n
    • 10.2 获取类结构 287 n
    • 10.2.1 获取类的接口 288 n
    • 10.2.2 获取父类 289 n
    • 10.2.3 获取构造函数 290 n
    • 10.2.4 获取方法 292 n
    • 10.2.5 获取成员变量 294 n
    • 10.3 反射的应用 296 n
    • 10.3.1 反射调用方法 296 n
    • 10.3.2 反射访问成员变量 299 n
    • 10.3.3 反射调用构造函数 302 n
    • 10.4 动态代理 303 n
    • 10.5 小结 309 n
    • 第 11章 网络编程 310 n
    • 11.1 IP与端口 312 n
    • 11.1.1 IP 312 n
    • 11.1.2 端口 314 n
    • 11.2 URL和URLConnection 314 n
    • 11.2.1 URL 314 n
    • 11.2.2 URLConnection 317 n
    • 11.3 TCP协议 318 n
    • 11.4 UDP协议 322 n
    • 11.5 多线程下的网络编程 324 n
    • 11.6 综合练习 326 n
    • 11.7 小结 328
    展开阅读
    精选笔记1:java版飞机大战实战项目详细步骤

    19小时23分钟前回答

    本文为大家分享了java版飞机大战实战项目,供大家参考,具体内容如下

    分析

    飞机大战 首先对这个游戏分析,在屏幕上的物体都是飞行物,我们可以把建一个类,让其他飞行物继承这个类.游戏中应有英雄机(也就是自己控制的飞机)、敌人。而敌人应该分为打死给分的飞机(就是普通飞机),另一种就是打死有奖励的敌人。他们都应该是飞行物的子类,我们也可以为普通飞机和给奖励的敌人设一个接口让他们去实现接口,这样有利于以后的扩展,我在这里给的简化版的飞机大战,主要是为了让大家了解面向对象。

    第一步建立飞行物类

    import java.awt.image.BufferedImage;
     
    /**
     * 飞行物(敌机,蜜蜂,子弹,英雄机)
     */
    public abstract class FlyingObject {
     protected int x; //x坐标
     protected int y; //y坐标
     protected int width; //宽
     protected int height; //高
     protected BufferedImage image; //图片
     
     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 getWidth() {
     return width;
     }
     
     public void setWidth(int width) {
     this.width = width;
     }
     
     public int getHeight() {
     return height;
     }
     
     public void setHeight(int height) {
     this.height = height;
     }
     
     public BufferedImage getImage() {
     return image;
     }
     
     public void setImage(BufferedImage image) {
     this.image = image;
     }
     
     /**
     * 检查是否出界
     * @return true 出界与否
     */
     public abstract boolean outOfBounds();
     
     /**
     * 飞行物移动一步
     */
     public abstract void step();
     
     /**
     * 检查当前飞行物体是否被子弹(x,y)击(shoot)中
     * @param Bullet 子弹对象
     * @return true表示被击中了
     */
     public boolean shootBy(Bullet bullet){
     int x = bullet.x; //子弹横坐标
     int y = bullet.y; //子弹纵坐标
     return this.x<x && x<this.x+width && this.y<y && y<this.y+height;
     }
     
    }

    第二步创建英雄级类

    import java.awt.image.BufferedImage;
     
    /**
     * 英雄机:是飞行物
     */
    public class Hero extends FlyingObject{
     
     private BufferedImage[] images = {}; //英雄机图片
     private int index = 0;  //英雄机图片切换索引
     
     private int doubleFire; //双倍火力
     private int life; //命
     
     /** 初始化数据 */
     public Hero(){
     life = 3; //初始3条命
     doubleFire = 0; //初始火力为0
     images = new BufferedImage[]{ShootGame.hero0, ShootGame.hero1}; //英雄机图片数组
     image = ShootGame.hero0; //初始为hero0图片
     width = image.getWidth();
     height = image.getHeight();
     x = 150;
     y = 400;
     }
     
     /** 获取双倍火力 */
     public int isDoubleFire() {
     return doubleFire;
     }
     
     /** 设置双倍火力 */
     public void setDoubleFire(int doubleFire) {
     this.doubleFire = doubleFire;
     }
     
     /** 增加火力 */
     public void addDoubleFire(){
     doubleFire = 40;
     }
     
     /** 增命 */
     public void addLife(){ //增命
     life++;
     }
     
     /** 减命 */
     public void subtractLife(){ //减命
     life--;
     }
     
     /** 获取命 */
     public int getLife(){
     return life;
     }
     
     /** 当前物体移动了一下,相对距离,x,y鼠标位置 */
     public void moveTo(int x,int y){ 
     this.x = x - width/2;
     this.y = y - height/2;
     }
     
     /** 越界处理 */
     @Override
     public boolean outOfBounds() {
     return false; 
     }
     
     /** 发射子弹 */
     public Bullet[] shoot(){ 
     int xStep = width/4; //4半
     int yStep = 20; //步
     if(doubleFire>0){ //双倍火力
      Bullet[] bullets = new Bullet[2];
      bullets[0] = new Bullet(x+xStep,y-yStep); //y-yStep(子弹距飞机的位置)
      bullets[1] = new Bullet(x+3*xStep,y-yStep);
      return bullets;
     }else{ //单倍火力
      Bullet[] bullets = new Bullet[1];
      bullets[0] = new Bullet(x+2*xStep,y-yStep); 
      return bullets;
     }
     }
     
     /** 移动 */
     @Override
     public void step() {
     if(images.length>0){
      image = images[index++/10%images.length]; //切换图片hero0,hero1
     }
     }
     
     /** 碰撞算法 */
     public boolean hit(FlyingObject other){
     
     int x1 = other.x - this.width/2;   //x坐标最小距离
     int x2 = other.x + this.width/2 + other.width; //x坐标最大距离
     int y1 = other.y - this.height/2;  //y坐标最小距离
     int y2 = other.y + this.height/2 + other.height; //y坐标最大距离
     
     int herox = this.x + this.width/2;  //英雄机x坐标中心点距离
     int heroy = this.y + this.height/2;  //英雄机y坐标中心点距离
     
     return herox>x1 && herox<x2 && heroy>y1 && heroy<y2; //区间范围内为撞上了
     }
     
    }

    第三步:建立敌人接口(普通敌人)

    /**
     * 敌人,可以有分数
     */
    public interface Enemy {
     /** 敌人的分数 */
     int getScore();
    }

    第四步:建立给奖励的敌人接口(就是特殊的敌人)

    /**
     * 奖励
     */
    public interface Award {
     int DOUBLE_FIRE = 0; //双倍火力
     int LIFE = 1; //1条命
     /** 获得奖励类型(上面的0或1) */
     int getType();
    }

    第五步:普通敌人对象

    import java.util.Random;
     
    /**
     * 敌飞机: 是飞行物,也是敌人
     */
    public class Airplane extends FlyingObject implements Enemy {
     private int speed = 3; //移动步骤
     
     /** 初始化数据 */
     public Airplane(){
     this.image = ShootGame.airplane;
     width = image.getWidth();
     height = image.getHeight();
     y = -height;  
     Random rand = new Random();
     x = rand.nextInt(ShootGame.WIDTH - width);
     }
     
     /** 获取分数 */
     @Override
     public int getScore() { 
     return 5;
     }
     
     /** //越界处理 */
     @Override
     public boolean outOfBounds() { 
     return y>ShootGame.HEIGHT;
     }
     
     /** 移动 */
     @Override
     public void step() { 
     y += speed;
     }
     
    }

    第六步:特殊敌人(有奖励特殊的敌人)

    import java.util.Random;
     
    /** 蜜蜂 */
    public class Bee extends FlyingObject implements Award{
     private int xSpeed = 1; //x坐标移动速度
     private int ySpeed = 2; //y坐标移动速度
     private int awardType; //奖励类型
     
     /** 初始化数据 */
     public Bee(){
     this.image = ShootGame.bee;
     width = image.getWidth();
     height = image.getHeight();
     y = -height;
     Random rand = new Random();
     x = rand.nextInt(ShootGame.WIDTH - width);
     awardType = rand.nextInt(2); //初始化时给奖励
     }
     
     /** 获得奖励类型 */
     public int getType(){
     return awardType;
     }
     
     /** 越界处理 */
     @Override
     public boolean outOfBounds() {
     return y>ShootGame.HEIGHT;
     }
     
     /** 移动,可斜着飞 */
     @Override
     public void step() { 
     x += xSpeed;
     y += ySpeed;
     if(x > ShootGame.WIDTH-width){ 
      xSpeed = -1;
     }
     if(x < 0){
      xSpeed = 1;
     }
     }
    }

    第七步:子弹类的建立(子弹也是飞行物)

     /**
     * 子弹类:是飞行物
     */
    public class Bullet extends FlyingObject {
     private int speed = 3; //移动的速度
     
     /** 初始化数据 */
     public Bullet(int x,int y){
     this.x = x;
     this.y = y;
     this.image = ShootGame.bullet;
     }
     
     /** 移动 */
     @Override
     public void step(){ 
     y-=speed;
     }
     
     /** 越界处理 */
     @Override
     public boolean outOfBounds() {
     return y<-height;
     }
     
    }

    最后一部分

    我们的主类来了,我们的准备工作就完了

    激动的时刻来了

    import java.awt.Font;
    import java.awt.Color;
    import java.awt.Graphics;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.util.Arrays;
    import java.util.Random;
    import java.util.Timer;
    import java.util.TimerTask;
    import java.awt.image.BufferedImage;
     
    import javax.imageio.ImageIO;
    import javax.swing.ImageIcon;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
     
    public class ShootGame extends JPanel {
     public static void main(String[] args) {
     JFrame frame = new JFrame("Fly");
     ShootGame game = new ShootGame(); // 面板对象
     frame.add(game); // 将面板添加到JFrame中
     frame.setSize(WIDTH, HEIGHT); // 设置大小
     frame.setAlwaysOnTop(true); // 设置其总在最上
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 默认关闭操作
     frame.setIconImage(new ImageIcon("images/icon.jpg").getImage()); // 设置窗体的图标
     frame.setLocationRelativeTo(null); // 设置窗体初始位置
     frame.setVisible(true); // 尽快调用paint
     
     game.action(); // 启动执行
     }
     public static final int WIDTH = 400; // 面板宽
     public static final int HEIGHT = 654; // 面板高
     /** 游戏的当前状态: START RUNNING PAUSE GAME_OVER */
     private int state;
     private static final int START = 0;
     private static final int RUNNING = 1;
     private static final int PAUSE = 2;
     private static final int GAME_OVER = 3;
     
     private int score = 0; // 得分
     private Timer timer; // 定时器
     private int intervel = 1000 / 100; // 时间间隔(毫秒)
     
     public static BufferedImage background;
     public static BufferedImage start;
     public static BufferedImage airplane;
     public static BufferedImage bee;
     public static BufferedImage bullet;
     public static BufferedImage hero0;
     public static BufferedImage hero1;
     public static BufferedImage pause;
     public static BufferedImage gameover;
     
     private FlyingObject[] flyings = {}; // 敌机数组
     private Bullet[] bullets = {}; // 子弹数组
     private Hero hero = new Hero(); // 英雄机
     
     static { // 静态代码块,初始化图片资源
     try {
      background = ImageIO.read(ShootGame.class
       .getResource("background.png"));
      start = ImageIO.read(ShootGame.class.getResource("start.png"));
      airplane = ImageIO
       .read(ShootGame.class.getResource("airplane.png"));
      bee = ImageIO.read(ShootGame.class.getResource("bee.png"));
      bullet = ImageIO.read(ShootGame.class.getResource("bullet.png"));
      hero0 = ImageIO.read(ShootGame.class.getResource("hero0.png"));
      hero1 = ImageIO.read(ShootGame.class.getResource("hero1.png"));
      pause = ImageIO.read(ShootGame.class.getResource("pause.png"));
      gameover = ImageIO
       .read(ShootGame.class.getResource("gameover.png"));
     } catch (Exception e) {
      e.printStackTrace();
     }
     }
     
     /** 画 */
     @Override
     public void paint(Graphics g) {
     g.drawImage(background, 0, 0, null); // 画背景图
     paintHero(g); // 画英雄机
     paintBullets(g); // 画子弹
     paintFlyingObjects(g); // 画飞行物
     paintScore(g); // 画分数
     paintState(g); // 画游戏状态
     }
     
     /** 画英雄机 */
     public void paintHero(Graphics g) {
     g.drawImage(hero.getImage(), hero.getX(), hero.getY(), null);
     }
     
     /** 画子弹 */
     public void paintBullets(Graphics g) {
     for (int i = 0; i < bullets.length; i++) {
      Bullet b = bullets[i];
      g.drawImage(b.getImage(), b.getX() - b.getWidth() / 2, b.getY(),
       null);
     }
     }
     
     /** 画飞行物 */
     public void paintFlyingObjects(Graphics g) {
     for (int i = 0; i < flyings.length; i++) {
      FlyingObject f = flyings[i];
      g.drawImage(f.getImage(), f.getX(), f.getY(), null);
     }
     }
     
     /** 画分数 */
     public void paintScore(Graphics g) {
     int x = 10; // x坐标
     int y = 25; // y坐标
     Font font = new Font(Font.SANS_SERIF, Font.BOLD, 14); // 字体
     g.setColor(new Color(0x3A3B3B));
     g.setFont(font); // 设置字体
     g.drawString("SCORE:" + score, x, y); // 画分数
     y += 20; // y坐标增20
     g.drawString("LIFE:" + hero.getLife(), x, y); // 画命
     }
     
     /** 画游戏状态 */
     public void paintState(Graphics g) {
     switch (state) {
     case START: // 启动状态
      g.drawImage(start, 0, 0, null);
      break;
     case PAUSE: // 暂停状态
      g.drawImage(pause, 0, 0, null);
      break;
     case GAME_OVER: // 游戏终止状态
      g.drawImage(gameover, 0, 0, null);
      break;
     }
     }
     
     
     /** 启动执行代码 */
     public void action() {
     // 鼠标监听事件
     MouseAdapter l = new MouseAdapter() {
      @Override
      public void mouseMoved(MouseEvent e) { // 鼠标移动
      if (state == RUNNING) { // 运行状态下移动英雄机--随鼠标位置
       int x = e.getX();
       int y = e.getY();
       hero.moveTo(x, y);
      }
      }
     
      @Override
      public void mouseEntered(MouseEvent e) { // 鼠标进入
      if (state == PAUSE) { // 暂停状态下运行
       state = RUNNING;
      }
      }
     
      @Override
      public void mouseExited(MouseEvent e) { // 鼠标退出
      if (state != GAME_OVER&&state!=START) { // 游戏未结束,则设置其为暂停
       state = PAUSE;
      }
      }
     
      @Override
      public void mouseClicked(MouseEvent e) { // 鼠标点击
      switch (state) {
      case START:
       state = RUNNING; // 启动状态下运行
       break;
      case GAME_OVER: // 游戏结束,清理现场
       flyings = new FlyingObject[0]; // 清空飞行物
       bullets = new Bullet[0]; // 清空子弹
       hero = new Hero(); // 重新创建英雄机
       score = 0; // 清空成绩
       state = START; // 状态设置为启动
       break;
      }
      }
     };
     this.addMouseListener(l); // 处理鼠标点击操作
     this.addMouseMotionListener(l); // 处理鼠标滑动操作
     
     timer = new Timer(); // 主流程控制
     timer.schedule(new TimerTask() {
      @Override
      public void run() {
      if (state == RUNNING) { // 运行状态
       enterAction(); // 飞行物入场
       stepAction(); // 走一步
       shootAction(); // 英雄机射击
       bangAction(); // 子弹打飞行物
       outOfBoundsAction(); // 删除越界飞行物及子弹
       checkGameOverAction(); // 检查游戏结束
      }
      repaint(); // 重绘,调用paint()方法
      }
     
     }, intervel, intervel);
     }
     
     int flyEnteredIndex = 0; // 飞行物入场计数
     
     /** 飞行物入场 */
     public void enterAction() {
     flyEnteredIndex++;
     if (flyEnteredIndex % 40 == 0) { // 400毫秒生成一个飞行物--10*40
      FlyingObject obj = nextOne(); // 随机生成一个飞行物
      flyings = Arrays.copyOf(flyings, flyings.length + 1);
      flyings[flyings.length - 1] = obj;
     }
     }
     
     /** 走一步 */
     public void stepAction() {
     for (int i = 0; i < flyings.length; i++) { // 飞行物走一步
      FlyingObject f = flyings[i];
      f.step();
     }
     
     for (int i = 0; i < bullets.length; i++) { // 子弹走一步
      Bullet b = bullets[i];
      b.step();
     }
     hero.step(); // 英雄机走一步
     }
     
     /** 飞行物走一步 */
     public void flyingStepAction() {
     for (int i = 0; i < flyings.length; i++) {
      FlyingObject f = flyings[i];
      f.step();
     }
     }
     
     int shootIndex = 0; // 射击计数
     
     /** 射击 */
     public void shootAction() {
     shootIndex++;
     if (shootIndex % 30 == 0) { // 300毫秒发一颗
      Bullet[] bs = hero.shoot(); // 英雄打出子弹
      bullets = Arrays.copyOf(bullets, bullets.length + bs.length); // 扩容
      System.arraycopy(bs, 0, bullets, bullets.length - bs.length,
       bs.length); // 追加数组
     }
     }
     
     /** 子弹与飞行物碰撞检测 */
     public void bangAction() {
     for (int i = 0; i < bullets.length; i++) { // 遍历所有子弹
      Bullet b = bullets[i];
      bang(b); // 子弹和飞行物之间的碰撞检查
     }
     }
     
     /** 删除越界飞行物及子弹 */
     public void outOfBoundsAction() {
     int index = 0; // 索引
     FlyingObject[] flyingLives = new FlyingObject[flyings.length]; // 活着的飞行物
     for (int i = 0; i < flyings.length; i++) {
      FlyingObject f = flyings[i];
      if (!f.outOfBounds()) {
      flyingLives[index++] = f; // 不越界的留着
      }
     }
     flyings = Arrays.copyOf(flyingLives, index); // 将不越界的飞行物都留着
     
     index = 0; // 索引重置为0
     Bullet[] bulletLives = new Bullet[bullets.length];
     for (int i = 0; i < bullets.length; i++) {
      Bullet b = bullets[i];
      if (!b.outOfBounds()) {
      bulletLives[index++] = b;
      }
     }
     bullets = Arrays.copyOf(bulletLives, index); // 将不越界的子弹留着
     }
     
     /** 检查游戏结束 */
     public void checkGameOverAction() {
     if (isGameOver()) {
      state = GAME_OVER; // 改变状态
     }
     }
     
     /** 检查游戏是否结束 */
     public boolean isGameOver() {
     
     for (int i = 0; i < flyings.length; i++) {
      int index = -1;
      FlyingObject obj = flyings[i];
      if (hero.hit(obj)) { // 检查英雄机与飞行物是否碰撞
      hero.subtractLife(); // 减命
      hero.setDoubleFire(0); // 双倍火力解除
      index = i; // 记录碰上的飞行物索引
      }
      if (index != -1) {
      FlyingObject t = flyings[index];
      flyings[index] = flyings[flyings.length - 1];
      flyings[flyings.length - 1] = t; // 碰上的与最后一个飞行物交换
     
      flyings = Arrays.copyOf(flyings, flyings.length - 1); // 删除碰上的飞行物
      }
     }
     
     return hero.getLife() <= 0;
     }
     
     /** 子弹和飞行物之间的碰撞检查 */
     public void bang(Bullet bullet) {
     int index = -1; // 击中的飞行物索引
     for (int i = 0; i < flyings.length; i++) {
      FlyingObject obj = flyings[i];
      if (obj.shootBy(bullet)) { // 判断是否击中
      index = i; // 记录被击中的飞行物的索引
      break;
      }
     }
     if (index != -1) { // 有击中的飞行物
      FlyingObject one = flyings[index]; // 记录被击中的飞行物
     
      FlyingObject temp = flyings[index]; // 被击中的飞行物与最后一个飞行物交换
      flyings[index] = flyings[flyings.length - 1];
      flyings[flyings.length - 1] = temp;
     
      flyings = Arrays.copyOf(flyings, flyings.length - 1); // 删除最后一个飞行物(即被击中的)
     
      // 检查one的类型(敌人加分,奖励获取)
      if (one instanceof Enemy) { // 检查类型,是敌人,则加分
      Enemy e = (Enemy) one; // 强制类型转换
      score += e.getScore(); // 加分
      } else if (one instanceof Award) { // 若为奖励,设置奖励
      Award a = (Award) one;
      int type = a.getType(); // 获取奖励类型
      switch (type) {
      case Award.DOUBLE_FIRE:
       hero.addDoubleFire(); // 设置双倍火力
       break;
      case Award.LIFE:
       hero.addLife(); // 设置加命
       break;
      }
      }
     }
     }
     
     /**
     * 随机生成飞行物
     * 
     * @return 飞行物对象
     */
     public static FlyingObject nextOne() {
     Random random = new Random();
     int type = random.nextInt(20); // [0,20)
     if (type == 0) {
      return new Bee();
     } else {
      return new Airplane();
     }
     }
     
    }

    游戏到这里就结束了这里有几张图片游戏中用到的图片,大家也可以自己找些自己喜欢的图片去用

    hero1.png

    hero1.png

    hero0.png

    hero0.png

    start.png

    start.png

    gameover.png

    gameover.png

    pause.png

    pause.png

    bee.png

    bee.png

    airplane.png

    airplane.png

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

    展开阅读
    精选笔记2:Java String类简单用法实战示例【字符串输出、比较】

    9小时42分钟前回答

    本文实例讲述了Java String类简单用法。分享给大家供大家参考,具体如下:

    一 String类的实例化方式

    1 代码

    public class NewString
    {
      public static void main(String args[])
      {
        String str1= "Hello World!";       // 直接赋值建立对象str1
        System.out.println("str1:" + str1) ;    //输出
        String str2 = new String("有志者事竟成") ;  // 构造法创建并初始化对象str2
        System.out.println("str2:" + str2) ;
        String str3 = "new" + "string";      //采用串联方式生成新的字符串str3
        System.out.println("str3:" + str3) ;
      }
    }
    
    

    2 运行

    str1:Hello World!
    str2:有志者事竟成
    str3:newstring

    二 字符串对象比较

    1 代码

    public class StringEquals
    {
      public static void main(String args[])
      {
        String str1 = "Hello World!" ; // 直接赋值
        String str2 = "Hello World!" ; // 直接赋值
        String str3 = "Hello World1" ; // 直接赋值
        String str4 = new String("Hello World!") ; // 构造方法赋值
        String str5 = str2 ;  // 引用传递
        System.out.println(str1 == str2) ; // true
        System.out.println(str1 == str3) ; // false
        System.out.println(str1 == str4) ; // false
        System.out.println(str2 == str5) ; // true
        System.out.println(str1.equals(str2)) ; // true
        System.out.println(str1.equals(str3)) ; // false
        System.out.println(str2.equals(str5)) ; // true
      }
    }
    
    

    2 运行

    true
    false
    false
    true
    true
    false
    true

    更多关于java相关内容感兴趣的读者可查看本站专题:《Java字符与字符串操作技巧总结》、《Java数组操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

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

    展开阅读

    Java相关资源

    • Java 9并发编程实战

      Java 9并发编程实战

      大小:15.6 MBJava9

      立即下载
    • 分布式中间件技术实战:Java版

      分布式中间件技术实战:Java版

      《 分布式中间件技术(Java版) 》从初学者的角度介绍了几种流行的分布式中间件,引导读者从零开始一步步学习Java企业应用开发。在讲解了必要的理论知识和应用场景后,书中给出了实际的项目案例,可以提高读者的开发水平和项目实战能力。 分布式中间件技术(Java版)共10章,共分3篇。第一部分《开发工具的准备》,介绍了分布式系统架构的相关知识点,包括其功能、作用和演进,进而引出分布式中间件的相关介绍。第二部分介绍了实际开发中广泛使用

      大小:79 MB分布式

      立即下载
    • Java微服务实战

      Java微服务实战

      大小:43.2MBJava实战

      立即下载
    • Java微服务架构实战

      Java微服务架构实战

      编辑推荐 《名师讲坛Java微服务架构实战(SpringBoot SpringCloud Docker RabbitMQ)》内容特色如下。 (1)资深Java讲师进行技术剖析,全面把握学习命脉,问题分析一针见血。 (2)140个课程案例,完美演示微服务的方方面面。 (3)基于Maven实现项目管理,与真实项目完美衔接。 (4)丰富的架构图示说明,轻松掌握微架构设计方案。 (5)手把手步骤学习法,轻松掌握微架构开发。 (6)OAuth使用分析与代码实现,掌握企业级RPC认证与授权解决方案。 (7)微服

      大小:56 MBJava

      立即下载
    • 轻量级Java EE企业应用实战

      轻量级Java EE企业应用实战

      《 轻量级Java EE企业应用实战:Struts2+Spring4+Hibernate整合开发(第4版)》 是《轻量级Java EE企业应用实战》的第4版,第4版保持了前几版内容全面、深入的特点,主要完成全部知识的升级。 《轻

      大小:487.2 MBJava

      立即下载

    学习笔记

    10小时47分钟前回答

    java实战之桌球小游戏

    本文实例为大家分享了java桌球小游戏的具体代码,供大家参考,具体内容如下 源码: import java.awt.*; import javax.swing.*; public class BallGame2 extends JFrame{ Image ball = Toolkit.getDefaultToolkit().getImage("images/ball.png"); Image desk = Toolkit.getDefaultToolkit().getImage("images/desk.jpg"); double x = 100; //小球的横坐标 double y = 100; //小球的纵坐标 double degree = 3.14/3; //弧度,此处就是60度 //画窗口的方法 public void paint(Graphics g) { System.out.println("窗口被画了一次! "); g.drawImage(desk, 0, 0, null); g.drawImage(ball, (int)x, (int)y, null); x = x + 10*Math.cos(degree); y = y + 10*Math.sin(degree); if(y500-40-30 || y40+40) { //500是窗口高度, 40是桌子边框, 30是球直径, 最后一个40是标题栏的……

    5小时13分钟前回答

    java版飞机大战实战项目详细步骤

    本文为大家分享了java版飞机大战实战项目,供大家参考,具体内容如下 分析 飞机大战 首先对这个游戏分析,在屏幕上的物体都是飞行物,我们可以把建一个类,让其他飞行物继承这个类.游戏中应有英雄机(也就是自己控制的飞机)、敌人。而敌人应该分为打死给分的飞机(就是普通飞机),另一种就是打死有奖励的敌人。他们都应该是飞行物的子类,我们也可以为普通飞机和给奖励的敌人设一个接口让他们去实现接口,这样有利于以后的扩展,我在这里给的简化版的飞机大战,主要是为了让大家了解面向对象。 第一步 建立飞行物类 import java.awt.image.BufferedImage; /** * 飞行物(敌机,蜜蜂,子弹,英雄机) */p……