关键字和保留字

关键字（keyword）

• 定义：被Java语言赋予了特殊的含义，用作专门用途的字符串（单词）
• 特点：关键字中所有的字母都小写

保留字（reserved word）

• Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
• goto、const

标识符

Indentifier

标识符：

• Java对各种变量、方法和类等要素明明时使用的字符序列成为标识符
• 技巧：凡是自己可以其名字的地方都叫标识符

定义合法标识符规则：

• 由26个英文字母大小写。0-9 _ 或 $ 组成
• 数字不可以开头
• 不可以使用关键字和保留字，但能包含关键字和保留字
• Java中严格区分大小写，长度无限制
• 标识符不能包含空格

Java中的名称命名规范：

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，多有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写xxxYyyZzz
• 常量名：所有字母都大写，多单词时每个单词用下划线链接：XXX_YYY_ZZZ

在起名字时，为了提高阅读性，要尽量有意义，“见名知意”

Java采用unicode字符集，因此标识符也可以是汉字声明，但不建议使用

变量

变量的概念：

• 内存中的一个存储区域
• 该区域的数据可以在同一类型范围内不断变化
• 变量时程序中最基本的存储单元。包含变量类型、变量名和存储的值

变量的作用：

• 用于在内存中保存数据

使用变量注意：

• Java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：其定义所在的一对 { } 内
• 变量只有在其作用域内才有效
• 同一作用域内不能定义重名变量

数据类型

1. 基本数据类型

   1. 数值型

      1. 整数类型：byte、short、int、long
      2. 浮点类型：float、double
   2. 字符型：char
   3. 布尔型：boolean

2. 引用数据类型

   1. 类：class
   2. 接口：interface
   3. 数组：[]

整数类型

byte、short、int、long

• Java各整数类型有固定的表数范围和字段长度，不受具体OS影响，以保证Java程序的可移植性
• Java的整形常量莫问为 int 型，声明long型常量须后加 l或L
• Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

浮点类型

float、double

• 与整数类型相似，Java浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响

• 浮点型常量有两种表示形式：

  • 十进制数形式：5.12、512.0f、.512（必须有小数点）
  • 科学计数法形式：5.12e2、512E2、100E-2

• float：单精度尾数可精确到7位有效数字。很多情况下，精度很难满足需求

  double：双精度，精度时float的两倍。通常擦用此类型

• Java的浮点型常量默认为double型，声明float型常量，须后加f或F

字符类型

char

• char型数据用来表示通常意义上的 ” 字符 “（2字节）
• Java中的所有汉字都是用Unicode编码，故一个字符可以存储一个字母、一个汉字或其他书面语的一个字符

• 字符型变量的三种表现形式：

  • 字符常量时用单引号（ ’ ‘ ）括起来的单个字符
  • Java中还允许使用转义字符\来将其后的字符转百年未特殊字符型常量
  • 直接使用Unicode值来表示字符型常量：’\uXXXX‘。其中XXXX代表以恶十六进制整数
• char类型是可以进行运算的。以你为它都对应有Unicode码

/*
Java定义的数据类型

一、按照数据类型来分：

    基本数据类型：
        整形：byte、short、int、long
        浮点型：float、double
        字符型：char
        布尔型：boolean

    引用数据类型：
        类：class
        接口：interface
        数组：[]

二、变量在类中声明的位置：
    成员变量  vs  局部变量
*/
class VariableTest1 {
    public static void main(String[] args) {
        // 1.整形:byte(1字节=8bit)、short(2字节)、int(4字节)、long(8字节)
        // ① byte范围：-128-127
        byte b1 = 12;
        byte b2 = -128;
        // b2 = 128; // 编译不通过
        System.out.println(b1);
        System.out.println(b2);
        // ② 声明long型变量，必须以“l“或”L“结尾
        // ③ 通常，定义整形变量时，使用int型
        short s1 = 128;
        int i1 = 1234;
        long l1 = 2748013751235718299L;
        System.out.println(l1);

        // 2.浮点型：float（4字节）、double（8字节）
        // ① 浮点型，表示带小数点的数值
        // ② float表示数值的范围比long大

        double d1 = 123.3;
        System.out.println(d1);
        // ③ 定义float类型变量时，变量要以"f"或“F”结尾
        float f1 = 12.3F;
        System.out.println(f1);
        // ④ 通常，定义浮点类型变量时，使用double型

        // 3.字符型：char（1字符=2字节）
        // ① 定义char型变量，通常使用一对‘’
        char c1 = 'a';
        // c1 = 'AB';
        System.out.println(c1);

        char c2 = '1';
        char c3 = '中';
        char c4 = 'ん';
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);

        // ② 表示方式：1.声明一个字符  2.转义字符  3.直接使用Unicode值来表示字符型常量
        char c5 = '\n';
        c5 = '\t';
        System.out.print("hello" + c5);
        System.out.println("world");

        char c6 = '\u0043';
        System.out.println(c6);

        // 4.布尔型：boolean
        // ① 只能去两个值之一：true、false
        // ② 常常在条件判断、循环结构中使用
        boolean bb1 = true;
        System.out.println(bb1);

