javase知识点总结：三种程序逻辑结构，输入输出

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

顺序结构

顺序结构程序就是按语句出现的先后顺序执行的程序结构。计算机按顺序逐条执行语句，当一条语句执行完毕，

自动转到下一条语句。

javase知识点总结：三种程序逻辑结构，输入输出_System

分支结构

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_02

if 语句

1. 语法格式1

if(布尔表达式){
// 语句
}

如果布尔表达式结果为true，执行if中的语句，否则不执行。

2. 语法格式2

if(布尔表达式){
// 语句1
}else{
// 语句2
}

如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。

示例：

//1.判断一个属是否为偶数
        int num = 10;
        if(num % 2 == 0){
            System.out.println(num + "是偶数");
        }else{
            System.out.println(num + "不是偶数");
        }

输出：

javase知识点总结：三种程序逻辑结构，输入输出_System_03

3. 语法格式3

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}

表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

示例：

//        2.判断一个属是整数，0还是负数
        int num = -11;
        if(num >0){
            System.out.println("整数");
        }else if(num < 0){
            System.out.println("负数");
        }else{
            System.out.println("0");
        }

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_04

if语句可以嵌套使用，有多种嵌套方式，如：

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
    if(布尔表达式){
        // 语句2
    }else{
        // 语句3
    }
}else{
// 语句4
}

代码风格

// 风格1-----> 推荐
int x = 10;
if (x == 10) {
// 语句1
} else {
// 语句2
}

//风格2
int x = 10;
if (x == 10)
{
// 语句1
}
else
{
// 语句2
}

分号问题

