第二周习题

2.创建类MyDate,year属性和month属性,编写一个方法totalDays,该方法通过年份和月份判断该月一共有多少天,在主函数中接受用户输入年和月，调用该方法测试它.

这里考虑平年和闰年

“平年2月有28天。闰年的2月有29天

那么就有区别了

只要判断这一点就行了！！！

1 3 5 7 8 10 12:31天

4 6 9 11:30天  

这里还是用数组存储好一点

然后就是返回值的问题

 

 

 

 

创建一个图形类。可以根据指定的符号，打印正方形。通过组建类来完成这一功能;

1. 定义一个Figure类
2. 定义一个inChar 内部字符属性
3. 定义一个String showFigure() 返回图形字符串方法

public class Figure {
    private char inChar; // 内部字符

    public Figure(char inChar) {
        this.inChar = inChar;
    }

    public void showFigure(int sideLength) {
        String figure = "";

        for (int i = 0; i < sideLength; i++) {
            for (int j = 0; j < sideLength; j++) {
                figure += inChar;
            }
            figure += "\n";
        }

        System.out.println(figure);
    }

    public static void main(String[] args) {
        Figure square = new Figure('*');
        square.showFigure(5);
    }
}
 

 

 

 

创建一个银行类，用于计算存款的利息，和本利合 .

       利息的计算方法，年限小于一年的没有利息，1年以上的，利息为3%。

       通过面向对象的方式来处理这个问题

分析：

1. 定义一个Bank类
2. 定义money属性
3. 定义 double showInterest() 计算利息方法
4. 定义 String showSumMoney() 显示信息方法
5. 1000*0.3 = 300  1000+2(1000*0.03)

 

 

public class Bank {
    private double money; // 存款金额

    public Bank(double money) {
        this.money = money;
    }

    public double showInterest() {
        double interest = 0;
        if (money >= 1000) {
            interest = money * 0.03;
        }
        return interest;
    }

    public String showSumMoney() {
        double interest = showInterest();
        double sumMoney = money + interest;
        return "本金：" + money + "，利息：" + interest + "，本利合计：" + sumMoney;
    }

    public static void main(String[] args) {
        Bank bank = new Bank(1000);
        System.out.println(bank.showSumMoney());
    }
}
 

 酒店管理系统

import javax.xml.transform.Source;
import java.util.Scanner;

/**
 * 酒店管理系统
 */
public class HotelManagerSystem {
    //全局变量, 整个类都有效
    int[][][] rooms; //存储所有的房间信息
    String[] roomTypeArr={"单人间","双人间","标准间","商务房","豪华包"};
    int[] roomPriceArr={98,128,148,288,688};

    //程序入口
    public static void main(String[] args) {
        //调用初始化方法
        HotelManagerSystem sys = new HotelManagerSystem();
        sys.initRoom(3,8);
        //显示欢迎词
        System.out.println("==============欢迎使用飞思酒店管理系统==============");
        sys.showUI();
    }

    //显示菜单
    public void showUI(){
        System.out.println("1.查看房间;2.定房间;3.退房;4.修改价格;5.退出系统");
        System.out.print("请选择您需要的服务:");
        Scanner input = new Scanner(System.in);
        while(true){ //如果输入正确, 退出循环, 输入错误,继续循环
            //数据校验: 非数字的校验
            if(input.hasNextInt()){ //hasNextInt() 返回true: 输入的是一个数字, 否则不是
                //得到选项
                int choose = input.nextInt();
                //System.out.println(choose);
                if(choose >=1 && choose <=5){ //正确选项
                    //调用相对应服务
                    doService(choose); //处理用户选项
                    //退出循环
                    break;
                }else{ //不是正确选项
                    //错误提示
                    System.out.println("【友情提示】:没有该选项!");
                    System.out.print("请重新输入:");
                }
            }else{
                //错误提示
                System.out.println("【友情提示】:输入选项格式错误!");
                System.out.print("请重新输入:");
                input.next();
            }
        }

    }

    /**
     * 处理用户选项的服务
     * @param choose
     */
    public void doService(int choose) {
        switch(choose){
            case 1:
                 //查询房间
                queryAllRoom();
                break;
            case 2:
                //定房间
                updateRoomState(true);
                break;
            case 3:
                //退房
                updateRoomState(false);
                break;
            case 4:
                //修改房间价格
                updateRoomPrice();
                break;
            case 5:
                //退出
                exitSystem();
                break;
        }
        //回显菜单
        showUI();
    }

