语言基础第5天：

回顾：

Scanner接收用户输入的数据：共3步
分支结构(下)：
- if...else if结构：多条路
- switch...case结构：多条路
  - 优点：效率高、结构清晰
  - 缺点：只能对整数判断相等
  - break：跳出switch
循环：反复多次执行一段相同或相似的代码
循环三要素：
- 循环变量的初始化
- 循环的条件
- 循环变量的改变
  
  循环变量：在整个循环中反复改变的那个数
循环结构(上)：
- while结构：先判断后执行，有可能一次都不执行
- do...while结构：先执行后判断，至少执行一次
  
  若第1要素与第3要素的代码相同时，首选do...while

精华笔记：

循环结构(下)：
- for结构：应用率高，与次数相关的
三种循环结构如何选择：
- 先看循环是否与次数有关：
  - 若有关---------------------------------------------------------直接上for
  - 若无关，再看要素1与要素3的代码是否相同：
    - 若相同---------------------------------------------------直接上do...while
    - 若不同---------------------------------------------------直接上while
break：跳出循环

continue：跳过循环体中剩余语句而进入下一次循环
嵌套循环：
- 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
- 执行规则：外层循环走一次，内层循环走所有次
- 建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层
- break只跳出当前一层循环
数组(上)：
- 是一种数据类型(引用类型)
- 相同数据类型元素的集合
- 定义：
- 初始化：初始化数组中的元素
- 访问：访问的是数组中的元素
  - 通过(数组名.length)可以获取数组的长度(元素的个数)
  - 通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)
- 遍历/迭代：从头到尾挨个走一圈

笔记：

循环结构(下)：

for结构：应用率高，与次数相关的

1)语法:
  //    1      2       3
  for(要素1 ; 要素2 ; 要素3){
    语句块/循环体---------------反复执行的代码   4
  }
2)执行过程:
    1243243243243243...2

//for中的循环变量num的作用域，仅在当前for中----特殊情况特殊记
for(int num=1;num<=9;num++){
    System.out.println(num+"*9="+num*9);
}
for(int num=1;num<=9;num+=2){
    System.out.println(num+"*9="+num*9);
}
for(int num=9;num>=1;num--){
    System.out.println(num+"*9="+num*9);
}
for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
*/
/*
    执行过程:
    times=0  true  输出
    times=1  true  输出
    times=2  true  输出
    times=3  true  输出
    times=4  true  输出
    times=5  false for循环结束
    输出继续执行...
*/

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++){ //10次
            int a = (int)(Math.random()*100); //加数a(0到99之间的)
            int b = (int)(Math.random()*100); //加数b(0到99之间的)
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题

            System.out.println("算吧!");
            int answer = scan.nextInt(); //2)答题

            if(answer==-1){ //退出的条件只要不是0到198都可以
                break;
            }
            if(answer==result){ //判题
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

三种循环结构如何选择：
- 先看循环是否与次数有关：
  - 若有关---------------------------------------------------------直接上for
  - 若无关，再看要素1与要素3的代码是否相同：
    - 若相同---------------------------------------------------直接上do...while
    - 若不同---------------------------------------------------直接上while

break：跳出循环

for(int num=1;num<=9;num++){
    if(num==4){ //在某种特定条件下，提前结束循环
        break; //跳出循环
    }
    System.out.println(num+"*9="+num*9);
}

/*  执行过程:
    num=1  1*9=9
    num=2  2*9=18
    num=3  3*9=27
    num=4
*/

continue：跳过循环体中剩余语句而进入下一次循环

//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
    if(num%3!=0){
        System.out.println(num+"*9="+num*9);
    }
}

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
    if(num%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(num+"*9="+num*9);
}
  
/*  执行过程:
    num=1  1*9=9
    num=2  2*9=18
    num=3
    num=4  4*9=36
    num=5  5*9=45
    num=6
    num=7  7*9=63
    num=8  8*9=72
    num=9
    num=10 false
*/

嵌套循环：

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行规则：外层循环走一次，内层循环走所有次
建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层

break只跳出当前一层循环

public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ //控制行
            for(int i=1;i<=num;i++){ //控制列
                System.out.print(i+"*"+num+"="+i*num+"\t");
            }
            System.out.println(); //换行
        }
        /*
          执行过程:
            num=1
              i=1   1*1=1
              i=2   false
              换行
            num=2
              i=1   1*2=2
              i=2   2*2=4
              i=3   false
              换行
            num=3
              i=1   1*3=3
              i=2   2*3=6
              i=3   3*3=9
              i=4   false
              换行
         */
    }
}

数组(上)：

是一种数据类型(引用类型)
相同数据类型元素的集合

定义：

//声明整型数组arr1，包含5个元素，每个元素都是int类型，默认值为0
int[] arr1 = new int[5];
//声明浮点型数组arr2，包含20个元素，每个元素都是double类型，默认值为0.0
double[] arr2 = new double[20];
//声明布尔型数组arr3，包含26个元素，每个元素都是boolean类型，默认值为false
boolean[] arr3 = new boolean[26];

初始化：初始化数组中的元素

int[] arr4 = new int[3]; //0,0,0
int[] arr5 = {1,4,7}; //1,4,7
int[] arr6 = new int[]{1,4,7}; //1,4,7
int[] arr7;
//arr7 = {1,4,7}; //编译错误，此方式只能声明同时初始化
arr7 = new int[]{1,4,7}; //正确

访问：访问的是数组中的元素

通过(数组名.length)可以获取数组的长度(元素的个数)

int[] arr = new int[3];
System.out.println("数组的长度为:"+arr.length); //3

通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)

int[] arr = new int[3];
System.out.println("数组的长度为:"+arr.length); //3
System.out.println(arr[0]); //0，输出第1个元素的值
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
//arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值

数组的遍历/迭代：从头到尾挨个走一圈

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
    System.out.println(arr[i]); //输出每个元素的值
}

补充：

变量的重名：
- 作用域重叠时，变量不能同名
\t：水平制表位，固定占8位

默认值规则：

byte,short,int,long,char-----------------0
float,double-----------------------------0.0
boolean----------------------------------false

异常：
- ArrayIndexOutOfBounds：数组下标越界异常
  
  数组的下标为0到(数组长度-1)，若超出这个范围则会发生数组下标越界异常

明日单词：

1)copy:复制
2)arraycopy/copyOf:数组复制
3)max:最大值
4)min:最小值
5)sort:顺序、排序
6)method:方法
7)public static:公开静态的
8)void:空，没有返回结果的
9)return:返回
10)say:说
11)sayHi/sayHello:问好
12)getNum:获取数字
13)plus:加法
14)test:测试

语句基础：循环结构(下)；数组(上)

语言基础第5天：

回顾：

精华笔记：

笔记：

补充：