作业1
编写程序,使用一维数组,模拟栈数据结构。要求:
- 这个栈可以存储java中的任何引用类型的数据
- 在栈中提供push方法模拟压栈(栈满了,要有提示信息)
- 在栈中提供pop方法模拟弹栈(栈空了,也有有提示信息)
- 编写测试程序,new栈对象,调用push pop方法来模拟压栈弹栈的动作
- 假设栈的默认初始化容量是10(请注意无参数构造方法的编写方式)
以下是提示:
public class MyStack{ 栈类
提供一个数组来存储栈中的元素
Object[] elements;
栈帧(永远指向栈顶部的元素)
每加1个元素,栈帧+1
每减1个元素,栈帧-1
int index
构造方法
构造方法应该给一维数组一个初始化容量
push方法(push方法压栈)
压栈表示栈中多一个元素
但是栈如果已满,压栈失败
这个方法的参数以及返回值类型自己定义
pop方法(pop方法弹栈)
弹栈表示栈中少一个元素
但是栈如果已空,弹栈失败
这个方法的参数以及返回值类型自己定义
}
程序代码:
- 属性私有化
- 对外提供set和get方法(可能用不上,但必须得写上)
- 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("坦克开炮");
}
}