    /**
     * 修改同一类型的房间的价格
     */
    public void updateRoomPrice() {
        //1.显示所有的房间类型, 让用户选择需要修改的房间类型
        System.out.println("房间类型:");
        for (int i = 0; i < roomTypeArr.length ; i++) {
            System.out.println("\t"+(i+1)+"."+roomTypeArr[i]);
        }
        System.out.print("请选择:");
        Scanner input = new Scanner(System.in);
        int choose = input.nextInt();
        //2.根据房间类型得到下标
        int index = choose - 1;
        //3.修改价格数组对应的下标的值
        System.out.print("请输入修改的价格:");
        int price = input.nextInt();
        roomPriceArr[index] =price;
        System.out.println("修改房间价格成功!");
    }

    /**
     * 订房或者退房
     *  true: 订房
     *  false: 退房
     * @param flag
     */
    public void updateRoomState(boolean flag) {
        //1.直接让用户输入房间编号  -->得到楼层, 房间序号
        Scanner input = new  Scanner(System.in);
        System.out.print("请输入您要订房/退房的房间编号:");
        //数据校验
        while(true){
            if(input.hasNextInt()){
                int roomNo = input.nextInt();
                //得到楼层, 房间序号  108 --> 1 .8   120 --> 1 20
                int floor = roomNo/100%10; //楼层
                int index = roomNo%100; //房间序号
                //输入的编号验证
                if(floor<1 || floor > rooms.length ){
                    System.out.println("【友情提示】:没有该楼层!");
                    System.out.print("请重新输入:");
                }else if(index < 1 || index > rooms[floor-1].length){
                    System.out.println("【友情提示】:没有该房间!");
                    System.out.print("请重新输入:");
                }else{
                    //可以订房,或者退房
                    //System.out.println("可以订房,或者退房");
                    if(flag){ //true 订房
                        //判断状态
                        if(rooms[floor-1][index-1][2] == 0){ //空闲
                            //订房:
                            rooms[floor-1][index-1][2] = 1; //修改状态为1
                            System.out.println("恭喜您,订房成功!你的房间编号:"+roomNo);
                            //退出循环
                            break;
                        }else{
                            System.out.println("【友情提示】:该房间已被预订");
                            System.out.print("请重新输入:");
                        }
                    }else{
                        //判断状态
                        if(rooms[floor-1][index-1][2] == 1){ //有人
                            //退房:
                            rooms[floor-1][index-1][2] = 0; //修改状态为0
                            System.out.println("恭喜您,退房成功!");
                            //退出循环
                            break;
                        }else{
                            System.out.println("【友情提示】:该房间已退房!");
                            System.out.print("请重新输入:");
                        }
                    }
                }
            }else{ //非整数
                System.out.println("【友情提示】:输入房间编号格式错误!");
                System.out.print("请重新输入:");
                input.next();
            }
        }

        // 2.根据flag判断是否是定房还是退房: true: 订房 false: 退房
       //3. 如果订房,先判断房间是空闲, 才允许订房, 如果有人, 让用户重新输入
       //4. 如果退房, 先判断房间是有人, 才允许退房, 如果空闲, 让用户重新输入
    }

    /**
     * 退出系统
     */
    public void exitSystem() {
        System.out.println("感谢使用本系统,欢迎下次使用!");
        //系统退出
        System.exit(0);
    }

    /**
     * 查询所有房间信息
     */
    public void queryAllRoom() {
        System.out.println("酒店房间详情表:");
        System.out.println("楼层\t房间号\t价格\t类型\t状态");
        //循环遍历 rooms数组
        // rooms.length: 获取三维数组包含二维数组个数, 有多少层
        for (int i = 0; i < rooms.length ; i++) {
            int floor = i+1;
            //rooms[i].length 二维数组包含的一维数组个数 一层有多少个房间
            for (int j = 0; j <rooms[i].length ; j++) {
                //输出楼层
                if(j == 0){ //楼层第一个房间
                    System.out.print(floor+"\t"); //打印楼层
                }else{
                    System.out.print(" "+"\t"); //打印楼层
                }
                //j房间编号  房间编号: 三位数   百位: 楼层  后两位: 房间序号
                int roomNo = floor*100+j+1;
                System.out.print(roomNo+"\t");
                //rooms[i][j].length 一维数组长度  每个房间的属性
                for (int k = 0; k <rooms[i][j].length ; k++) {
                    switch (k){
                        case 0: //价格
                            System.out.print(roomPriceArr[rooms[i][j][0]]+"\t");
                          break;
                        case 1: //类型
                            System.out.print(roomTypeArr[rooms[i][j][1]]+"\t");
                            break;
                        case 2: //状态 0: 空闲,  1: 有人
//                            switch(rooms[i][j][2]){
//                                case 0:
//                                    System.out.print("空闲");
//                                    break;
//                                case 1:
//                                    System.out.print("有人");
//                                    break;
//                            }
                            System.out.println(rooms[i][j][2]==0?"空闲":"有人");
                            break;
                    }
                }
            }
            //一个房间的信息输出完成, 换行
            System.out.println();
        }
    }

