更新记录

1.0（2024-03-31）

无

平台兼容性

java笔记

P18 运行机制

.java文件——源文件

.class文件——字节码文件

源文件经过编译后可得到字节码文件

P19 开发细节

一个源文件中最多只能有一个public类，其它类的个数不限

编译后，每一个类，都对应一个.class文件

也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法了

P21 转义字符

\t ：一个制表位，实现对齐功能

\n : 换行符

\\ : 一个\

\" : 一个"

\' : 一个'

\r : 一个回车

课堂练习：System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");

P22 易犯错误

1. 找不到文件

解决方法：源文件不存在或写错，或者当前路径错误

2. 主类名和文件名不一致

解决方法：声明为public的主类应与文件名一致，否则编译失败

3. 缺少分号

解决方法：编译失败，注意错误出现的行数，再到源代码中指定位置改正错误

P23 注释介绍

注释类型：

1. 单行介绍

2. 多行注释

3. 文档注释

P24 单行+多行注释

单行注释： //注释内容

多行注释： / 注释内容 /

P25 文档注释

文档注释： /**/ 在两星号中间回车即可

P26 代码规范

选中，然后按 tab 整体右移

选中，然后按 shift + tab 整体左移

源文件使用uft - 8编码

运算符和 = 两边习惯各加一个空格

每一行尽量不超过80个字符

编写代码次行风格和行尾风格

P27 dos原理（了解）

Dos：磁盘操作系统

Dos基本原理：接受，解析，执行

P28 路径详解

相对路径和绝对路径

相对路径：从当前目录开始定位，形成的一个路径

绝对路径：从顶级目录开始定位，形成的路径

P32 作业1

1. JDK , JRE , JVM,三者的关系

JDK = JRE + java开发工具

JRE = JVM + 核心类库

2. 环境变量path配置及其作用

环境变量的作用是为了在dos的任意目录，可以去使用java和javac命令

P33 作业2

• java编写步骤

1. 编写java的源代码

2. javac编译，得到对应的.class字节码文件

3. java运行，本质就是把.class文件加载到jvm运行

• java编写规范
• 初学者易犯错误

P38 变量细节

int 4个字节

double 8个字节

变量必须先声明，后使用，即有顺序

该区域的数据可以在同一类型范围内不断变化

变量在同一作用域内不能重名

变量三要素：变量名、值、变量类型

变量 = 变量名 + 值 + 变量类型

P39 加号

1. 当左右两边都是数值型时，做加法运算

   System.out.println(98 + 3 ); // 101

2. 当左右两边有一方为字符串，做拼接运算

   System.out.println(98 + 3 + "hello"); // 101hello

3. 运行顺序：从左到右

P40 数据类型


说明：

1. java数据类型分为两大类 基本数据类型、引用类型
2. 基本数据类型有8种，数值型【byte,short,int,long,float,double】,char,boolean
3. 引用类型[类，接口，数组]
4. 字符串String是一个类

P41 整型使用


P42 整型细节

1. Java的整型常量默认为int型，声明long型常量须后加 l 或 L

    int n1 = 1L; // 报错
    long n2 = 1L; // 正确

2. Java的整型常量默认为int型，除非不足以表示大数，才使用long

3. bit：计算机中的最小存储单位

   byte(字节)：计算机中的基本存储单位，1 byte = 8 bit

P43 浮点类型

分类：


说明：

1. 关于浮点数在机器中存放形式的简单说明，浮点数 = 符号位 + 指数位 + 尾数位
2. 尾数部分可能丢失，造成精度损失（小数都是近似值）

P44 浮点数细节1

1. Java的浮点型常量（具体值）默认为double型，声明float类型常量，须后加 f 或 F

      float num1 = 1.1; // 错误
      float num2 = 1.1F; // 正确
      double num3 = 1.1; // 正确
      double num4 = 1.1F; // 正确

2. 浮点型常量有两种表现形式


5.12e2 ——> 512.0

5.12E-2 ——> 0.0512

3. 一般情况下用double，因为双精度浮点型精度更高

P45 浮点数细节2


重要使用点：当我们对运算结果是小数的进行相等判断时，要小心

应该是以两个数差值的绝对值，在某个精度范围内判断


细节：如果是直接查询得到的小数或者直接赋值，可以直接判断相等

P46 Java文档

Java API 中文在线文档：https://www.matools.com/

P47 字符类型


char类型是可以进行运算的，相当于一个整数，因为它都有对应的Unicode码

    System.out.println('a' + 10); // 结果：107

