JAVASE基础知识梳理 ＜ 二 ＞ 之《流程控制》

JAVASE基础知识梳理 ＜ 二 ＞ 之《流程控制》

1、Scanner

1.1Java中的Scanner用法

Java中的Scanner用法
答：Scanner是Java语言中一个常用的输入类，它可以从控制台或文件中读取数据。Scanner类提供了多种方法来读取不同类型的数据，例如整数、浮点数、字符串等。

1.1.1创建Scanner对象

创建Scanner之前，需要先创建一个Scanner对象。创建Scanner对象时，需要传入一个输入源，可以是标准输入流（System.in） 或文件流 等。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
    }
}

1.1.2 读取整数类型数据

1.nextInt()方法

解释：nextInt()方法可以读取一个整数类型的数据，该方法会阻塞程序直到用户输入了一个合法的整数。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println("输入的整数为：" + num);
    }
}

2.hasNextInt()和nextInt()方法配合使用

如何配合使用：hasNextInt()方法用于判断下一个输入是否为整数类型，如果是则返回true，否则返回false。当hasNextInt()返回true时，可以调用nextInt()方法来读取该整数。
例子如下：

import java.util.Scanner;
public class Test{
public static void main(String[] args){
   Scanner sc = new Scanner(System.in);
   if(sc.hasNextInt){
    	int num = sc.nextInt();
    	System.out.println("输入的整数为："+num);
    }else{
     	System.out.println("输入的不是整数！！");
     }
 }
}
==================================================
public class ScannerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()){
            System.out.println(scanner.nextInt());
        }
        System.out.println("输入的不是整数，结束输入。");
    }
}

1.1.3读取浮点数类型数据

1.nextDouble()方法

解释：nextDouble()方法可以读取一个浮点数类型的数据，该方法会阻塞程序直到用户输入了一个合法的浮点数。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double num = sc.nextDouble();
        System.out.println("输入的浮点数为：" + num);
    }
}

2.hasNextDouble()和nextDouble()方法配合使用

如何配合使用：hasNextDouble()方法用于判断下一个输入是否为浮点数类型，如果是，则返回true；否则返回false。当hasNextDouble()返回true时，可以调用nextDouble()方法来读取该浮点数。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if (sc.hasNextDouble()) {
            double num = sc.nextDouble();
            System.out.println("输入的浮点数为：" + num);
        } else {
            System.out.println("输入的不是浮点数！");
        }
    }
}

1.1.4读取字符串类型数据

1.next()方法

解释：next()方法可以读取一个字符串类型的数据，该方法会阻塞程序直到用户输入了一个字符串，并且以空格作为分隔符。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println("输入的字符串为：" + str);
    }
}

2.nextLine()方法

解释：nextLine()方法可以读取一行字符串类型的数据，该方法会阻塞程序直到用户输入了一个回车符（‘\n’）。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        System.out.println("输入的字符串为：" + str);
    }
}

3.hasNext()和next()方法配合使用

如何配合使用：hasNext()方法用于判断下一个输入是否为字符串类型，如果是，则返回true；否则返回false。当hasNext()返回true时，可以调用next()方法来读取该字符串。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if (sc.hasNext()) {
            String str = sc.next();
            System.out.println("输入的字符串为：" + str);
        } else {
            System.out.println("没有输入任何内容！");
        }
    }
}

1.1.5关闭Scanner对象

解释：在使用完Scanner对象后，需要关闭它以释放资源。可以调用close()方法来关闭Scanner对象。
例子如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        // 读取数据
        
        sc.close();
    }
}

1.1.6总结

本文介绍了Java中Scanner类的常用用法，包括创建Scanner对象、读取整数类型数据、读取浮点数类型数据、读取字符串类型数据和关闭Scanner对象等。在实际开发中，可以根据具体需求选择合适的方法来读取输入数据。

2、顺序结构

图例如下

3、选择结构

有哪些语法呢?>>①if；②if-else；③switch case；
②图例如下：

4、循环结构

在Java中，常见的循环结构有以下几种：for循环、while循环、do-while循环。

4.1for循环示例代码:

for (int i = 0; i < 5; i++) {
    System.out.println("当前循环次数: " + i);
}

这段代码会执行5次循环，每次循环会输出当前循环次数的值。

4.2while循环示例代码：

int i = 0;
while (i < 5) {
    System.out.println("当前循环次数: " + i);
    i++;
}

这段代码会执行5次循环，每次循环会输出当前循环次数的值。

4.3do-while循环示例代码:

int i = 0;
do {
    System.out.println("当前循环次数: " + i);
    i++;
} while (i < 5);

这段代码会执行5次循环，每次循环会输出当前循环次数的值。不同于for循环和while循环，do-while循环会先执行循环体，再判断条件。
这些是Java中常见的循环结构以及示例代码，你可以根据具体需求选择合适的循环结构来实现不同的功能。

5、关键字break&continue

5.1break关键字

