2.基础语法 - JavaSE | Yume Shoka = 123 = 456

# switch 语句

# switch 语句结构

格式

	switch (表达式) {
	case 1:
	语句体1;
	break;
	case 2:
	语句体2;
	break;
	...
	default:
	语句体n+1;
	break;
	}

执行流程：
- 首先计算出表达式的值
- 其次，和 case 依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break 就会结束。
- 最后，如果所有的 case 都和表达式的值不匹配，就会执行 default 语句体部分，然后程序结束掉。

# switch 语句练习 - 春夏秋冬

需求：一年有 12 个月，分属于春夏秋冬 4 个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
示例代码：

	public class Demo1 {
	public static void main(String[] args) {
	// 键盘录入月份数据，使用变量接收
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入一个月份：");
	int month = sc.nextInt();
	//case 穿透
	switch(month) {
	case 1:
	case 2:
	case 12:
	System.out.println("冬季");
	break;
	case 3:
	case 4:
	case 5:
	System.out.println("春季");
	break;
	case 6:
	case 7:
	case 8:
	System.out.println("夏季");
	break;
	case 9:
	case 10:
	case 11:
	System.out.println("秋季");
	break;
	default:
	System.out.println("你输入的月份有误");
	}
	}
	}

注意：如果 switch 中得 case，没有对应 break 的话，则会出现 case 穿透的现象。

# for 循环

# for 循环结构

循环：
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为 false，从而结束循环，否则循环将一直执行下去，形成死循环。
for 循环格式：

	for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
	}

格式解释：
- 初始化语句：用于表示循环开启时的起始状态
- 条件判断语句：用于表示循环反复执行的条件
- 循环体语句：用于表示循环反复执行的内容
- 条件控制语句：用于表示循环执行中每次变化的内容
执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是 true 还是 false
如果是 false，循环结束
如果是 true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

# for 循环练习 - 求和

需求：求 1-5 之间的数据和，并把求和结果在控制台输出

	public class ForTest02 {
	public static void main(String[] args) {
	for(int i=1; i<=5; i++) {
	sum += i;
	}
	System.out.println("1-5之间的数据和是：" + sum);
	}
	}

本题要点：
- 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
- 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的

# for 循环练习 - 求偶数和

需求：求 1-100 之间的偶数和，并把求和结果在控制台输出 }
示例代码：

	public class ForTest03 {
	public static void main(String[] args) {
	int sum = 0;
	for(int i=1; i<=100; i++) {
	if(i%2 == 0) {
	sum += i;
	}
	}
	System.out.println("1-100之间的偶数和是：" + sum);
	}
	}

# for 循环练习 - 水仙花

	public class ForTest04 {
	public static void main(String[] args) {
	// 输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从 100 开始，到 999 结束
	for(int i=100; i<1000; i++) {
	// 在计算之前获取三位数中每个位上的值
	int ge = i%10;
	int shi = i/10%10;
	int bai = i/10/10%10;

	// 判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
	if(gegege + shishishi + baibaibai == i) {
	// 输出满足条件的数字就是水仙花数
	System.out.println(i);
	}
	}
	}
	}

# for 循环练习 - 统计水仙花数个数

需求：统计 “水仙花数” 一共有多少个，并在控制台输出个数
示例代码：

	public class ForTest05 {
	public static void main(String[] args) {
	// 定义变量 count，用于保存 “水仙花数” 的数量，初始值为 0
	int count = 0;
	// 输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从 100 开始，到 999 结束
	for(int i=100; i<1000; i++) {
	// 在计算之前获取三位数中每个位上的值
	int ge = i%10;
	int shi = i/10%10;
	int bai = i/10/10%10;
	// 在判定水仙花数的过程中，满足条件不再输出，更改为修改 count 的值，使 count+1
	if(gegege + shishishi + baibaibai == i) {
	count++;
	}
	}
	// 打印输出最终结果
	System.out.println("水仙花共有：" + count + "个");
	}
	}