课堂测试：

    char c1 = 'b' + 1;
    System.out.println((int)c1); // 结果：99
    System.out.println(c1); // 结果：c

P48 字符类型的本质



P49 常用编码




P51 布尔类型 Boolean

细节说明：java中不能用0或者1的整数代替false和true，这点和C语言不同

P52 自动类型转换

介绍：当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的类型，这就是自动类型转换

数据类型精度（容量）大小排序为（背，规则）


P53 自动类型转换细节1

1. 有多种理性的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算

2. 当我们把精度大的数据类型赋值给精度小的数据类型时，就会报错，反之就会进行自动类型转换

      double n1 = 10; //将低精的整型数值转换为高精的double类型，进行自动类型转换，10.0

3. （byte , short）和char之间不会相互自动转换

      byte b1 = 10; //正确，因为byte的范围是-128~127
      char c1 = b1; //错误，因为byte不能自动转换为char

4. byte，short，char他们三者可以计算，在计算时首先转换为int类型

      byte b2 = 1;
      byte b3 = 1;
      short s1 = 1;
      short s2 = b2 + s1; //错误，b2 + s1后结果是int类型，而int类型的精度高于short类型，故无法自动转换
      int s2 = b2 + s1; //正确
      byte b4 = b2 + b3; //错误，因为经过加法运算后的结果会被转换为int类型

5. boolean类型不参与自动转换

6. 自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型

P55 强制类型转换

介绍：自动类型转换的逆过程，**将容量大的数据类型转换为容量小的数据类型。***使用时要加上强制转换符（），

但可能造成精度降低或溢出，格外要注意

P56 强制类型转换细节

1. 当进行数据的大小从大——小，就需要使用到强制转换
2. 强制转换符号只针对最近的操作数有效，往往会使用小括号提升优先级

    int x = (int)10 * 3.5 + 6 * 1.5; //强转只给到了数字10，编译错误: double -> int
    int y = (int)(10 * 3.5 + 6 * 1.5); //正确
    System.out.println(y); //4

3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转

    char c1 = 100; //正确
    int m = 100; //正确
    char c2 = m; //错误，整型m的精度高于字符型c2，无法自动从高转低
    char c3 = (char)m; //正确

4. byte 和 short 类型在进行运算时，当作int类型处理

P57 基本数据类型转换练习题

1. short s = 12; 
   s = s - 9; 错
2. byte b = 10; 
   b = b + 11; 错
   b = (byte)(b+11); 正确，使用强转
3. char c = 'a';
   int i = 6; 
   float d = .314F;
   double result = c + i + d; 对
4. byte b = 16;
   short s = 14;
   short t = s + b; 错


P58 基本数据类型和String类型的转换

介绍：在程序开发中，我们经常需要将基本数据类型转换成String类型，或者将String类型转换成基本数据类

//基本数据类型转换成String
        int n1 = 100;
        float f1 = 1.1F;
        double d1 = 4.5;
        boolean b1 = true;
        String s1 = n1 + "";
        String s2 = f1 + "";
        String s3 = d1 + "";
        String s4 = b1 + "";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        //String类型转换成基本数据类型
        //解读: 使用基本数据类型对应的包装类的相应方法,得到基本数据类型
        String s5 = "123";
        int num1 = Integer.parseInt(s5);
        double num2 = Double.parseDouble(s5);
        float num3 = Float.parseFloat(s5);
        boolean num4 = Boolean.parseBoolean("true");
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);

        //怎么把字符串转成字符char --> 含义是指把字符串的第一个字符得到
        //解读: s5charAt(0) 得到 s5 字符串的第一个字符 1
        System.out.println(s5.charAt(0));

P59 String转基本数据类型注意事项


P63 算术运算符

介绍：运算符是一种特殊的符号，用以表示数据的运算、赋值和比较


算术运算符：


P64 算术运算符使用

1. 除号的使用细节

    System.out.println(10/4); //从数学来看是2.5，但是java中是2
    System.out.println(10.0/4); //10.0是double类型，运算后的结果仍然是高精度的，所以是2.5
    double d = 10 / 4; //java的结果是2，但是将整型的2赋值给浮点型的d，会将结果转换成2.0
    System.out.println(d);

2. 求模的使用细节

//java中 % 的本质是看一个公式：a % b = a - a / b * b
        System.out.println(10 % 3); //1
        System.out.println(-10 % 3);  // - 10 % 3 --> -10 - (-10) / 3 * 3 = -10 - (-3) * 3 = -10 + 9 = -1
        System.out.println(10 % -3); //1
        System.out.println(-10 % -3); //-1
        System.out.println(-10 - -10 / -3 * -3); //-1

