[Java知识库]Java知识点（二）

第二章Java基本语法

java基础知识图解

2.1关键字和保留字

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

用于定义数据类型的关键字： class、interface、enum、byte、short、int、long、float、double、char、boolean、void

用于定义流程控制的关键字： if、else、switch、case、default、while、do、for、break、continue、return

用于定义访问权限修饰符的关键字： private、protected、public

用于定义类，函数，变量修饰符的关键字： abstract、final、static、synchronized

用于定义类与类之间的关键字： exdents、implements

用于定义建立实例及引用实例，判断实例的关键字： new、this、super、instanceof

用于异常处理的关键字： try、catch、finally、throw、throws

用于包的关键字： package、import

其它修饰符关键字： native、strictfp、transient、volatile、assert

• 保留字

  Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使

  用。自己命名标识符时要避免使用这些保留字

  goto 、const

2.2标识符

• 标识符：

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

• 定义合法标识符规则：

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

• Java中的命名规范：

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

  如果不遵守上面的规则，编译可以通过！建议大家遵守

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

? 2、Java采用unicde字符集，因此标识符也可以用汉字声明，编译可以通过！建议不要使用

2.3变量

• 变量的概念：
  • 内存中的一个存储区域
  • 该区域的数据可以在同一类型范围内不断变化
  • 变量是程序中最基本的存储单元。包含变量类型、变量名和储存的值
• 变量的作用：
  • Java中每个变量必须先声明，后使用
  • 使用变量名来访问这块区域的数据
  • 变量的作用域：其定义所在的一对{}内
  • 变量只有在其作用域内才有效
  • 同一个作用域内，不能定义同名的变量
• 声明变量
  • 语法：<数据类型> <变量名称>
  • 例如：int var；
• 变量的赋值
  • 语法：<变量名称> = <值>
  • 例如：var = 10
• 声明和赋值变量
  • 语法：<数据类型> <变量名> = <初始化值>
  • 例如：int var = 10

变量的分类-按数据类型

对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间

• 在方法体外，类体内声明的变量称为成员变量
• 在方法体内部的变量成为局部变量

• 注意：二者在初始化值的异同：

  同：都有生命周期 异：局部变量除形参外，需显式初始化

整数类型：byte、short、int、long

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

bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。

public class Variabletest2{
    public static void main(String[] args){
        int number1;
        number1 = 10;
        
        int number2;
        number = 20;
        
        int number3;
        number3 = number1 + number2;
        System.out.println(number3);
        
        int number4;
        number4 = 50;
        
        int number5;
        number5 = number4 - number3;
        System.out.println(number5);
    } 
}

浮点类型：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编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
• 字符型变量的三种表现形式：
  • 字符常量是用单引号（’ '）括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
  • Java中还允许使用转义字符‘\’来将其后的字符转为特殊字符型常量。例如：char c3 = ‘\n’; 表示换行符。
  • 直接使用Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。例如：\u000a 表示\n。
• char类型时可以进行运算的。因为它都对应有Unicode码。

ASCII码

• 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态， 因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一 共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 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位用来对字符进行编码。

boolean

• boolean类型用来判断逻辑条件，一般用于程序流程控制：
  • if条件控制语句；
  • while循环控制语句；
  • do-while循环控制语句；
  • for循环控制语句；
• boolean类型数据只允许取值true和false，无null。
  • 不可以使用0或非0的整数代替false和true，这点与C语言不同。
  • Java虚拟机中没有任何boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替：true用1表示，false用0表示。

基本数据类型转换

• 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
• byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型。
• boolean类型不能与其他数据类型运算。
• 当基本数据类型的值和字符串（String）进行连接运算时（+），基本数据类型的值将自动转化为字符串（String）类型。

字符串类型：String

• String不是基本数据类型，属于引用数据类型

• 使用方式与基本数据类型一致。例如：String str = “abcd”;

• 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

  ? str = str + “xyz”;

  ? int n = 100;

  ? str = str + n;

• String可以和8种基本数据变量做运算，且运算只能是连接运算：+（连接运算符）。运算的结果仍然是String类型。

