JAVA学习日记day15

最新推荐文章于 2023-10-20 17:06:54 发布
最新推荐文章于 2023-10-20 17:06:54 发布
阅读量100 收藏 1
点赞数
分类专栏： 学习日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/azure10492/article/details/118940274
版权

复习1.创建窗口对象

2.创建画板对象

3.类的设计 – 确定类中目前需要的成员变量和成员方法

4.成员方法目前只有一个 – move（），研究不同类的移动方法

5.创建类需要不同的构造方法 – 初始化成员变量

a -> static-> 静态代码块 需要静态成员变量

b –> 获取父类中的成员变量

  1. 如果父类中的成员变量是protected修饰的 子类可以直接获取
  2. 如果父类中的成员变量是private修饰的 调用有参构造方法/get set

今天主要写程序 把“飞机大战”写了一部分

paint部分

import PlaneFight.Bullet;



import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.*;
import java.util.Timer;


public class JPaintImage extends JPanel  {
    private Bullet[] bullets = {};
    private Hero h1 = new Hero();
    
    ArrayList<Plane> flying = new ArrayList<>();
    static BufferedImage bigPlane;
    static BufferedImage bg;
    static BufferedImage smallPlane;
    static BufferedImage Bee;
    static BufferedImage hero0;
    static BufferedImage hero1;
    static BufferedImage bullet;
    public static BufferedImage start;
    public static BufferedImage pause;
    public static BufferedImage gameover;
    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;
    static{
        try {
        bg = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/background.png")));
        smallPlane=ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/airplane.png")));
        bigPlane = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/bigplane.png")));
        Bee = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/bee.png")));
        hero0 = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/hero0.png")));
        hero1 = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/hero1.png")));
        bullet = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/bullet.png")));
        start = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/start.png")));
        pause = ImageIO.read(Objects.requireNonNull(ImageDemo.class.getResource("pic/pause.png")));
        gameover = ImageIO
                    .read(Objects.requireNonNull(ImageDemo.class.getResource("pic/gameover.png")));
    } catch (IOException e) {
        e.printStackTrace();
       }
    }

    public void paint(Graphics g) {

        super.paint(g);
        //画背景
        g.drawImage(bg,0,0,this);
        //设置字体
        setFont(g);
        //生成飞机

        paintBullets(g);

        drawHero(g);
        drawFlying(g);
        paintState(g);
    }

    java.util.Timer timer = new Timer();

    public void action(){
        MouseAdapter l = new MouseAdapter() {
            @Override
            public void mouseMoved(MouseEvent e) { // 鼠标移动
                if (state == RUNNING) {
                    int x = e.getX();
                    int y = e.getY();
                    h1.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: // 游戏结束，清理现场
                        flying.clear(); // 清空飞行物
                        bullets = new Bullet[0]; // 清空子弹
                        h1= new Hero(); // 重新创建英雄机
                         // 清空成绩
                        state = START; // 状态设置为启动
                        break;
                }

            }
        };
        this.addMouseListener(l); // 处理鼠标点击操作
        this.addMouseMotionListener(l); // 处理鼠标滑动操作

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                if (state == RUNNING) {
                    h1.move();
                    shootAction();
                    //enterAction();
                    //stepAction();
                    creatPlanes();
                    flyingMove();

                    outOfBoundsAction();
                }repaint();
            }
        }, 100,  40);

    }
    /*int flyEnteredIndex = 0;
    public void enterAction() {
        flyEnteredIndex++;
        if (flyEnteredIndex % 40 == 0) { // 400毫秒生成一个飞行物--10*40
            Plane obj = nextOne(); // 随机生成一个飞行物
            Planes = Arrays.copyOf(Planes, Planes.length + 1);
            Planes[Planes.length - 1] = obj;
        }
    }
    public void drawPlanes(Graphics g){
        for (int i = 0; i < Planes.length; i++) {
            Plane obj = Planes[i];
            g.drawImage(obj.getImg(), obj.getX(),obj.getY(),this);
        }
    }
    public void stepAction() {
        for (int i = 0; i < Planes.length; i++) { // 飞行物走一步
            Plane f = Planes[i];
            f.move();
        }
    }*/
    int flyingCount = 0;
    public void creatPlanes(){
        flyingCount++;
        if(flyingCount%40==0) {
            int random = (int) (Math.random() * 20);
            Plane fly;
            if (random == 0) {
                fly = new Bee();
            } else if (random == 1 || random == 2 || random == 3) {
                fly = new BigPlane();
            } else {
                fly = new SmallPlane();
            }
            flying.add(fly);
        }
    }

    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 drawHero(Graphics g){ g.drawImage(h1.getImg(),h1.x,h1.y,this); }
    public void drawFlying(Graphics g){
        Plane fly ;
        for (int i = 0; i < flying.size(); i++) {
            fly = flying.get(i);
            g.drawImage(fly.getImg(), fly.getX(),fly.getY(),null);
        }

    }
    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;
        }
    }
    int shootIndex = 0;

    public void shootAction() {
        shootIndex++;
        if (shootIndex % 30 == 0) { // 300毫秒发一颗
            Bullet[] bs = h1.shoot(); // 英雄打出子弹
            bullets = Arrays.copyOf(bullets, bullets.length + bs.length); // 扩容
            System.arraycopy(bs, 0, bullets, bullets.length - bs.length,
                    bs.length); // 追加数组
        }
    }
    public void flyingMove(){
        for (int i = 0; i < flying.size(); i++) {
            Plane fly = flying.get(i);
            fly.move();
        }
        for (int i = 0; i < bullets.length; i++) { // 子弹走一步
            Bullet b = bullets[i];
            b.step();
        }
    }
    public void outOfBoundsAction(){
        for (int i = 0; i < flying.size(); i++) {
            Plane f = flying.get(i);
            if(f.outOfBounds()){
                flying.remove(f);
                i--;
            }
        }
        int 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 setFont(Graphics g){
        Font font = new Font("宋体",Font.BOLD,15);
        g.setFont(font);
        Color c = Color.black;
        g.setColor(c);
        g.drawString("score : ",10,20);
    }

    /*public static Plane nextOne() {
        Random random = new Random();
        int type = random.nextInt(20); // [0,20)
        if (type == 0) {
            return new Bee();
        } else if(type == 1||type ==2){
            return new BigPlane();
        }else return new SmallPlane();
    }*/
}

 抽象主类plane