答：break关键字用于终止循环或者switch语句的执行，当程序执行到break语句时，循环或者switch语句会立即终止，不再执行之后的代码。break语句通常用于循环或者switch语句中的某个条件满足时需要跳出并结束循环或者switch语句的执行。
代码示例如下：

for (int i = 0; i < 5; i++) {
    if (i == 3) {
        break;
    }
    System.out.println(i);
}

上述代码中，当i的值等于3时，break语句会被执行，循环会立即终止，输出结果为：

0
1
2

5.2.continue关键字用于跳过循环体中剩余的代码，直接进行下一次循环的执行。当程序执行到continue语句时，会中断当前的循环迭代，然后进入下一次迭代。continue语句通常用于循环体中的某个条件满足时需要跳过当前迭代，直接进行下一次迭代。

以下是使用continue关键字的示例代码：

for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue;
    }
    System.out.println(i);
}

上述代码中，当i的值等于2时，continue语句会被执行，此时该次循环体中System.out.println(i)会被跳过，直接进行下一次循环的执行，输出结果为：

0
1
3
4

5.3

总结：

break关键字用于终止循环或者switch语句的执行。
continue关键字用于忽略当前迭代的剩余代码，直接经行下一次迭代。

5.4break，continue关键字在switch中的例子。

在switch语句中，break和continue关键字的使用方式是有所不同的。

使用break关键字在switch语句中终止执行：

int num = 2;
switch (num) {
    case 1:
        // 代码块1
        break;
    case 2:
        // 代码块2
        break;
    case 3:
        // 代码块3
        break;
    default:
        // 默认代码块
        break;
}

在上述示例中，当num的值为2时，对应的case 2中的代码块2会被执行，随后遇到break关键字，switch语句会立即终止，不再执行后续的case。如果没有使用break关键字，switch语句会继续执行后续的case，直到遇到break或者switch语句结束。
continue关键字在switch语句中无法直接使用，因为continue关键字的作用是跳过本次循环的剩余代码，进入下一次循环，而switch语句并没有循环的概念。如果想要在switch语句中实现类似的功能，可以使用break语句来间接达到目的。如下所示：

int num = 2;
switch (num) {
    case 1:
        // 代码块1
        break;
    case 2:
        // 代码块2
        // 需要跳过后续的case代码块时，可以使用break来实现类似continue的效果
        break;
    case 3:
        // 代码块3
        break;
    default:
        // 默认代码块
        break;
}

在上述示例中，当num的值为2时，对应的case 2中的代码块2会被执行，然后使用break关键字来终止switch语句的执行。这样可以达到跳过后续case代码块的效果，相当于实现了类似continue的功能。

总结：

在switch语句中，可以使用break关键字来终止执行并跳出switch语句。
相对于循环语句中的continue关键字，switch语句中无法直接使用continue关键字来跳过剩余代码，但可以使用break关键字来间接实现类似的效果。

6、方法

谈谈你对Java中方法的理解。

答：在Java中，方法（Method）是一种封装了一系列代码块的可重复使用的代码片段。方法用于执行特定的操作，并可以接受输入参数并返回一个结果。

方法的作用是将一段功能逻辑封装在一个独立的代码模块中，通过调用方法可以重复执行该功能逻辑。方法的使用可以提高代码的可读性、可维护性和代码复用性。

在Java中，方法由以下几个要素组成：

1. 方法名（Method Name）：方法的名称，用于在程序中唯一标识一个方法。
2. 返回类型（Return Type）：方法的返回结果的数据类型，可以是任意合法的Java数据类型，如果方法不返回任何结果，可以使用void关键字表示。
3. 参数列表（Parameter List）：方法接受的输入参数，可以包含零个或多个参数，每个参数由数据类型和参数名组成，多个参数之间用逗号分隔。
4. 方法体（Method Body）：方法的具体实现，包含一系列的代码块，用于完成特定的操作。

方法的定义示例：

返回类型 方法名(参数列表) {
    // 方法体
    // 执行特定的操作
    return 结果; // 如果有返回结果，使用return语句返回
}

方法的调用示例：

方法名(参数列表); // 调用方法并传递相应的参数

方法具有以下特点：

1. 方法可以被重载（Overloading）：Java允许在同一个类中定义多个同名但参数列表不同的方法，称为方法重载。方法重载可以提供更多的调用方式和适应不同的输入参数。
2. 方法可以有访问修饰符（Access Modifier）：方法可以被声明为public、protected、private或者不使用访问修饰符（默认为包私有），用于控制方法的访问权限。
3. 方法可以抛出异常（Exceptions）：方法可以声明可能抛出的异常，使用throws关键字在方法签名中声明，以便调用者能够处理异常情况。
4. 方法可以是静态（Static）或实例方法：静态方法属于类本身，可以通过类名直接调用，而实例方法属于类的对象，需要通过对象来调用。

通过合理地使用方法，可以将程序的功能模块化、封装化，提高代码的可读性、可维护性和复用性，从而使开发更加高效。
方法的定义示例：

返回类型 方法名(参数列表) {
    // 方法体
    // 执行特定的操作
    return 结果; // 如果有返回结果，使用return语句返回
}

