Java | 个人学习指南笔记

前言：由于作者已经有C语言，C++和Python语言的基础了，所以在文章的编写时会以这几门编程语言作对比。本文学习自 C语言中文网的 Java 教程，部分内容引用自这、引用内容仅作学习使用。

第1章：Java程序设计基础

1.1、标识符和关键词

任何一种计算机语言都离不开标识符和关键字，因此下面将详细介绍 Java 的标识符、关键字和保留字。

标识符

关于标识符问题，Java和C++是同类型的

Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。

标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。

另外，Java 严格区分大小写，因此 myvar 和 MyVar 是两个不同的标识符。

同样在进行标识符命名时，不能以数字开头，也不能以 Java 的关键词作为标识符使用（基操了

标识符用来命名常量、变量、类和类的对象等。因此，一个良好的编程习惯要求命名标识符时，应赋予它一个有意义或有用途的名字。

关键字

Java 语言目前定义了 51 个关键字，这些关键字不能作为变量名、类名和方法名来使用。以下对这些关键字进行了分类。

数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
保留字：true、false、null、goto、const。

提示：由于 Java 区分大小写，因此 public 是关键字，而 Public 则不是关键字。但是为了程序的清晰及可读性，要尽量避免使用关键字的其他形式来命名。

1.2、Java注释

与 C++ 不同的是：Java在支持 单行、多行注释的同时还支持 文档注释

1）单行注释

以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。

图 1.2.1 单行注释

2）多行注释

包含在“/”和“/”之间，能注释很多行的内容。为了可读性比较好，一般首行和尾行不写注释信息（这样也比较美观好看）。

注意：多行注释可以嵌套单行注释，但是不能嵌套多行注释和文档注释。

图 1.2.2 多行注释

3）文档注释

包含在“ /** ”和“ */ ”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。注释后，鼠标放在类和变量上面会自动显示出我们注释的内容

注意：文档注释能嵌套单行注释，不能嵌套多行注释和文档注释，一般首行和尾行也不写注释信息。

图 1.2.3 文档注释

文档注释可以通过 Javadoc 命令把文档注释中的内容生成文档，并输出到 HTML 文件中，方便记录程序信息。还可以包含一个或多个 @ 标签，每个 @ 标签都在新的一行开始。

图 1.2.4 引言

1.3、Javadoc（文档注释）

Java 支持 3 种注释，分别是单行注释、多行注释和文档注释。文档注释以/**开头，并以*/结束，可以通过 Javadoc 生成 API 帮助文档，Java 帮助文档主要用来说明类、成员变量和方法的功能。

详细讲解：Here

1.4、Java常量的定义和分类

常量是指在程序的整个运行过程中值保持不变的量。在这里要注意常量和常量值是不同的概念，常量值是常量的具体和直观的表现形式，常量是形式化的表现。通常在程序中既可以直接使用常量值，也可以使用常量。

常量不同于常量值，它可以在程序中用符号来代替常量值使用，因此在使用前必须先定义。

在声明常量的同时要赋予一个初始值。常量一旦初始化就不可以被修改（类似C++的 const。它的声明格式为：

final dataType variableName = value;
//其中，final 是定义常量的关键字，dataType 指明常量的数据类型，variableName 是变量的名称，value 是初始值。

final 关键字表示最终的，它可以修改很多元素，修饰变量就变成了常量。例如，以下语句使用 final 关键字声明常量。

