Java流程控制.xmind

1.常用的快捷键

Ctrl+C 复制
Ctrl+V 粘贴
Ctrl+A 全选
Ctrl+X 剪切
Ctrl+Z 撤销
Ctrl+S 保存
Shift+Delete 永久删除
Win+R 命令行
Win+E 打开我的电脑
Home+Shift+End选中本行文字

2.用户交互类Scanner

1.Scanner类的基本使用

我们通过Scanner类来获取用户的输入。
创建Scanner对象的基本语法如下：

  1. Scanner s=new Scanner（System.in）;

2.使用next和nextLine方法

通常我们在对数据进行输入时，通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：

1.next和nextLine的相关例子

nextDemo：

  1. import java.util.Scanner; 
  3. public class ScannerDemo {
  4.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  6.         // 从键盘接收数据
  8.         // next方式接收字符串
  9.         System.out.println("next方式接收：");
  10.         // 判断是否还有输入
  11.         if (scan.hasNext()) {
  12.             String str1 = scan.next();
  13.             System.out.println("输入的数据为：" + str1);
  14.         }
  15.         //关闭I/O流
  16.         scan.close();
  17.     }
  18. }

输出结果：

  1. next方式接收：
  2. runoob com
  3. 输入的数据为：runoob

nextLineDemo:

  1. import java.util.Scanner;
  3. public class ScannerDemo {
  4.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  6.         // 从键盘接收数据
  8.         // nextLine方式接收字符串
  9.         System.out.println("nextLine方式接收：");
  10.         // 判断是否还有输入
  11.         if (scan.hasNextLine()) {
  12.             String str2 = scan.nextLine();
  13.             System.out.println("输入的数据为：" + str2);
  14.         }
  15.         scan.close();
  16.     }
  17. }

输出结果：

  1. nextLine方式接收：
  2. runoob com
  3. 输入的数据为：runoob com

2.next（）和nextLine（）的区别

next():

  • 1、一定要读取到有效字符后才可以结束输入。
  • 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next() 不能得到带有空格的字符串。

nextLine()：

  • 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
  • 2、可以获得空白。

    3.hasNextXxx()方法

    1.基础用法

    如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：
    hasNextDemo： ```java import java.util.Scanner;

public class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); // 从键盘接收数据 int i = 0; float f = 0.0f; System.out.print(“输入整数：”); if (scan.hasNextInt()) { // 判断输入的是否是整数 i = scan.nextInt(); // 接收整数 System.out.println(“整数数据：” + i); } else { // 输入错误的信息 System.out.println(“输入的不是整数！”); } System.out.print(“输入小数：”); if (scan.hasNextFloat()) { // 判断输入的是否是小数 f = scan.nextFloat(); // 接收小数 System.out.println(“小数数据：” + f); } else { // 输入错误的信息 System.out.println(“输入的不是小数！”); } scan.close(); } }

  1. 输出结果：
  2. ```java
  3. 输入整数：12
  4. 整数数据：12
  5. 输入小数：1.2
  6. 小数数据：1.2

2.连续输入

demo：
输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：

  1. import java.util.Scanner;
  3. class RunoobTest {
  4.     public static void main(String[] args) {
  5.         System.out.println("请输入数字：");
  6.         Scanner scan = new Scanner(System.in);
  8.         double sum = 0;
  9.         int m = 0;
  11.         while (scan.hasNextDouble()) {
  12.             double x = scan.nextDouble();
  13.             m = m + 1;
  14.             sum = sum + x;
  15.         }
  17.         System.out.println(m + "个数的和为" + sum);
  18.         System.out.println(m + "个数的平均值是" + (sum / m));
  19.         scan.close();
  20.     }
  21. }

输出结果：

  1. 请输入数字：
  2. 12
  3. 23
  4. 15
  5. 21.4
  6. end
  7. 4个数的和为71.4
  8. 4个数的平均值是17.85

2.常见的逻辑结构

1.顺序结构

顺序执行的代码语句。

2.选择结构

1.if结构

1.if单选择结构

一个 if 语句包含一个布尔表达式和一条或多条语句。
语法：
if 语句的语法如下：

  1. if(布尔表达式)
  2. {
  3.    //如果布尔表达式为true将执行的语句
  4. }

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。
ifDemo：

  1. public class Test {
  3.    public static void main(String args[]){
  4.       int x = 10;
  6.       if( x < 20 ){
  7.          System.out.print("这是 if 语句");
  8.       }
  9.    }
  10. }

