Java快速入门（三）

729 views

目录:

Java快速入门（三）

顺序结构

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        var sc = new Scanner(System.in);
        System.out.print("请输入姓名：");
        String name = sc.nextLine();
        System.out.printf("%n欢迎你：%s。\n", name);
        System.out.print("请输入年龄：");
        String age = sc.next();
        System.out.println(age);

    }
}

选择结构

  • 选择结构：根据条件来选择性地执行某段代码

if 语句

  • 语法结构
if (boolean 表达式 或 boolean 变量) {
        // 条件结果为 true 时执行
        // 条件执行体    
}。
  • 执行流程

if语句 图 1 if语句

  • if (boolean 表达式) 后没有 ;

if-else 语句

  • 语法结构

  • else 的隐含条件是对前面条件取反

if (boolean 表达式 或 boolean 变量) {    
        条件执行体 1 // 为 true 时执行 
} else { 
       条件执行体 2 // 为 false 时执行
}
  • 执行流程

if-else语句
图 2 if-else语句

  • if-else 语句和三元运算符：从语义上二者的含义相同；从本质上说，if-else 是语句结构，三元运算符是一种运算符号，三元运算符运算结束后会得到一个结果，而 if-else，不能返回什么结果，只能控制语句的执行流程。

  • 不能直接使用 else 语句.

if-else if-else 语句

  • 语法结构