        boolean isMarried = true;
        if (isMarried){
            System.out.println("真羡慕");
        }else{
            System.out.println("单身狗");
        }
    }
}

ASCII码

• 在计算机内部，所有数据都是用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此8个二进制位就可以组合出256种状态，这被称为一个字节（byte）。一个字节一共可以用来表示256中不同的状态，每一个状态对应一个符号，就是256个符号，从00000000到11111111.
• ASCII码：上世纪60年代，美国制定了一套字符编码，对英语字符和二进制位之间的关系做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0

• 缺点：

  • 不能表示所有字符
  • 相同的编码显示的字符不一样。比如：130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

Unicode

• 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
• Unicode：一种编码，将世界上所有的符号都纳入其中。每一一个符号都给予一个独一无二的编码，使用Unicode没有乱码的问题。
• Unicode的缺点： Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别Unicode和ASCII。计算机无法区分三个字节表示一个符号.还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定， 每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

UTF-8

• UTF-8是在互联网上使用最广的一种Unicode的实现方式。
• UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。

• UTF-8的编码规则：

  • 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）
  • 对于多字节的UTF-8编码，如果编码包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0，该字节的剩余各位用来对字符进行编码。在第一-个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

自动类型转换

• 自动类型提升
• 结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型byte、char、short --> int --> long --> float --> double
• 特别的：当byte、char、short三种类型的变量做运算时，结果为int型

/*
基本数据类型之间的运算规则:
前提：这里讨论只是7种基本数据类型变量间的运算，不包含boolean类型的
1. 自动类型提升
    结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
    byte、char、short --> int --> long --> float --> double
    特别的：当byte、char、short三种类型的变量做运算时，结果为int型
2. 强制类型转换
说明：此时的容量大小指的是，表示数的范围和大小。比如:float容量要大于long的容量
*/
class VariableTest2 {
    public static void main(String[] args) {
        byte b1 = 2;
        int i1 = 12;
        // 编译不通过
        // byte b2 = b1 + i1;
        int i2 = b1 + i1;
        long l1 = b1 + i1;
        System.out.println(i2);

        float f = b1 + i1;
        System.out.println(f);

        short s1 = 123;
        double d1 = s1;
        System.out.println(d1);//123.0

        // ****************************
        char c1 = 'a';
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);

        short s2 = 100;
        // char c2 = c1 + s2;//编译不通过

        byte b2 = 10;
        // char c3 = c1 + s2;//编译不通过

        // short s3 = b2 + s2;//编译不通过

        // short s4 = b1 + b2;//编译不通过
    }
}

强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：( ) ，但可能造成精度降低或溢出，格外要注意
• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型
• 如String a = "43" ，int i = integer.parselnt(a)
• boolean类型不可以转换为其他的数据类型

/*
强制类型转换：自动类型提升运算的逆运算
1.需要使用强转符：（）
2.注意点：强制类型转换，可能会导致精度损失
*/
class VariableTest3 {
    public static void main(String[] args) {

        double d1 = 12.9;

        int i1 = (int)d1;// 截断操作
        System.out.println(i1);

        // 没有精度损失
        long l1 = 123;
        short s2 = (short)l1;
        System.out.println(s2);

        // 精度损失举例2
        int i2 = 128;
        byte b = (byte)i2;
        System.out.println(b);//-128

    }
}

字符串类型

String

• String不是基本的数据类型，属于引用数据类型
• 声明String类型变量时，使用一对“”
• 使用方式与基本数据类型一致。例如：String str=”abcd“;
• 一个字符串可以串接另一个字符串，也可以直接串接其它类型的数据。例如

str = str + "xyz";
int n = 100;
str = =str + 100;

/*
String 类型变量的使用
1. String 属于引用数据类型，翻译为：字符串
2. 声明String类型变量时，使用一对“”
3. String可以和8中基本数据类型做运算，且运算只能是连接运算：+
4. 运算结果仍然是String类型
*/
class StringTest {
    public static void main(String[] args) {
        String s1 = "Hello World!";

        System.out.println(s1);

        String s2 = "a";
        String s3 = "";

        // char c = " "; // 编译不通过

        //===============================
        int number = 1001;
        String numberStr = "学号:";
        String info = numberStr + number; // +：连接运算
        boolean b1 = true;
        String info1 = info + b1;  // +：连接运算
        System.out.println(info1);

        //===============================
        // 练习1

        char c = 'a'; // 97
        int num = 10;
        String str = "hello";
        System.out.println(c + num + str); // 107hello
        System.out.println(c + str + num); // ahello10
        System.out.println(c + (num + str)); // a10hello
        System.out.println((c + num) + str); // 107hello
        System.out.println(str + num + c); // hello10a

        // 练习2
        //*    *
        System.out.println("*    *");
        System.out.println('*' + '\t' + '*');
        System.out.println('*' + "\t" + '*');
        System.out.println('*' + '\t' + "*");
        System.out.println('*' + ('\t' + "*"));

        //===============================

        // String str1 = 123;  // 编译不通过
        String str1 = 123 + "";
        System.out.println(str1); // "123"

        // int num1 = str1;
        // int num1 = (int)str1;

        int num1 = Integer.parseInt(str1);
        System.out.println(num1); // 123
    }
}