结果：

  1. 这是 if 语句

equals：判断字符串是否相等

2.if…else双选择结构

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。
语法

  1. if(布尔表达式){
  2.    //如果布尔表达式的值为true
  3. }else{
  4.    //如果布尔表达式的值为false
  5. }

ifelseDemo：

  1. public class Test {
  3.    public static void main(String args[]){
  4.       int x = 30;
  6.       if( x < 20 ){
  7.          System.out.print("这是 if 语句");
  8.       }else{
  9.          System.out.print("这是 else 语句");
  10.       }
  11.    }
  12. }

运行结果：

  1. 这是 else 语句

3.if…else if…else多选择结构

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：

  • if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
  • if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
  • 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

语法：

  1. if(布尔表达式 1){
  2.    //如果布尔表达式 1的值为true执行代码
  3. }else if(布尔表达式 2){
  4.    //如果布尔表达式 2的值为true执行代码
  5. }else if(布尔表达式 3){
  6.    //如果布尔表达式 3的值为true执行代码
  7. }else {
  8.    //如果以上布尔表达式都不为true执行代码
  9. }

ifsDemo：

  1. public class Test {
  2.    public static void main(String args[]){
  3.       int x = 30;
  5.       if( x == 10 ){
  6.          System.out.print("Value of X is 10");
  7.       }else if( x == 20 ){
  8.          System.out.print("Value of X is 20");
  9.       }else if( x == 30 ){
  10.          System.out.print("Value of X is 30");
  11.       }else{
  12.          System.out.print("这是 else 语句");
  13.       }
  14.    }
  15. }

运行结果：

  1. Value of X is 30

4.嵌套的if…else语句

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。
语法
嵌套的 if…else 语法格式如下：

  1. if(布尔表达式 1){
  2.    ////如果布尔表达式 1的值为true执行代码
  3.    if(布尔表达式 2){
  4.       ////如果布尔表达式 2的值为true执行代码
  5.    }
  6. }

2.switch多选择结构

1.基本用法

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法：

  1. switch(expression){
  2.     case value :
  3.        //语句
  4.        break; //可选
  5.     case value :
  6.        //语句
  7.        break; //可选
  8.     //你可以有任意数量的case语句
  9.     default : //可选
  10.        //语句
  11. }

2.switch语句规则

switch case 语句有如下规则：

  • switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
  • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
  • case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
  • 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
  • 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
  • switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

3.switchDemo

  1. public class Test {
  2.    public static void main(String args[]){
  3.       //char grade = args[0].charAt(0);
  4.       char grade = 'C';
  6.       switch(grade)
  7.       {
  8.          case 'A' :
  9.             System.out.println("优秀"); 
  10.             break;
  11.          case 'B' :
  12.          case 'C' :
  13.             System.out.println("良好");
  14.             break;
  15.          case 'D' :
  16.             System.out.println("及格");
  17.             break;
  18.          case 'F' :
  19.             System.out.println("你需要再努力努力");
  20.             break;
  21.          default :
  22.             System.out.println("未知等级");
  23.       }
  24.       System.out.println("你的等级是 " + grade);
  25.    }
  26. }

运行结果：

  1. 良好
  2. 你的等级是 C

3.循环结构

1.while循环

while是最基本的循环，它的结构为：

  1. while( 布尔表达式 ) {
  2.   //循环内容
  3. }

只要布尔表达式为 true，循环就会一直执行下去。
whileDemo：

  1. public class Test {
  2.    public static void main(String args[]) {
  3.       int x = 10;
  4.       while( x < 20 ) {
  5.          System.out.print("value of x : " + x );
  6.          x++;
  7.          System.out.print("\n");
  8.       }
  9.    }
  10. }

运行结果：

  1. value of x : 10
  2. value of x : 11
  3. value of x : 12
  4. value of x : 13
  5. value of x : 14
  6. value of x : 15
  7. value of x : 16
  8. value of x : 17
  9. value of x : 18
  10. value of x : 19

2.do…while循环

基础语法：

  1. do {
  2.        //代码语句
  3. }while(布尔表达式);