例子：

public class Varabletext2{
    public static void main(String[] args){
        int no = 10;
        String str = "abcdef";
        String str1 = str + "xyz" + no;
        
        str1 = str1 + "123";
        char c = '国';
        
        double pi = 3.1416;
        str1= str1 + pi;
        boolean b = false;
        str1 = str1 + b;
        str1 = str1 + c;
        
        System.out.println("str1 = " + str1);
    }
}

练习：

public class StringTest {
    public static void main(String[] args) {
        char c = 'a';//97
        int num = 10;
        String str = "hello";
        
        System.out.println(c + num + str);//107hello
        System.out.println(c + str + num);//chello10
        System.out.println(c + (num + str));//a10hello
        System.out.println((c + num) + str);//107hello
        
        System.out.println("*	*");
        System.out.println('*' + '\t' + '*');//93
        System.out.println('*' + "\t" + '*');//*	*
        System.out.println('*' + '\t' + "*");//51*
        System.out.println('*' + ('\t' + "*"));//*	*
    }
}

强制类型转换

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

进制转换

变量的使用：

1、Java定义变量的格式：数据类型 变量名 = 变量值；

2、说明：

? （1）变量必须先声明，后使用。

? （2）变量都定义在其作用域内。在作用域内，他是有效的。

? （3）同一个作用域内不可以声明两个同名的变量。

变量运行算法则的两个特殊情况：

• 整型常量，默认类型为int型
• 浮点类型，默认类型为double型

2.4运算符

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

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

public class AriTest {
    public static void mian(String[] args) {
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        syetm.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);
        System.out.println(result4);//2.4
        
        
        int n1 = 12;
        int m1 = 5;
        System.out.println("n1 % m1 = " + n1 % m1);//2
        
        int n2 = -12;
        int m2 = 5;
        System.out.println("n2 % m2 = " + n2 % m2);//-2
        
        int n3 = 12;
        int m3 = -5;
        System.out.println("n3 % m3 = " + n3 % m3);//2
        
        int n4 = -12;
        int m4 = -5;
        System.out.println("n4 % m4 = " + n4 % m4);//-2
    }
}

算数运算符的注意问题

• 如果对负数取模，可以把模数符号忽略不计，如：5%-2=1.但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x = 3510; x = x / 1000 * 1000;x的结果是3000。

• “+”除字符串相加功能外，还能把非字符串转换成字符串。例如：System.out.println("5 + 5 = " + 5 + 5);打印结果为

  5 + 5 = 55

例子：

public class SignTest{
    public static void main(String[] args){
        int i1 = 10;
        int i2 = 20;
        int i = i1++;
        System.out.println("i = " + i);//10
        System.out.println("i1 = " + i1);//11
        
        i = ++i1;
        System.out.println("i = " + i);//12
        System.out.println("i1 = " + i1);//12
        
        i = i2--;
        System.out.println("i = " + i);20
        System.out.println("i2 = " + i2);19
        
        i = --i2;
        System.out.println("i = " + i);18
        System.out.println("i2 = " + i2);18
    }
}

赋值运算符

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

比较运算符

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

逻辑运算符：&——逻辑与、|——逻辑或、!——逻辑非、&&——短路与、||——短路或、^——逻辑异或

• 逻辑运算符用于连接布尔类型表达式，在Java中不可以写为3<x<6，应该写成x>3 & x<6。

• "&“和”&&"的区别：

  • “&”时，左边无论真假，右边都参与运算；
  • “&&”时，如果右边为真，左边参与运算，如果左边为假，那么右边不参与运算。

• “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

• 异或（^）与或（|）的不同之处是：当左右都为true时，结果为false。

  理解：异或，追求的是“异”！

例子：

public class Test{
    public static void main(String[] args){
        boolean x = true;
        boolean y = false;
        short z = 42;
        //if(y == true)
        if((z++ == 42) && (y = true)) z++;
        if((x = false) || (++z == 45)) z++;
        
        System.out.println("z = " + z);
    }
}

位运算符

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

三元运算符