进制

• 对于是所有数字在计算机底层都以二进制形式存在

• 对于整数，有四种表示方式：

  • 二进制：0 , 1 满2进1，以 0b 或 0B 开头
  • 十进制：0-9，满 10 进 1
  • 八进制：0-7，满 8 进 1，以 0 开头
  • 十六进制：0-9 及 A-F，满 16 进 1，以 0x 或 0X 开头，此处 A - F 不区分大小写

/*
计算机中不同进制的使用说明
对于整数，有四种表示方式：
- 二进制(binary)：0,1 满2进1，以 0b 或 0B 开头
- 十进制(decimal)：0-9，满 10 进 1
- 八进制(octal)：0-7，满 8 进 1，以0开头
- 十六进制(hex)：0-9 及 A-F，满 16 进 1，以 0x 或 0X 开头，此处 A-F 不区分大小写
*/
class BinaryTest {
    public static void main(String[] args) {

        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0127;
        int num4 = 0x110A;

        System.out.println("num1=" + num1);
        System.out.println("num2=" + num2);
        System.out.println("num3=" + num3);
        System.out.println("num4=" + num4);
    }
}

二进制

• Java整数常量默认是 int 类型，当用二进制定义整数时，其第32位时符号位；当是 long 类型时，二进制默认占64位，第64位是符号位

• 二进制的整数有如下三种形式：

  • 原码：直接将一个整数值换成二进制数。最高位是符号位
  • 负数反码：是对原码按位取反，市值最高位（符号位）确定为1
  • 负数补码：其反码加1

• 计算机以二进制补码的形式保存所有的整数

  • 正数的原码、反码、补码都相同
  • 负数的补码是其反码 +1

运算符

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

• 算数运算符
• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 位运算符
• 三元运算符

算数运算符

/*
运算符之一：算数运算符：
+ - + - * / (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {
    public static void main(String[] args) {

        // 除号：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1); // 2
        int result2 = num1 / num2 * num2;
        System.out.println(result2); // 10
        double result3 = num1 / num2;
        System.out.println(result3); // 2.0
        double result4 = num1 / num2 + 0.0; // 2.0
        double result5 = num1 / (num2 + 0.0);
        System.out.println(result5);
        double result6 = (double) num1 / num2; // 2.4
        double result7 = (double) (num1 / num2); // 2.0
        System.out.println(result5);
        System.out.println(result6);

        // %:取模运算
        // 结果的符号与被模数的符号相同
        // 开发中，经常使用%来判断能否被除尽
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);

        // (前)++：先自增 1，再运算
        // (后)++：先运算，再自增 1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + "\tb1 = " + b1);

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + "\tb2 = " + b2);

        int a3 = 10;
        ++a3;//a3++;
        int b3 = a3;

        // 注意点
        short s1 = 10;
        // s1 = s1 + 1;
        // s1 = (short) (s1 + 1); // 正确
        s1++; // 自增 1 不会改变本身变量的数据类型
        System.out.println(s1);

        // 问题
        byte b = 127;
        b++;
        System.out.println("b = " + b);

        // (前)--：先自减 1，然后再运算
        // (后)--：先运算，再自减 1

        int a4 = 10;
        int b4 = a4--;// int b4 = --a4;
        System.out.println("a4 = " + a4 + "\tb4 = " + b4);
    }
}

赋值运算符

• 符号：=

  • 当 ”=“ 两侧数据不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
  • 支持连续赋值
• 扩展赋值运算符：+=，-=，*=，/+，%=

/*
运算符之二：赋值运算符
= += -= *= /= %=
*/
class SetValueTest {
    public static void main(String[] args) {
        // 赋值符号：=
        int i1 = 10;
        int j1 = 10;

        int i2,j2;
        i2 = j2 = 10;
        int i3 = 10,j3 = 20;

        // ======================
        int num1 = 10;
        num1 += 2; // num1 = num1 + 2
        System.out.println(num1); // 12

        int num2 = 12;
        num2 %= 5; // num2 = num2 % 5
        System.out.println(num2);

        short s1 = 10;
        // s1 = s1 + 2; // 编译失败
        s1 += 2; // 不会改变变量本身的数据类型
        System.out.println(s1);
    }
}

比较运算符

• 比较运算符的结果都是 boolean 型，也就是要么是 true ，要么是 false
• 比较运算符 == 不能误写成 =

/*
运算符之三：比较运算符
== != > < >= <= instanceof

// 结论：
1. 比较运算符的结果是 Boolean 类型
2. 区分 == 和 =
*/
class CompareTest {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        System.out.println(i == j); // false
        System.out.println(i = j); // 20

        boolean b1 = true;
        boolean b2 = false;

        System.out.println(b2 == b1); // false
        System.out.println(b2 = b1); // true
    }
}

逻辑运算符

& ：逻辑与 && ：短路与

| ：逻辑或 || ：短路或

! ：逻辑非 ^ ：逻辑异或