本题要点：
- 今后如果需求带有统计 xxx，请先想到计数器变量
- 计数器变量定义的位置，必须在循环外部

# while 循环

# while 结构

while 循环完整格式：

	初始化语句;
	while (条件判断语句) {
	循环体语句;
	条件控制语句;
	}

while 循环执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是 true 还是 false
如果是 false，循环结束
如果是 true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
示例代码：

	public class WhileDemo {
	public static void main(String[] args) {
	// 需求：在控制台输出 5 次 "HelloWorld"
	//for 循环实现
	for(int i=1; i<=5; i++) {
	System.out.println("HelloWorld");
	}
	System.out.println("--------");
	//while 循环实现
	int j = 1;
	while(j<=5) {
	System.out.println("HelloWorld");
	j++;
	}
	}
	}

# while 循环练习 - 珠穆朗玛峰

需求：世界最高山峰是珠穆朗玛峰 (8844.43 米 = 8844430 毫米)，假如我有一张足够大的纸，它的厚度是 0.1 毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
示例代码：

	public class WhileTest {
	public static void main(String[] args) {
	int count = 0;
	double paper = 0.1;
	int zf = 8844430;
	while(paper <= zf) {
	paper *= 2;
	count++;
	}
	System.out.println("需要折叠：" + count + "次");
	}
	}

# 循环细节

# do...while 循环结构

完整格式：

	初始化语句;
	do {
	循环体语句;
	条件控制语句;
	}while(条件判断语句);

执行流程：
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是 true 还是 false
如果是 false，循环结束
如果是 true，继续执行
⑤ 回到②继续
示例代码：

	public class DoWhileDemo {
	public static void main(String[] args) {
	// 需求：在控制台输出 5 次 "HelloWorld"
	//for 循环实现
	for(int i=1; i<=5; i++) {
	System.out.println("HelloWorld");
	}
	System.out.println("--------");
	//do...while 循环实现
	int j = 1;
	do {
	System.out.println("HelloWorld");
	j++;
	}while(j<=5);
	}
	}

# 三种循环的区别

