JavaSE 数组实践

作业1

编写程序，使用一维数组，模拟栈数据结构。要求：

1. 这个栈可以存储java中的任何引用类型的数据
2. 在栈中提供push方法模拟压栈（栈满了，要有提示信息）
3. 在栈中提供pop方法模拟弹栈（栈空了，也有有提示信息）
4. 编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作
5. 假设栈的默认初始化容量是10（请注意无参数构造方法的编写方式）

以下是提示：

public class MyStack{  栈类
	
	提供一个数组来存储栈中的元素
	Object[] elements;

	栈帧（永远指向栈顶部的元素）
	每加1个元素，栈帧+1
	每减1个元素，栈帧-1
	int index

	构造方法
	构造方法应该给一维数组一个初始化容量

	push方法（push方法压栈）
	压栈表示栈中多一个元素
	但是栈如果已满，压栈失败
	这个方法的参数以及返回值类型自己定义

	pop方法（pop方法弹栈）
	弹栈表示栈中少一个元素
	但是栈如果已空，弹栈失败
	这个方法的参数以及返回值类型自己定义
}

程序代码：

1. 属性私有化
2. 对外提供set和get方法（可能用不上，但必须得写上）
3. index==elements.length-1的时候满了

 MyStack

public class MyStack {

    //存储任何引用类型数据的数组
    private Object[] elements;
    //栈帧
    private int index;

    public MyStack() {
        elements = new Object[10];
        index = -1;
    }

    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    /**
     *压栈的方法
     * @param obj
     */
    public void push(Object obj){
        if(index>=elements.length-1){
            System.out.println("压栈失败，栈已满！");
            return;
        }
        //程序能走到这里,说明栈没满
        //向栈中加一个元素,栈帧向上移动一个位置
        index++;
        elements[index]=obj;
        //所有的sout()方法执行时,如果输出引用的话,自动调用引用的toString()方法.
        System.out.println("压栈"+obj+"元素成功,栈帧指向"+index);
    }

    /**
     *弹栈的方法
     * @return
     */
    public void pop(){
        if (index<0) {
            System.out.println("弹栈失败,栈已空！");
            return;
        }
        //程序能够执行到此处说明栈没有空.
        System.out.print("弹栈"+elements[index]+"元素成功,栈帧指向");
        //栈帧向下移动一位
        index--;
        System.out.println("栈帧指向"+index);
    }
}

改进：加一个MyStackException、修改在MyStack中pop+push方法、为MyStackTest添加try-catch捕获

public class MyStackException extends Exception{

    public MyStackException() {
    }

    public MyStackException(String message) {
        super(message);
    }
}

    /**
     *压栈的方法
     * @param obj
     */
    public void push(Object obj) throws MyStackException{
        if(index>=elements.length-1){

            throw new MyStackException("压栈失败，栈已满！");
        }
        //程序能走到这里,说明栈没满
        //向栈中加一个元素,栈帧向上移动一个位置
        index++;
        elements[index]=obj;
        //所有的sout()方法执行时,如果输出引用的话,自动调用引用的toString()方法.
        System.out.println("压栈"+obj+"元素成功,栈帧指向"+index);
    }

    /**
     *弹栈的方法
     * @return
     */
    public void pop() throws MyStackException {
        if (index<0) {

            throw new MyStackException("弹栈失败,栈已空！");
        }
        //程序能够执行到此处说明栈没有空.
        System.out.print("弹栈"+elements[index]+"元素成功,栈帧指向");
        //栈帧向下移动一位
        index--;
        System.out.println("栈帧指向"+index);
    }

 MyStackTest

public class MyStackTest {

    public static void main(String[] args) {
        
        MyStack myStack = new MyStack();

        for(int i=0;i<10;i++){
            myStack.push(new Object());
        }
        myStack.push(new Object());

        for(int i=0;i<10;i++){
            myStack.pop();
        }
        myStack.pop();
    }

}

改进后的MyStackTest

public class MyStackTest {

    public static void main(String[] args)  {

        MyStack myStack = new MyStack();

        for(int i=0;i<10;i++){
            try {
                myStack.push(new Object());
            } catch (MyStackException e) {
                e.printStackTrace();
            }
        }
        try {
            myStack.push(new Object());
        } catch (MyStackException e) {
            e.printStackTrace();
        }

        for(int i=0;i<10;i++){
            try {
                myStack.pop();
            } catch (MyStackException e) {
                e.printStackTrace();
            }
        }
        try {
            myStack.pop();
        } catch (MyStackException e) {
            e.printStackTrace();
        }
    }

}

作业2（难）

为某个酒店编写程序∶酒店管理系统，模拟订房、退房、打印所有房间状态等功能。要求：

1.该系统的用户是：酒店前台

2.酒店使用一个二维数组来模拟（“Room[ ][ ] rooms;”）

3.酒店中的每一个房间应该是一个java对象：Room

4.每一个房间Room应该有：房间编号、房间类型、房间是否空闲

