JAVA SE — Day 04

目 录

第1章 流程控制语句
1.1选择结构 switch
1.2选择结构 switch 练习
1.3switch语句接受的数据类型
1.4case穿透
第2章 数组
2.1数组的定义
2.2数组遍历
2.3常见问题
2.3.1数组最值
2.3.2数组异常
2.3.2.1数组越界异常
2.3.2.2空指针异常
2.4二维数组
2.4.1二维数组的定义格式及元素访问
2.4.2二维数组元素遍历
2.4.2二维数组累加求和
2.4.3公司销售综合练习
第3章 随机点名器案例

第1章 流程控制语句

1.1选择结构 switch

①switch语句解构
switch只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
格式如下:

 **swtich(表达式){
                  case 常量1 :
                    要执行的语句;
                  break;

                  case 常量2 :
                    要执行的语句;
                  break;

                  case 常量3 :
                    要执行的语句;
                  break;

                  default:
                    要执行的语句;
                  break;
              }**

【switch语句中表达式的数据类型，是有要求的。JDK1.0-1.4接收的数据类型为byte short int char;JDK1.5接受byte short int char enum（枚举）类型; JDK1.7接受byte short int char enum（枚举）string类型】
执行流程: 表达式,和case后面的常量进行比较和哪个case后的常量相同,就执行哪个case后面的程序,遇到break,就全结束【写代码时要注意关键字和标点符号】

1.2选择结构 switch 练习

使用switch语句的星期判断
①需求:初始化int类型变量(1-7)代表星期几,使用switch语句进行判断,并打印出该整数对应的星期.

②代码实现

 public class SwitchDemo01 {
                public static void main(String[] args) {
                    int week = 5;
                    switch (week) {
                    case 1:
                        System.out.println("星期一");
                        break;
                    case 2:
                        System.out.println("星期二");
                        break;
                    case 3:
                        System.out.println("星期三");
                        break;
                    case 4:
                        System.out.println("星期四");
                        break;
                    case 5:
                        System.out.println("星期五");
                        break;
                    case 6:
                        System.out.println("星期六");
                        break;
                    case 7:
                        System.out.println("星期天");
                        break;
                    default:
                        System.out.println("输入的数字不正确...");
                        break;
                    }
                }
            }

1.3switch语句接受的数据类型

switch语句中的表达式的数据类型,是有要求的

        JDK1.0 - 1.4  数据类型接受 byte short int char
        JDK1.5   数据类型接受 byte short int char enum(枚举)
        JDK1.7   数据类型接受 byte short int char enum(枚举), String    

1.4case穿透

①含义：在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。case下边没有break，程序就一直向下穿透。注意：即便case与switch数据相同的情况，没有break依然会向下穿透。
②案例：例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。
代码如下：

public class Switch_case {
public static void main(String[] args) {
    int week= 23;

    switch(week) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("工作日");
        break;
    case 6:
    case 7:
        System.out.println("休息日");
        break;
    default:
    System.out.println("输入信息不正确……");
    break;
      }
   }
}

注意：没有break的情况，case的穿透如下

第2章 数组

2.1数组的定义

①定义：数组就是一种容器，存数据用的。比如喝水不是一滴一滴喝而是喝一杯，这里一杯就是一个数组。
数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致并且要指定大小，也就是最多存储数据的个数。
②格式:
数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
eg: int[] x = new int[100];
③要点说明
1）数据类型: 数组中存储元素的数据类型
[] 表示数组的意思
变量名 自定义标识符
new 创建容器关键字
数据类型: 数组中存储元素的数据类型
元素个数,就是数组中,可以存储多少个数据 (恒定, 定长)
2）关于数组内存：

3）利用索引方式找到并输出数组中的元素：

4）数组的length属性
a. lenth属性：
在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可通过“数组名.length”的方式来获得长度，即元素的个数。
所以数组的最小索引是0，最大索引是length-1。
b. 求数组的长度
图例：

代码：

