04Java基础语法（循环嵌套breakcontinue方法方法的重载数组动态初始化）

Posted 2021-03-02 ShawnYue-08

复习：

流程控制语句

- 顺序结构
- 分支结构
  - if-else
  - switch
- 循环结构
  - for
  - while
  - do...while

1、循环嵌套

2、控制循环的语句

3、方法

4、方法的重载

5、数组的动态初始化

1、循环嵌套

ctrl + alt + L 格式化代码

"
"换行符
"	"制表符

九九乘法表

for (int i = 1; i < 10; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (j * i) + "	");
    }
    System.out.print("
");
}

2、控制循环的语句

• break
• continue

//输出1-10，当i==5时退出循环
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

break的使用场景：

• switch
• 循环

离开这两种场景使用没有意义，用来结束switch语句或者循环。

int j = 1;
while (true) {
    if (j == 10) {
        break;
    }
    System.out.println("x");
    j++;
}

IDEA建议将条件修改为

int j = 1;
while (j != 10) {
    System.out.println("x");
    j++;
}

break在循环嵌套中，结束本层循环。（结束内层循环）

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

在内层循环中结束外层循环

//在内层循环结束外层循环，根据循环的别名
outside:
for (int i = 0; i < 10; i++) {
    inside:
    for (int j = 0; j < 10; j++) {
        if (j == 2) {
            break outside;
        }
        System.out.print("*");
    }
    System.out.println();
}

continue：使用在循环语句中，结束本次循环。

//输出偶数
for (int i = 0; i < 10; i++) {
    if (i % 2 == 1) {
        continue;
    }
    System.out.println(i);
}

//不输出5和6
for (int i = 0; i < 10; i++) {
    if (i == 5 || i == 6) {
        continue;
    }
    System.out.println(i);
}

输出2次"Java基础班"

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        break;
    }
    System.out.println("Java基础班");
}

输出7次"Java基础班"

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    System.out.println("Java基础班");
}

输出13次"Java基础班"

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        System.out.println("Java基础班");
    }
    System.out.println("Java基础班");
}

3、方法

• 方法就是完成特定功能的代码块
• 在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。

方法的格式

修饰符（权限修饰符、状态修饰符） 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
    									  //形参列表
    方法体;
    return 返回值;
}

方法的格式的详细说明

• 修饰符 比较多,后面会详细介绍。目前使用 public static，以方便main方法调用，因为静态方法不能调用非静态方法；
• 返回值类型 用于限定返回值的数据类型
• 方法名 就是一个名称，它的存在是为了方便我们调用方法
• 参数类型 限定调用方法时传入参数的数据类型
• 参数名 是一个变量，接收调用方法时传入的参数，这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的
• 方法体 完成功能的代码
• return 结束方法以及返回方法指定类型的值
• 返回值 就是功能的结果，由return带回，带回给调用者

方法的注意事项

1. 方法不调用，不执行
2. 方法与方法是平级关系，不能嵌套定义
3. 方法定义的时候参数之间用逗号隔开
4. 方法调用的时候不用在传递数据类型
5. 如果方法有明确的返回值，一定要由return带回一个值
6. main方法是由JVM主动调用，但是自定义方法需要主动调用

public static void main(String[] args) {
    send();
}

public static void send() {
    System.out.println("发射子弹");
}

void：表示方法没有明确的返回值。

return

作用：退出一个方法，跳转到上层调用的方法。

如果你的方法的返回值类型为void，return可以省略。（main方法里的return;就是省略了）

方法括号里的参数：形式参数。

两数之和

public static void main(String[] args) {
    int sum = add(30, 40);
    			//实际参数，简称实参
    System.out.println("sum = " + sum);
}

private static int add(int num1, int num2) {
    			//形式参数，简称形参
    return num1 + num2;
}

• 输出调用：System.out.println(add(3, 4));
• 单独调用：add(3, 4);
• 赋值调用：int sum = add(3, 4);

从键盘录入两数，求最大值

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    int max = getMax(a, b);
    System.out.println("max = " + max);
}

private static int getMax(int num1, int num2) {
    return num1 > num2 ? num1 : num2;
}

从键盘录入两数，判断两数是否相等

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    boolean isEqual = isEqual(a, b);
    System.out.println("isEqual:" + isEqual);
}

private static boolean isEqual(int num1, int num2) {
    return num1 == num2;
}

根据键盘录入的行数和列数，在控制台输出星形

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入行数：");
    int rows = sc.nextInt();
    System.out.println("请输入列数：");
    int cols = sc.nextInt();
    showStar(rows, cols);
    //单独调用
}

private static void showStar(int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            System.out.print("*");
        }
        System.out.println();
    }
}

根据键盘录入的数据输出对应的乘法表

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    showMulti(n);
    //单独调用
}

private static void showMulti(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j + "*" + i + "=" + (j*i) + "	");
        }
        System.out.print("
");
    }
}

4、方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。

参数列表不同：

• 参数个数不同
• 参数类型不同

public static int add(int num1, int num2) {
    System.out.println("两个整型");
    return num1 + num2;
}

public static int add(int num1, int num2, int num3) {
    System.out.println("三个整型");
    return num1 + num2 + num3;
}

public static double add(int num1, double num2) {
    System.out.println("一个整型，一个浮点型");
    return num1 + num2;
}

5、数组的动态初始化

就像一个容器，可以存储多个相同类型的元素。

数组可以存储什么类型的元素？

• 基本数据类型（四类八种）
• 引用数据类型（数组、类、接口、枚举、...）

数组的定义格式：

• 数据类型[] 数组名 = new 数据类型[数组长度];
• 数据类型 数组名[] = new 数据类型[数组长度];（不推荐）

int[] array1 = new int[5];

public static void main(String[] args) {
    /*
        * Java中的数组必须先初始化，然后才能使用；
        * 初始化：为数组元素分配内存空间，并为每个数组元素赋值
        *
        * 初始化的分类：
        *   动态初始化：只指定长度，由系统给出初始化值；
        *   静态初始化：给出初始化值，由系统决定长度；
        * */
    int[] array1 = new int[5];
    //动态初始化

    System.out.println(Arrays.toString(array1));
    //查看动态初始化，系统赋给元素的默认值
    //[0, 0, 0, 0, 0]

    double[] array2 = new double[5];
    System.out.println(Arrays.toString(array2));
    //[0.0, 0.0, 0.0, 0.0, 0.0]

    boolean[] array3 = new boolean[5];
    System.out.println(Arrays.toString(array3));
    //[false, false, false, false, false]

    char[] array4 = new char[5];
    System.out.println(Arrays.toString(array4));
    //[ ,  ,  ,  ,  ]
}

整型数组默认值都是0；（int、long、short、byte）；

浮点型数组默认值都是0.0；（float、double）；

char数组默认值是空字符（‘u0000‘）。

char[] array = new char[3];
System.out.println((int)array[0]);
//0

通过索引重新覆盖数组元素的默认值

int[] array1 = new int[5];
System.out.println(array1[0]);
//0

array1[0] = 20;
System.out.println(array1[0]);
//20