3. 自增自减的使用细节

int i = 10;
i++; //自增，等价于i = i + 1;
System.out.println(i); //i = 11

作为表达式使用：

++i 先自增后赋值

i++先赋值后自增

    int j = 8;
    int k = ++j; //等价 j = j + 1; k = j;
    System.out.println("k = " + k); // k = 9
    System.out.println("j = " + j); // j = 9

    int j2 = 8;
    int k2 = j2++; //等价  k = j; j = j + 1;
    System.out.println("k2 = " + k2); // k2 = 8
    System.out.println("j2 = " + j2); // j2 = 9

P65 算术运算符练习

• 面试题1

    int i = 1;
    i = i++; //规则使用临时变量：(1) temp = i; (2) i = i + 1; (3) i = temp;
    System.out.println("i = " + i);

结果：i = 1

• 面试题2

    int i = 1;
    i = ++i; //规则使用临时变量：(1) i = i + 1; (2) temp = i; (3) i = temp;
    System.out.println("i = " + i);

结果：i = 2

P66 算数运算符练习2

• 自增自减课堂练习

    int i1 = 10;
    int i2 = 20;
    int i = i1++;
    System.out.println("i = " + i); //i = 10
    System.out.println("i2 = " + i2); // i2 = 20
    i = --i2;
    System.out.println("i = " + i); // i = 19
    System.out.println("i2 = " + i2); // i2 = 19

P67 算数运算符练习3

1. 假如还有59天放假，问：合xx星期零xx天

    int a = 59; //还有a天放假
    int b = a / 7; //还有b个星期放假
    int c = a % 7; //余c天
    System.out.println("假如还有59天放假，合" + b + "个星期零" + c + "天");

P68 算数运算符练习4

2. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*（华氏温度-100），请求出华氏温度对应的摄氏温度。[234.5]

double a = 234.5; //华氏温度
double b = 5.0 / 9 * (a - 100); //摄氏温度,若写成5/9在java中取整得到0，则结果为0
System.out.println("当前气温为：" + b);

P69 关系运算符（比较运算符）

介绍：

1. 关系运算符的结果都是boolean型，也就是要么是true，要么是false
2. 关系表达式经常在if结构的条件中或循环结构的条件中


P70 关系运算符案例演示


int a = 9;
int b = 8;
System.out.println(a > b); //true
System.out.println(a >= b); //true
System.out.println(a <= b); //false
System.out.println(a < b); //false
System.out.println(a == b); //false
System.out.println(a != b); //true

P71 逻辑运算符

介绍：用于连接多个条件（多个关系表达式），最终结果也是一个boolean值



P72 短路与 逻辑与 &&

int age = 50;
if(age > 20 && age < 90) {
    System.out.println("ok");
}


        int a = 4;
        int b = 9;
        if(a < 1 && ++b < 50) { // a < 1 为假，短路与不再判断第二个条件，所以b=9，效率更高
            System.out.println("ok");
        }
        System.out.println("a = " + a + ",b = " + b); //a = 4,b = 9

        if(a < 1 & ++b < 50) {
            System.out.println("ok");
        }
        System.out.println("a = " + a + ",b = " + b); //a = 4,b = 10

P73 短路或 逻辑或 ||


P74 取反 ！



        //取反演示
        System.out.println(60 > 20); //true
        System.out.println(!(60 > 20)); //false

        //逻辑异或演示: a ^b 当 a 和 b 不同时为true，否则为false
        boolean b = (10 > 1) ^ (3 < 5);
        System.out.println("b = " + b); //false

P75 逻辑运算符练习题

• 练习1

        int x = 5;
        int y = 5;
        if(x++ == 6 & ++y == 6) { 
            x = 11;
        }
        System.out.println("x = " + x + ", y = " + y); //x = 6, y = 6

• 练习2

        int x = 5, y = 5;
        if(x++ == 6 && ++y == 6) {
            x = 11;
        }
        System.out.println("x = " + x + ", y = " + y); //x = 6, y = 5

• 练习3

        int x = 5, y = 5;
        if(x++ == 5 | ++y == 5) {
            x = 11;
        }
        System.out.println("x = " + x + ", y = " + y); //x = 11, y = 6

• 练习4

int x = 5, y = 5;
        if(x++ == 5 || ++y == 5) {
            x = 11;
        }
        System.out.println("x = " + x + ", y = " + y); //x = 11, y = 5