public class ArrayDemo01 {
        public static void main(String[] args) {
            int[] arr; // 声明变量
            arr = new int[3]; // 创建数组对象
                    System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素
                    System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素
                    System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素
                    System.out.println("数组的长度是：" + arr.length); // 打印数组长度
                }
            }

5)为数组的元素赋值
①第一种方法：
公式：
类型[] 数组名 = new 类型[]{元素，元素，……};
int[] arr = new int[]{1,2,3,4};
②第二种方法 （推荐使用）
公式：
类型[] 数组名 = {元素，元素，元素，……};
int[] arr = { 1, 2, 3, 4 };
如图：

③第三种方法
也可以显式地为这些元素赋值。

public class ArrayDemo02 {
    public static void main(String[] args) {
         int[] arr = new int[4]; // 定义可以存储4个整数的数组
                    arr[0] = 1; // 为第1个元素赋值1
                    arr[1] = 2; // 为第2个元素赋值2
                    // 下面的代码是打印数组中每个元素的值
                    System.out.println("arr[0]=" + arr[0]);
                    System.out.println("arr[1]=" + arr[1]);
                    System.out.println("arr[2]=" + arr[2]);
                    System.out.println("arr[3]=" + arr[3]);
                }
            }

2.2数组遍历

①定义：通过索引的方式将数组中的每个元素，分别提取出来。
②例如：

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
        // 使用for循环遍历数组的元素
        //技巧：一般情况知道循环次数用for；不确定循环次数用while
        for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]); // 通过索引访问元素
                }
            }
        }

【数组遍历的操作要求达到及其熟练！】
上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。

2.3常见问题

2.3.1数组最值

数组获取最值代码实现
①分析如何获取数组中的最大值（最小值同理）

如上图所示。先定义变量为0索引上的元素；然后利用索引遍历，用变量与其他索引的数进行比较，赋值两数较大的数值，当遍历完成后，变量则为最大值。
代码实现：

public class ArrayDemo05 {
    public static void main(String[] args) {
            int[] arr = { 4, 1, 6, 3, 9, 8 };   // 定义一个数组
            int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值

            // 下面通过一个for循环遍历数组中的元素
            for (int x = 1; x < arr.length; x++) {
                 if (arr[x] > max) { // 比较 arr[x]的值是否大于max
                        max = arr[x]; // 条件成立，将arr[x]的值赋给max
                    }
                }
                System.out.println("max=" + max); // 打印最大值
            }
        }

2.3.2数组异常

2.3.2.1数组越界异常

比如输出索引不存在时，设置三个元素，然后输出第四个索引arr[3]。
如图：

2.3.2.2空指针异常

代码：

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

        //空指针异常
        int[] arr2 = {1,5,8};
        System.out.println(arr2[2]);
        arr2 = null; // null是一个特殊常量，所有的引用类型都可以使用，含义为空，表示不再保存地址，此时虚拟机可能已经将地址删除，所以也不可能二次建立地址，内存地址只能给一次。
                System.out.println(arr2[2]);//java.lang.NullPointerException
            }
        }

2.4二维数组

①二维数组的作用：
要统计一个学校各个班级学生的考试成绩，又该如何实现呢？
这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。
②二维数组的内存图解：

2.4.1二维数组的定义格式及元素访问

定义格式：
①第一种定义格式:
int[][] arr = new int[3][4];
* 上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组。
* 图解如下：

那么需要注意的是：

②第二种定义格式
int[][] arr = new int[3][];
* 第二种方式和第一种类似，只是数组中每个元素的长度不确定
*图解如下：

不推荐这种定义方式的原因是，每个一维数组长度没确定，导致使用时需要重新定义，如下图：

③第三种定义格式（最简单的定义方式）
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
* 二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}
* 元素访问：

2.4.2二维数组元素遍历

①分析
int[][] arr = {{1,2,4},{4,7},{0,9,3}};
先使用for循环遍历arr这个二维数组,得到每一个元素为arr[i]为一维数组
再外层for循环中嵌套一个for循环遍历每一个一维数组arr[i],得到每一元素