public abstract class Plane {

    public BufferedImage img;
    int x,y,blood;
    int width,height;
    public void setX(int x) {
        this.x = x;
    }

    public  BufferedImage getImg() {
        return img;
    }

    public void setImg(BufferedImage img) {
        this.img =img;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public boolean outOfBounds(){
        return false;
    }

    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 abstract void move();
    public abstract void death() throws IOException;
}

bullet类

​
public class Bullet extends Plane{

    Bullet(){}
    Bullet(int x,int y){
        this.x = x;
        this.y = y;
        this.img = JPaintImage.bullet;
    }

    @Override
    public BufferedImage getImg() {
        return this.img;
    }

    @Override
    public int getX() {
        return this.x;
    }

    @Override
    public int getY() {
        return this.y;
    }

    @Override
    public void move() {
       y = y-3;
    }

    @Override
    public void death() throws IOException {

    }
    public 	boolean outOfBounds(){
        return y<0;
    }
}

​

Hero类 

public class Hero extends Plane{
    private int index = 0;
    private int doubleFire;
    int score;
    private BufferedImage[] images = {};
    public Hero(){
        doubleFire = 0;
        img = JPaintImage.hero0;
        images = new BufferedImage[]{JPaintImage.hero0, JPaintImage.hero1};
        width = img.getWidth();
        height = img.getHeight();
        blood = 3;
        x = 150;
        y = 400;
    }

    @Override
    public BufferedImage getImg() {
        return img;
    }
    public void moveTo(int x,int y){
        this.x = x - width/2;
        this.y = y - height/2;
    }
    @Override
    public void setImg(BufferedImage img) {
        super.setImg(img);
    }
    public void addDoubleFire(){
        doubleFire = 40;
    }
    @Override
    public void move() {
        //图片的切换效果
        if(images.length>0){
            img = images[index++/10%images.length];  //切换图片hero0，hero1
        }
    }

    @Override
    public void death() throws IOException {

    }
    public PlaneFight.Bullet[] shoot(){
        int xStep = width/4;      //4半
        int yStep = 20;  //步
        if(doubleFire>0){  //双倍火力
            PlaneFight.Bullet[] bullets = new PlaneFight.Bullet[2];
            bullets[0] = new PlaneFight.Bullet(x+xStep,y-yStep);  //y-yStep(子弹距飞机的位置)
            bullets[1] = new PlaneFight.Bullet(x+3*xStep,y-yStep);
            return bullets;
        }else{      //单倍火力
            PlaneFight.Bullet[] bullets = new PlaneFight.Bullet[1];
            bullets[0] = new Bullet(x+2*xStep,y-yStep);
            return bullets;
        }
    }
}

大敌机类

public class BigPlane extends Plane{
    int score;
   BufferedImage img;