• 格式：
  

  • 表达式1和表达式2为同种类型
  • 三元运算符与if-slse的联系与区别：
    • 三元运算符可简化为if-else语句
    • 三元运算符要求必须返回一个结果
    • if后的代码块可有多个语句

运算符的优先级

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

2.5程序流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句。可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
  • 顺序结构
    • 程序从上到下逐行地执行
  • 顺序结构
    • 根据条件，选择性地执行某段码代码
    • 如if…else和switch-case两种分支语句
  • 循环结构
    • 根据循环条件，重复性的执行某段代码
    • 有while、do…while、for三种循环语句
    • 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

2.5.1顺序结构

顺序结构

Java中定义成员变量时采用合法的向前引用。如：

public class Test{
    int num1 =12;
    int num2 = num1 + 2;
}

错误形式：

public class Test{
    int num2 = num1 + 2;
    int num1 = 12;
}

2.5.2分支语句1：if-else结构

if语句的三种格式：

1、if (条件表达式){

? 执行代码块；

}

2、if(条件表达式){

? 执行代码块1；

} else {

? 执行代码块2；

}

3、if(条件表达式1){

? 执行代码块1；

} else if(执行表达式2) {

执行代码块2；

} … else{

执行代码块n；

}

if-else使用说明：

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓；当多个条件是“包含”关系时，“小上大下 / 子上父下”

例子：

public class AgeTest{
    public static void main(String[] args){
        int age = 75;
        if (age < 0) {
            System.out.println("不可能！");
        } else if (age > 250) {
            System.out.println("是个妖怪！");
        } else {
            System.out.println("人家芳龄" + age + "，马马虎虎啦！");
        }
    }
}

习题1：岳小鹏参加Java考试，他和他的父亲岳不群达成承诺：如果成绩为100分，奖励一辆BMW；成绩为(80, 90]，奖励一台iPhone xs max；成绩为[60, 80]时，奖励一台iPad；成绩为其他时，什么奖励也没有。请从键盘输入岳小鹏的成绩，并加以判断。

import java.util.Scanner;

public class Test{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的成绩：");
        int input = sc.nextInt();
        
        if (input == 100) {
            System.out.println("奖励一辆BMW！");
        } else if ((input <= 90) || (input > 80)) {
            System.out.println("奖励一台iPhone xs max！");
        } else if ((input <= 80) || (input >= 60)) {
            System.out.println("奖励一台iPad！");
        } else {
            System.out.println("没有奖励！");
        }
    }
}

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

import java.util.Scanner;

public class Test1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int num1 = sc.nextInt();

        System.out.println("请输入第二个数：");
        int num2 = sc.nextInt();

        System.out.println("请输入第三个数：");
        int num3 = sc.nextInt();

        if (num1 < num2) {
            if (num2 < num3) {
                System.out.println("从小到大排序为：" + num1 + "小于" + num2 + "小于" + num3);
            } else {
                if (num1 > num3) {
                    System.out.println("从小到大排序为：" + num3 + "小于" + num1 + "小于" + num2);
                } else {
                    System.out.println("从小到大排序为：" + num1 + "小于" + num3 + "小于" + num2);
                }
            }
        } else {
            if (num2 > num3) {
                System.out.println("从小到大排序为：" + num3 + "小于" + num2 + "小于" + num1);
            } else {
                if (num1 > num3) {
                    System.out.println("从小到大排序为：" + num2 + "小于" + num3 + "小于" + num1);
                } else {
                    System.out.println("从小到大排序为：" + num2 + "小于" + num1 + "小于" + num3);
                }
            }
        }
    }
}

练习3：编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入第一个数：");
        int n1 = sc.nextInt();
        System.out.print("请输入第二个数：");
        int n2 = sc.nextInt();
        
        if ((n1 + n2) >= 50) {
            System.out.println("Hello World!");
        }
    }
}

练习4：编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入第一个数：");
        double n1 = sc.nextDouble();
        System.out.print("请输入第二个数：");
        double n2 = sc.nextDouble();

        if ((n1 > 10.0) && (n2 < 20.0)) {
            System.out.println("两数之和为：" + (n1 + n2));
        } else {
            System.out.println("两数之积为：" + (n1 * n2));
        }
    }
}