/*
运算符之四：逻辑运算符
& && | || ! ^
说明：
逻辑运算符操作的都是 boolean 类型的变量
*/
class LogicTest {
    public static void main(String[] args) {
        // 区分 & 与 &&
        // 相同点：& 与 && 的运算结果相同
        // 相同点：当符号左边是 true 时，两者都会执行符号右边的运算
        // 不同点：当符号左边是 false 时，& 会继续执行符号右边的运算；&& 不在执行符号右边的运算
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)){
            System.out.println("BeiJing");
        }else {
            System.out.println("NanJing");
        }
        System.out.println(num1);

        boolean b2 = true;
        b1 = false;
        int num2 = 10;
        if (b1 && (num2++ > 0)){
            System.out.println("BeiJing");
        }else {
            System.out.println("NanJing");
        }
        System.out.println(num2);

        // | 与 ||
        // 相同点：| 与 || 的运算结果相同
        // 相同点：当符号左边是 false 时，两者都会执行符号右边的运算
        // 不同点：当符号左边是 true 时，| 会继续执行符号右边的运算；|| 不在执行符号右边的运算
        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if (b3 | (num3++ > 0)){
            System.out.println("BeiJing");
        }else {
            System.out.println("NanJing");
        }
        System.out.println(num3);

        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if (b4 || (num4++ > 0)){
            System.out.println("BeiJing");
        }else {
            System.out.println("NanJing");
        }
        System.out.println(num4);
    }
}

位运算符

注意：无 <<<

• 位运算是直接对整数的二进制进行的运算

/*
运算符之五：位运算符（了解）

结论：
1. 位运算符的操作都是整形的数据
2. << 在一定范围内，每向左移 1 位，相当于 * 2
   >> 在一定范围内，每向左移 1 位，相当于 / 2

面试题：最高效方式计算 2 * 8 ?  2 << 3  8 << 1
*/
class BitTest {
    public static void main(String[] args) {
        int i = 21;
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 27));

        int m = 12;
        int n = 5;
        System.out.println("m & n : " + (m & n));
        System.out.println("m | n : " + (m | n));
        System.out.println("m ^ n : " + (m ^ n));

        // 练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;

        // 方式一：定义临时变量
        // int temp;
        // temp = num1;
        // num1 = num2;
        // num2 = temp;

        // 方式二：
        // 好处：不用定义临时变量
        // 弊端：
        // ① 相加操作可能超出存储范围
        // ② 有局限性：只能适用于数值类型
        // num1 = num1 + num2; // 30
        // num2 = num1 - num2; // 30 - 20 = 10
        // num1 = num1 - num2; // 30 - 10 = 20

        // 方式三：使用位运算符
        // 有局限性：只能适用于数值类型
        // k = n ^ m
        // k ^ n = m
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;

        System.out.println(num1);
        System.out.println(num2);
    }
}

三元运算符

• 格式：

  • ( 条件表达式 ) ? 表达式1 : 表达式2;
  • 条件为 true，运算后的结果是表达式 1
  • 条件为 false，运算后的结果是表达式 2
• 表达式 1 和 表达式 2 为同种类型

• 三元运算符与if - else 的区别：

  1. 三元运算符可以简化 if - else 语句
  2. 三元运算符要求必须返回一个结果
  3. if 后的代码块可有多个语句

/*
运算符之六：三元运算符
1. 结构：( 条件表达式 ) ? 表达式1 : 表达式2;
2. 说明：
① 条件表达式的接口为 boolean 类型
② 根据条件表达式的真或假，决定执行 表达式 1 还是 表达式 2
   如果条件表达式为 true，执行 表达式 1
   如果条件表达式为 false，执行 表达式 2
③ 表达式 1 和 表达式 2 要求是一致的
③ 三元运算符可以嵌套使用
3. 凡是可以使用三元运算符的地方，都可以改写为 if - else
反之，不成立
4. 如果程序既可以使用三元运算符，又可以使用 if - else 结构，那么优先选择三元运算符。原因：简洁、执行效率高
*/
class SanYuanTest {
    public static void main(String[] args) {
        // 获取两个整数的较大值
        int m = 12;
        int n = 5;

        int max = (m > n) ? m : n;
        System.out.println(max);

        double num = (m > n) ? m : n;

        // (m > n) ? m : "n大"; // 编译不通过
        n = 12;
        String maxStr = (m > n) ? "m 大" : ((m == n) ? "m 和 n 相等" : "n 大");
        System.out.println(maxStr);

        // 获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;

        int max1 = (n1 > n2) ? n1 : n2;
        int max2 = (max1 > n3) ? max1 : n3;
        System.out.println(max2);
    }
}

运算符的优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序，如下图，上一行运算符总优于下一行

• 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

练习

随意给出一个整数，打印显示它的个位数，十位数，百位数的值
格式如下：
数字XXX的情况如下：
个位数：
十位数：
百位数：

class AriExer {
    public static void main(String[] args) {
        int num = 479;
        int bai = num / 100;
        int shi = num % 100 / 10;
        int ge = num % 10;
        System.out.println("数字 " + num + " 的情况如下：");
        System.out.println("百位数:" + bai);
        System.out.println("十位数:" + shi);
        System.out.println("个位数:" + ge);
    }
}

程序流程控制