5.系统应该对外提供的功能：

• 可以预定房间：用户输入房间编号，订房
• 可以退房：用户输入房间编号，退房
• 可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态

程序代码：

Room

public class Room {
    private int number;     //房间编号
    private String type;    //房间类型
    private Boolean status; //房间状态

    public Room() {

    }

    public Room(int number, String type, Boolean status) {
        this.number = number;
        this.type = type;
        this.status = status;
    }

    public int getNumber() {
        return number;
    }

    public Boolean isStatus() {
        return status;
    }

    public void setStatus(Boolean status) {
        this.status = status;
    }

    @Override
    //重写equals()用来比较两个房间编号
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || !(obj instanceof Room)) return false;
        Room room = (Room) obj;
        return number == room.number;
    }

    @Override
    //重写toString()用来将java对象转换成字符串形式
    public String toString() {
        return "["+number+","+type+","+(status?"空闲":"占用")+"]";
    }
}

HotelSystem

public class HotelSystem {

    private Room[][] rooms;

    public HotelSystem() {

        rooms=new Room[3][3];

        for(int i=0;i<rooms.length;i++){
            for(int j=0;j<rooms[i].length;j++){
                if(i==0){
                    //第一层
                    rooms[i][j]=new Room((i+1)*100+j+1,"单人间",true);
                }else if(i==1){
                    //第二层
                    rooms[i][j]=new Room((i+1)*100+j+1,"双人间",true);
                }else if(i==2){
                    //第三层
                    rooms[i][j]=new Room((i+1)*100+j+1,"豪华间",true);
                }
            }
        }

    }

    /**
     *遍历房间信息
     * @return
     */
    public void checkRoomInfo(){
        for(int i=0;i<rooms.length;i++){
            for(int j=0;j<rooms[i].length;j++){
                System.out.print(rooms[i][j]+" ");
            }
            System.out.println();
        }
    }

    /**
     *预订房间
     * @param roomNumber 房间编号
     */
    public void reserveRoom(int roomNumber){

        for(int i=0;i<rooms.length;i++){
            for(int j=0;j<rooms[i].length;j++){
                //遍历找到编号对应的数组元素房间
                if(roomNumber==rooms[i][j].getNumber()){

                    //判断该房间状态是否为空闲
                    if(rooms[i][j].isStatus()==true){
                        System.out.println("房间"+roomNumber+"预订成功!");
                        rooms[i][j].setStatus(false);
                        return;
                    }else{
                        System.out.println("该房已占用，预订失败！");
                        return;
                    }
                }
            }
        }
        System.out.println("没有编号为"+roomNumber+"的房间");
    }

    /**
     *退订房间
     * @param roomNumber 房间编号
     */
    public void checkOut(int roomNumber){
        for(int i=0;i<rooms.length;i++){
            for(int j=0;j<rooms[i].length;j++){
                //遍历找到编号对应的数组元素房间
                if(roomNumber==rooms[i][j].getNumber()){

                    //判断该房间状态是否为占用
                    if (rooms[i][j].isStatus()==false){
                        System.out.println("房间"+roomNumber+"退订成功！");
                        rooms[i][j].setStatus(true);
                        return;
                    }else {
                        System.out.println("房间本为空闲,无需退订！");
                    }

                }
            }
        }
        System.out.println("没有编号为"+roomNumber+"的房间");
    }
    /*
    public void checkOut(int roomNumber){
        Room room = rooms[roomNumber / 100 - 1][roomNumber % 100 - 1];
        room.setStatus(true);
        System.out.println(roomNumber+"已退房！");
    }
    */
}

 HotelSystemTest

import java.util.Scanner;

public class HotelSystemTest {
    public static void main(String[] args) {

        HotelSystem receptionDesk= new HotelSystem();
        /**
         * 输出一个欢迎界面
         */
        System.out.println("欢迎使用酒店管理系统,请认真阅读以下使用说明");
        System.out.println("功能编号对应的功能：[0]表示退出系统 [1]表示查看房间列表 [2]表示订房 [3]表示退房");

        while(true){
            //如果不import,java.util.Scanner=new java.util.Scanner(System.in);
            Scanner s = new Scanner(System.in);
            System.out.println("------------------------------------------------");
            System.out.print("请输入功能编号：");
            int i=s.nextInt();
            if(i==0){
                System.out.println("再见,欢迎下次再来！");
                return;

            }else if(i==1){
                receptionDesk.checkRoomInfo();

            }else if(i==2){
                System.out.print("请输入要预订的房间编号：");
                int roomNo=s.nextInt();
                receptionDesk.reserveRoom(roomNo);

            }else if(i==3){
                System.out.print("请输入要退订的房间编号：");
                int roomNo = s.nextInt();
                receptionDesk.checkOut(roomNo);

            }else{
                System.out.println("输入功能编号有误,请重新输入!");

            }
        }

    }
}

 

作业3

生成5个不重复的随机数，如果重复的话重新生成，最终生成的5个随机数放到数组中，要求数组中这5个随机数不重复

 RandomTest

