目录

流程控制语句

分支语句

循环语句

Random随机数

数组

方法

流程控制语句

• 分为顺序语句(从上到下，依次执行)，分支语句(if，else...)和循环语句(for，while，do...while)

分支语句

• 分为if与switch两大类

单分支

if（关系表达式）{ 语句体； }

• 如果表达式成立，则执行语句体。不满足则不会执行语句体

if(true) {
            System.out.println("只有表达式成立，才会执行里面的");
        }

双分支

if（关系表达式）{ 语句体1； } else { 语句体2； }

• 如果表达式成立，则执行语句体1。否则则执行语句体2

if(true) {
            System.out.println("只有表达式成立，才会执行里面的");
        } else {
            System.out.println("表达式如果不成立，则执行这里的");
        }

多分支

if（关系表达式1）{ 语句体1； } else if（关系表达式2）{ 语句体2； } ... else { 语句体n； }

• 如果表达式1成立，则执行语句体1。如果表达式2成立，则执行语句体2，...如果表达式都不满足，则执行语句体n

int num = 1;
        if(num == 1) {
            System.out.println("1111");
        } else if(num == 2) {
            System.out.println("2222");
        } else if(num == 3) {
            System.out.println("3333");
        } else {
            System.out.println("其他的...");
        }

分支语句 switch

switch（表达式）{

        case 值1：

                语句体1；

                break；

        case 值2：

                语句体2；

                break；

        ......

        default：

                语句体n；

                break；

}

• 值与表达式做对比，如果匹配上了，则执行对应的语句体。如果都没有匹配到，则执行语句n

int num = 1;
        switch (num) {
            case 1:
                System.out.println("111");
                break;
            case 2:
                System.out.println("222");
                break;
            default:
                System.out.println("没有匹配到");
                break;
        }

循环语句

• 分为for循环，while循环和do...while循环三大类
• break关键字，会结束循环
• continue关键字，会跳过当前次循环

for循环

for（初始化语句①；条件判断语句②；条件控制语句③）{ 循环语句④； }

• 适合确定次数的循环
• ①②④③④③④......，一直到条件不成立，则结束循环

for (int i = 0;i < 10;i++) {
            System.out.println("这是第" + (i + 1) + "次执行");
        }

1. 会先定义一个变量名为i的变量(局部变量)，初始值是0
2. 然后判断变量i是否小于10，小于则执行循环语句
3. 条件成立(0确实小于10)，执行循环语句
4. 进行自增，变量i为2
5. 然后再进行条件判断，看变量i是否小于10(2也小于10)，小于10则执行循环语句
6. 重复4和5操作，直到条件不成立，结束循环

while循环

初始化语句；

while（判断条件语句）{

        循环体语句；

        条件控制语句；

}

• 适合不确定次数的循环

int num = 0;
        while (num < 10) {
            System.out.println("这是第" + (num + 1) + "次执行");
            num++;
        }

do...while循环

do {

        循环体语句；

} while（条件判断语句）；

• 不管条件成立不成立，至少都会执行一次

int num = 0;
        do{
            System.out.println("这是第" + (num + 1) + "次执行");
            num++;
        } while (num < 10);

break与continue

• break关键字，会结束循环
• continue关键字，会跳过当前次循环

for (int i = 0;i < 5;i++) {
            // 变量 i 为 3 的时候，会跳出当前这次的循环
            if (i == 3) {
                continue;
            }
            // 变量 i 为 4 的时候，会结束当前循环
            if (i == 4) {
                break;
            }
            System.out.println("这是第" + (i + 1) + "次执行"); // 输出结果只有1 2 3次
        }

Random随机数

• 生成一个0-n之间的随机数，需要用到Random库

使用

• 导包

import java.util.Random;

• 创建对象

Random r = new Random();

• 获取随机数

int num = r.nextInt(10);  // 会生成一个0到10之间的随机数，但是不会取到10

举例

import java.util.Random;
import java.util.Scanner; // 1. 导包