• 顺序结构

  • 程序从上到下逐行地执行，中间没有任何的判断和跳转

• 分支结构

  • 根据条件，选择性的执行某段代码
  • 有 if - else 和 switch - case 两种分支语句

• 循环结构

  • 根据循环条件，重复性的执行某段代码
  • 有 while、do……while 、for 三种循环语句
  • 注意：JDK1.5提供了 foreach 循环，方便的遍历集合、数组元素

if - else 结构

/*
分支结构中的 if -

1. 三种结构
第一种：
if (条件表达式){
    执行代码块;
}

第二种：二选一
if (条件表达式){
    执行代码块;
}else {
    执行代码块;
}

第三种：三选一
if (条件表达式1){
    执行代码块;
}else if (条件表达式2){
    执行代码块2;
}……
else {
    执行代码块n;
}
*/
class IfTest {
    public static void main(String[] args) {

        // 举例 1
        int heartBrats = 79;
        if (heartBrats < 60 || heartBrats > 100){
            System.out.println("需要做进一步检查");
        }
        System.out.println("检查结束");

        // 举例 2
        int age = 23;
        if (age < 18){
            System.out.println("你可以回家写作业");
        }else {
            System.out.println("你可以去网吧写程序了");
        }

        // 举例 3
        if (age < 0){
            System.out.println("您输入的数据不合法");
        }else if (age < 18){
            System.out.println("青少年时期");
        }else if (age < 35){
            System.out.println("青壮年时期");
        }else if (age < 60){
            System.out.println("中年时期");
        }else if (age < 120){
            System.out.println("老年时期");
        }else {
            System.out.println("你要成仙啊~");
        }
    }
}

从控制台获取不同类型的变量

/*
如何从控制台获取不同类型的变量：需要使用 Scanner 类

具体实现步骤：
1. 导包：import java.util.Scanner
2. Scanner 的实例化
3. 调用 Scanner 类的相关方法 ( next() / nextXxx() )，用来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMismatchException
导致程序终止
*/
// 1. 导包：import java.util.Scanner
import java.util.Scanner;
class ScannerTest {
    public static void main(String[] args) {
        // 2. Scanner 的实例化
        Scanner scan = new Scanner(System.in);
        // 3. 调用 Scanner 类的相关方法
        System.out.print("请输入你的姓名：");
        String name = scan.next();
        System.out.println(name);

        System.out.print("请输入你的年龄：");
        int age = scan.nextInt();
        System.out.println(age);

        System.out.print("请输入你的体重：");
        double weight = scan.nextDouble();
        System.out.println(weight);

        System.out.print("TURE/FALSE");
        boolean isTrue = scan.nextBoolean();
        System.out.println(isTrue);

        // 对于 char 类型的数据，Scanner 没有提供相应的方法。只能获取一个字符串。
        System.out.print("sex:");
        String gender = scan.next();
        char genderChar = gender.charAt(0);
        System.out.println(genderChar);
    }
}

练习

岳小鹏参加 Java考试，他和父亲岳不群达成承诺:
如果:
成绩为 100 分时，奖励一辆 BMW;
成绩为 (80，99] 时，奖励一台 iPhone Xs Max;
当成绩为 [60, 80]时，奖励一个 iPad;
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

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

        System.out.print("请输入岳小鹏的期末成绩：(0-100)");
        int score = scan.nextInt();

        if (score == 100){
            System.out.println("BMW");
        }else if(score > 80){
            System.out.println("iPhone Xs Max");
        } else if (score >= 60) {
            System.out.println("iPad");
        }else {
            System.out.println("Nan");
        }
    }
}

编写程序:由键盘输入三个整数分别存入变量 num1、num2、num3,
对它们进行排序 (使用 if-else if-else) ,并且从小到大输出。

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

        System.out.print("请输入第一个整数");
        int num1 = scan.nextInt();
        System.out.print("请输入第二个整数");
        int num2 = scan.nextInt();
        System.out.print("请输入第三个整数");
        int num3 = scan.nextInt();

        if (num1 >= num2){
            if (num3 >= num1){
                System.out.println(num2 + "\t" + num1 + "\t" + num3);
            }else if (num3 <= num2){
                System.out.println(num3 + "\t" + num2 + "\t" + num1);
            }else {
                System.out.println(num2 + "\t" + num3 + "\t" + num1);
            }
        }else {
            if (num3 >= num2){
                System.out.println(num1 + "\t" + num2 + "\t" + num3);
            }else if (num3 <= num1){
                System.out.println(num3 + "\t" + num1 + "\t" + num2);
            }else {
                System.out.println(num1 + "\t" + num3 + "\t" + num2);
            }
        }
    }
}

我家的狗5岁了，5岁的狗相当于人类多大呢？
其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。
那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
如果用户输入负数，请显示一个提示信息。

import java.util.Scanner;
class DogAge {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入狗的年龄：");
        int dogAge = scan.nextInt();
        if (dogAge < 0){
            System.out.println("您输入数值不合法");
        }else if (dogAge <= 2){
            System.out.println(dogAge * 10.5 + "岁");
        }else {
            System.out.println((dogAge - 2) * 4 + (2 * 10.5) + "岁");
        }