public class demo {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;
    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

常量有三种类型：静态常量、成员常量和局部常量。

代码第 3 行的是声明静态常量，使用在 final 之前 public static 修饰。public static 修饰的常量作用域是全局的，不需要创建对象就可以访问它，在类外部访问形式为 HelloWorld. PI。这种常量在编程中使用很多。

代码第 5 行声明成员常量，作用域类似于成员变量，但不能修改。代码第 9 行声明局部常量，作用域类似于局部变量，但不能修改。

在定义常量时，需要注意如下内容：

在定义常量时就需要对该常量进行初始化。
final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
为了与变量区别，常量取名一般都用大写字符。

当常量被设定后，一般情况下不允许再进行更改，如果更改其值将提示错误。例如，如下图中定义常量 AGE 并赋予初值，如果更改 AGE 的值，那么在编译时将提示不能重合赋值错误。

图 1.4.1 常量不能修改

1.5、Java变量的声明和初始化

Java 和 C++ 一样是强类型（Strongly Typed）语言，其定义为以下两方面：

所有的变量必须先声明、后使用。
指定类型的变量只能接受类型与之匹配的值。

这意味着每个变量和每个表达式都有一个在编译时就确定的类型。类型限制了一个变量能被赋的值，限制了一个表达式可以产生的值，限制了在这些值上可以进行的操作，并确定了这些操作的含义。

声明变量

在 java 中用户可以通过指定数据类型和标识符来声明变量，其基本语法如下所示：

DataType identifier;

或者

DataType identifier=value;

上述语法代码中涉及 3 个内容：DataType、 identifier 和 value，其具体说明如下：

DataType：变量类型，如 int、string、 char 和 double 等。
identifier：标识符，也叫变量名称。
value：声明变量时的值。

关于变量标识符的命名规范已经在前文提及了：Here

如下代码分别声明了 String、boolean 和 int 类型的变量。

String employee = “Zhangsan";    // String 类型的变量
boolean isSave = true;    // boolean 类型的变量
int create_at;    // int 类型的变量

当然，变量可以先声明然后赋值

String username;    // 先声明
username ="Zhangsan";    // 后赋值

另外，多个同类型的变量可以同时定义或者初始化，但是多个变量中间要使用逗号分隔，声明结束时用分号分隔。

String username,address,phone,tel;    // 声明多个变量
int num1=12,num2=23,result=35;    // 声明并初始化多个变量

Java 中初始化变量时需要注意以下事项：

变量是类或者结构中的字段，如果没有显式地初始化，默认状态下创建变量并默认初始值为 0。
方法中的变量必须显式地初始化，否则在使用该变量时就会出错。

1.6、变量的作用域：静态变量、全局变量和局部变量

变量的作用域规定了变量所能使用的范围，只有在作用域范围内变量才能被使用。根据变量声明地点的不同，变量的作用域也不同。

根据作用域的不同，一般将变量分为不同的类型：成员变量和局部变量。

1.7、Java自增和自减运算符（++和--）

package Study;

public class demo{
    public static void main(String[] args) {
        int x = 5,y; // 声明用于自增和自减的整型变量
        char cx = 'B',cy;// 声明用于自增和自减的字符型变量
        float fx = 5.5f,fy;// 声明用于自增和自减的浮点型变量
        System.out.println("---------对整数的自增和自减---------");
        y = x++;
        System.out.printf("y=x++ 的结果为：%d ,%d 
", x, y);
        y = x--;
        System.out.printf("y=x-- 的结果为：%d ,%d 
", x, y);
        y = ++x;
        System.out.printf("y=++x 的结果为：%d ,%d 
", x, y);
        y = --x;
        System.out.printf("y=--x 的结果为：%d ,%d 
", x, y);
        System.out.println("
---------对浮点的自增和自减---------");
        fy = fx++;
        System.out.printf("fy=fx++ 的结果为：%f ,%f 
", fx, fy);
        fy = fx--;
        System.out.printf("fy=fx-- 的结果为：%f ,%f 
", fx, fy);
        fy = ++fx;
        System.out.printf("fy=++fx 的结果为：%f ,%f 
", fx, fy);
        fy = --fx;
        System.out.printf("fy=--fx 的结果为：%f ,%f 
", fx, fy);
        System.out.println("
---------对字符的自增和自减---------");
        cy = cx++;
        System.out.printf("cy=cx++ 的结果为：%c ,%c 
", cx, cy);
        cy = cx--;
        System.out.printf("cy=cx-- 的结果为：%c ,%c 
", cx, cy);
        cy = ++cx;
        System.out.printf("cy=++cx 的结果为：%c ,%c 
", cx, cy);
        cy = --cx;
        System.out.printf("cy=--cx 的结果为：%c ,%c 
", cx, cy);
    }

}

运行结果

---------对整数的自增和自减---------
y=x++ 的结果为：6 ,5
y=x-- 的结果为：5 ,6
y=++x 的结果为：6 ,6
y=--x 的结果为：5 ,5

---------对浮点的自增和自减---------
fy=fx++ 的结果为：6.500000 ,5.500000
fy=fx-- 的结果为：5.500000 ,6.500000
fy=++fx 的结果为：6.500000 ,6.500000
fy=--fx 的结果为：5.500000 ,5.500000

---------对字符的自增和自减---------
cy=cx++ 的结果为：C ,B
cy=cx-- 的结果为：B ,C
cy=++cx 的结果为：C ,C
cy=--cx 的结果为：B ,B

从运行结果来看，无论是何种类型，只要是自增和自减运算符支持的类型，都可以参与运算。在这部分和 C++ 相同。

1.8、位运算

定义的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括 long，int，short，char 和 byte。

位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。

Java 语言中的位运算符分为位逻辑运算符和位移运算符两类，下面详细介绍每类包含的运算符。

位逻辑运算符

位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。表 1 中列出了它们的基本用法。

运算符	含义	实例	结果
&	按位进行与运算（AND）	4 & 5	4
\|	按位进行或运算（OR）	4 \| 5	5
^	按位进行异或运算（XOR）	4 ^ 5	1
~	按位进行取反运算（NOT）	~ 4	-5

位与运算符

位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。

例如下面的表达式：

100&0

图 1 所示为这个运算过程，结果为 0。

图 1 100位与0的运算过程

下面是两个非零的数字进行位与运算的过程。

int x = 5,y = 12; // 创建整型变量保存两个数
int z = x&y; // 对这两个数进行位与运算，结果保存到z

这两行语句执行后变量 Z 的值是 4，图 2 所示为这个运算过程。

图 2 5位与12的运算过程

位或运算符

位或运算符为|，其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。

下面是一个使用位或运算符的表达式。

11|7

运算结果为 15，图 3 所示为其运算过程。

图 3 11位或7的运算过程

位异或运算符

位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。

下面是一个使用位异或运算符的表达式。

11^7

运算结果为 12，图 4 所示为其运算过程。

图 4 11位异或7的运算过程

提示：在有的高级语言中，将运算符^作为求幂运算符，要注意区分。

位取反运算符

位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。

下面是一个使用位取反运算符的表达式。

~10

运算结果为 65525，图 5 所示为其运算过程。

图 5 对10位取反的运算过程

我们可以使用如下的程序来检查这个运算结果。

int i = 10;System.out.printf("%d 
",~i);

编译执行以上程序，会发现输出的结果是 -11，而不是 65525。这是因为取反之后的结果是十六进制数，而在上面的程序中使用 %d 将输出转换为了十进制数。

可以使用如下语句查看十六进制结果。

int i=10;System.out.printf("%x 
",~i);

可以看到输出结果为 fff5，将它转换为二进制是 1111111111110101。这个二进制数的最高位为 1，表示这个数为负数。除最高位外，按位取反再加 1，即得到二进制原码 1000000000001011，用十进制数表示即为 -11。

注意：位运算符的操作数只能是整型或者字符型数据以及它们的变体，不用于 float、double 或者 long 等复杂的数据类型。

位移运算符

位移运算符用来将操作数向某个方向（向左或者右）移动指定的二进制位数。表 2 列出了 Java 语言中的两个位移运算符，它们都属于双目运算符。

运算符	含义	实例	结果
»	右移位运算符	8»1	4
«	左移位运算符	9«2	36

左位移运算符

左移位运算符为«，其运算规则是：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。

例如，将整数 11 向左位移 1 位的过程如图 6 所示。

图 6 对11左移1位运算过程

从图 6 中可以看到，原来数的所有二进制位都向左移动 1 位。原来位于左边的最高位 0 被移出舍弃，再向尾部追加 0 补位。最终到的结果是 22，相当于原来数的 2 倍。

右位移运算符

右位移运算符为»，其运算规则是：按二进制形式把所有的数字向右移动对应的位数，低位移出（舍弃），高位的空位补零。

例如，将整数 11 向右位移 1 位的过程如图 7 所示。

图 7 对11右移1位运算过程

从图 7 中可以看到，原来数的所有二进制位都向右移动 1 位。原来位于右边的最低位 1 被移出舍弃，再向最高位追加 0 补位。最终到的结果是 5，相当于原数整除 2 的结果。

复合位赋值运算符

所有的二进制位运算符都有一种将赋值与位运算组合在一起的简写形式。复合位赋值运算符由赋值运算符与位逻辑运算符和位移运算符组合而成。表 3 列出了组合后的复合位赋值运算符。

运算符	含义	实例	结果
&=	按位与赋值	num1 &= num2	等价于 num 1=num 1 & num2
\|=	按位或赋值	num1 \|= num2	等价于 num 1=num 1 \| num2
^=	按位异或赋值	num1 ^= num2	等价于 num 1=num 1 ^ num2
-=	按位取反赋值	num1 ~= num2	等价于 num 1=num 1 ~ num2
«=	按位左移赋值	num1 «= num2	等价于 num 1=num 1 « num2
»=	按位右移赋值	num1 »= num2	等价于 num 1=num 1 » num2

下面的程序定义了几个 int 型变量，然后运用位赋值简写的形式将运算后的值赋给相应的变量：

int a = 1;
int b = 2;
int c = 3;

a &= 4;
a |= 4;
a ^= c;
a -= 6;
b >>= 1;
c <<= 1;

System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);

该程序的输出为：

a = 1
b = 1
c = 6

在位运算的技巧其实和C++是相通的，可以去位运算的奇技淫巧（二）查阅。

1.9 条件运算符和运算符的优先级

条件运算符

Java和C++一样提供三目运算符（也称：三元运算符）经常用于取代某个类型的 if-then-else 语句。

result = <expression> ? <statement1> : <statement3>;

其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1，否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。

运算符的优先级

详细讲解：Here

第2章：Java流程控制语句

引言：

流程是人们生活中不可或缺的一部分，它表示人们每天都在按照一定的流程做事。比如出门搭车、上班、下班、搭车回家。这其中的步骤是有顺序的。程序设计也需要有流程控制语句来完成用户的要求，根据用户的输入决定程序要进入什么流程，即“做什么”以及“怎么做”等。

从结构化程序设计角度出发，程序有 3 种结构：顺序结构、选择结构和循环结构。若是在程序中没有给出特别的执行目标，系统则默认自上而下一行一行地执行该程序，这类程序的结构就称为顺序结构。

到目前为止，我们所编写的程序都属于顺序结构。但是事物的发展往往不会遵循早就设想好的轨迹进行，因此，所设计的程序还需要能够具有在不同的条件下处理不同问题以及当需要进行一些相同的重复操作时，如何能省时省力地解决问题的能力。

在if else 和 switch case语句这部分和C++基本相通，所以直接开始实战了。

2.1、项目实战1：实现淡旺季飞机票打折

某航空公司为吸引更多的顾客推出了优惠活动。原来的飞机票价为 3000 元，活动时，4~11 月旺季，头等舱 9 折，经济舱 8 折；1~3 月、12 月淡季，头等舱 5 折，经济舱 4 折，求机票的价格。

if-else 实现

import java.util.Scanner;

public class demo{
    public static void main(String[] args) {
        double plane_price = 3000.0;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入出行的月份：");
        int month = sc.nextInt();
        System.out.println("选择头等舱还是经济舱：1 为头等舱，2 为经济舱");
        int kind = sc.nextInt();
        double result = 60000;//原始价格
        //旺季价格计算
        if (month >= 4 && month <= 11) {
            if (kind == 1) result *= 0.9;
            else if (kind == 2) result *= 0.8;
            else System.out.println("选择种类有误，请重新输入！");
        } else if (month >= 1 && month <= 3 || month == 12) {
            if (kind == 1) result *= 0.5;
            else if (kind == 2) result *= 0.4;
            else System.out.println("选择种类有误，请重新输入！");
        } else {
            System.out.println("日期选择有误，请重新输入！");
        }
        System.out.println("您选择的机票价格为：" + result);
    }
}

旺季经济舱出行的输出结果如下所示：

请输入出行的月份：
6
选择头等舱还是经济舱？数字1为头等舱，数字2为经济舱
2
您选择的机票价格为：48000.0

淡季头等舱的输出结果如下所示：

请输入出行的月份：
2
选择头等舱还是经济舱？数字1为头等舱，数字2为经济舱
1
您选择的机票价格为：30000.0

switch-case实现

import java.util.Scanner;

public class demo{
    public static void main(String[] args) {
        double plane_price = 3000.0;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入出行的月份：");
        int month = sc.nextInt();
        System.out.println("选择头等舱还是经济舱？数字1为头等舱，数字2为经济舱");
        int kind = sc.nextInt();
        double result =60000;
        switch (month){
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
            case 11:
                switch (kind){
                    case 1:
                        result *= 0.9;
                        break;
                    case 2:{
                        result *= 0.8;
                        break;
                    }
                    default:
                        System.out.println("选择种类有误，请重新输入！");
                        break;
                }
                break;
            case 1: case 2:
            case 3: case 12:
                switch (kind){
                    case 1:
                        result *= 0.5;
                        break;
                    case 2:{
                        result *= 0.4;
                        break;
                    }
                    default:
                        System.out.println("选择种类有误，请重新输入！");
                        break;
                }
                break; default:{
                    System.out.println("日期选择有误，请重新输入！");
                    break;
                }
        }
        System.out.println("您选择的机票价格为：" + result);
    }
}

写的时候发现IDEA默认的缩进有点不对劲，之后需要修一下

2.2、项目实战2：根据出生日期计算（判断）星座

下面我们来了解一下十二星座对应的日期划分范围。

白羊：0321~0420          天秤：0924~1023
金牛：0421~0521          天蝎：1024~1122
双子：0522~0621          射手：1123~1221
巨蟹：0622~0722          摩羯：1222~0120
狮子：0723~0823          水瓶：0121~0219
处女：0824~0923          双鱼：0220~0320

例如，出生日期为 0609（6 月 9 号），则对应的是双子座。

根据上述描述，在程序中需要用户输入一个 4 位数字，再根据这个数字所处的范围进行判断，其中前两位是月份，后两位是日期。这里我们分别用 if else 语句和 switch 语句实现，希望读者自己运行，以便更好的掌握 if else 和 switch 的区别和适用场景。

if-else 实现

import java.util.Scanner;

public class demo{
    public static void main(String[] args) {
        System.out.println("请输入您的出生年月(如 0123 表示 1月23日)：");
        Scanner sc = new Scanner(System.in);
        int monthday = sc.nextInt(),month = monthday / 100,day = monthday % 100;
        String xingzuo = "";
        if (month == 1) {
            if (day < 21) {
                xingzuo = "摩羯座";
            } else {
                xingzuo = "水瓶座";
            }
        } else if (month == 2) {
            if (day < 20) {
                xingzuo = "水瓶座";
            } else {
                xingzuo = "双鱼座";
            }
        } else if (month == 3) {
            if (day < 21) {
                xingzuo = "双鱼座";
            } else {
                xingzuo = "白羊座";
            }
        } else if (month == 4) {
            if (day < 21) {
                xingzuo = "白羊座";
            } else {
                xingzuo = "金牛座";
            }
        } else if (month == 5) {
            if (day < 22) {
                xingzuo = "金牛座";
            } else {
                xingzuo = "双子座";
            }
        } else if (month == 6) {
            if (day < 22) {
                xingzuo = "双子座";
            } else {
                xingzuo = "巨蟹座";
            }
        } else if (month == 7) {
            if (day < 23) {
                xingzuo = "巨蟹座";
            } else {
                xingzuo = "狮子座";
            }
        } else if (month == 8) {
            if (day < 24) {
                xingzuo = "狮子座";
            } else {
                xingzuo = "处女座";
            }
        } else if (month == 9) {
            if (day < 24) {
                xingzuo = "处女座";
            } else {
                xingzuo = "天秤座";
            }
        } else if (month == 10) {
            if (day < 24) {
                xingzuo = "天秤座";
            } else {
                xingzuo = "天蝎座";
            }
        } else if (month == 11) {
            if (day < 23) {
                xingzuo = "天蝎座";
            } else {
                xingzuo = "射手座";
            }
        } else if (month == 12) {
            if (day < 22) {
                xingzuo = "射手座";
            } else {
                xingzuo = "摩羯座";
            }
        }
        System.out.println("您的星座是：" + xingzuo);
    }
}

switch-case 实现

package Study;

import java.util.Scanner;

public class demo{
    public static void main(String[] args) {
        System.out.println("请输入您的出生年月(如 0123 表示 1月23日)：");
        Scanner sc = new Scanner(System.in);
        int monthday = sc.nextInt(),month = monthday / 100,day = monthday % 100;
        String xingzuo = "";
        switch (month) {
　　    case 1:
                xingzuo = day<21?"摩羯座":"水瓶座";
                break;
　　    case 2:
                xingzuo = day<20? "水瓶座":"双鱼座";
                break;
　　    case 3:
                xingzuo = day<21?"双鱼座":"白羊座";
                break;
　　    case 4:
                xingzuo = day<21?"白羊座":"金牛座";
                break;
            case 5:
                xingzuo = day<22?"金牛座":"双子座";
                break;
　　    case 6:
                xingzuo = day<22?"双子座":"巨蟹座";
                break;
　　    case 7:
                xingzuo = day<23?"巨蟹座":"狮子座";
                break;
　　    case 8:
                xingzuo = day<24?"狮子座":"处女座";
                break;
　　    case 9:
                xingzuo = day<24?"处女座":"天秤座";
                break;
　　    case 10:
                xingzuo = day<24?"天秤座":"天蝎座";
                break;
　　    case 11:
                xingzuo = day<23?"天蝎座":"射手座";
                break;
　　    case 12:
                xingzuo = day<22?"射手座":"摩羯座";
                break;
        }
        System.out.println("您的星座是：" + xingzuo);
    }
}

最终运行效果如下所示：

请输入您的出生年月（如 0123 表示 1 月 23 日）：
0521
您的星座是：金牛座

请输入您的出生年月（如 0123 表示 1 月 23 日）：
1109
您的星座是：天蝎座

上述代码中，首先声明变量 monthday 保存用户输入的信息，然后用 month 和 day 变量分别表示月份和日期。接下来 switch 语句根据月份判断执行 case 子句中的代码，在每个 case 子句中，使用三元运算符根据日期判断所属的星座。

2.3、循环语句

常见的循环有 while , do-while和 for，但 foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

foreach 循环语句的语法格式如下：

和 C++11 标准下的for循环一样

for(类型 变量名:集合) {
    语句块;
}

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程如图 1 所示。

图 2. 3. 1 foreach 循环语句的执行流程图

样例：

public static void main(String[] args) {
        // 声明并初始化数组
        int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
        System.out.println("----for----");
        // for语句
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Count is:" + numbers[i]);
        }
    	System.out.println("----for-each----");
        // for-each语句
        for (int item : numbers) {
            System.out.println("Count is:" + item);
        }
    }

2.4、项目实战3：判断闰年平年并输出某月的天数

要用的循环语句分支语句和 return break continue 语句

所谓闰年，就是指 2 月有 29 天的那一年。闰年同时满足以下条件：

年份能被 4 整除。
年份若是 100 的整数倍，须被 400 整除，否则是平年。

例如，1900 年能被 4 整除，但是因为其是 100 的整数倍，却不能被 400 整除，所以是平年；而 2000 年就是闰年；1904 年和 2004 年、2008 年等直接能被 4 整除且不能被 100 整除，都是闰年；2014 是平年。

下面综合本章学习的知识来编写一个判断闰年的案例，其主要功能如下：

判断用户输入的年份是不是闰年。
根据年份和月份输出某年某月的天数。

实现步骤分为以下几步：

1）新建一个类并在该类中导入需要的 java.util.Scanner 类，同时需要创建该类的入口方法 main()，其实现代码如下：

import java.util.Scanner;
public class demo {
    public static void main(String[] args) {
        // 在这里编写其他代码
    }
}

2）在 main() 方法中编写 Java 代码，获取用户输入的年份和月份，其实现代码如下：

Scanner sc = new Scanner(System.in);
System.out.println("请输入年份(注: 必须大于 1990 年):");
int year = sc.nextInt();
System.out.println("请输入月份:");
int month = sc.nextInt();

3）根据用户输入的年份，判断该年份是闰年还是平年，其实现代码如下：

boolean isRen;
if((year%4==0 && year%100!=0)||(year%400==0)) {
    System.out.println(year+"闰年");
    isRen = true;
} else {
    System.out.println(year+"平年");
    isRen = false;
}

4）根据用户输入的月份，判断该月的天数，其实现代码如下：

int day = 0;
switch(month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        day = 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        day = 30;
        break;
    default:
        if(isRen) {
            day = 29;
        } else {
            day = 28;
        }
        break;
}
System.out.println(year+"年"+month+"月共有"+day+"天");

5）该程序代码执行结果如下所示：

请输入年份(注: 必须大于 1990 年):
2014
请输入月份:
2
2014平年
2014年2月共有28天

请输入年份(注: 必须大于 1990 年):
2000
请输入月份:
2
2000闰年
2000年2月共有29天

2.5、总结

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转。

如果 main 方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。这意味着：如果没有流程控制，Java 方法里的语句是一个顺序执行流，从上向下依次执行每条语句。

不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。

Java 同样提供了这两种流程控制结构的语法，Java 提供了 if 和 switch 两种分支语句，并提供了 while、do while 和 for 三种循环语句。一般写循环语句时，分以下三步走：

定义初始值
设置判断条件
初始值变化

除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、数组的元素。

Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：

break：表示跳出当前层循环
continue：表示跳出本次循环，进入下一次循环
return：跳出当前方法的循环

当在实现某个功能语句时，如果需要通过某一个条件去判断，则用选择结构。当实现某个功能需要通过循环去实现，则用循环结构。当然循环和选择是可以相互嵌套的。

The desire of his soul is the prophecy of his fate
你灵魂的欲望，是你命运的先知。