public class Main {
    public static void main(String[] args) {
        System.out.println("请您输入一个整数数字(需要大于0)：");
        // 获取用户输入，并限制用户只能输入数字型
        int inputNum  = new Scanner(System.in).nextInt();
        // 2. 创建Random对象
        Random r = new Random();
        // 3. 获取随机数
        int num = r.nextInt(inputNum);
        System.out.println("得到的随机数为：" + num);
    }
}

数组

• 可以一次性存储大量的数据变量，并且数据变量必须都为同一个数据类型
• 数组就是一个相同数据变量的集合

数组声明

数据类型  [  ]  变量名                或者        数据类型  变量名 [  ]

int[] arr; // 声明了一个数字型的数组，变量名为arr
int arr2[]; // 声明了一个数字型的数组，变量名为arr2

数组初始化

• java中的数组必须先初始化，然后才能使用
• 初始化就是为数组中的每个数组元素分配内存空间，并为每个数组元素赋值
• 数组初始化分为动态初始化（动态赋值）和静态初始化（静态赋值，给出固定的）

动态初始化

• 初始化的时候只指定数组长度，由系统为数组动态分配初始值

数据类型 [  ]  变量名 = new 数据类型 [ 数组长度 ]；

int[] arr = new int[6];
System.out.println(arr); // 直接打印变量名，会输出内存地址
System.out.println(arr[0]); // 0
System.out.println(arr[1]); // 0

每种数据类型的默认值是不一样的

静态初始化

• 初始化时指定每个数组元素的初始值

数据类型 [  ]  变量名 = new 数据类型 [  ] { 初始值1，初始值2... }；   或者

数据类型 [  ]  变量名 = { 初始值1，初始值2... }；

int[] arr = new int[] { 1,2,3 };
System.out.println(arr[0]); // 1
// 简写形式，一般都用这种
int[] arr2 = { 1,2,3,4,5 };
System.out.println(arr[2]); // 3

遍历数组

• 通过for循环进行遍历，数组变量名.length，可以得出数组的长度。
• 但是小标时从 0 开始的，所以需要小于 数组变量名.length

int[] arr = { 1,2,3,4,5 };
for (int i = 0;i<arr.length;i++) {
    System.out.println("数组第" + i + "项为：" + arr[i]);
}

方法

• 方法其实就是函数，先讲解一下简单的函数
• 要使用方法，必须先声明，再调用
• 方法里面不能套方法，但是可以调用其他方法

方法声明

public  static  返回值类型  方法名（参数1，参数2...）{

        ... // 方法体

}

• 返回值类型，函数最终返回什么类型，这里就写什么类型。如果没有返回值，则写void
• 参数格式：数据类型  参数名

方法调用

方法名()       // 这是无参数的

方法名(参数1，参数2...)        // 这是有参数的

• 方法不调用，自己不会执行

public class Main {
    // 定义一个没有参数的方法
    public static void fn() {
        System.out.println("我没有返回值哦");
    }
    // 定义一个有参数的方法
    public static int getSum(int num1,int num2) {
        return num1 + num2;
    }

    public static void main(String[] args) {
        // 调用没有参数的方法
        fn();
        // 调用有参数的方法
        int sum = getSum(10,30);
        System.out.println(sum);
    }
}

方法重载

• 重载就是多个方法都具有相同的方法名，并且都在同一个类中，但是方法的参数个数或者类型不相同，这就是方法的重载

注意：同一个类中，是不允许出现方法名称和参数列表都一样的方法，否则会报错

public class Main {
    public static int getSum(int num1,int num2) {
        return num1 + num2;
    }

    public static int getSum(int num1,int num2,int num3) {
        return num1 + num2 + num3;
    }

    public static void main(String[] args) {
        int sum = getSum(10,30);
        System.out.println(sum);
        int sum2 = getSum(10,20,30);
        System.out.println(sum2);
    }
}

输出小提示

System.out.println("表示输入并换行");

System.out.print("表示输入但是不换行");

System.out.println();  // 只是单纯起到一个换行作用