• 练习5

        boolean x = true;
        boolean y = false;
        short z = 46;
        if((z++ == 46) && (y = true)) { // z = 47
            z++; //z = 48
        }
        if((x = false) || (++z == 49)) { // z = 49
            z++; // z = 50
        }
        System.out.println("z = " + z);

P76 赋值运算符

介绍：赋值运算符就是将某个运算后的值，赋给指定的值


P77 赋值运算符案例演示

        int n = 10;
        n += 4; //n = n + 4;
        System.out.println(n); // n = 14

！复合赋值运算符会进行类型转换！

        byte b = 3;
        b = b + 2; //报错，因为b + 2的结果是整型，而整型的精度是大于byte型的，无法进行自动类型转换
        b += 2; //等价 b = (byte)(b + 2);
        System.out.println(b);

P78 三元运算符


• 案例演示

        int a = 10;
        int b = 99;
        int result = a > b ? a++: b--;
        System.out.println("a = " + a + ", b = " + b); //a = 10, b = 98 

P79 三元运算符使用细节


• 细节1案例：

        int a = 3;
        int b = 8;
        int c = a > b ? 1.1 : 3.4; //报错，因为1.1和3.4是浮点型，精度大于整型，无法赋值给c
        int c = a > b ? (int)1.1 : (int)3.4; //正确
        double d = a > b ? 1.1 : 3.4; //正确

P80 三元运算符课堂练习

案例：实现三个数的最大值

        int a = 13;
        int b = 9;
        int c = 199;
        int cen = a > b ? a : b; //先得到a和b中的最大数，保存到cen中
        int max = cen > c ? cen : c; //再将cen与c相比较，将结果保存到max中
        System.out.println("最大的数字是：" + max);

//      int max2 = (a > b ? a : b) > c ? (a > b ? a : b) : c; //嵌套至一条语句,效果与上方一致
//      System.out.println("最大的数字是：" + max2);

P81 运算符优先级（多用即可）

1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行
2. 只有单目运算符、赋值运算符从右向左运算的


P82 标识符规则


P83 标识符练习

        int hsp; 
        int hsp12;
        int 1hsp; //不能数字开头
        int h-s; //不能带-
        int x h; //不能带空格
        int h$4;
        int class; //不能使用关键字
        int int; //不能使用关键字
        int double; //不能使用关键字
        int public; //不能使用关键字
        int static; //不能使用关键字
        int goto; //不能使用保留字
        int stu_name; 

P84 标识符规范


P85 关键字 保留字

• 关键字：



• 保留字：


P86 键盘输入语句

介绍：在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取

import java.util.Scanner;       

        Scanner sc = new Scanner(System.in);
        String name = sc.next(); //当程序执行到next方法时，会暂停程序，等待用户输入~~~
        System.out.println(name);

P87 四种进制介绍


int n1 = 0b1010; //二进制
int n2 = 1010; //十进制
int n3 = 01010; //8进制
int n4 = 0x10101; //16进制
System.out.println("n1 = " + n1); //10
System.out.println("n2 = " + n2); //1010
System.out.println("n3 = " + n3); //520
System.out.println("n4 = " + n4); //65793

进制图示：




P88 2进制转10进制

规则：从最低位（右位）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和

案例：将0b1011转成十进制的数


P89 8进制转10进制

规则：从最低位开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和

案例：将0234转成十进制的数

0234 = 4 1 + 3 8 + 2 * 64 = 156

P90 16进制转10进制

规则：从最低位开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和

案例：将0x23A转成十进制的数

0x23A = 10 1 + 3 16 + 2 16 16 = 571

P91 10进制转2进制

规则：将该数不断除以2，直到商为0，然后将每步得到的余数倒过来（从下往上），就是对应的二进制

案例：将34转换成二进制 = 0B00100010


P92 10进制转8进制

规则：将该数不断除以8，直到商为0，然后将每步得到的余数倒过来，就是对应的八进制

案例：将131转换成8进制 = 0203


P93 10进制转16进制

规则：将该数不断除以16，直到商为0，然后将每步得到的余数倒过来，就是对应的十六进制

案例：将237转成16进制 = 0xED


练习：

123 转成二进制 ——》 0B01111011

678 转成八进制 ——》 1246

8912 转成十六进制 ——》 0x0D220

P94 2进制转8进制

规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可

案例：将ob11010101转成八进制 ——》0325

P95 2进制转16进制

规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可

