语句的概念与基本语句
语句的概念
• Java 语句是 Java 标识符的集合，由关键字、常量、变量和表达式构成。
• 一个计算过程由一系列计算步骤组成，Java 语句用于描述计算步骤。
• 从功能角度，Java 语句分为基本语句、复合语句、控制结构语句、以及 package 语句和 import 语句等。
• 从程序执行的角度，Java 语句分为说明性语句和操作性语句。
Java的基本语句和块
• 空语句、标号语句、表达式语句、结构控制语句、break 语句、continue 语句、return 语句等。
• 空语句
- 空语句是只有一个分号的语句，单独一个分号被看作一个空语句
- 空语句不做任何事情
• 标号语句
- 语句可以由label前缀
- 通常和break语句或continue语句一起使用，用来控制程序流程跳转到哪个地方去执行。
• 表达式语句
- 某些类别的表达式，通过在它们后面加个分号，可以用作语句。
- 在赋值表达式、自增/自减表达式和方法调用表达式之后加上分号即变成语句，称为表达式语句。
块
• 块是放在大括号中的一系列语句、本地类声明和局部变量声明。
• 块有时也叫复合语句。
• 块是通过按它所包含的第一个到最后一个语句的顺序执行的。
• 尽管块含有任意多个语句，但从语法上讲，一个复合语句被看作是一个简单语句
• 块的大括号之后不需要分号标识语句的结束，因为}已经标识了。
一个块的例子：
package com.buptnu.demos;
public class Statement2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int x = 1, y = 2, temp;
{
temp = x;
x = y;
y = temp;
}
System.out.println(“x = “ + x);
System.out.println(“y = “ + y);
}
}
运行结果：
程序设计的三种基本结构
结构化程序设计方法推荐使用三种程序结构：顺序结构、分支结构和循环结构。在程序设计中，只需要使用这三种结构就能实现所有可计算任务。
控制语句
• 程序设计语言的每条语句都使程序执行一个相应的动作，它被直接翻译成一条或多条计算机可执行的指令。
• 语句有多种，其中的控制语句就是一个可以改变程序中语句执行顺序的命令语句。
• 顺序结构不用单独的控制语句，分之结构用选择语句（也叫分支语句）控制，循环结构用循环语句控制。
选择语句
选择语句为程序提供了分支结构。分支结构是这样一种控制机制，它根据条件值或表达式值的不同，选择不同的语句序列，其他与条件值或表达式值不匹配的语句序列则被跳过不执行。
• Java 用于分支结构的语句
- if 语句
- if … else 语句
- if … else …if 语句
- switch 语句
if 语句
if语句的语法结构如下：
if (条件表达式)
if语句提供了最简单的单分支结构。当条件表达式的值为true时，执行s1语句，否则就忽略s1语句，执行if语句的下一个语句。其中的s1语句，即可以是单一的一条语句，也可以是复合语句。
if语句的流程图如图所示。
一个if语句的例子：
package com.buptnu.sample;
public class IfStatment1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double d1 = 23.4;
double d2 = 35.1;
if (d1 >= d2)
System.out.println(d2+” >= “+d1);
System.out.println(“end”);
}
}
运行结果：
在分支结构中使用“块”
如果待选择的分支中有多条语句，怎么办？
package com.buptnu.demo;
public class IfStatment2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double d1 = 23.4;
double d2 = 35.1;
if (d1 >= d2)
{
System.out.println(d1);
System.out.println(d2);
System.out.println(d1+” >= “+d2);
}
System.out.println(“end”);
}
}
运行结果：
如果不使用“块”，会怎么样呢？像下面程序这样：
package com.buptnu.demo;
public class IfStatment2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double d1 = 23.4;
double d2 = 35.1;
if (d1 >= d2)
System.out.println(d1);
System.out.println(d2);
System.out.println(d1+” >= “+d2);
System.out.println(“end”);
}
}
请你尝试运行一下这个程序，观察程序运行结果，想一想为什么？
if…else语句
if…else语句的语法结构如下：
if (条件表达式)
s1 语句;
else
s2 语句;
If语句与else语句配套使用，形成二分之结构。当条件表达式的值为true，就执行s1语句，忽略else和s2语句；否则，条件表达式的值为false，程序忽略s1语句，执行else后面的s2语句。s1和s1都可以是复合语句。
if…else语句的流程图如图所示。
一个if…else语句的示例
package com.buptnu.sample;
public class IfStatement3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double d1=23.4;double d2=35.1;
if (d1>=d2)
System.out.println(d1+”>=”+d2);
else
System.out.println(d1+“<”+d2);
}
System.out.println(“end”);
}
例：已知三角形的三条边长 a，b，c，求三角形面积
package com.buptnu.sample;
public class IfStatment4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double a = 3.0, b = 4.0, c = 5.0;
double area;
if ((a + b > c) && (b + c > a) && (c + a > b))
{
double s;
s = (a + b + c)/ 2.0;
area = Math.sqrt(s (s - a) (s - b)*(s - c));
}
else
area = 0.0;
System.out.println(“area = “ + area);
}
}
if…else…if语句
if…else…if语句的语法结构如下：
if (条件表达式1)
s1语句;
else if (条件表达式2)
s2语句;
else if (条件表达式3)
s3语句;
else
s4语句;
if…else…if语句可以用来处理多分之结构。程序执行的时候，会依次计算条件表达式，如果某个条件表达式的值为true，就执行它后面的语句，其余的部分被忽略；如果所有的条件表达式的值都为false ，就执行最后一个else语句后的s4语句。
if…else语句的流程图如图所示。
一个if…else…if语句的示例
package com.buptnu.simple;
public class IfStatment5 {
public static void main(String[] args) {
int score = 78;
if (score >= 90)
System.out.println(“A”);
else if (score >= 80)
System.out.println(“B”);
else if (score >= 70)
System.out.println(“C”);
else if (score >= 60)
System.out.println(“D”);
else
System.out.println(“E”);
System.out.println(“END”);
}
}
switch 语句
虽然是用if_else_if语句可以实现多分之结构，但是在实际编程中更常用的是switch开关语句。
switch语句的语法结构如下：
switch （表达式）
{
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
……
default:
语句n;
}
结构解说：这个结构以关键字switch开始，后面跟有圆括号括起来的表达式，再后面是一个复合语句。该复合语句中包含两类java语句，一类是case语句，另一类是default语句。它们都称为switch语句的子句。在每个case语句之后，有一个break语句，这个break语句是可选的。
switch语句的执行过程如下：首先计算switch后面表达式的值，然后将表达式的值与各个case子句中的常量比较，如果表达式的值与某个常量相等，就执行该case语句中内嵌的语句。然后继续往下比较。如果对所有case语句中的常来量进行比较之后，没有与表达式的值相等的常量，则进入default分支，并执行其中的语句。
遇到break语句，退出switch结构，否则继续往后执行switch结构中的语句。
在执行任何一个case分支的时候，一旦遇到break语句，就退出switch开关语句。
使用开关语句的时候，要注意以下两个问题：
（1） case后面的常量必须是整数或字符型数据，而且不能有相同的值；
（2） 通常在每一个case分支中都使用一个break语句，提供一个出口，使流程跳出开关语句。否则，在第一个满足条件的case后面的所有语句都会被执行。
例：计算
例：分段函数求值。
package com.buptnu.sample;
public class SwitchStatement1 {
public static void main(String[] args) {
double x = 3.8;
double y = 0;
switch ((int)(x + 0.5))
{
case 1: y = Math.sin(x); break;
case 2:
case 3:
case 4: y = Math.log(x); break;
case 5:
case 6:
case 7: y = Math.exp(x); break;
default: System.out.println(“数据超出范围”);
}
System.out.println(“y = “ + y);
}
}
使用开关语句的时候，要注意以下两个问题：
(1)case后面的常量的类型必须限于char，int，short 和 byte，而且不能有相同的值
(2)通常在每一个case分支中都使用一个break语句，提供一个出口，使流程跳出开关语句。否则，在第一个满足条件的case后面的所有语句都会被执行
循环语句
• 程序的循环结构
- 循环结构是这样一种控制机制，它根据条件值或表达式值的不同，重复执行一些语句
• Java 中有三种循环语句
- while 语句
- do_while 语句
- for 语句
while 语句
while语句的语法结构如下：
while (条件表达式)
循环体
while循环语句的执行流程：
每次循环之前都要计算条件表达式的值，其值为真时，就执行一次循环体语句，然后在计算条件表达式，决定是否继续执行循环体语句，当条件表达式为假（false）时，跳出循环，执行循环体下面的语句。
一个while语句的示例：
package com.buptnu.sample;
public class WhileStatement {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 1, sum = 0;
while (i <= 3 ) {
sum += i; // sum = sum + i;
i++;
}
System.out.println(“sum = “ + sum);
}
}
运行结果：
执行过程：
| 第n次循环 | 变量的值 |
|---|---|
| 0（控制流进入循环之前） | i: 1 sum: 0 |
| 1 | sum: 1 i: 2 |
| 2 | sum: 3 i: 3 |
| 3 | sum: 6 i: 4 |
| 4 | sum: i: |
| （控制流转到循环之后的语句） |
do…while 语句
do_while语句的语法结构如下：
do {
循环体
} while (条件表达式);
do_while循环语句的执行流程：
先执行do下面的循环体，然后计算while后面表达式的值，如果为真（true），则重复执行循环体，否则就结束循环。
一个do…while语句的示例：
package com.buptnu.sample;
public class DoWhileStatement {
public static void main(String[] args) {
int i=1,sum=0;
do {
sum+=i;
i++;
} while(i<=3);
System.out.println(“1+2+3=”+sum);
}
}
运行结果：
执行过程：
| 第n次循环 | 变量的值 |
|---|---|
| 0（控制流进入循环之前） | i: 1 sum: 0 |
| 1 | sum: 1 i: 2 |
| 2 | sum: 3 i: 3 |
| 3 | sum: 6 i: 4 |
| 4 | sum: i: |
| （控制流转到循环之后的语句） |
for语句
for语句的语法结构如下：
for (表达式1;表达式2;表达式3)
循环体
其中，for是该语句的关键字。表达式1通常给循环变量赋初值；表达式2通常是一个循环条件；表达式3则通常是循环变量的增值。for语句中的循环体，可以是一个简单语句，也可以是一个复合语句。
for循环语句的执行流程：
1．第一次进入for循环时，计算表达式1，给循环变量赋初值。
2．然后计算表达式2，判断是循环条件是否为真，如果为真，就执行循环体；如果为假，就跳出循环体，执行for语句的下一条语句。
3．每次执行循环体语句之后，都要计算表达式3，对循环变量进行增值。然后在回到步骤2，重新判断循环条件，决定是否继续执行循环。
一个for语句的示例
运行结果：
执行过程：
| 第n次循环 | 变量的值 |
|---|---|
| 0（控制流进入循环之前） | i: ? sum: 0 |
| 1 | i: 1 sum: 1 i: 2 |
| 2 | i: 2 sum: 3 i: 3 |
| 3 | i: 3 sum: 6 i: 4 |
| 4 | i: 4 sum: i: |
| （控制流转到循环之后的语句） |
for 语句的特殊情况
• （1）表达式1，表达式2，表达式3都可以省略，即为空
- 表达式1省略的情况
例如：
int i,sum = 0;
i = 1;
for (;i<=10;i++)
sum+=i;
- 表达式2省略的情况
例如：
int i,sum = 0;
for (i = 1;;i++)
{
if (i > 10)
break;
sum += i;
}
- 表达式3省略的情况
例如：
int i,sum = 0;
for (i = 1; i <= 10;)
{
sum += i;
i++;
}
• （2）表达式1，表达式2，表达式3都可以包含多个子表达式
例如
int i, sum;
for (i = 1, sum = 0; i <= 10; i++)
sum += i;
• （3）允许在初始化部分（表达式1）对变量作声明
例如：
int sum = 0;
for (int i = 1; i <= 10; i++)
sum += i;
for语句中声明的变量是局部变量
这样可以吗？为什么？
package com.buptnu.demos;
public class ForStatement1 {
public static void main(String[] args) {
for (int i = 1, sum = 0; i <= 10; i++)
sum += i;
System.out.println(“1+2+…+10=”+sum);
}
}
不可以。for语句中声明的变量，其作用域范围是for语句范围，出了for语句范围就不能用了。
嵌套循环（多重循环）
嵌套循环是由一个外层循环和一个或多个内层循环组成的。
每当重复执行一次外层循环时，再次进入内部循环，然后重新开始。
一个嵌套循环的示例：
package com.buptnu.sample;
public class NestedLoops {
public static void main(String[] args) {
int i, j;
for (j = 1; j <= 9; j++) {
for (i = 1; i <= j; i++) {
System.out.print(i + ““ + j + “=” + (i j) + “ “);
}
System.out.print(“\n”);
}
}
}
运行结果：
循环结构中的break语句
break语句用于switch、while、do…while或for语句中。
break语句会将控制流转移到包含它的语句之外。
break语句在循环结构时，提供了一种方便的退出循环的方法。
它有两种形式：不带标号的break语句和带标号的break语句。
• 不带标号的break语句的格式是：
break;
• 带标号的break语句的格式是：
break BlockLabel;
不带标号的break语句可以退出当前的循环，并且从紧跟当前循环之后第一条语句开始执行。带标号的break语句可以让你退出多重嵌套循环。
一个不带标号的break语句的示例
运行结果：
带标号的break语句的用法：
标号应该加在你想中断的那个循环之前，同时在这个标号之后必须跟一个冒号（:）。例如
outer: for (int i=0;i<10;i++) {
inner: for (int j=0;j<10;j++) {
if （条件） {
......
break outer;
}
......
} // 内层循环结束
} // 外层循环结束
...... // 跳出后，从这里开始执行
在这个例子中，有两个标号，一个是outer。另一个是inner，在定义标号的时候都在标号的后面加了一个冒号（:），以说明它门是标号。当满足条件时，程序执行完相应的语句之后，遇到break outer语句，就会跳转到标有outer标号的循环，之后的语句开始执行。
循环结构中的continue语句
continue语句用于while、do…while或for语句中。
continue语句会将控制流转移到迭代语句（ while、do…while或for ）的循环持续点上。
continue语句只能用在循环结构中，它跳过循环体中尚未执行的语句，重新开始下一轮循环。
continue语句也分为不带标号的continue语句和带标号的continue语句两种。
• 不带标号的continue语句的格式是：
continue;
• 带标号的continue语句的格式是：
continue BlockLabel;
不带标号的continue语句的作用仅限于当前循环；而带标号的continue语句通常用在嵌套循环的内层循环中，它可以使程序跳到标号指明的外层循环中。
一个不带标号的continue语句的示例：
运行结果：
其它语句简介
• package语句
- 用于声明当前文件中定义的类和接口在某个程序包中
• import语句
- 用来引入所需要的某个程序包中的类
• return语句
- 将控制流返回给方法或构造器（Constructor）的调用者
- return语句用于方法的返回。当程序执行到return语句时，终止当前方法的执行，返回调用这个方法的语句。 return语句通常位于一个方法的方法体的最后一行。有带参数和不带参数的return语句两种形式。
- 不带参数的return语句的格式是：
return;
- 带参数的return语句的格式是：
return 表达式;
其中，表达式的值是方法的返回值。
• throw语句
- 会导致异常对象被抛出。其结果就是控制流会立即转移，直到找到可以捕获抛出值的try语句
• synchronized语句
- 会代表执行线程获取互斥锁、执行一个语句块，然后释放锁。当执行线程拥有锁时，其他任何线程都不可以获取该锁。
- synchronized语句获取的锁与synchronized方法隐式获取的锁相同。
- 简单说就是用于线程同步。
• try语句
- 用于执行一个语句块。
- try语句有一个或多个catch子句和一个finally子句。
- try中的被执行的语句块如果抛出了异常，且某些catch子句可以捕获该异常，则控制流转移到第一个这种catch子句上。
- 不管是否产生异常，finally子句总是被执行。
若有收获，就点个赞吧
0 人点赞