    public BigPlane()  {
        img = JPaintImage.bigPlane;
        y=0;
        x=(int)(Math.random()*350);
        blood = 5;
        width = img.getWidth();
        height = img.getHeight();
    }
    @Override
    public void move() {
      y=y+3;
    }

    @Override
    public BufferedImage getImg() {
        return this.img;
    }

    @Override
    public int getX() {
        return this.x;
    }

    @Override
    public int getY() {
        return this.y;
    }
    public 	boolean outOfBounds(){
        return y>MainFrame.HEIGHT;
    }
    @Override
    public void death() throws IOException {


    }
}

奖励蜜蜂类

public class Bee extends Plane{
    BufferedImage img;
    int speed_x=1;
    int speed_y=1;
    Bee(){
        img = JPaintImage.Bee;
        width = img.getWidth();
        height = img.getHeight();
        y=0;
        x=(int)(Math.random()*350);
        blood = 3;
    }
    @Override
    public void move() {
          y+=speed_y;
          x+=speed_x;
          if(x>MainFrame.WIDTH-this.width-40){
              speed_x = -1;
          }
          if(x<0){
              speed_x = 1;
          }
    }

    @Override
    public void death() throws IOException {

    }

    @Override
    public BufferedImage getImg() {
        return this.img;
    }
    public 	boolean outOfBounds(){
        return y>MainFrame.HEIGHT;
    }
    @Override
    public int getX() {
        return this.x;
    }

    @Override
    public int getY() {
        return this.y;
    }
}

 小敌机类

public class SmallPlane extends Plane{
    int score;
   BufferedImage img;

    public SmallPlane(){
        img = JPaintImage.smallPlane;
        y=0;
        x=(int)(Math.random()*350);
        blood = 3;
        width = img.getWidth();
        height = img.getHeight();
    }
    @Override
    public void move() {
        y=y+5;
    }