案例：将ob11010101转成16进制 ——》 0xD5

练习：

0b11100101转成8进制 ——》 0345

0b1110010110转成16进制 ——》 0x396

P96 8进制转换成2进制

规则：将八进制每1位，转成对应的一个3位的二进制数即可

案例：将0237转成二进制 ——》 0b10011111

P97 16进制转换成2进制

规则：将十六进制每1位，转换成对应的一个4位的二进制数即可

案例：将0x23B转成二进制 ——》 0b001000111011

练习：

01230转成二进制 ——》 0b001010011000

0xAB29 ——》 0b1010101100101001

P99 原码 反码 补码


P100 位运算符详解1


案例：2&3

案例： ~-2

案例： ~2


P101 位运算符详解2


应用案例：


P102 本章练习

// -10.5 % 3 = ？
double a = -10.5; // - 10.5 - (- 10.5) / 3 * 3 = 
System.out.println(a % 3); //-1.5


int i = 66;
System.out.println(++i+i); //134



String name = "1";
Double d = Double.parseDouble(name);
String name2 = d + "";
System.out.println(name.charAt(0));

P103 顺序控制

介绍：程序从上到下逐行执行，中间没有任何判断和跳转


P104 单分支使用


P105 单分支使用

        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        if(age > 18) {
            System.out.println("你年龄大于18，要对自己的行为负责，送入监狱");
        }

P106 单分支流程图


P107 双分支使用


Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
if(age > 18) {
    System.out.println("你年龄大于18，要对自己的行为负责，送入监狱");
}else {
    System.out.println("你年龄不大，这次就放过你了");
}

P108 双分支流程图


P109 双分支练习

• 判断两数和

Scanner sc = new Scanner(System.in);
Double d1 = sc.nextDouble();
Double d2 = sc.nextDouble();
if(d1 > 10.0 && d2 < 20.0) {
    System.out.println(d1 + d2);
}

• 判断一个年份是否是闰年

        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                System.out.println(year + "是闰年");
        }else {
            System.out.println(year + "不是闰年");
        }

P110 多重分支使用


特别说明：

1. 多重分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
2. 如果有else，如果所有的条件表达式都不成立，则默认执行else代码块

P111 多重分支练习1


        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        if(a == 100) {
            System.out.println("信用极好");
        }else if(a <= 99 && a > 88) {
            System.out.println("信用优秀");
        }else if(a <= 80 && a > 60) {
            System.out.println("信用一般");
        }else if(a > 100 || a < 0) {
            System.out.println("输入错误");
        }
        else {
            System.out.println("信用不合格");
        }


解：

1. 结果：b
2. 结果：d

P113 嵌套分支


Scanner sc = new Scanner(System.in);
        double score = sc.nextDouble();
        char gender = sc.next().charAt(0); //先接受一个字符串，再接受这个字符串中的第一个字符
        if(score > 8.0) {
            if(gender == '男') {
                System.out.println("恭喜进入男子组决赛");
            }else {
                System.out.println("恭喜进入女子组决赛");
            }
        }else {
            System.out.println("淘汰");
        }

P114 嵌套分支练习


        Scanner sc = new Scanner(System.in);
        int mouth = sc.nextInt();
        int age = sc.nextInt();
        if(mouth >= 4 && mouth <= 10) {
            if(age >= 18 && age <= 60) {
                System.out.println("票价为：60");
            }else if(age < 18) {
                System.out.println("票价为：半价");
            }else if(age > 60) {
                System.out.println("票价为：20");
            }
        }else {
            if(age >= 18 && age <= 60) {
                System.out.println("票价为：40");
            }else {
                System.out.println("票价为：20");
            }
        }

P115 switch基本结构


P116 switch基本语法


P117 switch快速入门


        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个字符(a-g)");
        char zi = sc.next().charAt(0);//将接受到的字符串转换成字符
        switch(zi) {
        case 'a':System.out.println("星期一");
        break;
        case 'b':System.out.println("星期二");
        break;
        case 'c':System.out.println("星期三");
        break;
        case 'd':System.out.println("星期四");
        break;
        case 'e':System.out.println("星期五");
        break;
        case 'f':System.out.println("星期六");
        break;
        case 'g':System.out.println("星期天");
        break;
        default: System.out.println("你输入的字符不匹配，请重新输入");
        }

P118 switch细节

• 细节1

  表达式数据类型，应该与case后的常量类型一致，或者是可以自动转换成可以相互比较的类型

  比如输入的是字符，而常量是int