练习5：我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。

import java.util.Scanner;

public class Test8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入狗的年龄：");
        double dogAge = sc.nextDouble();
        double age = 0;
        if (dogAge <= 2) {
            age = dogAge;
            age = age * 10.5;
            System.out.println(dogAge + "岁的狗相当于人类多少年龄:" + age);
        } else {
            age = dogAge;
            age = 2 * 10.5 + (age - 2) * 4;
            System.out.println(dogAge + "岁的狗相当于人类多少年龄:" + age);
        }
    }
}

练习6：假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。

1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。

2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。

3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。

4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。

5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入你的数字：");
        int input = sc.nextInt();
        int number = (int) (Math.random() * 90 + 10);
        System.out.println("中将号码为：" + number);

        if (input == number) {
            System.out.println("恭喜你中奖10,000美元");
        } else {
            int a = input % 10;
            int b = input / 10;
            int c = number % 10;
            int d = number / 10;
            if(a == c && b == d){
                System.out.println("恭喜你中奖3,000美元");
            }else if((a == c && b != d) || (a != c && b == d)){
                System.out.println("恭喜你中奖1,000美元");
            }else if((a == d && b != c) || (b == c && a != d) ){
                System.out.println("恭喜你中奖500美元");
            } else {
                System.out.println("彩票作废！");
            }
        }
    }
}

练习7：大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。

如果这三个条件同时满足，则：“我一定要嫁给他!!!”

如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”

如果三个条件都不满足，则：“不嫁！”

import java.util.Scanner;

public class ForTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入你的身高：(cm)");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：(千万)");
		double wealth = scan.nextDouble();
        System.out.println("请输入你是否帅：(true/false)");
		boolean isHandsome = scan.nextBoolean();
        
        if (height >= 180 && wealth >= 1 && isHandsome) {
            System.out.println("我一定要加嫁他！！！");
        } else if (height >= 180 || wealth >= 1 || isHandsome) {
            System.out.println("嫁吧，比上不足，比下有余。");
        } else {
            System.out.println("不嫁！！");
        }
    }
}

2.5.3分支语句2：switch-case结构

switch (表达式) {
    case 常量1:
        语句1;
        //break;
    case 常量2:
        语句2;
        //break;
    ... ...
    case 常量N:
        语句N;
        //break;
    default:
        语句;
        //break;
}

例子：

public class SwitchTest {
    public static void main(String[] args) {
        int i = 1;
        switch (i) {
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            default:
                System.out.println("default");
                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("冬雪皑皑");
            default:
                System.out.println("季节输入错误");
                break;
        }
    }
}

switch有关规则：

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举(jdk5.0)，String(jdk7.0)；
• case子句中的值必须是常量，不能是变量名或不正确的表达式值；
• 同一个switch语句，所有的case子句中的常量值互不相同；
• break语句用来执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会执行到switch结尾；
• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。

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

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入字母：");
        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;
            default:
                System.out.println("other");
                break;
        }
    }
}

习题2：根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;

public class Test11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入月份：");
        int month = sc.nextInt();
        
        switch (month) {
            case 3:
            case 4:
            case 5:
                System.out.println("spring");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("summer");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("autumn");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("winter");
                break;
            default:
                System.out.prinln("error");
                break;
        }
    }
}

2.5.4循环结构

循环结构：在某些条件满足的情况下，反复执行特定代码的功能。

循环语句分类：

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

循环语句的四个组成部分：

• 初始化部分（init_statement）
• 循环条件部分（test_exp）
• 循环体部分（body_statement）
• 迭代部分（alter_statement）

循环结构1：for循环

语法格式

? for (1、初始化部分; 2、循环条件部分; 4、迭代部分) {3循环体部分}

执行过程：

1-2-3-4-2-3-4-2-3-4-…-2

说明：

• 2循环条件部分为boolean类型表达式，当值为false时，退出循环
• 1初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• 4可以有多个变量更新，用逗号隔开