    @Override
    public void death() throws IOException {

    }
    public 	boolean outOfBounds(){
        return y>MainFrame.HEIGHT;
    }
    @Override
    public BufferedImage getImg() {
        return img;
    }
}

 

azure10492
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java飞机大战项目
Java学习博客
04-01 1万+
飞机大战游戏是一款十分有趣的射击类小游戏，流畅的画面，高难度的挑战。游戏中，玩家驾驶英雄机，在空中进行战斗。点击并移动自己的英雄机，发射炮弹，打掉敌飞机以及蜜蜂，来获得分数和奖励，打掉一架敌飞机赢得5分，打掉一只蜜蜂赢得1条命或是获得20次双倍火力，如果撞上敌飞机或小蜜蜂，将减少命、双倍火力清零。每撞到一次蜜蜂或是敌飞机命减1，当命数为0时，则游戏结束。游戏界面如下图所示 下面就是...
Java移除出界敌机_Java程序之飞机大战
weixin_36222664的博客
02-25 140
import java.awt.image.BufferedImage;import javax.imageio.ImageIO;import javax.swing.JFrame; //框架import javax.swing.JPanel; //画板import java.awt.Graphics; //paint()中的参数import java.util.Random;...
Java版本飞机大战
‎‎‎‎‎不想吃泡面
07-24 4667
1.关于这个飞机大战 学Java有一段时间了，然后通过Java开发了一些简易安卓APP。最近很想实现以前自己很想写的飞机大战，也练练手。代码和界面参考（抄袭 ）了许多，毕竟天下码农一家亲。 游戏大概长下面这样，鼠标点击即开始游戏，然后用鼠标操作飞机移动（鼠标到哪飞机移动到哪，超出游戏界面就暂停）。 2.代码实现 首先写几个bean。GameStateBean里面存放了一些游戏状态的常量，Img...
java学习日记 day15
m0_53606110的博客
04-02 51
java集合；ArrayList;集合的添加与删除；存储字符串并遍历；存储学生对象并遍历
Java学习日记DAY15
qq_32591735的博客
02-17 117
1.集合容器（set） import java.util.ArrayList; import java.util.HashSet; public class rongqi { public static void main(String[] args) { ArrayList&lt;String&gt; a=new ArrayList&lt;String&gt;(); a.add("fi...
Java学习日记Day15（面向对象day09）
表达 交流 自省 完善
07-20 129
多态
Java学习日记Day1
samahh666的博客
10-16 101
我们从上往下看;首先是外部的一个class类。所有的java代码都必须写在class类的括号内；其次是main方法。每一个Java应用程序都必须有main方法，可以理解为程序最后的出口最后是中心的调用语句。在Java中，我们想要实现某个功能，需要调用该功能所在的方法等，这时就需要用到调用。通常Java程序以这种格式调用一个方法：对象名.方法名（输入参数）
Java学习日记Day2
samahh666的博客
10-18 89
封装在java编码中，类是很重要的。比如Day1提到的Math类，我们可以使用该类里面的方法，比如说Math.random()而不用知道他们是如何实现的。我们只需要知道该方法的名字和所需要的参数即可。这种将方法存放于类中的操作在java中我们称之为封装。对象和对象变量当我们需要调用一个对象的时候，我们首先要做的是构造他们。在Java中，我们使用构造器来创建（构造）一个对象。构造器是一种特殊的方法，其目的是构造并初始化一个对象。// 此时，deadline的值为null。
Java学习日记Day3
最新发布
samahh666的博客
10-20 77
/......//......由上图所示，extends关键字一般放在子类后面，声明其继承的父类是谁。在完成这一系列操作后，子类中必然包含父类中的所有成员（包括private修饰的tips：这里就要解释一下：如上所述，子类必然继承父类的所有成员，只不过对于private修饰的对象，子类无法直接访问和看见，但是可以通过调用父类本身的方法来获取和调用这些对象。
Day11实习日记1
08-08
Day11 实习日记 1，表明这是一个 Java 实训项目的日记记录，记录了作者在学习 Java Web 开发时的经验和感受。 描述解释 描述部分为空，这表明作者主要是记录自己的实践经验和感受，而不是对项目的总结或介绍。 ...
Day10实习日记1
08-08
Spring MVC框架实践日记 通过阅读Day10实习日记1，我们可以了解到Spring MVC框架的基本概念...Day10实习日记1提供了Spring MVC框架的基本概念和实践操作，帮助我们了解到Spring MVC框架的使用技术和Java实训的重要性。
Day04实习日记1
08-08
今天是暑期Java实训的第四天，我们主要集中在Java EE、Servlet、Web动态网页制作以及前端技术的学习上。Java EE是企业级应用开发的重要框架，它包括了Servlet等关键组件，用于构建服务器端应用程序。 上午的课程...
Day09实习日记1
08-08
Java 实训 Day09 实习日记1 今天是 2017 年 7 月 12 日星期三，晴天，地点在工科楼 A203，老师是张明星，单位是南京华信智源教育科技有限公司。本次实习日记主要记录了使用 Java 进行的 MVC 相关操作，并使用 ...
Java学习笔记
11-20
java学习的笔记，回顾一些基本的要领，知识点，很有帮助 比如： Day Eight 异常： 异常的分类 Java会将所有的异常封装成对象，其根本父类为Throwable。 Throwable有两个子类：Error 和Exception。 Error：一个...
mysql报错：子查询返回值大于一
azure10492的博客
07-28 1425
运行某个查询，报错：Subquery returns more than 1 row 代表你的子查询的筛选条件有问题，查出来的行数大于一，直接看子查询，单独摘出来在运行，排查错误即可。
java学习日记day27
azure10492的博客
08-09 259
复习: 1.字节流(缓冲) 父类: InputStream/OutputStream FileInputStream("相对路径") - 输入流 read() - 读单个字节 read(byte[]) - 字节数组 FileOutputStream("相对路径",true) - 输出流 write(int) write(byte[]) write...
mysql学习日记day01
azure10492的博客
08-23 239
1.什么是数据库? 1)全称: DataBase 简称:DB 2)数据库其实就是按照一定的格式进行存储数据的一些文件或者文件集合 理解:存储数据的仓库,而这些数据在实时存储的过程中是有特定格式的. 2.什么是数据库管理系统? 1)全称: DataBaseManagement System 简称:DBMS 2).数据库管理系统专用来管理数据库中数据 可以对数据库中的数据进行增删改查操作 3)数据库管理系统类型: (1...
jedis，maven和反射的简单理解
azure10492的博客
10-08 223
Redis: 1.Redis的数据结构: redis的存储: key:value的格式进行存储. 其中key都是字符串,value有5中不同的数据结构 * value的数据结构: 1)字符串类型 String 2)哈希类型 hash -> map格式 3)列表类型 list -> linkedList格式, 支持重复元素 4)集合类型 set -> 不允许重复元素 5)有序集合类型 sortedset -> 不允许重复元素,且元素有顺序 * 通用命令: 1)k.
java学习日记day26
azure10492的博客
08-09 159
复习: 路径: 绝对路径: 从盘符出发 相对路径 :有一个参考值 参考值: 当前目录 1.new File("相对路径") 主方法: 工程下 测试方法: 模块下 2.xx.class.getResource("相对路径").getPath() 必须存在同包下 3.xx.class.getClassLorder().getResource("相对路径").getPath() 必须存在src下 IO: 字节输入流/字节输出流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值