关于#Java#的问题，如何解决？飞机大战实训

Question

怎么添加拓展 除了6

import java.awt.Container;
import javax.swing.JFrame;

public class planeFrame extends JFrame {
    public planeFrame() {
        
        setTitle("飞行射击类游戏");
        
        GamePanel panel = new GamePanel();
        Container contentPane = getContentPane();
        contentPane.add(panel);
        
        pack();
    }
    public static void main(String[] args) {
        planeFrame e1 = new planeFrame();
        
        e1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        e1.setVisible(true);
    }
}

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.ImageObserver;
import javax.swing.JPanel;

// ӵ   
public class Bullet {
    static final int BULLET_STEP_X = 3;    
    static final int BULLET_STEP_Y = 15;  
    static final int BULLET_WIDTH = 40;
    public int m_posX = 0;
    public int m_posY = 0;
    boolean mFacus = true;
    private Image pic[] = null;
    private int mPlayID = 0;
    public Bullet() {
        pic = new Image[4];
        for (int i = 0; i < 4; i++) 
                pic[i] = Toolkit.getDefaultToolkit().getImage(
                        "images\\bullet_" + i + ".png");
    }
    
    public void init(int x, int y) {
    m_posX = x;
    m_posY = y;
    mFacus = true;
    }
    
    public void DrawBullet(Graphics g,JPanel i)
    {
        g.drawImage(pic[mPlayID++],m_posX,m_posY,(ImageObserver)i);
        if(mPlayID==4)mPlayID=0;
    }
    public void UpdateBullet() {
    if (mFacus) {
        m_posY -= BULLET_STEP_Y;
    }

    }
    
}

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.ImageObserver;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Enemy {
   public static final int ENEMY_ALIVE_STATE = 0;  
   public static final int ENEMY_DEATH_STATE = 1;    
   static final int ENEMY_STEP_Y = 5; 
   public int m_posX = 0;
   public int m_posY = 0;     
   public int mAnimState = ENEMY_ALIVE_STATE;  
   private Image enemyExplorePic[] = new Image[6]; 
   public int mPlayID = 0;
   public Enemy() {
        for (int i = 0; i < 6; i++) 
            enemyExplorePic[i] = Toolkit.getDefaultToolkit().getImage(
                        "images\\bomb_enemy_" + i + ".png");
    }
    
   public void init(int x, int y) {
    m_posX = x;
    m_posY = y;
    mAnimState = ENEMY_ALIVE_STATE;
    mPlayID = 0;
    }    
    public void DrawEnemy(Graphics g,JFrame i)
    {
        Image pic;
        try {
            pic = ImageIO.read(new File("images/e1_0.png"));
            g.drawImage(pic,m_posX,m_posY,(ImageObserver)i);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
                    
    }
    public void DrawEnemy(Graphics g,JPanel i)
    {
        
        if(mAnimState == ENEMY_DEATH_STATE && mPlayID<6) {
            g.drawImage(enemyExplorePic[mPlayID],m_posX,m_posY,(ImageObserver)i);
            mPlayID++;
            return;
        }
       
        Image pic = Toolkit.getDefaultToolkit().getImage("images/e1_0.png");
        g.drawImage(pic,m_posX,m_posY,(ImageObserver)i);                    
    }
  
    public void UpdateEnemy() {
        m_posY += ENEMY_STEP_Y;
    }
}

import java.awt.Dimension;
import java.awt.Event;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;

import bean.Bullet;
import bean.Enemy;

public class GamePanel extends JPanel  implements Runnable,KeyListener{

    private int mScreenWidth = 320;
    private int mScreenHeight = 480;
    private static final int STATE_GAME = 0;
    private int mState = STATE_GAME;
    private Image mBitMenuBG0 = null;
    private Image mBitMenuBG1 = null;
    private int mBitposY0 = 0;
    private int mBitposY1 = 0;
    final static int BULLET_POOL_COUNT = 15;
    final static int PLAN_STEP = 10;
    final static int PLAN_TIME = 500;
    final static int ENEMY_POOL_COUNT = 5;
    final static int ENEMY_POS_OFF = 65;
    private Thread mThread = null;
    private boolean mIsRunning = false;
    public int mAirPosX = 0;
    public int mAirPosY = 0;
    Enemy mEnemy[] = null;
    Bullet mBuilet[] = null;
    public int mSendId = 0;
    public Long mSendTime = 0L;
    Image myPlanePic[];
    public int myPlaneID = 0; 
    public GamePanel() {
        setPreferredSize(new Dimension(mScreenWidth, mScreenHeight));
        setFocusable(true);
        addKeyListener(this);
        init();
        setGameState(STATE_GAME);
        mIsRunning = true;
        mThread = new Thread(this);
        mThread.start();
        //setVisible(true);
    }
    protected void Draw() {
        switch (mState) {
        case STATE_GAME:
            renderBg();
            updateBg(); 
            break;
        }
    }

    private void init() {
        
        try {
            mBitMenuBG0 = Toolkit.getDefaultToolkit().getImage("res\\map_0.png");
            mBitMenuBG1 = Toolkit.getDefaultToolkit().getImage("res\\map_1.png");
            ImageIO.read(new File("res/map_1.png"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        mBitposY0 = 0;
        mBitposY1 = -mScreenHeight;
        mAirPosX = 150;
        mAirPosY = 400;
        myPlanePic = new Image[6];
        for (int i = 0; i < 6; i++)
            myPlanePic[i] = Toolkit.getDefaultToolkit().getImage(
                    "res\\plan_" + i + ".png");
        mEnemy = new Enemy[ENEMY_POOL_COUNT];
        for (int i = 0; i < ENEMY_POOL_COUNT; i++) {
            mEnemy[i] = new Enemy();
            mEnemy[i].init(i * ENEMY_POS_OFF, i * ENEMY_POS_OFF-300);
        }

        mBuilet = new Bullet[BULLET_POOL_COUNT];
        for (int i = 0; i < BULLET_POOL_COUNT; i++) {
            mBuilet[i] = new Bullet();
        }
        mSendTime = System.currentTimeMillis();
    }

    private void setGameState(int newState) {
        mState = newState;
    }

    public void renderBg() {
        myPlaneID++;
        if (myPlaneID == 6)
            myPlaneID = 0;
        repaint();
    }

    public void paint(Graphics g) {
        g.drawImage(mBitMenuBG0, 0, mBitposY0, this);
        g.drawImage(mBitMenuBG1, 0, mBitposY1, this);
        g.drawImage(myPlanePic[myPlaneID], mAirPosX, mAirPosY, this);
        for (int i = 0; i < BULLET_POOL_COUNT; i++)
            mBuilet[i].DrawBullet(g, this);
        for (int i = 0; i < ENEMY_POOL_COUNT; i++)
            mEnemy[i].DrawEnemy(g, this);
    }

    private void updateBg() {
        mBitposY0 += 10;
        mBitposY1 += 10;
        if (mBitposY0 == mScreenHeight) {
            mBitposY0 = -mScreenHeight;
        }
        if (mBitposY1 == mScreenHeight) {
            mBitposY1 = -mScreenHeight;
        }
        for (int i = 0; i < BULLET_POOL_COUNT; i++) {
            mBuilet[i].UpdateBullet();
        }
        for (int i = 0; i < ENEMY_POOL_COUNT; i++) {
            mEnemy[i].UpdateEnemy();
            if (mEnemy[i].mAnimState == Enemy.ENEMY_DEATH_STATE
                    && mEnemy[i].mPlayID == 6
                    || mEnemy[i].m_posY >= mScreenHeight) {
                mEnemy[i].init(UtilRandom(0, ENEMY_POOL_COUNT) * ENEMY_POS_OFF,
                        0);
            }
        }
        if (mSendId < BULLET_POOL_COUNT) {
            long now = System.currentTimeMillis();
            if (now - mSendTime >= PLAN_TIME) {
                mBuilet[mSendId].init(mAirPosX-5, mAirPosY-40);
                mSendTime = now;
                mSendId++;
            }
        } else {
            mSendId = 0;
        }
        Collision();
    }

    public void Collision() {
        for (int i = 0; i < BULLET_POOL_COUNT; i++) {
            for (int j = 0; j < ENEMY_POOL_COUNT; j++) {
                if (mBuilet[i].m_posX >= mEnemy[j].m_posX
                        && mBuilet[i].m_posX <= mEnemy[j].m_posX + 30
                        && mBuilet[i].m_posY >= mEnemy[j].m_posY
                        && mBuilet[i].m_posY <= mEnemy[j].m_posY + 30
                ) {
                    mEnemy[j].mAnimState = Enemy.ENEMY_DEATH_STATE;
                }
            }
        }
    }
    private int UtilRandom(int botton, int top) {
        return ((Math.abs(new Random().nextInt()) % (top - botton)) + botton);
    }
    public void run() {//2
        while (mIsRunning) {            
            Draw();            
            try { 
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        System.out.println(key);
        if (key == KeyEvent.VK_UP)
            mAirPosY -= PLAN_STEP;
        if (key == KeyEvent.VK_DOWN)
            mAirPosY += PLAN_STEP;
        if (key == KeyEvent.VK_LEFT) {  
            mAirPosX -= PLAN_STEP;
            if (mAirPosX < 0)
                mAirPosX = 0;
        }
        if (key == KeyEvent.VK_RIGHT) {  
            mAirPosX += PLAN_STEP;
            if (mAirPosX > mScreenWidth - 30)
                mAirPosX = mScreenWidth - 30;
        }
        
    }
    public void keyReleased(KeyEvent arg0) {}
    public void keyTyped(KeyEvent arg0) {}    
}

Answer 1

• 你可以看下这个问题的回答https://ask.csdn.net/questions/7721112
• 这篇博客也不错, 你可以看下Java 加解密类的功能用法介绍及实际项目中数据加密解密的解决办法
• 除此之外, 这篇博客: Java线程相关知识点中的 一 进程是什么？线程是什么？两者有什么联系和区别？ 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 1.1 进程：进程，直观点来说，保存在硬盘上的程序运行之后，会在内存空间形成一个独立的内存体，这个内存体有自己独立的地址空间，有自己的堆，上级是操作系统。操作系统会 以进程为单位，分配系统资源（CPU时间片，内存等），进程是最小的资源分配单位；

  1.2 线程：有时被称为轻量级的进程，是操作系统调度执行的最小单位

  1.3 区别：

  • 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位
  • 并发性：不仅进程之间可以并发，同一个进程的多个线程之间也可并发执行
  • 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但是可以访问当前进程的资源
  • 系统开销：在创建和撤销进程的时候，系统要为它分配和回收资源，所以导致系统的开销比线程的创建和销毁时要大。但是进程有独立的地址空间，一个进程崩溃了之后，不会影响其他的进程，而线程没有独立的地址空间，一个进程死掉后，所拥有的线程全部都要销毁，所以多进程的程序比多线程的要健壮，但是在进程切换，消耗的资源比较大，性能及效率较差

  1.4 联系：

  • 一个进程有多个线程，至少有一个线程，而一个线程只能属于某一个进程
  • 同一个进程中的所有线程，共享该进程中的所有资源

• 您还可以看一下 范铁钢老师的【超强干货分享】Java程序员算法面试「通关秘籍」课程中的 课程推出原因小节, 巩固相关知识点