编译器以分号作为分隔依据
int x = 1;
if(x == 2);{
    System.out.println("hh");//和if分支没有任何关系，无论是否满足都会执行
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_05

悬垂 else 问题

//        else匹配的是最近的if
int a = 10;
int b = 20;
if(a == 10)
    if (b == 10)//下面的else匹配的是这里的if
        System.out.println("aaaaaa");
    else
        System.out.println("bbbbbb");

验证：第一个if中 a == 20

int a = 10;
int b = 20;
if(a == 20)//验证else匹配的是下面的if: a == 20
    if (b == 10)
        System.out.println("aaaaaa");
    else
        System.out.println("bbbbbb");

上述代码等同于下面的代码：

int a = 10;
int b = 20;
if (a == 20) {
    // 1
    if (b == 10) {
        // 2
        System.out.println("aaa");
    }else {
        System.out.println("bbb");
    }

练习：

//3.判断num两位数有几个9
        判断num的个位数是多少 %10
        两位数 判断十位数字是多少 num/10
        int num = 99;
        int count  = 0;
        if(num % 10 ==9){
            count ++;
        }
        if(num /10 == 9){
            count ++;
        }
        System.out.println(count);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_System_06

//判断闰年
//        世纪年能被4整除，且不能被100整除的是闰年;世纪年能被400整除的是闰年
int year = 1900;
if(year % 100 == 0) {
    if (year % 400 == 0) {
        System.out.println(year + "是世纪闰年");
    }
    else {
        System.out.println(year + "不是闰年");
    }
}else{
    if(year % 4 == 0){
        System.out.println(year + "是普通闰年");
    }else{
        System.out.println(year + "不是闰年");
    }
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_07

switch 语句

基本语法

switch(表达式){
case 常量值1:{
语句1;
[break;]
}
case 常量值2:{
语句2;
[break;]
}
 ...
default:{
内容都不满足时执行语句;
}
}

（switch 虽然支持嵌套, 但是代码不美观，一般不推荐）

执行流程：

1. 先计算表达式的值

2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束

3. 当表达式的值没有与所列项匹配时，执行default

代码示例: 根据 day 的值输出星期

int day = 4;
switch(day){
    case 1 : {
        System.out.println("星期一");
    }
    case 2 : {
        System.out.println("星期二");
    }
    case 3 : {
        System.out.println("星期三");
    }
    case 4 : {
        System.out.println("星期四");
    }
    case 5 : {
        System.out.println("星期五");
    }
    case 6 : {
        System.out.println("星期六");
    }
    case 7 : {
        System.out.println("星期天");
    }
    default:
        System.out.println("输入有误");
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_08

之所以会一直输出，是因为没有添加break语句跳出switch语句，程序匹配到 case 4 就一直往下执行，直到遇到break语句或者switch语句结束。此时需要在每个case语句结束添加break语句才能达到 "多分支选择" 的效果。

如：

int day = 4;
switch(day){
    case 1 : {
        System.out.println("星期一");break;//break跳出switch语句
    }
    case 2 : {
        System.out.println("星期二");break;
    }
    case 3 : {
        System.out.println("星期三");break;
    }
    case 4 : {
        System.out.println("星期四");break;
    }
    case 5 : {
        System.out.println("星期五");break;
    }
    case 6 : {
        System.out.println("星期六");break;
    }
    case 7 : {
        System.out.println("星期天");break;
    }
    default:
        System.out.println("输入有误");
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_09

注意：

1.多个case后的常量值不可以重复

2.switch的括号内只能是以下类型的表达式：

基本类型：byte、char、short、int，注意不能是long类型

引用类型：String常量串、枚举类型

例如：

// switch不支持浮点数和长整型
double num = 3.0;
switch (num) {
    case 1.0 :
        System.out.println("哈哈");
        break;
}

javase知识点总结：三种程序逻辑结构，输入输出_System_10

运行时：

javase知识点总结：三种程序逻辑结构，输入输出_System_11

switch 不能表达复杂的条件

//        switch不支持复杂条件，计算结果必须是确定数字，不能表示区间
int num = 15;
switch (num > 10 && num < 20){
    case 15 :{
        System.out.println("num");
    }
}

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_12

运行时：

javase知识点总结：三种程序逻辑结构，输入输出_System_13

循环结构

javase知识点总结：三种程序逻辑结构，输入输出_System_14

while 循环

基本语法格式

while(循环条件){
循环语句;
}

循环条件为 true, 则执行循环语句; 否则结束循环.

代码示例1：

//打印 1 - 10 的数字
int num = 1;
while (num <= 10){
    //print不换行，println换行
    System.out.print( num + " ");
    num ++;
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_15

代码示例2：计算 1 - 100 的和

int num = 1;
int sum = 0;
while (num <= 100){
    //            sum = sum + num;
    //            num ++;
    sum += num ++;
}
System.out.println(sum);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_System_16

示例代码3：计算 5 的阶乘

int num2 = 5;
int ret = 1;
while (num2 >0){
    ret = ret * num2;
    num2 = num2 - 1;
}
System.out.println(ret);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_17

示例代码4:计算 1! + 2! + 3! + 4! + 5!

int sum = 0;
int num = 1;

//外循环一次走到5
while (num<=5){
    //内循环计算当前num的阶乘值，需要一个局部变量存储当前内循环计算出来的阶乘值
    int tmp = 1;
    int tmpFactor = 1;
    while (tmp <= num){
        tmpFactor *= tmp;
        tmp ++;
    }
    sum += tmpFactor;
    num ++;
}
System.out.println(sum);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_18

注意事项（if，while，for类似）

1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. while 后面的 { 建议和 while 写在同一行.

3. while 后面不要多写分号, 否则可能导致循环不能正确执行.

//        分号问题
//        出现程序卡死，检查循环
int num = 1;
while ( num<=10);{
    System.out.println(num ++ + " ");
}

运行时：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_19

break

break 的功能是让循环提前结束.

代码示例1: 找到 100 - 200 中第一个 3 的倍数

//        100~200内的第一个3的倍数
int num = 100;
while (num <= 200){
    if(num % 3 == 0){
        System.out.print(num+" ");
        break;//结束当前循环
    }
    num ++;
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_20

用 break outter 跳出两层循环

int num = 1;
outter:
while (num <= 100){
    int tmp = 1;
    while(tmp <= 100){
        if (tmp % 3 == 0){
            System.out.println(tmp + " ");
            break outter;//跳出两层循环
        }
        tmp ++;
    }
    num ++;
}

continue

continue 的功能是跳过这次循环, 立即进入下次循环.

示例代码：找到 100 - 200 中所有 3 的倍数

//        100~200内的所有3的倍数
int tmp = 100;
while (tmp <= 200){
    if(tmp % 3 != 0){
        tmp ++;
        continue;//继续下一次循环，本循环剩余代码不再执行
    }
    System.out.print(tmp+" ");
    tmp ++;
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_21

for 循环

【基本语法】

for(初始化表达式;布尔表达式;表达式3){
表达式4;
}

初始化表达式: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次

布尔表达式: 循环条件，满则循环继续，否则循环结束

表达式3: 循环变量更新方式

表达式4：满足条件执行的语句

代码示例1:打印 1 - 10 的数字

//        打印1~10的数字
//        快捷输出for循环： fori
//        i定义在for里面，i只能在for循环里使用
for(int i = 1;i <= 10;i ++){
    if(i == 10){
        System.out.println(i);
        continue;
    }
    System.out.print(i +" ");
}

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_22

代码示例2：计算 1 - 100 的和

int sum = 0;
for(int num = 1;num <= 100;num ++){
    sum += num;
}
System.out.println(sum);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_System_23

代码示例3：计算 1! + 2! + 3! + 4! + 5!

//        实现1！+2！+3！+4！+5!
int sum2 = 0;
for(int i = 1;i <= 5;i ++){
    int tmpFactor = 1;
    //i用过了，快捷键仍然是fori，会自动更换i
    for(int tmp = 1;tmp <= i;tmp++){
        tmpFactor *= tmp;
    }
    sum2 += tmpFactor;
}
System.out.println(sum2);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_System_24

do while 循环

一般 do while 很少用到, 更推荐使用 for 和 while，因此不做笔记。

输入输出

输出到控制台

基本语法

System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

println 输出的内容自带 \n, print 不带 \n

printf 的格式化输出方式和 C 语言的 printf 是基本一致的。

从键盘输入

使用 Scanner 读取字符串/整数/浮点数

//        1.产生Scanner的对象
Scanner sc = new Scanner(System.in);
//        2.从键盘读取内容
System.out.println("请输入姓名：");
//        nextXXX() -> 要获取的类型
String name = sc.nextLine();//获取一行输入，默认以回车结尾，类型为String
System.out.println("请输入年龄：");
int age = sc.nextInt();
System.out.println("请输入工资：");
double sal = sc.nextDouble();
System.out.println("姓名：" + name +"年龄：" + age + "工资：" + sal);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_布尔表达式_25

换行符问题：

Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄 : ");
int age = sc.nextInt();
System.out.println("请输入姓名 : ");
// 只是为了吃掉换行符
sc.nextLine();
String name = sc.nextLine();
//nextLine默认以回车作为输入的结束，只识别回车
//如果先输入一个整数，回车，然后用nextLine方法获取字符串，这个字符会拿不到
//因此需要吃掉换行符（先调用一次nextLine）
System.out.println("请输入工资 : ");
double sal = sc.nextDouble();
System.out.println("姓名为 : " + name + ",年龄为 : " + age + ",工资为 : " + sal);

示例代码：读取多个整数，然后计算平均值

// 读取多个整数，然后计算平均值
// 1.获取Scanner对象
Scanner sc = new Scanner(System.in);
// 2.使用while循环，搭配hasNextXXX() -> 方法，检测程序输入是否是指定类型的内容
// hasNextInt () -> 下一个输入的为整数
// hasNextLine () -> 下一个输入的是整行数据
// hasNextDouble () -> 下一个输入的为小数
// 若输入内容和判断内容不一致，循环退出
int count = 0;
int sum = 0;
while (sc.hasNextInt()) {
    System.out.println("请输入数字 : ");
    int tmp = sc.nextInt();
    count ++;
    sum += tmp;
}
// 当输入的不是数字时，循环退出
double avg = sum / count * 1.0;
System.out.println(avg);

输出：

javase知识点总结：三种程序逻辑结构，输入输出_代码示例_26

Random类

//        1.产生Random类的对象
Random random = new Random();
//        2.调用random对象的nextInt方法
//        要指定左区间，只需要 + 左区间的数字即可
//        生成[0，100）的随机数
int num = random.nextInt(100);
System.out.println(num);

//        [20,100)
int num2 = random.nextInt(80)+20;
System.out.println(num2);