②代码如下：

public class ArrayDemo_2{
    public static void main(String[] args){
        int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} };

          //外循环,遍历二维数组
          for(int i = 0 ; i < arr.length ;i++){
          //内循环,遍历每个一维数组 arr[0] arr[1] arr[i]
          for(int j = 0 ; j < arr[i].length; j++){
                  System.out.print(arr[i][j]);
                    }
                    System.out.println();
                }
            }
        }

2.4.2二维数组累加求和

累加求和，就是将二维数组中每个元素相加求和的运算。其中除了二维数组元素遍历的应用还要注意累计求和时“+=”的应用。
代码如下：

public class ArratDemo_1 {
    public static void main(String[] args){
        int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
        int sum2 = 0;
        for (int i=0; i<arr2.length; i++) {
            for (int j=0; j<arr2[i].length; j++) {
                 //System.out.println(arr2[i][j])
                sum2 += arr2[i][j];
            }
        }
        System.out.println("sum2= "+ sum2);
    }
}

2.4.3公司销售综合练习

①需求分析：
要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示：
* 第一小组销售额为{11, 12}万元
* 第二小组销售额为{21, 22, 23}万元
* 第三小组销售额为{31, 32, 33, 34}万元。

②代码实现：

    public class ArrayDemo10 {
            public static void main(String[] args) {
                int[][] arr = new int[3][];             // 定义一个长度为3的二维数组
                arr[0] = new int[] { 11, 12 };          // 为数组的元素赋值
                arr[1] = new int[] { 21, 22, 23 };
                arr[2] = new int[] { 31, 32, 33, 34 };      
                int sum = 0;                            // 定义变量记录总销售额
                for (int i = 0; i < arr.length; i++) { // 遍历数组元素
                    int groupSum = 0; // 定义变量记录小组销售总额
                for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
                        groupSum = groupSum + arr[i][j];
                }
                    sum = sum + groupSum;           // 累加小组销售额
                    System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元");
                }
                System.out.println("总销售额为: " + sum + " 万元");
            }
        }

另外一组代码也是可以的，如图：

注意两种代码的区别：
第二个代码需要在for内循环结尾将group Sum清零，因为int groupSum= 0 这个设定在for内循环之外，所以每次内循环后groupSum是带着让一次循环的值进行下一次循环的，所以必须在内循环结尾处清零。而第一种方法将int groupSum= 0 设定在for外循环内，也就是说只要i满足条件进行内循环之前，groupSum都会重新赋值为0接着进行后边代码的操作。

第3章 随机点名器案例

3.1案例介绍

需求： 随机点名器，即在全班同学中随机的打印出一名同学名字。
* 1)定义数组存数全班同学的姓名
* 2)总览全班同学的姓名
* 3)随便点名一人，将其输出在控制台上

3.2需求分析

• 1)定义数组存数全班同学
  
  • 2)生成随机数范围0 到 数组长度-1
  • 3)根据这个索引找到数组中的同学名称

3.3实现代码

  import java.util.Random;
        public class CallName{
            public static void main(String[] args){
                //存储姓名,姓名存储到数组中
                //数组存储姓名,姓名的数据类型,String
                String[] names = {"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"};

                //预览: 遍历数组,打印所有姓名
                for(int i = 0 ; i < names.length ; i++){
                    System.out.println(names[i]);
                }
                System.out.println("=============");

                //随机出一个人的名
                //利用随机数,生成一个整数,作为索引,到数组中找到对应的元素
                Random ran = new Random();
                //随机数,范围必须是0-数组的最大索引
                int index = ran.nextInt(names.length);//index 就是随机数,作为索引
                System.out.println(names[index]);
            }
        }

以上代码可以简化为：

import java.util.Random;
public class CallName{
    public static void main(String[] args){
        String[] names = {"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"};
        System.out.println(names[new Random().nextInt(names.length)]);
    }
}