用idea写一个星飞机大战

很好，下面是用 Java 语言和 IntelliJ IDEA 编写的星飞机大战游戏的示例代码。

首先，创建一个 `Main` 类，这个类包含了游戏的主要逻辑和窗口的绘制。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Main extends JPanel implements ActionListener {
    private Timer timer;
    private Player player;
    private Enemy enemy;
    private Missile missile;

    public Main() {
        setBackground(Color.BLACK);
        player = new Player();
        enemy = new Enemy();
        missile = new Missile();
        timer = new Timer(10, this);
        timer.start();
        addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                player.keyPressed(e);
            }
            public void keyReleased(KeyEvent e) {
                player.keyReleased(e);
            }
        });
        setFocusable(true);
    }

    public void actionPerformed(ActionEvent e) {
        player.move();
        enemy.move();
        missile.move();
        repaint();
    }

    public void paint(Graphics g) {
        super.paint(g);
        player.draw(g);
        enemy.draw(g);
        missile.draw(g);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Starship");
        frame.setSize(600, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new Main());
        frame.setVisible(true);
    }
}

`Main` 类继承了 `JPanel`，并实现了 `ActionListener` 接口，用于处理游戏的主要逻辑。在构造函数中，我们设置了游戏窗口的背景颜色、创建了玩家、敌人和导弹对象，以及启动了一个定时器，每隔10毫秒更新一次游戏画面。我们还添加了一个键盘监听器，用于处理玩家的键盘输入。

在 `actionPerformed` 方法中，我们调用了 `move` 方法，使玩家、敌人和导弹移动，并调用 `repaint` 方法刷新游戏画面。

在 `paint` 方法中，我们调用了各个对象的 `draw` 方法，用于绘制它们在游戏中的位置和状态。

最后，在 `main` 方法中，我们创建了一个 `JFrame` 对象，并将 `Main` 类添加到窗口中。

接下来，我们创建 `Player`、`Enemy` 和 `Missile` 类，用于处理玩家、敌人和导弹的逻辑和绘制。

import java.awt.*;
import java.awt.event.*;

public class Player {
    private int x, y;
    private int dx, dy;
    private boolean left, right, up, down;

    public Player() {
        x = 300;
        y = 300;
        dx = 0;
        dy = 0;
    }

    public void move() {
        if (left) {
            dx = -5;
        } else if (right) {
            dx = 5;
        } else {
            dx = 0;
        }
        if (up) {
            dy = -5;
        } else if (down) {
            dy = 5;
        } else {
            dy = 0;
        }
        x += dx;
        y += dy;
        if (x < 0) {
            x = 0;
        }
        if (x > 550) {
            x = 550;
        }
        if (y < 0) {
            y = 0;
        }
        if (y > 350) {
            y = 350;
        }
    }

    public void draw(Graphics g) {
        g.setColor(Color.BLUE);
        g.fillRect(x, y, 50, 50);
    }

    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) {
            left = true;
        }
        if (key == KeyEvent.VK_RIGHT) {
            right = true;
        }
        if (key == KeyEvent.VK_UP) {
            up = true;
        }
        if (key == KeyEvent.VK_DOWN) {
            down = true;
        }
    }

    public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) {
            left = false;
        }
        if (key == KeyEvent.VK_RIGHT) {
            right = false;
        }
        if (key == KeyEvent.VK_UP) {
            up = false;
        }
        if (key == KeyEvent.VK_DOWN) {
            down = false;
        }
    }
}

`Player` 类处理了玩家的移动和绘制。在构造函数中，我们初始化了玩家的位置和速度。在 `move` 方法中，我们根据玩家的键盘输入更新玩家的速度和位置，限制了玩家不能移动出游戏窗口。在 `draw` 方法中，我们绘制了一个蓝色的矩形作为玩家。

下面是 `Enemy` 类的代码。

import java.awt.*;

public class Enemy {
    private int x, y;
    private int dx, dy;

    public Enemy() {
        x = 100;
        y = 100;
        dx = 3;
        dy = 3;
    }

    public void move() {
        x += dx;
        y += dy;
        if (x < 0 || x > 550) {
            dx = -dx;
        }
        if (y < 0 || y > 350) {
            dy = -dy;
        }
    }

    public void draw(Graphics g) {
        g.setColor(Color.RED);
        g.fillOval(x, y, 50, 50);
    }
}

