企业官网建设流程全解析

目录

顺序结构

分支语句

if-else条件判断结构

基础语法

结构1:单分支条件判断:if

执行流程:

结构2：双分支条件判断：if...else

格式:

执行流程

结构3：多分支条件判断：if...else if...else

说明:

执行流程:

典型案例:

建议:

if...else嵌套

执行的特点：

典型案例:

Scanner的使用

流程:

例子:

获取一个随机数

swith-case选择结构

基本语法

语法结构

执行过程：

使用注意点：

例子:春夏秋冬

if-else语句与switch-case语句比较

循环语句

解释:

分类:

for循环

基本语法

格式:

说明:

执行过程:

经典代码:

小结：

whle循环

基本语法

格式

执行过程:1-2-3-4-2-3-4-...-2

说明:

经验案例:

do-while循环语句

基础语法

格式:

执行过程:

图示

说明：

案例:

三种循环结构的对比

都具有四个要素：

从循环次数角度分析

如何选择

"无限"循环结构

语法格式：

适用场景：

经典代码:

嵌套循环(或多重循环)

使用说明

技巧：

开发经验：

例如:

经典案例:

关键字break和continue的使用

break和continue的说明

带标签的使用

经典案例

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

程序设计中规定的三种流程结构，即：

顺序结构：

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

分支结构：

• 根据条件，选择性地执行某段代码。

• 有if…else和switch-case两种分支语句。

逻辑结构：

• 根据循环条件，重复性的执行某段代码。

• 有for、while、do-while三种循环语句。

• 补充：JDK5.0 提供了foreach循环，方便的遍历集合、数组元素

顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

例子如下：

public class StatementTest{ public static void main(String[] args){ int x = 1; int y = 2; System.out.println("x = " + x); System.out.println("y = " + y); //对x、y的值进行修改 x++; y = 2 * x + y; x = x * 10; System.out.println("x = " + x); System.out.println("y = " + y); } }

注意：由上到下和由左到右的执行命令，如果有未申明的变量，就不执行不了。也就是Java中定义变量时采用合法的前向引用。

分支语句

if-else条件判断结构

基础语法

结构1:单分支条件判断:if

格式:

if(条件表达式){

语句块;

}

说明:条件表达式必须是布尔表达式（关系表达式或逻辑表达式)或布尔变量。

执行流程:

1.首先判断条件表达式看其结构是true还是false

2.如果是true就执行语句块

3.如果是false就不执行语句块

结构2：双分支条件判断：if...else

格式:

if(条件表达式) {
语句块1;
}else {
语句块2;
}

执行流程

1. 首先判断条件表达式看其结果是true还是false

2. 如果是true就执行语句块1

3. 如果是false就执行语句块2

结构3：多分支条件判断：if...else if...else

if (条件表达式1) {
语句块1;
} else if (条件表达式2) {
语句块2;
}
...
}else if (条件表达式n) {
语句块n;
} else {
语句块n+1;
}

说明:

一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构。

执行流程:

1. 首先判断关系表达式1看其结果是true还是false

2. 如果是true就执行语句块1，然后结束当前多分支

3. 如果是false就继续判断关系表达式2看其结果是true还是false

4. 如果是true就执行语句块2，然后结束当前多分支

5. 如果是false就继续判断关系表达式…看其结果是true还是false

…

n. 如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支。

典型案例:

岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为(80，99]时，奖励一辆山地自行车；
当成绩为[60,80]时，奖励环球影城一日游；
其它时，胖揍一顿。

说明：默认成绩是在[0,100]范围内