三种循环的区别
- for 循环和 while 循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
- do...while 循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for 循环和 while 的区别
- 条件控制语句所控制的自增变量，因为归属 for 循环的语法结构中，在 for 循环结束后，就不能再次被访问到了
- 条件控制语句所控制的自增变量，对于 while 循环来说不归属其语法结构中，在 while 循环结束后，该变量还可以继续使用
死循环（无限循环）的三种格式
1. for(;😉{}
2. while(true){}
3. do {} while(true);

# 跳转控制语句

跳转控制语句（break）
- 跳出循环，结束循环
跳转控制语句（continue）
- 跳过本次循环，继续下次循环
注意： continue 只能在循环中进行使用！

# 循环嵌套

循环嵌套概述：在循环中，继续定义循环

示例代码：

	public static void main(String[] args) {
	// 外循环控制小时的范围，内循环控制分钟的范围
	for (int hour = 0; hour < 24; hour++) {
	for (int minute = 0; minute < 60; minute++) {
	System.out.println(hour + "时" + minute + "分");
	}
	System.out.println("--------");
	}
	}

理解：
- 请反复理解这句话（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）
结论：
- 外循环执行一次，内循环执行一圈

# Random

# Random 产生随机数

概述：
- Random 类似 Scanner，也是 Java 提供好的 API，内部提供了产生随机数的功能
  - API 后续课程详细讲解，现在可以简单理解为 Java 已经写好的代码
使用步骤：
1. 导入包
  import java.util.Random;
2. 创建对象
  Random r = new Random();
3. 产生随机数
  int num = r.nextInt(10);
  解释： 10 代表的是一个范围，如果括号写 10，产生的随机数就是 0-9，括号写 20，参数的随机数则是 0-19
示例代码：

	import java.util.Random;
	public class RandomDemo {
	public static void main(String[] args) {
	// 创建对象
	Random r = new Random();
	// 用循环获取 10 个随机数
	for(int i=0; i<10; i++) {
	// 获取随机数
	int number = r.nextInt(10);
	System.out.println("number:" + number);
	}
	// 需求：获取一个 1-100 之间的随机数
	int x = r.nextInt(100) + 1;
	System.out.println(x);
	}
	}

# Random 练习 - 猜数字

需求：
程序自动生成一个 1-100 之间的数字，使用程序实现猜出这个数字是多少？
示例代码：

	import java.util.Random;
	import java.util.Scanner;

	public class RandomTest {
	public static void main(String[] args) {
	// 要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围 1 到 100
	Random r = new Random();
	int number = r.nextInt(100) + 1;

	while(true) {
	// 使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
	Scanner sc = new Scanner(System.in);

	System.out.println("请输入你要猜的数字：");
	int guessNumber = sc.nextInt();

	// 比较输入的数字和系统产生的数据，需要使用分支语句。
	// 这里使用 if..else..if.. 格式，根据不同情况进行猜测结果显示
	if(guessNumber > number) {
	System.out.println("你猜的数字" + guessNumber + "大了");
	} else if(guessNumber < number) {
	System.out.println("你猜的数字" + guessNumber + "小了");
	} else {
	System.out.println("恭喜你猜中了");
	break;
	}
	}

	}
	}

# IDEA 开发工具

# 数组

# 数组定义格式

# 第一种

数据类型 [] 数组名

	int[] arr;
	double[] arr;
	char[] arr;

# 第二种

数据类型数组名 []

	int arr[];
	double arr[];
	char arr[];

# 数组动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

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

# 数组元素访问

索引：从 0 开始，可以通过数组的索引访问到数组中的元素。

	public class ArrayDemo {
	public static void main(String[] args) {
	int[] arr = new int[3];

	// 输出数组名
	System.out.println(arr); //[I@880ec60

	// 输出数组中的元素
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	}
	}

# java 中的内存分配

我们编写的程序存放在硬盘中，在硬盘中的程序不会运行。必须放进内存中才能运行，运行完毕后会清空内存。 Java 虚拟机要运行程序，必须要对内存进行空间的分配和管理。

目前我们只需要记住两个内存，分别是：栈内存和堆内存

区域名称	作用
寄存器	给 CPU 使用，和我们开发无关。
本地方法栈	JVM 在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的 class 文件。
堆内存	存储对象或者数组，new 来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如 main 方法运行，进入方法栈中执行。

# 静态初始化

在创建数组时，直接将元素确定

完整版格式

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

简化版格式

数据类型[] 数组名 = {元素1,元素2,...};

	public class ArrayDemo {
	public static void main(String[] args) {
	int[] arr = {1, 2, 3};
	System.out.println(arr);
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	}
	}

# 数组异常

# 索引越界异常

# 空指针异常

	public class ArrayDemo {
	public static void main(String[] args) {
	int[] arr = new int[3];

	// 把 null 赋值给数组
	arr = null;
	System.out.println(arr[0]);
	}
	}

arr = null 这行代码，意味着变量 arr 将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，

解决方案
给数组一个真正的堆内存空间引用即可！

# 数组遍历

	public class ArrayTest01 {
	public static void main(String[] args) {
	// 定义数组
	int[] arr = {11, 22, 33, 44, 55};

	// 使用通用的遍历格式
	for(int x=0; x<arr.length; x++) {
	System.out.println(arr[x]);
	}
	}
	}

# 数组最值

	public class ArrayTest02 {
	public static void main(String[] args) {
	int[] arr = {12, 45, 98, 73, 60};
	int max = arr[0];
	for(int x=1; x<arr.length; x++) {
	if(arr[x] > max) {
	max = arr[x];
	}
	}
	System.out.println("max:" + max);
	}
	}