        // 如何获取一个随机数：10 - 99
        int value = (int)(Math.random() * 90 + 10);
        // 公式 [a , b] : (int)Math.random() * (b - a + 1) + a);
        System.out.print("请输入一个数字：");

        int numbers = scan.nextInt();
        int numbersShi = numbers / 10;
        int numbersGe = numbers % 10;
        int valueShi = value / 10;
        int valueGe = value % 10;

        if (numbers == value) {
            System.out.println("$10000");
        }else if ((numbersGe == valueShi) && (numbersShi == valueGe)){
            System.out.println("$3000");
        }else if (numbersShi == valueShi || numbersGe == valueGe){
            System.out.println("$1000");
        }else if (numbersShi == valueGe || numbersGe == valueShi){
            System.out.println("$500");
        }else {
            System.out.println("$0");
        }
    }
}

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，

提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。

1. 如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2. 如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3000 美元。
3. 如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金 1000 美元。
4. 如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金 500 美元。
5. 如果用户输入的数字没有匹配任何一个数字，则彩票作废。

import java.util.Scanner;
class Lottery {
    public static void main(String[] args) {
        // 如何获取一个随机数：10 - 99
        int value = (int)(Math.random() * 90 + 10);
        // 公式 [a , b] : (int)Math.random() * (b - a + 1) + a);
        System.out.print("请输入一个数字：");

        int numbers = scan.nextInt();
        int numbersShi = numbers / 10;
        int numbersGe = numbers % 10;
        int valueShi = value / 10;
        int valueGe = value % 10;

        if (numbers == value) {
            System.out.println("$10000");
        }else if ((numbersGe == valueShi) && (numbersShi == valueGe)){
            System.out.println("$3000");
        }else if (numbersShi == valueShi || numbersGe == valueGe){
            System.out.println("$1000");
        }else if (numbersShi == valueGe || numbersGe == valueShi){
            System.out.println("$500");
        }else {
            System.out.println("$0");
        }
    }
}

大家都知道，男大当婚，女大当嫁。
那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；
富：财富1千万以上；帅：是。如果这三个条件同时满足，则：“一定”
如果三个条件有为真的情况，则：“犹豫。”
如果三个条件都不满足，则：“算了吧”

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

        System.out.print("请输入身高：（cm）");
        int wight = scan.nextInt();
        System.out.print("请输入存款：(千万)");
        double rmb = scan.nextDouble();
        System.out.print("请输入是否帅：（TRUE OR FALSE）");
        boolean isHandsome = scan.nextBoolean();

        if (wight > 180 && rmb > 1.0 && isHandsome){
            System.out.println("一定");
        }else if (wight > 180 || rmb > 1.0 || isHandsome){
            System.out.println("犹豫");
        }else {
            System.out.println("算了吧");
        }
    }
}

switch - case 结构

• switch - case 结构中的表达式，只能是如下的 6 种数据类型之一：

  • byte、short、char、int、枚举类型 (JDK5.0 新增)、String 类型 (JDK7.0 新增)

/*
分支结构之二：switch-case

1. 格式
switch(表达式){
case 常量1:
    语句1;
    // break;
case 常量2:
    语句2;
    // break;
   ……
case 常量n:
    语句n;
    // break;
default:
    语句n;
    // break;
}
2. 说明：
① 根据 switch 表达式中的值，依次匹配各个 case 中的常量，一旦匹配成功，则进入相应 case 结构中，调用其执行语句
   当调用完执行语句后，则仍然继续向下执行其它 case 结构中的执行语句，直到遇到 break 关键字或程序结束
② break 可以使用在 switch-case 结构中，表示一旦执行到此关键字，就跳出 switch-case 结构
③ switch 结构中的表达式，只能是如下的 6 种数据类型之一：byte、short、char、int、枚举类型(JDK5.0 新增)、String类型(JDK7.0 新增)
④ case 之后只能声明常量，不能声明范围
⑤ break 关键字是可选的
⑥ default：相当于 if-else 结构中的 else
            default 结构是可选的
*/
class SwitchCaseTest {
    public static void main(String[] args) {

        int number = 1;
        switch (number){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
                // break;
        }

        String season = "summer";
        switch (season){
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            default:
                System.out.println("季节输入有误");
        }

        // 情况1
        // boolean isHandsome = true;
        // switch (isHandsome){
        //    case 0:
        //        System.out.println("yes");
        //        break;
        //    case 1:
        //        System.out.println("no");
        //        break;
        //    default:
        //        System.out.println("Error!");
        // }
    }
}

• 凡是可以使用 switch - case 的结构，都可以转换为 if - else。反之，不成立
• 当既可以使用 switch - case 又可以使用 if - else 时，优先选择 switch - case （ switch - case 执行效率高）

练习

使用 switch - case 把小写类型的 char 型转为大写。只转换 a, b, c, d, e. 其它的输出 “ other ”。

import java.util.Scanner;
class SwitchCaseExer {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入字母(abcde):");
        String word = scan.next();
        char c = word.charAt(0);
        switch (c){
            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("Error!");
        }
    }
}