if (boolean 表达式 A) {    
    条件执行体 1 // A为 true 时执行 
} else if (boolean 表达式 B) { 
    条件执行体 2 // B为 true 时执行
} else {    
    条件执行体 3 // 为 false 时执行}
  • 执行流程

if-elseif-else语句

图 3 if-elseif-else语句

  • 不能单独使用 else if
  • 可以不需要 else，至少一个 else if

switch 语句

  • 语法结构
switch (整型表达式) {
        case 值 1:
            执行语句 1;
            break; // 注意是否要写 break
       case 值 2:
            执行语句 2;
            break;
       ...
       case 值 n:
            执行语句 n;
            break;
       default:
        以上值都不匹配时执行的语句; 
        // 不用写 break
}
  • 执行流程

if-elseif-else语句 图 4 if-elseif-else语句

  • switch 语句适用于对多个整型值进行匹配判断，从而实现条件的分支控制，即“整型表达式 == int类型的值”
  • switch 语句后的表达式的数据类型只能是 byte、short、char、int 四种整数类型，枚举类型和 String 类型（从 Java 7 才允许），不能是 boolean 类型
  • switch 语句支持的基本数据类型只有四种：byte、short、char、int，不支持 long 类型，本质：switch 仅仅只能支持 int 类型（byte、short、char 会自动提升为 int 类型）
  • switch 执行的时会把入口 case 之后的 case 统统忽略，会一直往下执行，直到遇到 break 或 return (穿透)
  • default 一般放在 switch 的最后，也不需要写 break

总结

  • if 语句：针对单个条件判断
  • if-else 语句：针对两个相斥条件判断
  • if-else if-else 语句：针对多个相斥条件判断（范围）
  • switch 语句：针对多个相斥条件判断（整型值）

循环结构

  • 循环结构：根据循环条件重复执行某段代码
  • 定义对象、变量、获取数据库连接等操作尽量移至循环体外处理

while 循环

  • 语法结构
while (boolean 表达式) {
    循环体;
    迭代语句; 
    // 自增或自减，用于对循环次数的控制
}
  • 执行流程

while循环

图 5 while循环

  • while 循环特点：先判断表达式，若为 true 就执行循环体，否则，跳过循环体
  • while 循环 和 do-while 循环 的循环体至少有 1 条语句用于对循环次数的控制（死循环除外）

do-while 循环

  • 语法结构
do {
    循环体;
    迭代语句; // 自增或自减，用于对循环次数的控制
}
while (boolean 表达式);
  • 执行流程

do-while循环

图 6 do-while循环

  • do while 循环特点：先执行一次循环体，再判断表达式，若为 true 就执行循环体，否则，跳过循环体
  • while 循环 和 do-while 循环 的循环体至少有 1 条语句用于对循环次数的控制（死循环除外）

for 循环

  • 语法结构
for (初始化语句; boolean 表达式; 迭代语句) {
        循环体;
}
  • 执行流程

for循环

图 7 for循环

增强的for循环

增强的for循环是for循环的另一种形式。 它是 Java 5 中引入的，它是一种更简单的方法来迭代集合和数组的所有元素。 它可以使您的循环更紧凑，更易于阅读。

增强的for循环语法

for(DataType obj: array/collection){
  // obj 从容器中按顺序获取元素
}

增强的for循环示例

import java.util.Arrays;
import java.util.List;


public class for_loop {
    public static void main(String[] args) {
        //enhanced for loop
        String[] array = {"Hello ", "Hi ", "How ", "are ", "you?"};
        List<String> list = Arrays.asList(array); 
        for (String str : array) {
            System.out.print(str);
        }
        System.out.println("\n");
        for (String str : list) {
            System.out.print(str);
        }
    }
}

上面代码的输出是

Hello Hi How are you?
Hello Hi How are you?

增强了循环遍历给定集合或数组中的每个对象，将对象存储在变量中和执行循环的主体。

建议尽可能使用增强的for循环。

在增强的 for 循环中找不到当前索引。 在需要索引号的情况下，可以使用旧的for循环，也可以尝试以下替代方法来获取索引号。

import java.util.Arrays;
import java.util.List;
public class for_loop {
    public static void main(String[] args) {
    //enhanced for loop
    String[] array = {"Hello ", "Hi ", "How ", "are ", "you?"};
    List<String> list = Arrays.asList(array);
    int index = 0;
    for (String str : array) {
        System.out.print(str);
        System.out.println("Current Index :" + index++);
   }
   System.out.println("\n");
   for (String str : list) {
        System.out.print(str);
       System.out.println("Current Index: " + list.indexOf(str));
   }
  }
}

代码输出

Hello Current Index :0
Hi Current Index :1
How Current Index :2
are Current Index :3
you?Current Index :4
Hello Current Index: 0
Hi Current Index: 1
How Current Index: 2
are Current Index: 3
you?Current Index: 4

死循环

while (true) {

}do {} 

while (true)

for ( ; ; ) {}

循环选择

  • 事先不知道循环次数，使用 while 循环或 do-while 循环，至少执行一次使用 do-while 循环
  • 事先知道循环次数，优先使用 for 循环
  • 死循环，推荐使用 while 循环

嵌套循环

  • 重复的操作（内层循环） 需要做 N 次（外层循环）
  • 确定：循环的是什么，要循环的次数
  • 嵌套 for 循环性能优化：
    • 将循环变量的声明放在循环外
    • 将循环次数少的作为外层循环

循环控制

  • break：结束当前 break 所在的整个循环
  • continue：跳过 continue 所在的本次循环剩下语句，开始下一次循环
  • return：结束 return 所在的方法
  • 控制外层循环
    • 在外层循环开始前使用标签标识一个外层循环，如 outer:
    • 在 break 或 continue 后紧跟标签名，如 break outer; 或 continue outer;
  • 三者相同点：在其后不能写语句（这个语句与其在同一个花括号中），否则编译报错

案例

例1：打印金字塔 

public class Main {
    public static void main(String[] args) {
        int lay = 10;
        for (int i = 1; i <= lay; i++) {
            for (int j = 1; j <= lay - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= i * 2 - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

结果：

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************

例2：打印空金字塔 

public class Main {
    public static void main(String[] args) {
        int lay = 10;
        for (int i = 1; i <= lay; i++) {
            for (int j = 1; j <= lay - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= i * 2 - 1; k++) {
                if (i == 1 || i == lay) {
                    System.out.print("*");
                } else {
                    if (k == 1 || k == i * 2 - 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}

结果：

         *
        * *
       *   *
      *     *
     *       *
    *         *
   *           *
  *             *
 *               *
*******************

例3: 数值比较与奇偶判断

/*
    if语句格式2的练习：
        A:获取两个数据中较大的值
        B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
*/

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //获取两个数据中较大的值
        System.out.println("请输入第一个数据：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据：");
        int b = sc.nextInt();
        //定义一个变量接收最大值
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        System.out.println("max:" + max);
        System.out.println("----------------");
        //判断一个数据是奇数还是偶数
        System.out.println("请输入你要判断的数据：");
        int x = sc.nextInt();
        if (x % 2 == 0) {
            System.out.println(x + "这个数据是偶数");
        } else {
            System.out.println(x + "这个数据是奇数");
        }
    }
}

例4: 水仙花数

/*
    需求：在控制台输出所有的”水仙花数”
    分析：
        我们都不知道什么叫"水仙花数"，你让我怎么做呢?
        所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
        举例：153就是一个水仙花数。
        153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
        A:三位数其实是告诉了我们范围。
        B:通过for循环我们就可以实现获取每一个三位数
          但是麻烦是如何获取这个三位数的个,十,百位上的数据
          我们如何获取一个数据的个,十,百呢?
            假设有个一个数据:153
            ge: 153%10 = 3
            shi: 153/10%10 = 5
            bai：153/10/10%10 = 1
            qian：x/10/10/10%10
            wan:  x/10/10/10/10%10
            ...
        C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
          如果相同，就把该数据在控制台输出。
*/
public class Main {
    public static void main(String[] args) {
        // 三位数其实是告诉了我们范围。
        for (int x = 100; x < 1000; x++) {
            int ge = x % 10;
            int shi = x / 10 % 10;
            int bai = x / 10 / 10 % 10;
            // 让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
            if (x == (ge * ge * ge + shi * shi * shi + bai * bai * bai)) {
                // 如果相同，就把该数据在控制台输出。
                System.out.println(x);
            }
        }
    }
}

例5: 求出1-100之和

/*
    求出1-100之和
*/
public class Main {
    public static void main(String[] args) {
        //求出1-100之和
        //for语句版本
        int sum = 0;
        for (int x = 1; x <= 100; x++) {
            sum += x;
        }
        System.out.println("sum:" + sum);
        System.out.println("--------");
        //while语句版本
        int sum2 = 0;
        int y = 1;
        while (y <= 100) {
            sum2 += y;
            y++;
        }
        System.out.println("sum2:" + sum2);
        System.out.println("--------");
    }
}

例6: 99乘法表

public class Main {
    public static void main(String[] args) {
        for (int x = 1; x <= 9; x++) {
            for (int y = 1; y <= x; y++) {
                System.out.print(y + "*" + x + "=" + y * x + "\t");
            }
            System.out.println();
        }
    }
}

1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81