Java坦克大战防重叠优化

已于 2024-06-27 09:26:53 修改
阅读量401 收藏 7
点赞数 5
文章标签： java python 开发语言
于 2024-06-26 17:02:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64295105/article/details/139993742
版权

Java坦克大战优化

基础思路

举例（敌人坦克与我方坦克）：
第一种： 当我方坦克方向向上（宽40，高60），敌人坦克方向向上或向下时。我方坦克左上角或者右上角坐标落在敌人坦克的区域内。

第二种： 当我方坦克方向向上（宽40，高60），敌人坦克方向向左或向右时。我方坦克左上角或者右上角坐标落在敌人坦克的区域内。

第三种：当我方坦克方向向右（宽60，高40），敌人坦克方向向上或向下时。我方坦克右上角或者右下角坐标落在敌人坦克的区域内。

第四种：当我方坦克方向向右（宽60，高40），敌人坦克方向向左或向右时。我方坦克右上角或者右下角坐标落在敌人坦克的区域内。

第五种：当我方坦克方向向下（宽40，高60），敌人坦克方向向上或向下时。我方坦克左下角或者右下角坐标落在敌人坦克的区域内。

第六种：当我方坦克方向向下（宽40，高60），敌人坦克方向向左或向右时。我方坦克左下角或者右下角坐标落在敌人坦克的区域内。

第七种：当我方坦克方向向左（宽60，高40），敌人坦克方向向上或向下时。我方坦克左上角或者右下角坐标落在敌人坦克的区域内。

第八种：当我方坦克方向向左（宽60，高40），敌人坦克方向向左或向右时。我方坦克左下角或者右下角坐标落在敌人坦克的区域内。

刚开始不明白为什么什么要判断两个点的，后来才明白是因为当我方坦克方向向上，敌人坦克方向下，我方坦克在敌方左下角重叠时我方坦克 x 坐标会小很多如图，只判断一个角还是会重叠，所以两个都需要判断。

在这里插入图片描述