dowhileDemo：

  1. public class Test {
  2.    public static void main(String args[]){
  3.       int x = 10;
  5.       do{
  6.          System.out.print("value of x : " + x );
  7.          x++;
  8.          System.out.print("\n");
  9.       }while( x < 20 );
  10.    }
  11. }

运行结果：

  1. value of x : 10
  2. value of x : 11
  3. value of x : 12
  4. value of x : 13
  5. value of x : 14
  6. value of x : 15
  7. value of x : 16
  8. value of x : 17
  9. value of x : 18
  10. value of x : 19

3.for循环

1.基础语法

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：

  1. for(初始化; 布尔表达式; 更新) {
  2.     //代码语句
  3. }

2.关于for循环的说明

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
  • 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量。

  • 再次检测布尔表达式。循环执行上面的过程。

    3.forDemo

    1. public class Test {
    2.  public static void main(String args[]) {
    4.     for(int x = 10; x < 20; x = x+1) {
    5.        System.out.print("value of x : " + x );
    6.        System.out.print("\n");
    7.     }
    8.  }
    9. }

    运行结果：

    1. value of x : 10
    2. value of x : 11
    3. value of x : 12
    4. value of x : 13
    5. value of x : 14
    6. value of x : 15
    7. value of x : 16
    8. value of x : 17
    9. value of x : 18
    10. value of x : 19

    4.While和do…while的区别:

    1.while先判断后执行。do…while是先执行后判断!
    2.Do…while总是保证循环体会被至少执行一次!这是他们的主要差别。

    4.增强for循环

    1.基础语法

    Java5 引入了一种主要用于数组的增强型 for 循环。
    Java 增强 for 循环语法格式如下:

    1. for(声明语句 : 表达式)
    2. {
    3.  //代码句子
    4. }

    2.使用注意

    声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
    表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

    3.powerforDemo

    1. public class Test {
    2.  public static void main(String args[]){
    3.     int [] numbers = {10, 20, 30, 40, 50};
    5.     for(int x : numbers ){
    6.        System.out.print( x );
    7.        System.out.print(",");
    8.     }
    9.     System.out.print("\n");
    10.     String [] names ={"James", "Larry", "Tom", "Lacy"};
    11.     for( String name : names ) {
    12.        System.out.print( name );
    13.        System.out.print(",");
    14.     }
    15.  }
    16. }

    运行结果：

    1. 10,20,30,40,50,
    2. James,Larry,Tom,Lacy,

    5.嵌套for循环的使用——打印三角形

    题目要求：打印如下图三角形。
    image.png
    解法：
    将此三角形分解为三部分，即：
    image.png
    代码实现：

    1. class Demo{
    2.   public static void main(String[] args){
    3.       for(int i=1;i<=5;i++){
    4.           for(int j=5; i<=j; j--)
    5.               System.out.print(" ");
    6.           for(int j=1; j<=i; j++)
    7.               System.out.print("*");
    8.           for(int j=1; j<i; j++)
    9.               System.out.print("*");
    10.           System.out.println();
    11.       }
    12.   }
    13. }

    4.break与continue

    1.break关键字

    1.基础语法

    break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
    break 跳出最里层的循环，并且继续执行该循环下面的语句。

    2.breakDemo

    1. public class Test {
    2.  public static void main(String args[]) {
    3.     int [] numbers = {10, 20, 30, 40, 50};
    5.     for(int x : numbers ) {
    6.        // x 等于 30 时跳出循环
    7.        if( x == 30 ) {
    8.           break;
    9.        }
    10.        System.out.print( x );
    11.        System.out.print("\n");
    12.     }
    13.  }
    14. }

    运行结果：

    1. 10
    2. 20

    2.continue关键字

    1.基础语法

    continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
    在 for 循环中，continue 语句使程序立即跳转到更新语句。
    在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

    2.continueDemo

    1. public class Test {
    2.  public static void main(String args[]) {
    3.     int [] numbers = {10, 20, 30, 40, 50};
    5.     for(int x : numbers ) {
    6.        if( x == 30 ) {
    7.       continue;
    8.        }
    9.        System.out.print( x );
    10.        System.out.print("\n");
    11.     }
    12.  }
    13. }

    运行结果：

    1. 10
    2. 20
    3. 40
    4. 50