import java.util.Random;

public class RandomTest {
    public static void main(String[] args) {

        Random random = new Random();
        int[] arrays = new int[5];

        //因为random随机数的生成是>=0的,所以这里赋值-1
        for(int i=0;i<arrays.length;i++){
            arrays[i]=-1;
        }

        int index=0;
        while(index< arrays.length){
            //随机升成的数在0~4之间,不包括5
            int num=random.nextInt(5);
            //如果数组中不包含num,就把num放进去
            if(!isContainNum(arrays,num)){
                //arrays[index]=num;
                //index++;
                arrays[index++]=num;
            }
        }

        for(int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
    }

    /**
     *查看数组中是否包含某元素
     * @param arr 数组
     * @param key 元素
     * @return true表示包含;false表示不包含
     */
    public static boolean isContainNum(int[] arr, int key){
        for(int i=0;i<arr.length;i++){
            if (arr[i]==key){
                return true;
            }
        }
        return false;
        /*
        //这方案有bug,排序之后会影响上面的代码逻辑
        //先对数组进行升序
        Arrays.sort(arr);
        //进行二分法查找
        //二分法查找的结果>=0说明,这个元素找到了,找到了表示存在!
        return Arrays.binarySearch(arr,key)>=0;
        */
    }
}

作业4

• 写一个类Army,代表一支军队
• 这个类有一个属性Weapon数组w（用来存储该军队所拥有的所有武器）
• 该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量，并用这一大小来初始化数组w
• 该类还提供一个方法addWeapon(Weapon wp),表示把参数wp所代表的武器加入到数组w中
• 在这个类中还定义两个方法attackAll()让w数组中的所有武器攻击：以及moveAll()让w数组中的所有可移动的武器移动
• 提示：Weapon是一个父类，应该有很多子武器。这些子武器应该有一些是可移动的，有一些是可攻击的

 Army

/**
 * 军队
 */
public class Army {

    private Weapon[] weapons;

    public Army(int count) {
        //动态初始化数组中每一个元素默认值是null
        weapons=new Weapon[count];
    }

    /**
     * 把武器加入数组
     * @param wp
     */
    public void addWeapon(Weapon wp) throws AddWeaponException {
        for(int i=0;i<weapons.length;i++){
            if (null==weapons[i]){
                weapons[i] = wp;
                System.out.println(wp+":武器添加成功!");
                return;
            }
        }
        //程序如果执行到此处,武器没有添加成功
        throw new AddWeaponException("武器数量已达到上限!");
    }

    /**
     * 让所有可攻击武器攻击
     */
    public void attackAll(){
        for(int i=0;i<weapons.length;i++){
            if(weapons[i] instanceof Offensive){
                //调用子类中的特有方法,向下转型
                Offensive offensive=(Offensive) weapons[i];
                offensive.shoot();
            }
        }
    }

    /**
     * 让所有可移动武器移动
     */
    public void moveAll(){
        for(int i=0;i<weapons.length;i++){
            if(weapons[i] instanceof Movable){
                Movable movable=(Movable) weapons[i];
                movable.move();
            }
        }
    }
}

 Weapon

public class Weapon {

    private String wpName;

    public Weapon() {

    }

    public Weapon(String wpName) {
        this.wpName = wpName;
    }

    @Override
    public String toString() {
        return wpName;
    }
}

 AddWeaponException

/**
 * 添加武器异常
 */
public class AddWeaponException extends Exception {

    public AddWeaponException() {
    }

    public AddWeaponException(String message) {
        super(message);
    }
}

 Fighter

/**
 * 战斗机是武器,  可移动,可攻击
 */
public class Fighter extends Weapon implements Movable,Offensive{

    public Fighter() {
    }

    public Fighter(String wpName) {
        super(wpName);
    }

    @Override
    public void move() {
        System.out.println("战斗机起飞");
    }

    @Override
    public void shoot() {
        System.out.println("战斗机开炮！");
    }
}

 Carrier

/**
 * 运输机能移动,但不能攻击
 */
public class Carrier extends Weapon implements Movable{
    public Carrier() {
    }

    public Carrier(String wpName) {
        super(wpName);
    }

    @Override
    public void move() {
        System.out.println("运输机运送物资");
    }
}

 Flak

/**
 * 高射炮是武器,  但是不能移动,只能移动
 */
public class Flak extends Weapon implements Offensive{
    public Flak() {
    }

    public Flak(String wpName) {
        super(wpName);
    }

    @Override
    public void shoot() {
        System.out.println("高射炮开炮");
    }
}

 Tank

/**
 *坦克是一个武器,可移动,可攻击。
 */
public class Tank extends Weapon implements Movable,Offensive{
    public Tank() {
    }

    public Tank(String wpName) {
        super(wpName);
    }

    @Override
    public void move() {
        System.out.println("坦克移动");
    }

    @Override
    public void shoot() {
        System.out.println("坦克开炮");
    }
}