• 细节2

  switch（表达式）中的表达式的返回值必须是：（byte,short,int,char,enum,String）

• 细节3

  case子句中的值必须是常量（1，’a‘）或者是常量表达式，而不能是变量

• 细节4

  default子句是可选的，当没有匹配的case时，执行default

  如果没有default子句，又没有匹配任何常量，则没有输出

• 细节5

  break语句用来执行完一个case分支后使程序跳出switch语句块

  如果没有写break，程序会顺序执行到switch结尾

P119 switch课堂练习1

• 练习1

//        将键盘输入得到的小写字母转换成大写字母（只转换a，b，c，d，e）
//        其它的输出out
        Scanner sc = new Scanner(System.in);
        char zi = sc.next().charAt(0);
        switch (zi){
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("other");
        }

• 练习2

根据输入的成绩打印合格和不合格

        Scanner sc = new Scanner(System.in);
        double score = sc.nextDouble();
        //保证输入成绩有效
        if (score >= 0 && score <= 100){
            switch ((int)(score / 60)) {
                case 0:
                    System.out.println("不合格");
                    break;
                case 1:
                    System.out.println("合格");
                    break;
                default:
            }
        }else {
            System.out.println("输入成绩应在1-100之间");
        }

• 练习3

打印月份的同时使用穿透

        Scanner sc = new Scanner(System.in);
        int mouth = sc.nextInt();
        switch (mouth) {
            case 3: 
            case 4: 
            case 5:
                System.out.println("春季");
                break;
            case 6: 
            case 7: 
            case 8:
                System.out.println("夏季");
                break;
            case 9: 
            case 10: 
            case 11:
                System.out.println("秋季");
                break;
            case 12: 
            case 1: 
            case 2:
                System.out.println("冬季");
                break;
        }

P121 switch 和 if 的比较

1. 如果判断的具体数值不多，而且符合byte,short,int,char,enum,String这6种类型。

   虽然两个语句都可以使用，但建议使用switch语句。

2. 其它情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

P122 for基本语法


P123 for语句循环结构


P124 for细节


P125 for编程思想1

• 打印1 ~ 100之间所有是9的倍数的整数，统计个数及综合【化繁为简，先死后活】

1. 化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成
2. 先死后活：先考虑固定的值，然后转成可以灵活变化的值

        int he = 0; //求和
        int count = 0; //统计个数
        for (int i = 1; i < 100; i++) {
            if (i % 9 == 0) { //先打印1-100再用if语句加以过滤
                System.out.println("i = " + i);
                count++; //个数累加
                he = he + i; //求和累加
            }
        }
        System.out.println("count = " + count);
        System.out.println("he = " + he);

P126 for编程思想2

• 完成下面的表达式输出

  

P127 while基本语法


P128 while执行流程


        int i = 0; //初始化循环变量
        while (i <= 10) { //循环条件
            System.out.println("hello，world" + i); //执行语句
            i++; //循环变量迭代
        }

P129 while课堂练习


• 练习1

  打印1-100内所有能被3整除的数

        int i = 1;
            while (i <= 100) {
                if(i % 3 == 0) {
                System.out.println(i);
            }
            i++;
        }

• 练习2

  打印40-200内所有的偶数

        int j = 40;
        while (j <= 200) {
            if (j % 2 == 0) {
                System.out.println(j);
            }
            j++;
        }

P130 do while语法


P131 do while流程图


        int i = 0;
        do {
            System.out.println("hello，world！" + i);
            i++;
        }while (i <= 10);

P132 do while练习

• 练习1

打印1-100

        int i = 1;
        int end = 100;
        do {
            System.out.println(i);
            i++;
        }while (i <= 100);

• 练习2

打印1-100的和

int i = 1;
int end = 100;
int sum = 0;
do {
    sum = sum + i; //求和公式
    i++;
}while (i <= 100);
System.out.println(sum);

• 练习3

统计1-200之间能被5整除但不能被3整除的数的个数

        int i = 1;
        int end = 200;
        int count = 0;
        do {
            if (i % 5 == 0 && i % 3 != 0) {
                count++;
            }
            i++;
        }while (i <= end);
        System.out.println(count);

• 练习4

        char c = ' ';
        Scanner sc = new Scanner(System.in);
        do {
            System.out.println("老韩使出了闪电五连鞭");
            System.out.println("老韩问：”还钱吗？ （y/n）“");
            System.out.println("李三的回答是");
            c = sc.next().charAt(0);
        }while (c != 'y');
        System.out.println("李三说还钱了");