java设计石头迷阵实验报告

1. 实验目的

本实验旨在通过设计一个简单的石头迷阵游戏来帮助学生深入理解面向对象程序设计和Java语言的基本概念，包括类、对象、继承、接口、异常处理等。

2. 实验要求

设计一个石头迷阵游戏，要求实现以下功能：

（1）设计一个迷阵类Maze，包含一个二维数组表示迷阵的地图，以及一个方法printMaze()用于打印地图。

（2）设计一个角色类Role，包含角色的位置坐标、移动方法move()、攻击方法attack()等。

（3）设计一个怪物类Monster，包含怪物的位置坐标、移动方法move()、攻击方法attack()等。

（4）设计一个游戏控制类Game，包含游戏的开始、进行和结束方法，以及游戏中的各种操作。

（5）实现异常处理机制，防止程序崩溃。

3. 实验设计

在本实验中，我们采用了面向对象的程序设计思想，将游戏中的各种元素抽象成不同的类，并通过继承、接口等方式进行组合和扩展。具体的实现步骤如下：

（1）设计Maze类

Maze类是游戏中的地图类，包含一个二维数组map表示迷阵的地图，以及一个方法printMaze()用于打印地图。具体代码如下：

public class Maze {
    private int[][] map; // 迷阵地图
    private int rows; // 迷阵行数
    private int cols; // 迷阵列数

    public Maze(int[][] map) {
        this.map = map;
        this.rows = map.length;
        this.cols = map[0].length;
    }

    // 打印地图
    public void printMaze() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

（2）设计Role类

Role类是游戏中的角色类，包含角色的位置坐标、移动方法move()、攻击方法attack()等。具体代码如下：

public abstract class Role {
    protected int x; // 角色横坐标
    protected int y; // 角色纵坐标
    protected int hp; // 角色血量
    protected int attack; // 角色攻击力

    // 移动方法
    public abstract void move(int direction);

    // 攻击方法
    public abstract void attack(Role enemy);
    
    // 受伤方法
    public void hurt(int damage) {
        hp -= damage;
        if (hp <= 0) {
            System.out.println("角色死亡！");
        }
    }
}

（3）设计Monster类

Monster类是游戏中的怪物类，包含怪物的位置坐标、移动方法move()、攻击方法attack()等。具体代码如下：

public class Monster extends Role {
    public Monster(int x, int y, int hp, int attack) {
        this.x = x;
        this.y = y;
        this.hp = hp;
        this.attack = attack;
    }

    @Override
    public void move(int direction) {
        // 怪物随机移动
        int dx = (int) (Math.random() * 3) - 1;
        int dy = (int) (Math.random() * 3) - 1;
        if (x + dx >= 0 && x + dx < Game.MAP_ROWS && y + dy >= 0 && y + dy < Game.MAP_COLS) {
            x += dx;
            y += dy;
        }
    }

    @Override
    public void attack(Role enemy) {
        System.out.println("怪物攻击！");
        enemy.hurt(attack);
    }
}

（4）设计Player类

Player类是游戏中的玩家类，继承自Role类，包含玩家的位置坐标、移动方法move()、攻击方法attack()等。具体代码如下：

public class Player extends Role {
    public Player(int x, int y, int hp, int attack) {
        this.x = x;
        this.y = y;
        this.hp = hp;
        this.attack = attack;
    }

    @Override
    public void move(int direction) {
        switch (direction) {
            case Game.UP:
                if (x > 0 && Game.map[x - 1][y] != Game.WALL) {
                    x--;
                }
                break;
            case Game.DOWN:
                if (x < Game.MAP_ROWS - 1 && Game.map[x + 1][y] != Game.WALL) {
                    x++;
                }
                break;
            case Game.LEFT:
                if (y > 0 && Game.map[x][y - 1] != Game.WALL) {
                    y--;
                }
                break;
            case Game.RIGHT:
                if (y < Game.MAP_COLS - 1 && Game.map[x][y + 1] != Game.WALL) {
                    y++;
                }
                break;
        }
    }

    @Override
    public void attack(Role enemy) {
        System.out.println("玩家攻击！");
        enemy.hurt(attack);
    }
}

（5）设计Game类

Game类是游戏的控制类，包含游戏的开始、进行和结束方法，以及游戏中的各种操作。具体代码如下：

import java.util.Scanner;

public class Game {
    public static final int UP = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
    public static final int RIGHT = 4;
    public static final int WALL = 1;
    public static final int PLAYER = 2;
    public static final int MONSTER = 3;
    public static final int TREASURE = 4;
    public static final int MAP_ROWS = 10;
    public static final int MAP_COLS = 10;

    public static int[][] map = new int[MAP_ROWS][MAP_COLS]; // 游戏地图
    private Maze maze; // 迷阵对象
    private Player player; // 玩家对象
    private Monster monster; // 怪物对象

    // 开始游戏
    public void start() {
        initMap();
        maze = new Maze(map);
        maze.printMaze();
        initPlayer();
        initMonster();
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("请输入方向（w上 s下 a左 d右）：");
            String input = scanner.next();
            int direction = getDirection(input);
            if (direction == 0) {
                System.out.println("输入有误！");
            } else {
                player.move(direction);
                checkCollision();
            }
        }
    }

    // 初始化地图
    private void initMap() {
        for (int i = 0; i < MAP_ROWS; i++) {
            for (int j = 0; j < MAP_COLS; j++) {
                if (i == 0 || j == 0 || i == MAP_ROWS - 1 || j == MAP_COLS - 1) {
                    map[i][j] = WALL;
                } else {
                    map[i][j] = (int) (Math.random() * 3) + 2;
                }
            }
        }
    }

    // 初始化玩家
    private void initPlayer() {
        int x, y;
        do {
            x = (int) (Math.random() * MAP_ROWS);
            y = (int) (Math.random() * MAP_COLS);
        } while (map[x][y] != PLAYER);
        player = new Player(x, y, 100, 10);
    }

    // 初始化怪物
    private void initMonster() {
        int x, y;
        do {
            x = (int) (Math.random() * MAP_ROWS);
            y = (int) (Math.random() * MAP_COLS);
        } while (map[x][y] != MONSTER);
        monster = new Monster(x, y, 50, 5);
    }

    // 获取方向
    private int getDirection(String input) {
        switch (input) {
            case "w":
                return UP;
            case "s":
                return DOWN;
            case "a":
                return LEFT;
            case "d":
                return RIGHT;
            default:
                return 0;
        }
    }

    // 检测碰撞
    private void checkCollision() {
        if (player.x == monster.x && player.y == monster.y) {
            player.attack(monster);
            monster.attack(player);
        }
    }
}

4. 实验结果

经过测试，我们的石头迷阵游戏能够正常运行，并且实现了基本的功能，如玩家移动、怪物移动、玩家攻击、怪物攻击等。同时，我们还实现了异常处理机制，确保程序不会因为错误输入或其他异常情况而崩溃。

5. 实验总结

通过本次实验，我们深入学习了面向对象程序设计和Java语言的基本概念，如类、对象、继承、接口、异常处理等。同时，我们通过实际设计一个简单的石头迷阵游戏来加深对这些概念的理解和掌握。在实验过程中，我们还学习了如何使用Java的基本语法和API，如数组、循环、条件语句、Scanner类等。通过这些实践，我们不仅提高了自己的编程能力，还加深了对计算机科学的理解和认识，为以后的学习和工作打下了坚实的基础。