对学生成绩大于 60 分的，输出 “ 合格 ”。低于60分的，输出 “ 不合格 ”。

import java.util.Scanner;
class SwitchCaseExer {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入学生成绩:");
        int score = scan.nextInt();
        switch (score / 10){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;
            default:
                System.out.println("Error!");
        }
        // 更优
        switch (score / 60){
            case 0:
                System.out.println("不及格");
                break;
            case 1:
                System.out.println("及格");
                break;
            default:
                System.out.println("Error!");
        }
    }
}

打印月份所属季节

import java.util.Scanner;
class SwitchCaseExer {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入月份:");
        int monthNum = scan.nextInt();
        switch (monthNum){
            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;
            default:
                System.out.println("Error!");
        }
    }
}

从键盘分别输入年、月、日，判断这一天是当年的第几天

/*
判断一年是否是闰年的标准:
  1) 可以被4整除，但不可被100整除
    或
  2) 可以被400整除
*/
import java.util.Scanner;
class SwitchCaseExer1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 获取年份
        System.out.print("请输入年份:");
        int year = scan.nextInt();
        // 获取月份
        System.out.print("请输入" + year + "的month:");
        int month = scan.nextInt();
        // 获取日期
        System.out.print("请输入" + year + "的day:");
        int day = scan.nextInt();
        // 初始化天数
        int sumDays = 0;
        switch (month){
            case 12:
                sumDays += 30;
            case 11:
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                // 判断是否是闰年
                if ((year % 4 == 0 && (year & 100) != 0) || year % 400 == 0){
                    sumDays += 29;
                }else {
                    sumDays += 28;
                }
            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;
        }
        System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
    }
}

循环结构

在条件满足的情况下，反复执行特定代码的功能

• for 循环
• while 循环
• do - while 循环

循环语句的四个组成部分

1. 初始化部分（init_statement）
2. 循环条件部分（test_exp）
3. 循环体部分（body_statement）
4. 迭代部分（alter_statement）

init_statement=>start: 初始化部分
test_exp=>condition: 循环条件
body_alter_statement=>operation: 循环体部分 / 迭代部分
other_code=>end: 其它语句

init_statement->test_exp
test_exp(yes)->body_alter_statement(top)->test_exp
test_exp(no,bottom)->other_code

for 循环

for ( 1 ; 2 ; 4 ) {
   3
}

执行过程：① => ② => ③ => ④ => ② => ③ => ④ => …… ②

/*
For 循环结构的使用
一、 循环结构的4个要素
① 初始化部分（init_statement）
② 循环条件部分（test_exp）
③ 循环体部分（body_statement）
④ 迭代部分（alter_statement）
*/
class ForTest {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i++){ // i:1,2,3,4,5
            System.out.println("Hello World");
        }

        // 练习
        int num = 1;
        for (System.out.println("a");num < 3; System.out.println("c"),num++){
            System.out.println("b");
        }
        // 输出结果：abcbc

        // 遍历 100 内的偶数
        int sum = 0;
        int count = 0;
        for (int i = 1;i <= 100;i++){
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
                count ++;
            }
        }
        System.out.println("总和为" + sum);
        System.out.println("总数为" + count);
    }
}

练习

编写程序从1循环到150，并在每行打印一个值

在每个3的倍数行上打印出 foo

在每个5的倍数行上打印 biz

在每个7的倍数行上打印输出 baz

class ForTest1 {
    public static void main(String[] args) {
        for (int i = 1;i <= 150;i++){
            System.out.print(i + "\t");
            if (i % 3 == 0){
                System.out.print("foo\t");
            }
            if (i % 5 == 0){
                System.out.print("biz\t");
            }
            if (i % 7 == 0){
                System.out.print("baz\t");
            }
            System.out.println();
        }
    }
}

输入两个正整数 m 和 n 求其最大公约数和最小公倍数
比如：12 和 20 的最大公约数是 4 最小公倍数是 60

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

        System.out.print("请输入第一个正整数:");
        int m = scan.nextInt();
        System.out.print("请输入第二个正整数:");
        int n = scan.nextInt();
        // 获取最大公约数
        for (int i = (m <= n)? m : n;i >= 1;i--){
            if (m % i == 0 && n % i == 0){
                System.out.println("最大公约数为:" + i);
                break;// 一旦在循环中指定到 break，就跳出循环
            }
        }
        // 获取最小公倍数
        for (int i = (m >= n)? m : n;i <= m * n;i++){
            if (i % m == 0 && i % n == 0){
                System.out.println("最小公倍数为:" + i);
                break;
            }
        }
    }
}

输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。

例如：153 = 1x1x1 + 3x3x3 + 5x5x5

class ForExer1 {
    public static void main(String[] args) {
        for (int i = 100;i < 1000;i++){
            int a = i / 100;
            int b = i % 100 / 10;
            int c = i % 10;
            if(a * a * a + b * b * b + c * c * c == i) {
                System.out.println(i);
            }
        }
    }
}

while 循环

1
while(2){
    3;
    4;
}

执行过程：① => ② => ③ => ④ => ② => ③ => ④ => …… ②

注意点：