`Enemy` 类处理了敌人的移动和绘制。在构造函数中，我们初始化了敌人的位置和速度。在 `move` 方法中，我们根据敌人的位置和速度更新敌人的位置，并在敌人到达游戏窗口边界时反转速度。在 `draw` 方法中，我们绘制了一个红色的圆形作为敌人。

最后，这是 `Missile` 类的代码。

import java.awt.*;

public class Missile {
    private int x, y;
    private int dy;
    private boolean visible;

    public Missile() {
        visible = false;
    }

    public void move() {
        if (visible) {
            y += dy;
            if (y < 0) {
                visible = false;
            }
        }
    }

    public void draw(Graphics g) {
        if (visible) {
            g.setColor(Color.WHITE);
            g.fillRect(x, y, 5, 10);
        }
    }

    public void fire(int playerX, int playerY) {
        if (!visible) {
            x = playerX + 20;
            y = playerY - 10;
            dy = -10;
            visible = true;
        }
    }

    public boolean isVisible() {
        return visible;
    }

    public Rectangle getBounds() {
        return new Rectangle(x, y, 5, 10);
    }
}

`Missile` 类处理了导弹的移动和绘制。在构造函数中，我们将导弹的可见性设置为假。在 `move` 方法中，如果导弹可见，我们根据导弹的速度更新导弹的位置，并在导弹离开游戏窗口时将其设置为不可见。在 `draw` 方法中，如果导弹可见，我们绘制了一个白色的矩形作为导弹。

在 `fire` 方法中，如果导弹不可见，我们将导弹的位置设置为玩家的位置加上一些偏移量，并将导弹的速度设置为负数，表示导弹朝上方移动。我们还将导弹的可见性设置为真。

最后，我们添加一些代码将玩家、敌人和导弹连接起来。

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import java.util.*;

public class Main extends JPanel implements ActionListener {
    private Timer timer;
    private Player player;
    private ArrayList<Enemy> enemies;
    private ArrayList<Missile> missiles;

    public Main() {
        setBackground(Color.BLACK);
        player = new Player();
        enemies = new ArrayList<Enemy>();
        missiles = new ArrayList<Missile>();
        timer = new Timer(10, this);
        timer.start();
        addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                player.keyPressed(e);
            }
            public void keyReleased(KeyEvent e) {
                player.keyReleased(e);
            }
        });
        setFocusable(true);
    }

    public void actionPerformed(ActionEvent e) {
        player.move();
        for (int i = 0; i < enemies.size(); i++) {
            Enemy enemy = enemies.get(i);
            enemy.move();
            if (enemy.getBounds().intersects(player.getBounds())) {
                System.out.println("Game Over!");
                System.exit(0);
            }
        }
        for (int i = 0; i < missiles.size(); i++) {
            Missile missile = missiles.get(i);
            missile.move();
            if (missile.isVisible()) {
                for (int j = 0; j < enemies.size(); j++) {
                    Enemy enemy = enemies.get(j);
                    if (missile.getBounds().intersects(enemy.getBounds())) {
                        enemy.setVisible(false);
                        missile.setVisible(false);
                    }
                }
            }
        }
        repaint();
    }

    public void paint(Graphics g) {
        super.paint(g);
        player.draw(g);
        for (int i = 0; i < enemies.size(); i++) {
            Enemy enemy = enemies.get(i);
            enemy.draw(g);
        }
        for (int i = 0; i < missiles.size(); i++) {
            Missile missile = missiles.get(i);
            missile.draw(g);
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Starship");
        frame.setSize(600, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Main game = new Main();
        frame.add(game);
        frame.setVisible(true);
        while (true) {
            game.enemies.add(new Enemy());
            game.repaint();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void fire() {
        Missile missile = new Missile();
        missile.fire(player.getX(), player.getY());
        missiles.add(missile);
    }
}

在 `Main` 类的构造函数中，我们创建了玩家、敌人和导弹的对象数组，以及一个定时器。在 `actionPerformed` 方法中，我们调用了各个对象的 `move` 方法，并检查敌人和导弹是否与玩家相撞。如果相撞，我们输出 "Game Over!" 并退出游戏。

在 `paint` 方法中，我们调用了各个对象的 `draw` 方法，以便绘制它们在游戏中的位置和状态。

在 `main` 方法中，我们添加了一个无限循环，每隔一秒创建一个敌人对象，并将其添加到敌人数组中，然后调用 `repaint` 方法刷新游戏画面。

最后，我们添加了一个 `fire` 方法，用于发射导弹。在 `fire` 方法中，我们创建了一个导弹对象，并将其添加到导弹数组中。