    /**
     *  店房间进行初始化操作的方法
     * @param n 有多少楼
     * @param m 一楼有多少房间
     */
    public void initRoom(int n, int m){
        rooms = new int[n][m][3];
        // n = rooms.length
        // m = rooms[i].length
        for (int i = 0; i <n ; i++) { //循环楼层
            for (int j = 0; j < m; j++) { //某一楼的某个房间
                // i = 0, j=0 表示 第一层第一个房间: 101
                for (int k = 0; k <rooms[i][j].length ; k++) {
                    //给某个房间设置 价格, 类型, 状态
                    switch(k){
                        case 0: //设置价格   j%价格数组长度(5)求余 = 0~4
                            rooms[i][j][0]= j%roomPriceArr.length;
                            break;
                        case 1: //设置类型
                            rooms[i][j][1]= j%roomTypeArr.length;
                            break;
                        case 2: //设置状态 0: 空闲  1: 有人
                            rooms[i][j][2]=0;
                            break;
                    }
                }
            }
        }
    }
}

扩展: 选择排序, 插入排序, 每一种排序时间复杂度

int left = 0;

int right = arr.length - 1;

while(left < right){

        int min = left;

        int max = left;

        for(int i = left;i <= right;i++){

                if(arr[i] < arr[min]){

                        min = i;

                }

                if(arr[i] > arr[max]){

                        max= i;

                }

        }

        swap(arr[left],arr[min]);

        if(left == max){

                max = min;

        }

        swap(right,max);

        left++;

        right--;

}

选择排序：O(n^2) 因为每一次遍历数组数组时，都要遍历数组选出最大和最小的数组，每一次遍历都是O(n),就算是自身有序的也要遍历筛选

int[] arr = {2,588,888,1000,10000};
if(arr.length <1){
    return;//终止
}
for(int i = 1;i<  arr.length;i++){
    int index = arr[i];
    int j;
    //查找插入位置
    for(j = i - 1;j >= 0;--j){
        if(arr[j] > index){
            arr[j+1] = arr[j];//数组整体移动
        }else{
            break;
        }
    }
    arr[j+1] = index;
}
for(int v:arr){
    System.out.print(v+"\t");
}
//时间复杂度：在完全有序的情况下，插入排序每个未排序区间元素只需要比较1次为O(n)
//极端情况下，比如数组时逆序排列分布，为O(n^2) 就等于每次把未排序元素插入到数组第一位。插入一个元素的时间复杂度为O(n) n个元素就是O(n^2)

 

 

        int[] praise = {2,588,888,1000,10000};
        int[] randomIndex = new int[5];
        boolean[] generateNumbers = new boolean[5];设置一个布尔数组，初值全部设置为false,代表里面的元素->代表索引,用来解决重复问题
        for(int i = 0;i <randomIndex.length;){
            int index = (int)(Math.random()*randomIndex.length);
            //一开始布尔索引里面放的全是false元素，给她加了索引(也没啥用还是false
            // ,但是取反之后就为真了，，如果下次·是一样的生成的索引就会取反为false)
            if (!generateNumbers[index]){
                randomIndex[i] = index;
                generateNumbers[index] = true;//generateNumber的索引应该也是随机的
                i++;
            }
        }

        for (int i = 0; i < praise.length; i++) {
            System.out.println(praise[randomIndex[i]] + "的奖金被抽出");
        }

        //1.声明数组
        int[] arr1;
        String arr2[];
        char[] arr3;

        //2.开辟空间
        arr1 = new int[5];
        System.out.println(arr1[0]);

        //3.给数组添加元素
        arr1[0] = 100;
        //4.使用数组的元素
        System.out.println(arr1[0]);