例1：

public class ForLoop {
    public static void main(String[] args) {
        int result = 0;
        for (int i = 1; i <= 100; i++) {
            result += i;
        }
        System.out.println("result = " + result);
    }
}

例2：编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。

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

例3：输入两个正整数m和n，求其最大公约数和最小公倍数。

比如：12和20的最大公约数是4，最小公倍数是60。

import java.util.Scanner;

public class Test13 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入第一个正整数：");
        int m = sc.nextInt();
        System.out.print("请输入第二个正整数：");
        int n = sc.nextInt();

        int min = m < n ? m : n;
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i ==0) {
                System.out.println(m + "和" + n + "最大公约数为：" + i);
                System.out.println("最小公倍数为：" + (m * n / i));
                break;
            }
        }
    }
}

练习1：打印1~100之间所有奇数的和

public class Test14 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 1) {
                sum = sum + i;
            }
        }
        System.out.println("1~100的奇数和为：" + sum);
    }
}

练习2：打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）

public class Test5 {
    public static void main(String[] args) {
        int sum = 0;
        int count = 0;

        for (int i = 1; i < 100; i++) {
            if (i % 7 == 0) {
                sum = sum + i;
                count++;
            }
        }
        System.out.println("1~100中7的倍数的个数为：" + count + ",总和为：" + sum);
    }
}

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

例如： 153 = 111 + 333 + 555

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

循环结构2：while循环

语法格式：

①初始化部分

while(②循环条件部分)｛

③循环体部分;

④迭代部分;

}

执行过程：

①-②-③-④-②-③-④-②-③-④-…-②

说明：

• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
• for循环和while循环可以相互转换。

例子：

public class WhileLoop {
    public static void main(String[] args) {
        int resule = 0;
        int i = 1;
        while (i <= 100) {
            result += i;
            i++;
        }
        System.out.println("result = " + resulr);
    }
}

循环结构3：do-while循环

语法结构：

①初始化部分;

? do{

? ③循环体部分

? ④迭代部分

? }while(②循环条件部分);

执行过程：

①-③-④-②-③-④-②-③-④-…②

说明：

• do-while循环至少进行一次循环。

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

嵌套循环

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

例1：打印九九乘法表

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

例2：100以内的所有质数

public class Test15 {
    public static void main(String[] args) {
        System.out.println("100以内的所有质数：");
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j <= i; j++) {
                if (i % j == 0 && i != j) {
                    break;
                }
                if (i == j) {
                    System.out.print(i + "\t");
                }
            }
        }
    }
}

特殊关键字的使用：break、co’ntinue

break语句：

• break语句用于终止某个语句块的执行

  {	......
      break;
   	......
  }
  

• break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是那一层语句块

  label1:{	......
  label2:    {	......
  lebel3:        {	......
              		break label2;
                  	......
                 }
              }
          }
  

  例1：

  public class BreakTest {
      public static void main(String[] args) {
          for (int i = 1; i < 10; i++) {
              if (i == 3) {
                  break;
                  System.out.println("i = " + i);
              }
          }
          System.out.println("Game over!");
      }
  }
  

continue语句：

• continue只能使用在循环结构中
• continue语句用于跳过所在循环语句块的一次执行，继续下一次循环
• continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明是那一层循环

例子：

public class ContinueTest {
    public static void mian(String[] args) {
        for (int i = 0; i < 100; i++) {
            if (i % 10 == 0) {
                continue;
            }
            System.out.println(i);
        }
    }
}

return：

• 并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
• 与break和continue不同的是，return直接结束整个方法，不管return处于多少层循环之内。

特殊流程控制语句说明：

• break只能用于switch语句和循环语句中。
• continue只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他语句，因为程序永远不会执行后面的语句。
• 标点语句必须紧接在循环的头部。标点语句不能用在非循环语句的前面.
• 很多语言都有goto语句，goto语句可以随意将控制转移到任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue使不同于goto的。

超强干货来袭

云风专访：近40年码龄，通宵达旦的技术人生