// 当我坦克是向上方向，敌方坦克是向上或向下方向
if (tank.direction == UP || tank.direction == DOWN) {
    // 当前坦克左上角的坐标在重叠的范围内
    // 我方坦克左上角坐标 [x, y]
    if (x >= tank.x
        && x <= tank.x + WIDTH
        && y >= tank.y
        && y <= tank.y + HEIGHT) {
        return true;
    }

    // 当前坦克右上角的坐标在重叠范围内，当我方坦克在敌方坦克的左方重叠时 我方的 x 坐标会比敌方 x 坐标小，
    // 只判断一个左上角还是会重叠，所以要判断两个角的坐标
    // 我方坦克右上角坐标 [x + WIDTH, y]
    if (x + WIDTH >= tank.x
        && x <= tank.x + WIDTH
        && y >= tank.y
        && y <= tank.y + HEIGHT) {
        return true;
    }

未优化代码

package com.example.tankgame06;


import java.util.List;
import java.util.Vector;

import static com.example.tankgame04.GameConstant.*;


/**
 * @author XiaoAi
 * @date 2024/6/22 10:44
 */
public abstract class Tank {
    private int x;
    private int y;
    private int direction; // 0 1 2 3
    private int speed = 1;
    private List<Bullet> bulletList = new Vector<>(); // 子弹
    // 总宽度（x）90 高度（80）
    public final static int WIDTH = 90;
    public final static int HEIGHT = 80;
    private boolean isLive = true;
    public static final List<Tank> ALL_TANK = new Vector<>();

    public Tank() {
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public void moveUp() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setY(this.y - speed);
    }

    public void moveRight() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setX(this.x + speed);
    }

    public void moveDown() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setY(this.y + speed);
    }

    public void moveLeft() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setX(this.x - speed);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        if (x >= 0 && x <= TankGame06.WIDTH - Tank.WIDTH) {
            this.x = x;
        }
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        if (y >= 0 && y <= TankGame06.HEIGHT - Tank.HEIGHT) {
            this.y = y;
        }
    }

  	//....get/set

    public void shotTank() {
        if (!this.isLive) {
            return;
        }

        List<Bullet> bulletList = getBulletList();
        Bullet bullet = null;
        switch (getDirection()) {
            case UP:
                bullet = new Bullet(getX() + WIDTH / 2 - 2, getY() - 10, UP);
                break;
            case RIGHT:
                bullet = new Bullet(getX() + WIDTH + 10, getY() + HEIGHT / 2 + 2, RIGHT);
                break;
            case DOWN:
                bullet = new Bullet(getX() + HEIGHT / 2 + 2, getY() + WIDTH, DOWN);
                break;
            case LEFT:
                bullet = new Bullet(getX() - 10, getY() + HEIGHT / 2 + 2, LEFT);
                break;
        }
        if (bullet != null) {
            bulletList.add(bullet);
            new Thread(bullet).start();
        }
    }

    /**
     * 坦克重叠判断
     *
     * @return 是否重叠
     */
    public boolean isTouchTank() {

        int offset = 20;
        if (ALL_TANK.size() == 1) {
            return false;
        }

        switch (direction) {
            case UP:
                for (int i = 0; i < ALL_TANK.size(); i++) {
                    Tank tank = ALL_TANK.get(i);
                    if (tank != this) {
                        // 当我坦克是向上方向，敌方坦克是向上或向下方向
                        if (tank.direction == UP || tank.direction == DOWN) {
                            // 当前坦克左上角的坐标在重叠的范围内
                            // 我方坦克左上角坐标 [x, y]
                            if (x >= tank.x
                                    && x <= tank.x + WIDTH
                                    && y >= tank.y
                                    && y <= tank.y + HEIGHT) {
                                return true;
                            }

                            // 当前坦克右上角的坐标在重叠范围内，当我方坦克在敌方坦克的左方重叠时 我方的 x 坐标会比敌方 x 坐标小，
                            // 只判断一个左上角还是会重叠，所以要判断两个角的坐标
                            // 我方坦克右上角坐标 [x + WIDTH, y]
                            if (x + WIDTH >= tank.x
                                    && x <= tank.x + WIDTH
                                    && y >= tank.y
                                    && y <= tank.y + HEIGHT) {
                                return true;
                            }
                        }
                        // 当我坦克是向上方向，敌方坦克是向右或向左方向
                        // 敌方坦克向右等于旋转九十度高宽互换
                        if (tank.direction == RIGHT || tank.direction == LEFT) {
                            // 当前坦克左上角的坐标在重叠的范围内
                            // 我方坦克左上角坐标 [x, y]
                            if (x >= tank.x
                                    && x <= tank.x + HEIGHT
                                    && y >= tank.y
                                    && y <= tank.y + WIDTH) {
                                return true;
                            }

                            // 当前坦克右上角的坐标在重叠的范围内
                            // 我方坦克右上角坐标 [x + WIDTH, y]
                            if (x + WIDTH >= tank.x
                                    && x <= tank.x + HEIGHT
                                    && y >= tank.y
                                    && y <= tank.y + WIDTH) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case RIGHT:
                // 我方坦克向右，右上角坐标[x + HEIGHT, y ]
                // 我方坦克向右，左下角坐标[x + HEIGHT, y + WIDTH]
                for (int i = 0; i < ALL_TANK.size(); i++) {
                    Tank tank = ALL_TANK.get(i);
                    if (tank != this) {
                        // 当我坦克是向右方向，敌方坦克是向上或下方向
                        if (tank.direction == UP || tank.direction == DOWN) {
                            // 当前坦克右上角的坐标在重叠的范围内
                            // 当前坦克右上角坐标 [x + HEIGHT, y ]
                            System.out.println(x + HEIGHT >= tank.x
                                    && x + HEIGHT <= tank.x + WIDTH);
                            System.out.println(y >= tank.y
                                    && y <= tank.y + HEIGHT);
                            if (x + HEIGHT >= tank.x
                                    && x + HEIGHT <= tank.x + WIDTH
                                    && y >= tank.y
                                    && y <= tank.y + HEIGHT) {
                                return true;
                            }
                            // 当前坦克左下角的坐标在重叠的范围内
                            // 当前坦克左下角坐标 [x + HEIGHT, y + WIDTH]
                            if (x + HEIGHT >= tank.x
                                    && x + HEIGHT <= tank.x + WIDTH
                                    && y + WIDTH >= tank.y
                                    && y + WIDTH <= tank.y + HEIGHT) {
                                return true;
                            }
                        }

                        // 当我坦克是向右方向，敌方坦克是向左或向右方向
                        if (tank.direction == LEFT || tank.direction == RIGHT) {
                            // 当前坦克右上角的坐标在重叠的范围内
                            // 当前坦克右上角坐标 [x + HEIGHT, y]
                            if (x + HEIGHT >= tank.x
                                    && x + HEIGHT <= tank.x + HEIGHT
                                    && y >= tank.y
                                    && y <= tank.y + WIDTH) {
                                return true;
                            }
                            // 当前坦克左下角的坐标在重叠的范围内
                            // 当前坦克左下角坐标 [x + HEIGHT, y + WIDTH]
                            if (x + HEIGHT >= tank.x
                                    && x + HEIGHT <= tank.x + HEIGHT
                                    && y + WIDTH >= tank.y
                                    && y + WIDTH <= tank.y + WIDTH) {
                                return true;
                            }
                        }
                    }
                }
                break;
            case DOWN:
                // 我方坦克向下，左下角坐标 [x, y + HEIGHT]
                // 我方坦克向下，右下角坐标 [x + WIDTH, y + HEIGHT]
                for (int i = 0; i < ALL_TANK.size(); i++) {
                    Tank tank = ALL_TANK.get(i);
                    if (tank != this) {
                        // 当我坦克是向下方向，敌方坦克是向上或下方向
                        if (tank.direction == UP || tank.direction == DOWN) {
                            // 我方左下角在重叠范围内
                            if (x >= tank.x
                                    && x <= tank.x + WIDTH
                                    && y + HEIGHT >= tank.y
                                    && y + HEIGHT <= tank.y + HEIGHT) {
                                return true;
                            }
                            // 我方右下角在重叠范围内
                            if (x + WIDTH >= tank.x
                                    && x + WIDTH <= tank.x + WIDTH
                                    && y + HEIGHT >= tank.y
                                    && y + HEIGHT <= tank.y + HEIGHT) {
                                return true;
                            }
                        }

                        // 当我坦克是向下方向，敌方坦克是向左或右方向
                        if (tank.direction == LEFT || tank.direction == RIGHT) {
                            // 我方左下角在重叠范围内
                            // 左下角坐标 [x, y + HEIGHT]
                            if (x >= tank.x
                                    && x <= tank.x + HEIGHT
                                    && y + HEIGHT >= tank.y
                                    && y + HEIGHT <= tank.y + WIDTH) {
                                return true;
                            }
                            // 我方右下角在重叠范围内
                            // 右下角坐标 [x + WIDTH, y + HEIGHT]
                            if (x + WIDTH >= tank.x
                                    && x + WIDTH <= tank.x + HEIGHT
                                    && y + HEIGHT >= tank.y
                                    && y + HEIGHT <= tank.y + WIDTH) {
                                return true;
                            }
                        }
                    }
                }
                break;
            case LEFT:
                // 我方坦克向左，左上角坐标 [x, y]
                // 我方坦克向左，左下角坐标 [x, y + WIDTH]
                for (int i = 0; i < ALL_TANK.size(); i++) {
                    Tank tank = ALL_TANK.get(i);
                    if (tank != this) {
                        if (tank.direction == UP || tank.direction == DOWN) {
                            // 左上角
                            if (x >= tank.x
                                    && x <= tank.x + WIDTH
                                    && y >= tank.y
                                    && y <= tank.y + HEIGHT) {
                                return true;
                            }
                            // 左下角
                            if (x >= tank.x
                                    && x <= tank.x + WIDTH
                                    && y + WIDTH >= tank.y
                                    && y + WIDTH <= tank.y + HEIGHT) {
                                return true;
                            }
                        }

                        if (tank.direction == LEFT || tank.direction == RIGHT) {
                            // 左上角
                            if (x >= tank.x
                                    && x <= tank.x + HEIGHT
                                    && y >= tank.y
                                    && y <= tank.y + WIDTH) {
                                return true;
                            }
                            // 左下角
                            if (x >= tank.x
                                    && x <= tank.x + HEIGHT
                                    && y + WIDTH >= tank.y
                                    && y + WIDTH <= tank.y + WIDTH) {
                                return true;
                            }
                        }
                    }
                }
                break;

        }
        return false;
    }
}

优化代码

说是优化其实只是套了一层娃，分离出来一个 calcTouch 方计算是否重叠1对1作比较。

对了一个offset变量偏移量，没有偏移量会重叠一个轮子的宽度如图

在这里插入图片描述

加减偏移量主要看你往哪个方向重叠，

如上图就是向右x就要加偏移量，向左重叠就要减偏移量

向下方向重叠y加偏移量，向上方向重叠y减偏移量;

x-- 左移 x++ 右移，y++上移 y–下移；

增加偏移量后
在这里插入图片描述

package com.example.tankgame06;


import java.util.List;
import java.util.Vector;

import static com.example.tankgame04.GameConstant.*;


/**
 * @author XiaoAi
 * @date 2024/6/22 10:44
 */
public abstract class Tank {
    private int x;
    private int y;
    private int direction; // 0 1 2 3
    private int speed = 1;
    private List<Bullet> bulletList = new Vector<>(); // 子弹
    // 总宽度（x）90 高度（80）
    public final static int WIDTH = 90;
    public final static int HEIGHT = 80;
    private boolean isLive = true;
    public static final List<Tank> ALL_TANK = new Vector<>();

    public Tank() {
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public void moveUp() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setY(this.y - speed);
    }

    public void moveRight() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setX(this.x + speed);
    }

    public void moveDown() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setY(this.y + speed);
    }

    public void moveLeft() {
        boolean isTouch = isTouchTank();
        if (isTouch) {
            return;
        }
        setX(this.x - speed);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        if (x >= 0 && x <= TankGame06.WIDTH - Tank.WIDTH) {
            this.x = x;
        }
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        if (y >= 0 && y <= TankGame06.HEIGHT - Tank.HEIGHT) {
            this.y = y;
        }
    }
		
    // ... get/set

    public void shotTank() {
        if (!this.isLive) {
            return;
        }

        List<Bullet> bulletList = getBulletList();
        Bullet bullet = null;
        switch (getDirection()) {
            case UP:
                bullet = new Bullet(getX() + WIDTH / 2 - 2, getY() - 10, UP);
                break;
            case RIGHT:
                bullet = new Bullet(getX() + WIDTH + 10, getY() + HEIGHT / 2 + 2, RIGHT);
                break;
            case DOWN:
                bullet = new Bullet(getX() + HEIGHT / 2 + 2, getY() + WIDTH, DOWN);
                break;
            case LEFT:
                bullet = new Bullet(getX() - 10, getY() + HEIGHT / 2 + 2, LEFT);
                break;
        }
        if (bullet != null) {
            bulletList.add(bullet);
            new Thread(bullet).start();
        }
    }

    /**
     * 坦克重叠判断
     *
     * @return 是否重叠
     */
    public boolean isTouchTank() {

        int offset = 20;
        if (ALL_TANK.size() == 1) {
            return false;
        }
        return isTouch(this, ALL_TANK);
    }

    public boolean isTouch(Tank myTank, List<Tank> allTank) {
        if (allTank == null || allTank.size() == 1) {
            return false;
        }
        for (int i = 0; i < allTank.size(); i++) {
            boolean isTouch = calcTouch(myTank, allTank.get(i));
            if (isTouch) {
                return true;
            }
        }
        return false;
    }


    /**
     * 计算是否重叠
     *
     * @param tank      我方坦克
     * @param enemyTank 敌方坦克
     * @return
     */
    public boolean calcTouch(Tank tank, Tank enemyTank) {
        if (tank == null || enemyTank == null) {
            return false;
        }
        if (tank == enemyTank) {
            return false;
        }
        int x = tank.x;
        int y = tank.y;
        int offset = 20; // 重叠偏移量 一个轮子的宽度
        switch (tank.direction) {
            case UP:
                // 当我坦克是向上方向，敌方坦克是向上或向下方向
                if (enemyTank.direction == UP || enemyTank.direction == DOWN) {
                    // 当前坦克左上角的坐标在重叠的范围内
                    // 我方坦克左上角坐标 [x, y]
                    if (x >= enemyTank.x
                            && x <= enemyTank.x + WIDTH
                            && y - offset >= enemyTank.y
                            && y - offset <= enemyTank.y + HEIGHT) {
                        return true;
                    }

                    // 当前坦克右上角的坐标在重叠范围内，当我方坦克在敌方坦克的左方重叠时 我方的 x 坐标会比敌方 x 坐标小，
                    // 只判断一个左上角还是会重叠，所以要判断两个角的坐标
                    // 我方坦克右上角坐标 [x + WIDTH, y]
                    if (x + WIDTH >= enemyTank.x
                            && x <= enemyTank.x + WIDTH
                            && y - offset >= enemyTank.y
                            && y - offset <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                }
                // 当我坦克是向上方向，敌方坦克是向右或向左方向
                // 敌方坦克向右等于旋转九十度高宽互换
                if (enemyTank.direction == RIGHT || enemyTank.direction == LEFT) {
                    // 当前坦克左上角的坐标在重叠的范围内
                    // 我方坦克左上角坐标 [x, y]
                    if (x >= enemyTank.x
                            && x <= enemyTank.x + HEIGHT
                            && y - offset >= enemyTank.y
                            && y - offset <= enemyTank.y + WIDTH) {
                        return true;
                    }

                    // 当前坦克右上角的坐标在重叠的范围内
                    // 我方坦克右上角坐标 [x + WIDTH, y]
                    if (x + WIDTH >= enemyTank.x
                            && x <= enemyTank.x + HEIGHT
                            && y - offset >= enemyTank.y
                            && y - offset <= enemyTank.y + WIDTH) {
                        return true;
                    }
                }


                break;
            case RIGHT:
                // 我方坦克向右，右上角坐标[x + HEIGHT, y ]
                // 我方坦克向右，左下角坐标[x + HEIGHT, y + WIDTH]

                // 当我坦克是向右方向，敌方坦克是向上或下方向
                if (enemyTank.direction == UP || enemyTank.direction == DOWN) {
                    // 当前坦克右上角的坐标在重叠的范围内
                    // 当前坦克右上角坐标 [x + HEIGHT, y ]

                    if (x + HEIGHT + offset >= enemyTank.x
                            && x + HEIGHT + offset <= enemyTank.x + WIDTH
                            && y >= enemyTank.y
                            && y <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                    // 当前坦克左下角的坐标在重叠的范围内
                    // 当前坦克左下角坐标 [x + HEIGHT, y + WIDTH]
                    if (x + HEIGHT + offset >= enemyTank.x
                            && x + HEIGHT + offset <= enemyTank.x + WIDTH
                            && y + WIDTH >= enemyTank.y
                            && y + WIDTH <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                }

                // 当我坦克是向右方向，敌方坦克是向左或向右方向
                if (enemyTank.direction == LEFT || enemyTank.direction == RIGHT) {
                    // 当前坦克右上角的坐标在重叠的范围内
                    // 当前坦克右上角坐标 [x + HEIGHT, y]
                    if (x + HEIGHT + offset >= enemyTank.x
                            && x + HEIGHT + offset <= enemyTank.x + HEIGHT
                            && y >= enemyTank.y
                            && y <= enemyTank.y + WIDTH) {
                        return true;
                    }
                    // 当前坦克左下角的坐标在重叠的范围内
                    // 当前坦克左下角坐标 [x + HEIGHT, y + WIDTH]
                    if (x + HEIGHT + offset >= enemyTank.x
                            && x + HEIGHT + offset <= enemyTank.x + HEIGHT
                            && y + WIDTH  >= enemyTank.y
                            && y + WIDTH <= enemyTank.y + WIDTH) {
                        return true;
                    }
                }
                break;
            case DOWN:
                // 我方坦克向下，左下角坐标 [x, y + HEIGHT]
                // 我方坦克向下，右下角坐标 [x + WIDTH, y + HEIGHT]

                // 当我坦克是向下方向，敌方坦克是向上或下方向
                if (enemyTank.direction == UP || enemyTank.direction == DOWN) {
                    // 我方左下角在重叠范围内
                    if (x >= enemyTank.x
                            && x <= enemyTank.x + WIDTH
                            && y + HEIGHT + offset >= enemyTank.y
                            && y + HEIGHT + offset <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                    // 我方右下角在重叠范围内
                    if (x + WIDTH >= enemyTank.x
                            && x + WIDTH <= enemyTank.x + WIDTH
                            && y + HEIGHT + offset >= enemyTank.y
                            && y + HEIGHT + offset <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                }

                // 当我坦克是向下方向，敌方坦克是向左或右方向
                if (enemyTank.direction == LEFT || enemyTank.direction == RIGHT) {
                    // 我方左下角在重叠范围内
                    // 左下角坐标 [x, y + HEIGHT]
                    if (x >= enemyTank.x
                            && x <= enemyTank.x + HEIGHT
                            && y + HEIGHT + offset >= enemyTank.y
                            && y + HEIGHT + offset <= enemyTank.y + WIDTH) {
                        return true;
                    }
                    // 我方右下角在重叠范围内
                    // 右下角坐标 [x + WIDTH, y + HEIGHT]
                    if (x + WIDTH >= enemyTank.x
                            && x + WIDTH <= enemyTank.x + HEIGHT
                            && y + HEIGHT + offset >= enemyTank.y
                            && y + HEIGHT + offset <= enemyTank.y + WIDTH) {
                        return true;
                    }
                }
                break;
            case LEFT:
                // 我方坦克向左，左上角坐标 [x, y]
                // 我方坦克向左，左下角坐标 [x, y + WIDTH]

                if (enemyTank.direction == UP || enemyTank.direction == DOWN) {
                    // 左上角
                    if (x - offset>= enemyTank.x
                            && x - offset <= enemyTank.x + WIDTH
                            && y >= enemyTank.y
                            && y <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                    // 左下角
                    if (x - offset >= enemyTank.x
                            && x - offset <= enemyTank.x + WIDTH
                            && y + WIDTH >= enemyTank.y
                            && y + WIDTH <= enemyTank.y + HEIGHT) {
                        return true;
                    }
                }

                if (enemyTank.direction == LEFT || enemyTank.direction == RIGHT) {
                    // 左上角
                    if (x - offset >= enemyTank.x
                            && x - offset <= enemyTank.x + HEIGHT
                            && y >= enemyTank.y
                            && y <= enemyTank.y + WIDTH) {
                        return true;
                    }
                    // 左下角
                    if (x - offset >= enemyTank.x
                            && x - offset <= enemyTank.x + HEIGHT
                            && y + WIDTH >= enemyTank.y
                            && y + WIDTH <= enemyTank.y + WIDTH) {
                        return true;
                    }
                }

                break;

        }
        return false;
    }

}

源代码网盘链接

游戏记录使用 json字符存储对象，导入fastjson
在这里插入图片描述

链接：https://pan.baidu.com/s/1DFc8nw6BGxFTzRV4t48YFA?pwd=gth4
提取码：gth4

小艾的博客
关注
java坦克大战小游戏
11-24
【Java坦克大战小游戏】是一款基于Java SE平台，利用面向对象编程技术开发的小型游戏，旨在帮助开发者巩固和实践面向对象的基础知识。在这个项目中，我们可以深入理解Java编程语言中的类、对象、继承、封装和多态等...
JAVA坦克大战程序改进（一）
letorangego的博客
07-30 1316
对Java坦克大战（韩顺平老师）进行改进
Java坦克大战游戏源代码
08-29
Java坦克大战游戏源代码 关于项目 Java中的坦克大战游戏是一款简单的多人游戏对战游戏。这个游戏和之前的游戏很相似。本系统是在Eclipse IDE中制作的。此外，您需要在计算机上安装 JDK 和 JRE 才能运行它。这是一个...
Java坦克大战
10-18
【Java坦克大战】是一款利用Java编程语言开发的小型游戏，非常适合初学者进行学习和实践。在这款游戏中，玩家可以通过控制坦克进行战斗，体验经典坦克大战的乐趣。通过分析这个游戏，我们可以学习到许多Java编程中的...
java版坦克大战源码
08-26
《Java版坦克大战源码解析》 坦克大战是一款经典的双人对战游戏，深受玩家喜爱。在Java编程语言中实现这款游戏，不仅可以加深对Java基础知识的理解，还能锻炼游戏开发的技能。下面，我们将深入探讨Java版坦克大战...
Java版 坦克大战 MVC游戏框架
01-04
【Java版 坦克大战 MVC游戏框架】是一款基于Java编程语言开发的坦克大战小游戏，其设计理念是采用MVC（Model-View-Controller）架构模式，以提高代码的可维护性和可扩展性。在这个项目中，我们将深入探讨如何利用...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 924
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 447
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 859
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 553
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 804
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 343
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1114
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 887
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 330
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1246
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 387
记忆中，两个指针合并即可。
Java中ResultSet接口的详细介绍
2301_77032029的博客
09-28 463
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 576
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值