方法的调用实例：

方法名(参数列表); // 调用方法并传递相应的参数

7、可变长参数

在Java中，可变参数（Variable Arguments）允许方法接受可变数量的参数，这使得方法的调用更加灵活和方便。可变参数是Java 5及其之后版本引入的一项特性。

可变参数的实现方式是通过使用省略号（…）来声明，它可以接受零个或多个相同类型的参数。在方法内部，可变参数被当作一个数组来处理。

使用可变参数的主要优点是可以接受不定数量的参数，不再需要明确指定参数个数。这样，可以更灵活地使用方法，无需为每种情况都定义不同参数个数的方法重载。

以下是可变参数的定义和使用示例：

返回类型 方法名(数据类型... 参数名) {
    // 方法体
}

// 调用可变参数的方法
方法名(参数1, 参数2, ...);

在编写可变参数方法时，需要考虑以下几点：

1. 可变参数必须是方法的最后一个参数：在方法签名中，可变参数必须位于参数列表的最后，这是因为它允许任意数量的参数传递给方法。
2. 可变参数只能有一个：一个方法只能有一个可变参数，如果有多个参数需要接受不定数量的值，可以使用数组或其他数据结构来处理。
3. 可变参数可以传递0个或多个参数：可变参数可以不传递任何参数，也可以传递一个或多个参数，方法内部将根据传递的参数个数自动创建数组。

以下是一个示例，展示了可变参数的使用：

public void printNumbers(int... numbers) {
    for (int num : numbers) {
        System.out.println(num);
    }
}

// 调用可变参数的方法
printNumbers(1, 2, 3);       // 输出：1 2 3
printNumbers(10, 20, 30, 40); // 输出：10 20 30 40
printNumbers();              // 不传递参数，不输出任何内容

总结而言，可变参数是Java中一种方便的特性，它允许方法接受不定数量的参数，提高了方法的灵活性和可读性。使用可变参数可以简化方法的调用，避免定义多个方法重载来处理不同个数的参数情况。在实际开发中，适当使用可变参数可以优化代码结构和提高开发效率。

8、递归

递归是一种通过自身调用的方式来解决问题的方法。在递归过程中，问题会被划分为更小的子问题，这些子问题通过递归调用来解决，最终达到解决原始问题的目的。

在Java中，递归通常通过编写一个递归方法来实现。递归方法包含两个重要的部分：递归终止条件和递归调用。

递归终止条件是用于结束递归过程的条件。在递归方法中，我们首先检查是否满足终止条件，如果满足，则返回结果。否则，我们将继续执行递归调用。

以下是一个计算阶乘的递归方法的示例：

public int factorial(int n) {
    // 递归终止条件
    if (n == 0 || n == 1) {
        return 1;
    }

    // 递归调用
    return n * factorial(n - 1);
}

在这个示例中，当n等于0或1时，递归终止，返回1。否则，递归调用factorial(n - 1)来计算(n-1)的阶乘，并将结果乘以n，返回计算结果。

需要注意的是，递归方法在实现时应当保证在满足终止条件的情况下能够收敛到终止条件。否则，递归调用可能会导致无限递归，最终导致堆栈溢出。

递归在解决某些问题时非常便捷，比如树的遍历、图的搜索等。但过度使用递归可能导致效率低下和内存消耗大，因此在使用递归时应当谨慎。

总结而言，递归是一种通过自身调用的方式来解决问题的方法。在Java中，递归通常通过编写递归方法来实现，其中包含递归终止条件和递归调用。递归方法在满足问题特性的前提下，能够简化问题的解决过程，但需要注意控制递归的终止条件，避免无限递归和性能问题。

9、数组

Java数组是一种数据结构，用于存储相同类型的多个元素。它是一个连续的、固定长度的数据结构，我们可以通过索引来访问和修改数组中的元素。

在Java中，数组的声明和初始化可以分为两步。首先，我们需要声明数组的类型和名称，然后通过关键字new来初始化数组并指定数组的长度。例如，int[] numbers = new int[5];声明了一个整数数组numbers，并指定其长度为5。

数组的元素可以通过索引访问，索引从0开始，到数组长度减1为止。例如，numbers[0]表示数组的第一个元素，numbers[2]表示数组的第三个元素。

Java数组还提供了一些常用的属性和方法。例如，length属性用于返回数组的长度，可以通过numbers.length来获取numbers数组的长度。

此外，Java数组还提供了一些实用的方法，例如Arrays.toString()方法可以将数组转换为字符串表示，Arrays.sort()方法可以对数组进行排序等。

需要注意的是，Java数组一旦初始化后，其长度是固定的，无法改变。如果需要动态增加或减少数组的长度，我们可以使用Java集合类，如ArrayList。

总结而言，Java数组是一种用于存储相同类型多个元素的数据结构。它具有固定长度、连续存储和通过索引访问元素的特性。在使用数组时，我们可以通过声明、初始化和索引来操作数组中的元素，并使用数组提供的属性和方法进行操作和处理。