switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法
switch case 语句格式:
switch(expression){ case value : //语句
break; //可选
case value : //语句
break; //可选 //你可以有任意数量的case语句
default : //可选 //语句}
switch case 语句有如下规则：
switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
练习
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;
}
}
}
上述代码中，由于变量week的值为5，整个switch语句判断的结果满足第17行的条件，因此打印“星期五”，例程中的default语句用于处理和前面的case都不匹配的值，将第3行代码替换为int week = 8，再次运行程序，输出结果如下
输入的数字不正确
使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。接下来通过一个案例来实现上面描述的情况
public class SwitchDemo02 { public static void main(String[] args) {int week = 2; switch (week) { case 1: case 2: case 3: case 4: case 5: // 当 week 满足值 1、2、3、4、5 中任意一个时，处理方式相同
System.out.println("今天是工作日"); break; case 6: case 7: // 当 week 满足值 6、7 中任意一个时，处理方式相同
System.out.println("今天是休息日"); break;
}
}
}
上述代码中，当变量week值为1、2、3、4、5中任意一个值时，处理方式相同，都会打印“今天是工作日”。同理，当变量week值为6、7中任意一个值时，打印“今天是休息日”。
数组
在Java中，可以使用以下格式来定义一个数组。如下
数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
int[] x = new int[100];
上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。为了更好地理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：
int[] x; // 声明一个int[]类型的变量x = new int[100]; // 创建一个长度为100的数组
接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。
第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示。
第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示。
在上图中描述了变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”。在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
接下来，通过一个案例来演示如何定义数组以及访问数组中的元素，
1 public class ArrayDemo01 { 2 public static void main(String[] args) { 3 int[] arr; // 声明变量 4 arr = new int[3]; // 创建数组对象 5 System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素 6 System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素 7 System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素 8 System.out.println("数组的长度是：" + arr.length); // 打印数组长度 9 }10 }
结果,你要自己敲哦!!!
在上述代码中声明了一个int[]类型变量arr，并将数组在内存中的地址赋值给它。在5~7行代码中通过角标来访问数组中的元素，在第8行代码中通过length属性访问数组中元素的个数。从打印结果可以看出，数组中的三个元素初始值都为0，这是因为当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。具体如下表所示。
表 1 元素默认值
数据类型 | 默认初始化值 |
byte、short、int、long | 0 |
float、double | 0.0 |
char | 一个空字符（空格），即’\u0000’ |
boolean | false |
引用数据类型 | null，表示变量不引用任何对象 |
如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。接下来通过一个程序来学习如何为数组的元素赋值，
1 public class ArrayDemo02 { 2 public static void main(String[] args) { 3 int[] arr = new int[4]; // 定义可以存储4个整数的数组
4 arr[0] = 1; // 为第1个元素赋值1
5 arr[1] = 2; // 为第2个元素赋值2
6 // 下面的代码是打印数组中每个元素的值
7 System.out.println("arr[0]=" + arr[0]); 8 System.out.println("arr[1]=" + arr[1]); 9 System.out.println("arr[2]=" + arr[2]); 10 System.out.println("arr[3]=" + arr[3]); 11 } 12 }
在上述代码中，第3行代码定义了一个数组，此时数组中每个元素都为默认初始值0。第2、3行代码通过赋值语句将数组中的元素arr[0]和arr[1]分别赋值为1和2，而元素arr[2]和arr[3]没有赋值，其值仍为0，因此打印结果中四个元素的值依次为1、2、0、0。
在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。
在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，具体格式如下：
1、类型[] 数组名 = new 类型[]{元素，元素，……};2、类型[] 数组名 = {元素，元素，元素，……};上面的两种方式都可以实现数组的静态初始化，但是为了简便，建议采用第二种方式。接下来通过一段代码来演示数组静态初始化的效果
1 public class ArrayDemo03 { 2 public static void main(String[] args) { 3 int[] arr = { 1, 2, 3, 4 }; // 静态初始化
4 // 下面的代码是依次访问数组中的元素
5 System.out.println("arr[0] = " + arr[0]); 6 System.out.println("arr[1] = " + arr[1]); 7 System.out.println("arr[2] = " + arr[2]); 8 System.out.println("arr[3] = " + arr[3]); 9 } 10 }
上述代码中采用静态初始化的方式为数组每个元素赋予初值，分别是1、2、3、4。需要注意的是，第3行代码千万不可写成int[] arr = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。
数组遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。接下来通过一个案例来学习如何使用for循环来遍历数组
public class ArrayDemo04 { public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组 // 使用for循环遍历数组的元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素 }
}
}
上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。(结果自己敲....)
数组最值
在操作数组时，经常需要获取数组中元素的最值。接下来通过一个案例来演示如何获取数组中元素的最大值
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); // 打印最大值 }
}
上述代码中，定义了一个临时变量max，用于记住数组的最大值。通过for 循环获取数组中的最大值，赋值给max变量。
首先假设数组中第一个元素arr[0]为最大值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比max值还大的元素，就将该元素赋值给max。这样一来，变量max就能够在循环结束时记住数组中的最大值。需要注意的是，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。
数组越界异常
每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错
1 public class ArrayDemo06 { 2 public static void main(String[] args) { 3 int[] arr = new int[4]; // 定义一个长度为4的数组
4 System.out.println("arr[0]=" + arr[4]); // 通过角标4访问数组元素
5 } 6 }
运行结果中提示的错误信息是数组越界异常ArrayIndexOutOfBoundsException，出现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。
所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因
空指针异常
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，接下来通过一个案例来演示这种异常
1 public class ArrayDemo07 { 2 public static void main(String[] args) { 3 int[] arr = new int[3]; // 定义一个长度为3的数组
4 arr[0] = 5; // 为数组的第一个元素赋值
5 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
6 arr = null; // 将变量arr置为null
7 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
8 } 9 }
上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常NullPointerException。
二维数组
在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组，接下来我们谈谈二维数组。
二维数组的定义有很多方式，接下来针对几种常见的方式进行详细地讲解
第一种方式：
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}，接下来通过一个图来表示这种情况，如图
对二维数组中元素的访问也是通过角标的方式，如需访问二维数组中第一个元素数组的第二个元素，具体代码如下：
arr[0][1];
二维数组元素的访问
操作二维数组时，经常需要获取数组中元素的值。接下来通过一个案例来演示如何获取数组中元素值，如下所示
class ArrayDemo08 { public static void main(String[] args){
//定义二维数组的方式
int[][] arr = new int[3][4];
System.out.println( arr );
System.out.println("二维数组的长度: " + arr.length); //获取二维数组的3个元素
System.out.println( arr[0] );
System.out.println( arr[1] );
System.out.println( arr[2] );
System.out.println("打印第一个一维数组的元素值");
System.out.println( arr[0][0] );
System.out.println( arr[0][1] );//访问的为二维数组中第1个一维数组的第2个元素
System.out.println( arr[0][2] );
System.out.println( arr[0][3] );
System.out.println("打印第二个一维数组的元素值");
System.out.println( arr[1][0] );
System.out.println( arr[1][1] );
System.out.println( arr[1][2] );
System.out.println( arr[1][3] );
System.out.println("打印第三个一维数组的元素值");
System.out.println( arr[2][0] );
System.out.println( arr[2][1] );
System.out.println( arr[2][2] );
System.out.println( arr[2][3] );
}
}
运行结果自己运行....嘻嘻
二维数组元素的遍历和数组元素累加和
数组的遍历及数组的元素累加和操作。
class ArrayDemo09 { public static void main(String[] args){ //一维数组的求累加和并遍历
int[] arr = {10,20,30,40,50}; int sum = 0;
for (int i=0; i<arr.length; i++) { //System.out.println(arr[i]);
sum += arr[i];
}
System.out.println("sum= " + sum);
System.out.println("---------------------"); //二维数组的求累加和并遍历
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);
}
}
运行结果:
-------------------------------------------------------------------------------------------------------------------
小练习:
随机点名器，即在全班同学中随机的打印出一名同学名字。
要做的随机点名器，它具备以下3个内容：
存储所有同学姓名
总览全班同学姓名
随机点名其中一人，打印到控制台
在编写案例前，我们先来学习下本案例中所涉及到的知识点：
数组
分析:
在全班同学中随机的打印出一名同学名字。
我们对本案例进行分析，得出如下分析结果：
1.存储全班同学名字
2.打印全班同学每一个人的名字
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字
在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。
编写CallName.java文件，完成程序的编写。
main方法中进行步骤1、2、3的代码实现
public static void main(String[] args) {
System.out.println("--------随机点名器--------"); // 创建一个存储多个同学名字的容器（数组）
String[] students = new String[3];
//1.存储全班同学名字 //2.打印全班同学每一个人的名字 //3.获取随机点名到的学生姓名，并打印
}
View Code
1.存储所有同学姓名
/**
* 1.存储全班同学名字
* 创建一个存储多个同学名字的容器（数组）
* 键盘输入每个同学的名字，存储到容器中（数组） */
//键盘输入多个同学名字存储到容器中
Scanner sc = new Scanner(System.in); for (int i = 0; i < students.length; i++) {
System.out.println("存储第"+i+"个名称：");
students[i] = sc.next();
}
View Code
2.打印全班同学每一个人的名字
/**
* 2打印全班同学每一个人的名字 */
//遍历数组，得到每个同学名字
for (int i = 0; i < students.length; i++) {
String name = students[i]; //打印同学名字
System.out.println("第"+i+"个学生名称：" + name);
}
View Code
3.获取随机点名到的学生姓名，并打印
/** * 3.在班级总人数范围内，随机产生一个随机数 */ //根据数组长度，获取随机索引 int index = new Random().nextInt(students.length); //通过随机索引从数组中获取名称 String name = students[index]; //返回随机点到的名称
View Code
上述代码中，通过随机数类Random产生一个从0到数组长度的随机索引。使用该索引获取students数组中对应的值，便得到了全班同学的随机姓名。
参考:http://www.runoob.com/java/java-array.html
共同学习，写下你的评论
评论加载中...
作者其他优质文章
