语言基础第五天

for循环小括号里声明的变量，作用域(可使用范围)只能在当前这个for 的结构可用，其它地方视作看不见。特殊作用域。

for (int i = 1; i <= 10; i++) {
      
  }
​
  for (int i = 1; i <= 10; i++) { //当前所用的循环变量 i  与上面的循环变量 i并不冲突
      
  }

练习题:

随机出10道加法题:   for 循环来实现
    
​
(1) 10 + 20 = ? 
    请回答后回车！
    30
    答对了
(2) 55 + 65 = ?
    请回答后回车！
    110
    答错了
(3) 67 + 99 = ?
    请回答后回车！
    166
    答对了
........
(10) 1 + 1 = ?
    请回答后回车！
    2
    答对了
//-------------------------------------
        //随机10道加法题：
        //步骤：1.如何出题？  通过两个随机数 来生成题目
        //     2.如何答题？  通过控制台接收用户输入的数据
        //     3.如何判题？  通过判断用户的数据是否与 题目的结果 相等
        Scanner s = new Scanner(System.in);//创建一个扫描器
        int score = 0;//声明了一个int 类型的变量 叫score 并赋值为0
        for (int i = 1; i <= 10; i++) {
            int num1 = (int) (Math.random() * 101);//随机0~100的数据
            int num2 = (int) (Math.random() * 101);//随机0~100的数据
            System.out.println("("+ i +") " + num1 + "+" + num2 + " =?");
            System.out.println("请答题后并回车！");
            int user = s.nextInt();//接收用输入的数据
            if (user == (num1 + num2)) {
                System.out.println("答对了");
                score +=10;
            } else {
                System.out.println("答错了！");
            }
        }
​
​
for循环嵌套
外层控制轮数，内层控制次数
外层控制行数，内层控制列数

        //打印 5 行 5 列的 * 号
        for (int i = 1; i <= 5; i++) {//外层行数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        } 

   // 9 9乘法表
//        int num = 3;
        //外层循环做一次
        for (int num = 1; num <= 9; num++) { //外层for 控制轮数
            //内层循环做多次(却决于内层循环的条件)
            for (int i = 1; i <= num; i++) { //内层for 控制次数
                System.out.print(i + "*" + num + "=" + (i * num) + "\t");// \t 表示加4个空格的意思
            }
            System.out.println();//换行
        }
​
        //打印 5 行 5 列的 * 号
        for (int i = 1; i <= 5; i++) {//外层行数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();

break：跳出循环

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

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

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


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

随机加法运算器案例：

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
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题

            System.out.println("算吧!----输入-1可提前结束");
            int answer = scan.nextInt(); //2)答题

            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

嵌套循环:

• 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
• 执行过程：外层循环走一次，内层循环走所有次
• 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
• break只能跳出当前一层循环

  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=3
        i=1  1*3=3
        i=2  2*3=6
        i=3  3*3=9
        i=4  false
        换行
      num=2
        i=1  1*2=2
        i=2  2*2=4
        i=3  false
        换行
      num=1
        i=1  1*1=1
        i=2  false
        换行
   */

  数组：

1. 是一种数据类型(引用类型)

2. 相同数据类型元素的集合

3. 定义：

   //声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
   int[] arr = new int[10];

4. 初始化：给数组中的元素做初始化

   int[] arr = new int[3]; //0,0,0
   int[] arr = {1,4,7}; //1,4,7
   int[] arr = new int[]{1,4,7}; //1,4,7
   int[] arr;
   //arr = {1,4,7}; //编译错误
   arr = new int[]{1,4,7}; //正确

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

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

int[] arr = new int[3];
System.out.println(arr.length); //3

        2.通过下标/索引来访问数组中的元素

          下标从0开始，最大到(数组的长度-1)

int[] arr = new int[3];
System.out.println(arr[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]); //输出最后一个元素的值

6.遍历/迭代：从头到尾挨个走一遍

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

1. 变量的同名问题：
   • 作用域重叠时，变量不能同名的
2. \t：水平制表位，固定占8位
3. ArrayIndexOutOfBoundsException数组下标越界异常
   • 数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常