//声明开辟空间
        String[] strs = new String[5];
        System.out.println(strs[0]);

        //静态初始化
        int[] arr = new int[]{1,3,5,7,9};

        String[] strs2 = {"张三","李四","王五"};

        //分开
        double[] arr2;
        arr2 = new double[]{1.2,1.3,1.4};

        //无法拆分
       // char[] chArr;
        //chArr = {'c','d','b'};

        //给数组赋值
       // arr2[3]=1.88;

       // System.out.println(arr2[-1]);

        //遍历数组
        int[] ages = new int[10];

        //循环赋值
        Scanner input = new Scanner(System.in);
        int sum = 0;
        for (int i = 0; i <ages.length ; i++) {
            System.out.print("请输入第"+(i+1)+"个学生的年龄:");
            ages[i] = input.nextInt();
        }

        //求学生总年龄   5硬编码, 写死
        for (int i = 0; i < ages.length ; i++) {
            sum += ages[i];
        }
        //平均年龄
        double avg = (double)sum / 5;
        System.out.println("平均年龄:"+avg);

//---------------------------------------------------------------------------------------
        int[] arr = {1,4,62,22,34,68,12,98,11};
        //1.假设第一个元素是最大值
        int max = arr[0];
        int index = 0;//假设最大值的下标
        //2.从数组第二个元素开始,依次与最大值比较,谁大谁就是最大
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
                index = i;
            }
        }
        System.out.println("最大值:"+max);
        System.out.println("最大值下标:"+index);

## 数组

 >存储数据

变量: 存储的一个值

int a = 10;

数组: 存储一组相同数据类型的值, 容器

变量要素:

1. 数据类型
2. 变量名
3. 变量的值

数组要素:

1. 数据类型

2. 数组名

3. 数组的下标:  >=0     小于等于数组的长度-1

4. 数组的元素

   

使用变量:

1. 声明变量(开辟空间) int a;
2. 给变量赋值
3. 使用

使用数组:

1. 声明数组   语法:  数据类型[] 数组名;     数据类型 数组名[];

   2. 开辟空间, 确定数组的长度(最多能存储几个元素)

      语法: 数组名 = new 数据类型[长度];

​        数组有默认值元素: 

>整数类型:  0
>
>浮点类型: 0.0
>
>char类型: \u000
>
>boolean类型: false
>
>String/类类型: null

3. 给数组添加元素   语法:  数组名[下标] = 值;
4. 获取数组的元素,使用  语法: 数组名[下标]

数组细节

1. 声明与开辟空间合并

   数据类型[] 数组名 = new 数据类型[长度];

2. 静态赋值 声明,开辟空间, 添加元素合并

   数据类型[] 数组名 = new 数据类型[]{值1,值2,…}

   简写: 数据类型[] 数组名 ={值1,值2,…}

   第一种写法: 声明数组与静态初始化可以拆分

   第二种写法: 声明数组与静态初始化不可以拆分

3. 数组下标问题 [0,数组长度-1]

   手动给数组赋值,使用下标

   获取数组的元素,使用下标

   如果下标超出范围,抛如下错误

数组的特征: 固定长度,一旦数组确定长度,这个数组存储元素个数确定(缺点)

解决方案: 扩容(手动实现数组的扩容) 扩展作业

public class ArrayExpansion {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
      
        // 扩容为原数组长度的两倍
        int[] expandedArray = new int[originalArray.length * 2];

        // 复制原数组的元素到新数组中
        for (int i = 0; i < originalArray.length; i++) {
            expandedArray[i] = originalArray[i];
        }

        // 将新数组赋值给原数组引用
        originalArray = expandedArray;

        // 输出扩容后的数组
        System.out.println("原始数组：" + Arrays.toString(originalArray));
    }
}
 

1. 数组的遍历, 与for匹配

   数组属性: length属性: 数组的长度

   数组名.length: 动态得到数组的长度

数组应用:

优化 找最大值/最小值

思路: 1. 假设第一个元素是最大/最小

在校足球联赛中,有5个班级的比赛积分如下表:

班级	积分
一班	15
二班	11
三班	13
四班	6
五班	9

分别使用冒泡排序和选择排序对5个班级的比赛积分进行降序排序

冒泡排序降序：