break的作用：

跳出循环（结束循环）
注意：break后面 不要写代码 永远不会被执行

例题：

//  打印[0, 100]中是7的倍数中的值最大那个数(两种)
//  保存最大值的变量
int max = 0;
for (int i = 0; i <= 100; i++) {
    if (i % 7 == 0) {
        //  只要进到这个if 都是7的倍数
        max = i;
    }           
}
//  打印最大值
System.out.println(max);

//  使用break 可以倒着打印 进到循环中的第一个数 就是最大值
for (int i = 100; i >= 0; i--) {
    if (i % 7 == 0) {
        //  第一个进来就是最大值
        System.out.println(i);
        //  停止循环
        break;
    }
}

死循环时break可以当做出口

int num = 0;
while (true) {
    if(num == 5) {
        //  写个出口 来结束死循环
        break;
    }
    num++;
    System.out.println(num);
}

continue的作用：

结束本次循环 继续下一次循环

例题：

//  班级12个人 跟每个人打招呼 讨厌的人不打招呼
//  我分别讨厌 3号 5号 9号
//  先完成需求 再考虑优化代码
for (int i = 1; i <= 12; i++) {
    if (i == 3 || i == 5 || i == 9) {
        continue;
    }
    System.out.println(i + "号，你好");
}

continue 和 break在for循环嵌套中的作用：

嵌套中：
break结束了 本层的循环
continue跳出这一次的本层循环 继续下一次的本层循环 
没有影响到 外层循环

代码示例：

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (j == 6) {
            //break;
            continue;
        }
        System.out.print(j + " ");
    }
    System.out.println();
}

Math类（随机数方法）：

定义：

返回的是 [0,1) double值 伪随机数（按照一定规则去随机）

公式：

*（最大值 - 最小值 + 1） + 最小值

例题：

//  打印[18,200]的随机整数
int num = (int)(Math.random() * (200 - 18 + 1) + 18);
System.out.println(num);

//  随机20个[10,300]之间的数 打印最大值
int max = 0;
for (int i = 0; i < 20; i++) {
    int num = (int)(Math.random() * (300 - 10 + 1) + 10);
    //  判断大小 如果大就赋值给max
    if (max < num) {
        max = num;
    }
    System.out.println(num);
}
System.out.println(max + "----最大值");

函数：

定义：

封装了 特定功能的代码块

优点：

方便使用 减少重复代码书写

写法：

关键字 返回值类型 函数名(参数类型 参数1,参数类型 参数2,......) {
        函数中的语句1;
        语句2......
        //  return后面返回的 返回值 要跟函数的返回值类型 对应
        return 返回值;
 }

位置：

在类中书写

分类：

1.无参数 无返回值 的 函数
2.有参数 有返回值 的 函数
3.有参数 无返回值 的 函数
4.无参数 有返回值 的 函数

编写步骤：

1.确定函数有没有返回值
（接下来 是否要使用这个返回值 根据实际情况考虑）
2.确定函数有没有参数 有的话 是几个 都是什么类型

函数调用：

使用 函数名(传入的参数);

例题：

//  打印 HelloWorld 的函数
//  如果函数没有返回 返回值类型 使用 void
public static void printHW() {
    System.out.println("HelloWorld");
}

函数重载：

定义：

实现相同的功能 但是函数的内部实现不同

特点：

函数名字 相同  跟参数有关（参数的类型 参数顺序 参数个数 有关）
跟参数的返回值 无关

作用：

以使用者的角度去考虑问题 方便使用

例题：

//  计算两个整数的和 的函数
public static int sum(int a, int b) {
    int rel = a + b;
    return rel;
}

//  计算三个整数的和 的函数
public static int sum (int a, int b, int c) {       
    return a + b + c;
}

//  计算两个数的最大值
public static int max(int a, int b) {   
    return a > b ? a : b;
}

//  计算三个数的最大值
public static int max(int a, int b, int c) {
    return num > c ? num : c;
}

//  计算四个数的最大值
public static int max(int a, int b, int c, int d) {
    int num = max(a, b, c);
    return num > d ? num : d;
}

//  计算五个数的最大值
public static int max(int a, int b, int c, int d, int e) {
    int num = max(a, b, c, d);
    return num > e ? num : e;
}

//  计算4的阶乘的函数 1 * 2 * 3 * 4
public static void fun() {
    //  保存计算结果
    int num = 1;
    //  为了拿到 1 2 3 4 这几个数
    for (int i = 1; i <= 4; i++) {      num = num * i;
    }
    System.out.println(num);
}

递归函数：

定义：

调用一个和自己函数名相同的函数

例题：

//  定义一个递归函数 计算 阶乘 4 * 3 * 2 * 1
public static int fun1(int n) {
    //  递归出口（停止递归）
    //  没有出口 相当于 死循环
    if (n == 1) {
        return 1;
    }
    return n * fun1(n - 1);     
}