public class IfElseTest3 { public static void main(String[] args) { int score = 67;//岳小鹏的期末成绩 //写法一：默认成绩范围为[0,100] if(score == 100){ System.out.println("奖励一辆跑车"); }else if(score > 80 && score <= 99){ //错误的写法：}else if(80 < score <= 99){ System.out.println("奖励一辆山地自行车"); }else if(score >= 60 && score <= 80){ System.out.println("奖励环球影城玩一日游"); } //else{ // System.out.println("胖揍一顿"); //} //写法二： // 默认成绩范围为[0,100] if(score == 100){ System.out.println("奖励一辆跑车"); }else if(score > 80){ System.out.println("奖励一辆山地自行车"); }else if(score >= 60){ System.out.println("奖励环球影城玩一日游"); }else{ System.out.println("胖揍一顿"); } } }

上述的两种写法,可以看出如下结论:

建议:

当条件表达式之间是“互斥”关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓。

当条件表达式之间是“包含”关系时，“小上大下 / 子上父下”，否则范围小的条件表达式将不可能被执行。

if...else嵌套

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构.

执行的特点：

（1）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件

（2）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

(3)语句块只有一条执行语句时，一对{}可以省略，但建议保留

(4)当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略

典型案例:

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

class IfElseTest4 { public static void main(String[] args) { //声明num1,num2,num3三个变量并赋值 int num1 = 23,num2 = 32,num3 = 12; if(num1 >= num2){ if(num3 >= num1) System.out.println(num2 + "-" + num1 + "-" + num3); else if(num3 <= num2) System.out.println(num3 + "-" + num2 + "-" + num1); else System.out.println(num2 + "-" + num3 + "-" + num1); }else{ //num1 < num2 if(num3 >= num2){ System.out.println(num1 + "-" + num2 + "-" + num3); }else if(num3 <= num1){ System.out.println(num3 + "-" + num1 + "-" + num2); }else{ System.out.println(num1 + "-" + num3 + "-" + num2); } } } }

交换法:

import java.util.Scanner; public class ThreeNumbersSorter1 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入第一个整数: "); int num1 = scanner.nextInt(); System.out.print("请输入第二个整数: "); int num2 = scanner.nextInt(); System.out.print("请输入第三个整数: "); int num3 = scanner.nextInt(); // 用于交换的临时变量 int temp; // 比较num1和num2，如果num1 > num2则交换 if (num1 > num2) { temp = num1; num1 = num2; num2 = temp; } // 比较num1和num3，如果num1 > num3则交换 if (num1 > num3) { temp = num1; num1 = num3; num3 = temp; } // 比较num2和num3，如果num2 > num3则交换 if (num2 > num3) { temp = num2; num2 = num3; num3 = temp; } System.out.println("从小到大排序结果: " + num1 + " " + num2 + " " + num3); scanner.close(); } }

类似交换法(找出最小数):

import java.util.Scanner; public class ThreeNumbersSorter3 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入第一个整数: "); int num1 = scanner.nextInt(); System.out.print("请输入第二个整数: "); int num2 = scanner.nextInt(); System.out.print("请输入第三个整数: "); int num3 = scanner.nextInt(); int min, mid, max; // 找出最小值 if (num1 <= num2 && num1 <= num3) { min = num1; } else if (num2 <= num1 && num2 <= num3) { min = num2; } else { min = num3; } // 找出最大值 if (num1 >= num2 && num1 >= num3) { max = num1; } else if (num2 >= num1 && num2 >= num3) { max = num2; } else { max = num3; } // 计算中间值 mid = num1 + num2 + num3 - min - max; System.out.println("从小到大排序结果: " + min + " " + mid + " " + max); scanner.close(); } }

Scanner的使用

流程:

1.导包import java.util.Scanner;

2.提供或者创建一个Scanner类的实例.

3.调用Scanner类中的方法,获取指定类型的值变量

4.关闭资源,调用Scanner类的close()

例子:

import java.util.Scanner;//调用Scanner public class ScannerTest { public static void main(String[] args) { Scanner scan=new Scanner(System.in);//定义一个变量为scan它由键盘输入 System.out.println("欢迎您登录网易天下"); System.out.print("请输入你的姓名"); String name =scan.next();//输入并获取 System.out.print("请输入您的年龄"); int age = scan.nextInt(); System.out.print("请输入您的性别"); String xb = scan.next(); System.out.print("请问您是否已婚,false or true:"); boolean single = scan.nextBoolean(); System.out.println("您的基本信息如下"); System.out.println("姓名为"+name);//输出结果 System.out.println("年龄为"+age); System.out.println("性别为"+xb); System.out.println("结婚状态"+single); scan.close(); } }

Scanner类中提供了获取byte\short\int\long \float \double \boolean \string类型变量的方法。
注意，没有提供获取char类型变量的方法。需要使用next().charAt(0);(获取变量首位),以及equal(相等,是否结婚如果定义变量为s,那就是 s.equal("是"); 就是判断与"是"是否相同,如果是是,就是true)

获取一个随机数

1.可以使用Java提供的API:Math类的random()

2.random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数

需求1:获取一个[0,100]范围的随机整数:

(int)(Math.random()*101

需求2:获取一个[1,100]范围的随机整数:

(int)(Math.random()*100+1

需求:获取一个[a,b]范围的随机整数?

(int)(Math.random()*(b-a+1)+a

swith-case选择结构

基本语法

语法结构

stith(表达式){

case 常量值1:

语句块1;

break;//也可能没有这个,具体按照实际编写.

case 常量值2:

语句块2;

break;//也可能没有这个,具体按照实际编写.

...

case 常量值n:

语句块n;

break;//也可能没有这个,具体按照实际编写.

[default:

语句块n+1;

break;

]

}

执行过程：

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后， ​

情况1：如果遇到break,则执行break并跳出当前的switch-case结构 ​

情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。--->case穿透​ ... ​ 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

使用注意点：

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

• case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；

• 同一个switch语句，所有case子句中的常量值互不相同；

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

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

• default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

例子:春夏秋冬

public class SwitchCaseTest2 { public static void main(String args[]) { 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("季节输入有误"); break; } } }

思维拓展,case的穿透案例:

class SwitchCaseTest3 { public static void main(String[] args) { int score = 67; /* 写法1：极不推荐 最笨的方法,将全部内容遍历一遍. switch(score){ case 0: System.out.println("不及格"); break; case 1: System.out.println("不及格"); break; //... case 60: System.out.println("及格"); break; //...略... } */ //写法2：整除10,只用十个选项,但还不够精简,却体现了是switch-case穿透的作用 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("输入的成绩有误"); break; } //写法3：发挥60这个关键,如果被60整除,那就是及格. switch(score / 60){ case 0: System.out.println("不及格"); break; case 1: System.out.println("及格"); break; default: System.out.println("输入的成绩有误"); break; } } }

if-else语句与switch-case语句比较

• 结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。

• 开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。

• 细节对比：

  • if-else语句优势

    • if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。

    • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。

  • switch语句优势

    • 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。

    • 使用switch可以利用穿透性，同时执行多个分支，而if...else没有穿透性。

循环语句

解释:

循环语句均有在某些条件满足的情况下,反复执行特定代码的功能.

分类:

for循环

while循环

do-while循环

for循环

基本语法

格式:

for(1初始条件部分;2循环条件部分;4迭代部分){

3循环体部分;

}

说明:

for(;;){}中的";"号是两个,不能多,也不能少.

1初始化部分可以声明多个变量,但必须是同一个类型,用逗号分隔.

2循环条件部分为boolean类型表达式,当值为false时,退出循环.

4可以有多个变量更新,用逗号分隔.

执行过程:

1-2-3-4-2-3-4-...-2

图示:

经典代码:

输出1000以内的水仙花数,并统计1000以内一共有几个水仙花数.

水仙花数的意思是,这个百位数等于其各个位上的数立方方后的综合,比如:153=1³+5³+3³

class Narcissistic { public static void main(String[] args) { int un, bai, shi, ge, a = 0; for (un = 100; un < 1000; un++) { bai = un / 100; shi = un / 10 % 10; ge = un % 10; if (un == (bai * bai * bai + shi * shi * shi + ge * ge * ge)) { System.out.println("水仙花数为:" + un); a++; } } System.out.println("1000以内的水仙花数共有:" + a + "个"); } }

案例二:

输入两个整数,求他们最大公约数和最小公倍数

import java.util.Scanner; class Masse { public static void main(String[] args) { Scanner scan =new Scanner(System.in); int a= scan.nextInt(); int b= scan.nextInt(); //最大公约数 int max = (a<b)?a:b; for(int d=max;d>=1;d--){ if(0==a%d && 0==b%d){ System.out.println("最大公约数为"+d); break; } } //最小公倍数 int min =(a>b)?a:b; for(int i =min;i<=a*b;i++){ if(i%a == 0 && i%b==0){ System.out.println("最大公倍数为"+i); break; } } scan.close(); } }

说明:我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。

小结：

如何结束一个循环结构？

结束情况1：循环结构中的循环条件部分返回false

结束情况2：循环结构中执行了break。

3、如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环。

whle循环

基本语法

格式

1初始化部分;

while(2循环条件部分){

3循环体部分;

4迭代部分;

}

执行过程:
1-2-3-4-2-3-4-...-2

图示

说明:

while(循环条件)中循环条件必须是boolean类型。

注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。

for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。

for循环与while循环的区别：初始化条件部分的作用域不同。

经验案例:

随机生成一个100以内的整数,用户随机输入一个数1-100的整数,看看用户通过几次猜中.

import java.util.Scanner; class GauseText1 { public static void main(String[] args) { int random = (int)(Math.random()*100)+1; System.out.println("请输入一个1-100的数字:"); Scanner scan = new Scanner(System.in); int b = scan.nextInt(); int a =1; while(random!=b){ if(random>b){ System.out.println("小了"); }else if(random<b){ System.out.println("大了"); } a++; System.out.println("请输入一个整数(1-100):"); b = scan.nextInt(); } System.out.println("一共采了"+a+"次数"); } }

do-while循环语句

基础语法

格式:

1初始化部分
do{

3循环部分

4迭代部分

}while(2循环条件);

执行过程:

1-3-2-4-2-3-4-2-3-4-...-2

图示

说明：

• 结尾while(循环条件)中循环条件必须是boolean类型

• do{}while();最后有一个分号

• do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

• 循环的三个结构for、while、do-while三者是可以相互转换的。

案例:

银行的操作界面

声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。

=========ATM========
1、存款
2、取款
3、显示余额
4、退出

用while循环

import java.util.Scanner; class Back { public static void main(String[] args) { double balance=0; Scanner scan = new Scanner(System.in); boolean isFlag =true; while(isFlag){ System.out.println("=========ATM========"); System.out.println("1、存款"); System.out.println(" 2、取款"); System.out.println(" 3、显示余额"); System.out.println("4、退出"); int selection = scan.nextInt(); switch( selection){ case 1: System.out.println("请输入存款金额:"); double addMoney=scan.nextDouble(); if(addMoney>0){ balance += addMoney; }else{ System.out.println("你的输入有问题,请重新选择:"); addMoney=scan.nextDouble(); } break; case 2: boolean withdrawComplete =false; while(!withdrawComplete){ System.out.println("请输入需要取款的金额(输入0返回主界面):"); double minusMoney=scan.nextDouble(); if(minusMoney==0){ break; }else if(minusMoney>0 && minusMoney<=balance){ balance -= minusMoney; }else if(minusMoney<0){ System.out.println("请重新输入(输入0返回主界面):"); }else{ System.out.println("您的余额不足,请重新输入(输入0返回主界面):"); } } break; case 3: System.out.println("你的可用余额为:"+balance); break; case 4: System.out.println("感谢您的使用,欢迎您的下次光临(￣▽￣)／"+balance); isFlag =false; break; default: System.out.println("你的输入有问题,请重新选择:"); break; } } scan.close(); } }

用do-while写:

import java.util.Scanner; class Back { public static void main(String[] args) { double balance = 0; Scanner scan = new Scanner(System.in); boolean isFlag = true; // 将外层循环改为 do-while do { System.out.println("=========ATM========"); System.out.println("1、存款"); System.out.println("2、取款"); System.out.println("3、显示余额"); System.out.println("4、退出"); System.out.print("请选择(1-4)："); int selection = scan.nextInt(); switch(selection) { case 1: System.out.println("请输入存款金额:"); double addMoney = scan.nextDouble(); if(addMoney > 0) { balance += addMoney; } else { System.out.println("你的输入有问题,请重新选择:"); addMoney = scan.nextDouble(); } break; case 2: boolean withdrawComplete = false; // 将内层取款循环也改为 do-while do { System.out.println("请输入需要取款的金额(输入0返回主界面):"); double minusMoney = scan.nextDouble(); if(minusMoney == 0) { withdrawComplete = true; } else if(minusMoney > 0 && minusMoney <= balance) { balance -= minusMoney; System.out.println("取款成功！当前余额为: " + balance); withdrawComplete = true; } else if(minusMoney < 0) { System.out.println("请重新输入(输入0返回主界面):"); } else { System.out.println("您的余额不足,请重新输入(输入0返回主界面):"); } } while(!withdrawComplete); break; case 3: System.out.println("你的可用余额为:" + balance); break; case 4: System.out.println("感谢您的使用,欢迎您的下次光临(￣▽￣)／"); isFlag = false; break; default: System.out.println("你的输入有问题,请重新选择:"); break; } } while(isFlag); // do-while 循环结束 scan.close(); } }

三种循环结构的对比

• 都具有四个要素：

  • 循环变量的初始化条件

  • 循环条件

  • 循环体语句块

  • 循环变量的修改的迭代表达式

• 从循环次数角度分析

  • do-while循环至少执行一次循环体语句。

  • for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。

• 如何选择

  • 遍历有明显的循环次数（范围）的需求，选择for循环

  • 遍历没有明显的循环次数（范围）的需求，选择while循环

  • 如果循环体语句块至少执行一次，可以考虑使用do-while循环

  • 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

"无限"循环结构

语法格式：

• 最简单"无限"循环格式：while(true),for(;;)

适用场景：

• 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。

• 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。

经典代码:

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

import java.util.Scanner; class PositiveNegative { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int positiveNumber = 0;//统计正数的个数 int negativeNumber = 0;//统计负数的个数 for(;;){ //while(true){ System.out.println("请输入一个整数：(输入为0时结束程序)"); int num = scanner.nextInt(); if(num > 0){ positiveNumber++; }else if(num < 0){ negativeNumber++; }else{ System.out.println("程序结束"); break; } } System.out.println("正数的个数为："+ positiveNumber); System.out.println("负数的个数为："+ negativeNumber); scanner.close(); } }

如果想用do-while也可以写,单这道题目更多的锻炼脑海中代码使用的灵活性.

第二种代码如下:

import java.util.Scanner; class PositiveNegative { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int positiveNumber = 0;//统计正数的个数 int negativeNumber = 0;//统计负数的个数 int num; do { System.out.println("请输入一个整数：(输入为0时结束程序)"); num = scanner.nextInt(); if(num > 0) { positiveNumber++; } else if(num < 0) { negativeNumber++; } else { System.out.println("程序结束"); } } while(num != 0); // 当输入不为0时继续循环 System.out.println("正数的个数为：" + positiveNumber); System.out.println("负数的个数为：" + negativeNumber); scanner.close(); } }

嵌套循环(或多重循环)

使用说明

• 所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。

  • 外层循环：循环结构A

  • 内层循环：循环结构B

• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。

• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

• 技巧：

• 从二维图形的角度看，外层循环控制行数，内层循环控制列数。

• 开发经验：

• 实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差.

• 例如:

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
循环体语句⑤;
}
}

//执行过程：① - ② - ③ - ④ - ⑤ - ⑥ - ④ - ⑤ - ⑥ - ... - ④ - ⑦ - ② - ③ - ④ - ⑤ - ⑥ - ④..

执行特点：外层循环执行一次，内层循环执行一轮。

经典案例:

九九乘法表:

class Multiplication { public static void main(String[] args) { for(int a = 1;a<=9;a ++){ for(int b = 1;b<=a; b++){ System.out.print(a +" *"+ b+" ="+a*b+" "); } System.out.println(" "); } } }

关键字break和continue的使用

break和continue的说明

适用范围 在循环结构中使用的作用 相同点

break switch-case
循环结构 一旦执行，就结束(或跳出)当前循环结构 此关键字的后面，不能声 明语句

continue 循环结构 一旦执行，就结束(或跳出)当次循环结构 此关键字的后面，不 能声明语句

此外，很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它，但使程序容易出错。Java中的break和continue是不同于goto的。

经典代码:

class BreakContinueTest1 { public static void main(String[] args) { for(int i = 1;i <= 10;i++){ if(i % 4 == 0){ //break;//123 continue;//123567910 //如下的语句不可能被执行，编译不通过 //System.out.println("今晚迪丽热巴要约我吃饭"); } System.out.print(i); } System.out.println("####"); //嵌套循环中的使用 for(int i = 1;i <= 4;i++){ for(int j = 1;j <= 10;j++){ if(j % 4 == 0){ //break; //结束的是包裹break关键字的最近的一层循环！ continue;//结束的是包裹break关键字的最近的一层循环的当次！ } System.out.print(j); } System.out.println(); } } }

带标签的使用

break语句用于终止某个语句块的执行 { …… break; …… } break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块 label1: { …… label2: { …… label3: { …… break label2; …… } } }

• continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环。

• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

• 举例：

class BreakContinueTest2 { public static void main(String[] args) { l:for(int i = 1;i <= 4;i++){ for(int j = 1;j <= 10;j++){ if(j % 4 == 0){ //break l; continue l; } System.out.print(j); } System.out.println(); } } }

经典案例

题目：找出100以内所有的素数（质数）？100000以内的呢？

目的：不同的代码的实现方式，可以效率差别很大。

分析：素数（质数）：只能被1和它本身整除的自然数。 ---> 从2开始，到这个数-1为止，此范围内没有这个数的约数。则此数是一个质数。 比如：2、3、5、7、11、13、17、19、23、...

实现方式1：

class PrimeNumberTest { public static void main(String[] args) { //boolean isFlag = true; //用于标识i是否被除尽过 long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数 int count = 0;//记录质数的个数 for(int i = 2;i <= 100000;i++){ //i boolean isFlag = true; //用于标识i是否被除尽过 for(int j = 2;j <= i - 1;j++){ if(i % j == 0){ //表明i有约数 isFlag = false; } } //判断i是否是质数 if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数 //System.out.println(i); count++; } //重置isFlag //isFlag = true; } long end = System.currentTimeMillis(); System.out.println("质数的个数为：" + count); System.out.println("执行此程序花费的毫秒数为：" + (end - start)); //16628 } }

实现方式2：针对实现方式1进行优化

class PrimeNumberTest1 { public static void main(String[] args) { long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数 int count = 0;//记录质数的个数 for(int i = 2;i <= 100000;i++){ //i boolean isFlag = true; //用于标识i是否被除尽过 for(int j = 2;j <= Math.sqrt(i);j++){ //优化2：将循环条件中的i改为Math.sqrt(i) if(i % j == 0){ //表明i有约数 isFlag = false; break;//优化1：主要针对非质数起作用 } } //判断i是否是质数 if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数 //System.out.println(i); count++; } } long end = System.currentTimeMillis(); System.out.println("质数的个数为：" + count); System.out.println("执行此程序花费的毫秒数为：" + (end - start));//1062 } }

实现方式3（选做）：使用continue + 标签

class PrimeNumberTest2 { public static void main(String[] args) { long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数 int count = 0;//记录质数的个数 label:for(int i = 2;i <= 100000;i++){ //i for(int j = 2;j <= Math.sqrt(i);j++){ //优化2：将循环条件中的i改为Math.sqrt(i) if(i % j == 0){ //表明i有约数 continue label; } } //一旦程序能执行到此位置，说明i就是一个质数 System.out.println(i); count++; } long end = System.currentTimeMillis(); System.out.println("质数的个数为：" + count); System.out.println("执行此程序花费的毫秒数为：" + (end - start));//1062 } }