1. 写 while 循环千万小心不要丢了迭代条件，一旦丢了，就可能导致死循环
2. 写程序，避免死循环

3. for 循环和 while 循环是可以相互转换的！

   区别：for 循环和 while 循环初始化条件的作用域不同

/*
while 循环的使用

一、 循环结构的4个要素
① 初始化部分（init_statement）
② 循环条件部分（test_exp）
③ 循环体部分（body_statement）
④ 迭代部分（alter_statement）

算法：有限性

*/
class WhileTest {
    public static void main(String[] args) {

        // 遍历 100 内所有偶数
        int i = 1;
        while (i <= 100){
            if (i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }
        // 出了 while 循环，仍可调用
        System.out.println(i); // 101
    }
}

do - while 循环

1
do{
    3;
    4;
}while(2);

执行过程：① => ③ => ④ => ② => ③ => ④ => …… ②

do - while 循环至少执行一次循环体

class DoWhileTest {
    public static void main(String[] args) {
        int num = 1;
        int sum = 0;
        int count = 0;
        do {
            if (num % 2 == 0){
                System.out.println(num);
                sum += num;
                count ++;
            }
            num ++;
        }while (num <= 100);
        System.out.println("总和为" + sum);
        System.out.println("总数为" + count);

        // ======= do-while 至少执行一次 =======
        int number1 = 10;
        while (number1 > 10){
            System.out.println("Hello:While");
            number1 --;
        }

        int number2 = 10;
        do{
            System.out.println("Hello:While");
            number1 --;
        }while (number2 > 10);
    }
}

练习

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

import java.util.Scanner;
class ForWhileTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个整数：(输入 0 退出)");
        int positiveCount = 0;
        int negativeCount = 0;
        /*
        for (;;){
            System.out.print("请输入一个整数：");
            int num = scan.nextInt();
            if (num > 0){
                zcount ++;
            }else if (num < 0){
                fcount ++;
            }else {
                break;
            }
        }*/
        while (true){
            int num = scan.nextInt();
            if (num > 0){
                positiveCount ++;
            }else if (num < 0){
                negativeCount ++;
            }else {
                break;
            }
        }
        System.out.println("正整数的数量为 " + positiveCount + " 个");
        System.out.println("负整数的数量为 " + negativeCount + " 个");
    }
}

嵌套循环

• 将一个循环放在另一个循环体内，就形成了循环嵌套。其中 for，while，do……while 均可以作为外层循环或内层循环
• 实质上，循环嵌套就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为 false 时，才会完全跳出内层循环，才可以结束外层的当次循环，开始下一次循环

嵌套循环的使用

1. 循环嵌套：将一个循环结构 A 声明在另一个循环结构 B 的循环体中，就构成了嵌套循环

2. 内外层循环说明：

   外侧循环：循环结构 B

   内层循环：循环结构 A

3. 说明：

   1. 内层循环结构遍历一遍，只相当于外城循环循环体执行了一次
   2. 假设外城循环需要执行 m 次，内存循环需要执行 n 次，此时内层循环的循环体一共执行了 m * n 次

4. 技巧：

   外层循环控制 行 数，内层循环控制 列 数

练习

九九乘法表

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

100以内的所有质数

class PrimeNumberTest1 {
    public static void main(String[] args) {
        boolean isFlag = true;  // 标识 i 是否被 j 除尽，一旦除尽，修改其值
        for (i = 2; i <= 100; i++){ 
            for (int j = 2; j < i; j++){
                if (i % j == 0){  // i 被 j 除尽
                    isFlag = false;
                }
            }
            //
            if (isFlag){
                System.out.println(i);
            }
            // 重置 isFlag
            isFlag = true;
        }
    }
}

break 和 continue

• break 和 continue 可以通过标签指定跳过哪一层循环

lable:for (int i = 1; i <= 1; i++){
    for (int j = 2; j <= 10; j++){
        if (i == j){
            continue lable;
        }
        System.out.println(i + j);
    }
}

练习

100000 内质数优化

class PrimeNumberTest1 {
    public static void main(String[] args) {
        // 当前时间
        long start = System.currentTimeMillis();
        // boolean isFlag = true;  // 标识 i 是否被 j 除尽，一旦除尽，修改其值
        int count = 0;  // 计数器
        for (i = 2; i <= 100000; i++){  // 遍历 100000 内的所有自然数
            // 优化二：对本身时质数的自然数是有效的
            // for (int j = 2; j < i; j++){
            for (int j = 2; j <= Math.sqrt(i); j++){  // j:被 i 去除
                if (i % j == 0){  // i 被 j 除尽
                    // isFlag = false;
                    // break;  // 优化一：只对本身是非质数的自然数时有效的
                    continue lable;
                }
            }
            // if (isFlag){
                // System.out.println(i);
            count++;
            // }
            // 重置 isFlag
            // isFlag = true;
        }
        // 完毕时间
        long end = System.currentTimeMillis();
        System.out.println("质数个数为：" + count);
        System.out.println("所花费的时间为：" + (end - start) + " 毫秒");
        // 原本时间：15801 ms
        // 优化一：1363 ms
        // 优化二：131 ms
        // 优化一 + 优化二：10 ms
    }
}