在讲解流程控制语句之前，我们先来说一下语句的问题。Java中的语句分为声明和赋值语句，条件和循环语句，调用和返回语句；我们之所以每两个放在一起是有深意的，我们大致将语句分为这三块，并以此为纲来说一下，重点在流程控制语句（条件和循环语句）。
程序就是由一系列的声明、赋值、条件、循环、调用和返回语句组成的。一般来说代码的结果都是嵌套的：一个条件或循环语句中也可以嵌套条件语句或循环语句。而一个函数中可以由若干各种语句组成，若干的函数组成类，正式这样的组合才形成了功能丰富的软件。下面我们从声明和赋值语句讲起；
1.1 声明与赋值语句
声明语句将一个变量名和一个类型在编译时关联起来。Java需要我们在声明语句的时候指定变量的名称和类型。这样我们才能清楚的明白能够对其进行的操作。Java是一种强类型语言，因为Java编译器会检查类型的一致性（例如，它不会允许boolean类型和浮点类型的变量相乘）。变量可以声明在第一次使用之前的任何地方，一般我们会在首次使用时声明它，变量的作用域就是定义它的地方（成员或局部），一般由相同代码段中声明之后的所有语句组成。
赋值语句（由一个表达式定义的）将某个数据类型的值（可以是具体值，也可以是一个引用）和一个变量关联起来。在Java中，我们进行赋值操作，我们表达的不是数学中的等于“=”，而是将一个地址与该变量名绑定，让该变量名指向这个内存地址。
package cn.assignment;
public class Test {
//声明语句由数据类型与变量名称构成，--这里的数据类型可以是基本数据类型，也可以是引用类型--对象
static int i;
/*int ii;
ii = 89;*///不允许在赋值语句声明完后再赋值，要在一起操作,但是可以成员声明,函数中进行赋值的操作
static int a1;
public static void main(String[] args) {
i = 23;
System.out.println(i);//23
System.out.println(a1 = 90);//90
}
}我们在开发中往往建议将声明和赋值放在一起操作，即声明的同时给语句赋值。
1.2 调用和返回语句
我们对Java最大的印象只怕就在面向对象了，我们写的所有类的最大作用就是在于为有需要的类提供可供解决的方法。这就是调用的的思想。例如我们写一个加法的运算，那么以后凡是遇到加法的运算，那么就都可以通过调用这个方法来解决了，这就是调用的思想，而有些方法是具有返回值的，返回值的语句是返回语句；举例如下：
//简单的加法运算
public static int add(int a,int b){
return a+b;//返回语句
}
通过上面我们发现语句并不固定于单类型语句的使用，而是花样百出的嵌套，组合使用，这也是高级编程语言的灵活所在。在返回语句中我们发现有一个关键字return，这里我们不多做介绍，我们放在流程语句和continue和break一起介绍。
1.3 流程控制语句
了解完声明和赋值语句、调用和返回语句，那么我们就进入今天的重头戏--流程控制语句了，我们在本节中会叙述流程控制语句的功能，同时还会附以案例加强，最后会深入探讨流程控制语句。
做任何事情都要遵循一定的原则。例如，到图书馆去借书，就必须有借书证，并且借书证不能过期，这两个条件缺一不可。程序设计也是如此，需要有流程控制语言来实现与用户的交流，并根据用户的输入决定程序要“做什么”、“怎么做”等。
流程控制语言对于任何一门编程语言来说都是至关重要的，它提供了控制程序步骤的基本手段。如果没有流程控制语句，整个程序将按照线性的顺序来执行，不能根据用户的输入来决定执行的序列。我们大略的将流程控制语句分为以下这么几类，复合语句、条件语句、循环语句。需要说明的一点是Java的控制流程结构与C、C++的控制流程结构一样，只有很少的例外情况。没有goto语句，但是通过break+标签，可以实现从内层跳出的目的，另外，JDK1.5提供了一种变形的for循环，这是在C、C++中没有出现过的。类似于C#中的foreach循环。
1.3.1 复合语句
与C语言及其它语言相同，Java语言的复合语句是以整个区块为单位的语句，所以又称块（block）语句。块是指由一堆大括号括起来的若干条简单的Java语句。块语句以整个块为单位，可以用在任何一个单独语句可以用到的地方，块确定了变量的作用域。一个块可以嵌套在另一个块中。在前面的学习中已经解触到了这种块语句。例如在定义一个类或方法时，类体就是以“{}”作为开始与结束的标记，方法体同样也是以“{}”作为标记。对于块语句中的每个语句都是从上到下的执行。
在使用复合语句时特别要注意，复合语句为局部变量创建一个作用域，该作用域为程序的一部分，在该作用域中某个变量被创建并能够被使用，如果某个变量的作用域外使用该变量，则会发生错误。同时，不能在嵌套的两个块中声明同名的变量，这也是不被允许的。
【例5.1】创建CompoundStatementPractice类，进行复合语句的一些验证；
class CompoundStatementPractice{
public static void main(String[] args){
int a = 23 ;
System.out.println("a的值是:"+a);
{
int b = 24 , c = 25 ;
System.out.println("b的值是:"+b);
boolean boo ; //我们一定要注意变量的作用域,也就是它的生命周期
{
boo = b > c ;
System.out.println("复合语句中的嵌套语句:"+boo);
}
// int a = 20 ; 如果在main方法中已经声明成员变量,复合语句中再次声明相同名字的成员变量会出现错误
a = a++ + 1 ;
}
//System.out.println("在变量的作用域外使用变量会出现错误:"+b); 会提示找不到符号
System.out.println("我们一定要注意变量的作用域,和语句的线性顺序:"+a);
}
}
1.3.2 条件语句
条件语句可根据不同的条件执行不同的语句。条件语句包括if条件语句和switch多分支语句。
1.3.2.1 if条件语句
If条件语句是一个重要的编程语句，它用于告诉程序在某个条件成立的情况下执行某段程序，而在另一种情况下执行另外的语句。
使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回的结果是true，则执行其后的语句；若为false，则不执行if条件之后的语句。If条件语句可分为简单的if条件语句、if...else语句和if...else if多分支语句。if语句在开发过程中可能会出现Dead Code情况,我们平时可能较少遇到,但是要知道这种情况,并且明白这是编译器多做的优化.
1.3.2.1.1 简单的if语句
语法格式如下：
if(布尔表达式){
语句序列
}- 布尔表达式：必要参数，表示它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，或者使用关系或布尔运算符的表达式。
- 语句序列：可选参数。可以是一条或多条语句，当表达式为true时执行这些语句。如果语句序列中仅含有一条语句，则可以省略条件表达语句中的大括号。如果我们自己编程时书写了大括号，同时语句序列中只有一条语句，那么编译器在编译时会自动帮我们去除大括号。
【例5.2】创建IfPractice类，进行简单if条件语句的练习
class IfPractice{
public static void main(String[] args){
int a = 23 , b = 24 ;
boolean boo = true ,aoo = false ;
if(! false == boo || (5 == 6)){
System.out.println("表达式的形式可以多样但其结果必须为boolean类型");
}
if(5 == 6);{
System.out.println("如果if条件语句后即()后直接跟;则该条if简单语句语句无论是否成立都继续下面代码");
}
if(a < b){
if( a < b){
System.out.println("If语句可以像复合语句一样嵌套语句!");
}
System.out.println("简单if语句的标准形态;");
}
if(aoo) System.out.println("简单if语句序列中若只有一条语句则可以省略{}这时并无语法错误,并且if语句的作用范围也可覆盖,但不支持,为了增强阅读性");
System.out.println("if语句若省略{},那么其作用范围只是紧随其后的一条语句,其他的语句会线性执行,不会受其表达式的影响!");
if(boo){}//当简单if语句序列中没有内容时可以省略{},末尾加;,当然也可以保留,
if(a < b && boo){
System.out.println("简单if语句中的条件一定要是布尔表达式,也就是结果必须是布尔型,格式不限制");
}
/*if(3 = 3){
System.out.println("我们一定要确定if语句条件表达式的数据类型,如上3是int型,结果也是int型,会爆出错误以外的类型");
}*/
}
}
| If语句注意点： a,每一种格式都是单条语句。 b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。 c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false; D.if语句同复合语句一样可以嵌套语句 |
If语句流程运行图：
|
1.3.2.1.2 if...else语句
| If....else语句和三元运算符的区别 |
If ....else语句的执行行程图 |
| 对于if...else语句可以使用三元运算符对语句进行简化,如下面的代码 if(a > 0) b = a ; else b = -a; 可以简化成: b = a>0?a:-a ；上面代码为求绝对值的语句，如果a > 0，就把a的值赋给b,否则将-a赋值给b。也就是“？”前面的表达式为真，则将问号和冒号之间的表达式的计算结果赋值给变量b，否则将冒号后面的计算结果赋值给b，使用三元运算符的好处是可以使代码简洁，并且有一个返回值。 |
图3.4 if...else语句的执行过程图 |
在第一种简单if语句中条件不成立时if语句不能给出任何反馈,这是出现了第二种if语句当条件表达式的结果为true则执行语句1,否则执行语句2.
注意事项:
A.else没有条件表达式
B.else必须和if组合使用,else不能单独使用会报错
C.一个if语句只能有一个else
else是可以省略的,当知道条件表达式成立时,可以省略else,这时就相当于1.1if语句
if语句和else联合使用时,if如果控制多行语句就一定要加{},否则出现B错误,这时情况为if语句+输出语句+else,B情况产生,如果if控制一行else控制一行时大括号能省,这时如果条件表达式为true则进行紧挨if语句的输出,反之输出else,当if控制一行else控制多行时如果条件表达式为true则进行紧挨if语句的输出,else中输出除去紧挨else的语句 反之else中输出,所以Java中不管什么情况不要省略{},避免错误
【例5.3】创建IfElsePractice类，并针对if....else的一些特性进行验证
class IfElsePractice{
public static void main(String[] args){
/*else{
System.out.println("else必须和if语句连用,不能单独使用,否则会错误,有'if',但是没有'else'");
}*/
if(5 > 6){
System.out.println("我们可以看到简单if语句条件不成立时,if语句不能出现任何反馈,那么我们怎么知道是条件不成立还是程序错误呢,这时就出现了if...else语句");
}
if(5 > 6){
System.out.println("为补充if语句而出现的if...else语句");
}else/*(5 < 6)*/{
System.out.println("if...else语句中else语句后不能有条件语句直接跟随{},如果跟随(),会发出错误,提示在()后加;");
}/*else{
System.out.println("一个if语句只能和一个else语句连用,否则会错误,有'if',但是没有'else'");
}*/
if(5 < 6){
System.out.println("当if后面只控制一条语句时,可以省略{},它会直接输出,否则不支持,因为它只会输出紧跟他的一条");
}else{
System.out.println("当else后面只控制一条语句时,可以省略{},它会直接输出,否则不支持,因为它只会输出紧跟他的一条");
}
/*if(5 > 6)
System.out.println("{}省略"); 当if...else...语句中，if后边控制多条语句时，{}不可
以省略，否则会报错“有if没有else”
System.out.println("{}省略");
else{
System.out.println("{}省略时,");
}*/
//嵌套语句在if...else语句中的应用
if(true){
if(false){
System.out.println("嵌套语句在if...else中的使用");
}else{
System.out.println("嵌套语句在if...else中的使用");
}
}else{
System.out.println("嵌套语句在if...else中的使用");
}
/*三元运算符和if...else语句的区别,
If--else语句与三元运算符的区别:三元运算符运算完要有值出现。好处是：可以写在其他表达式中,而if----else语句则没有这种限制,但是可以写在其他方法中,不能写在表达式中*/
//求 a的绝对值和b的和
int a = 7 , b = 3 , sum ;
if(a > 0){
System.out.println("您所求的两个数的和为:"+(a+b));
}else
System.out.println("您所求的数的绝对值为:"+(-a+b));
sum = (a > 0 ? a : (-a))+b;
System.out.println("您所求的两个数的和为:"+sum);
}
}
面试题：问下面一段代码是否会正常输出?
if(5 > 6)
System.out.println("{}省略”);
System.out.println("{}省略");
else{
System.out.println("{}省略时,");
}答:不会,代码会出现错误,当代码判断条件语句不成立时,会自动跳过紧跟他的一条语句,这是它的作用范围,然后编译下一条代码,这时因为没有发现else,会将他认为是简单if语句,再往下执行时发现了else语句,这是编译会将其作为不合法代码跳出”错误:有’if’没有’else’”
1.3.2.1.3 if...else if语句
注意事项:
- A.else if必须和if组合使用，else if语句末尾可以（意味着非必须）是一条单独的else语句
- B.else不能有条件表达式
- C.我们if语句第三种格式,任何一个条件表达式成立,if语句直接结束.
【例5.4】创建IfElseIfPractice类，进行对IfElseIf语句的特性进行一些验证
class IfElseIfPractice{
public static void main(String[] args){
if(false){
System.out.println("1");
}else if(false){
System.out.println("2");
}else if(true){//当发现if条件语句为true时,只执行这条语句,其他的就不再执行,
System.out.println("3");//跳出这个if..else..if语句,执行其他程序
}else if(true){
System.out.println("4");
}else{
System.out.println("5");
}
}
}
1.3.2.1.4 if条件语句练习
【例5.5】学生考试成绩出来了请对其进行划分等级,要求90--100 A等 80--89 B等 70--79 C等 60--69 D等 60分以下 叫家长,谈人生
分析：我们初看到这道题目时，要注意这么几点
- 考试成绩大于等于0小于等于100,所以我们要考虑输入错误的情况!
- 由于成绩是一个变量，所以这里我们需要一个变量来代表这个成绩
- 等级对于成绩来说是一个区间，并且这是一个条件语句，所以我们需要应用到比较运算符，和逻辑运算符。
- 由于我们在这里需要比较很多区间，所以我们需要考虑用哪种语句，在这里很明显选择第三种if语句
class GradePractice{
public static void main(String[] args){
int score = 178 ;
if(score <= 100 && score >= 90){
System.out.println("您的成绩是:"+score+",相对应的成绩等级为:A等");
}else if(score < 90 && score >= 80){
System.out.println("您的成绩是:"+score+",相对应的成绩等级为:B等");
}else if(score < 80 && score >= 70){
System.out.println("您的成绩是:"+score+",相对应的成绩等级为:C等");
}else if(score < 70 && score >= 60){
System.out.println("您的成绩是:"+score+",相对应的成绩等级为:D等");
}else if(score >=0 && score < 60){
System.out.println("您的成绩是:"+score+",叫家长,谈人生!");
}else{
System.out.println("成绩输入错误请检查后重新输入!");
}
}
}
【例5.6】给出月份,判断它所处的季节 3-5 春季 6-8 夏季 9-11 秋季 12-2 冬季
分析：我们首先来看需求
- 首先我们需要定义一个变量来代表月份，我们用这个变量来在区间中比较；
- 第二这个变量要符合我们的要求，即大于等于1，小于等于12，所以我们要考虑输入错误的情况；
- 第三我们要选择合适的语句，在这里我们有很多种方法，下面一一介绍
方法一：一个个比较,使用简单if语句。
class SeasonPractice1{
public static void main(String[] args){
int month = 9 ; //声明一个代表月份的变量
if( month == 1){
System.out.println("这个月份属于冬季!");
}
......
if( month == 3){
System.out.println("这个月份属于春季!");
}
......
if( month == 6){
System.out.println("这个月份属于夏季!");
}
......
if( month == 9){
System.out.println("这个月份属于秋季!");
}
......
if( month == 12){
System.out.println("这个月份属于冬季!");
}else{
System.out.println("您输入的数据储存在问题,请检查后重新输入!");
}
}
}
方法2：使用逻辑运算符加上if语句。
class SeasonPractice2{
public static void main(String[] args){
int month = 2 ;
if(month == 12 || month == 1 || month == 2){
System.out.println("这个月份属于冬季!");
//我们在这里使用if...else.if语句,需要明白语句的一个特性当有else.if语句为真时即跳出语句不再进行if.else语句,进行其他语句
}else if(month == 3 || month == 4 || month == 5){
System.out.println("这个月份属于冬季!");
}else if(month == 6 || month == 7 || month == 8){
System.out.println("这个月份属于冬季!");
}else if(month == 9 || month == 10 || month == 11){
System.out.println("这个月份属于冬季!");
}else {
System.out.println("对不起,您输入的数据存在问题,请检查后重新输入!");
}
}
}
方法三：使用比较运算符,逻辑运算符和if语句；
class SeasonPractice3{
public static void main(String[] args){
int month = 17 ;
if(month == 1 || month == 2 || month == 12){
System.out.println("这个月份属于冬季!");
}else if(month >= 3 && month <= 5){
System.out.println("这个月份属于春季!");
}else if(month >= 6 && month <= 8){
System.out.println("这个月份属于夏季!");
}else if(month >= 9 && month <= 11){
System.out.println("这个月份属于秋季!");
}else{
System.out.print("对不起,您输入的数据错误,请检查后重新输入!");
}
}
}
方法四：精简代码，从上面的三种方法我们可以看出代码的相同性有这么几点，（变量的判断比较，结果的输出，逻辑运算符的运用），我们将这相同的几点进行精简如下！
class SeasonLastPractice{
public static void main(String[] args){
int month = 7 ;
String str ;
if(month == 1 || month == 2 || month == 12){
str = "这个月份属于冬季!";
}else if(month >= 3 && month <= 5){
str = "这个月份属于春季!";
}else if(month >= 6 && month <= 8){
str = "这个月份属于夏季!";
}else if(month >= 9 && month <= 11){
str = "这个月份属于秋季!";
}else{
str = "对不起,您输入的数据错误,请检查后重新输入!";
}
System.out.print(str);
}
}【例5.7】比较三个数的大小(if语句的嵌套使用)
package cn.if_else;
public class ComparePractice {
public static void main(String[] args) {
test(7, 7, 7);
test(1, 2, 3);
test(2, 1, 3);
test(3, 2, 1);
test(1, 3, 2);
}
public static void test(int a,int b,int c){
if(a>=b){
if(b>=c)
System.out.println("这三个数的大小为:"+"a>=b>=c");
else if (a>=c) {
System.out.println("这三个数的大小为:"+"a>=c>b");
}else {
System.out.println("这三个数的大小为:"+"c>a>=b");
}
}else {
if(b<=c)
System.out.println("这三个数的大小为:"+"a<b<=c");
else if(a<=c){
System.out.println("这三个数的大小为:"+"a<=c<b");
}else {
System.out.println("z这三个数的大小为:"+"c<a<b");
}
}
}
}
【例5.8】求三个数中的最值；（这里本人做出了一种测试，实际可以有多重方法，不一一赘述，详细的可以参见CSDN的一篇文章，代码赘述在下面）
package cn.if_else;
public class MaxPractice {
public static void main(String[] args){
max(7, 6, 9);
min(7, 6, 9);
}
public void test(){
int a = 2 , b = 8 , c = 6 , max = 0;
//如果只是求最大值,那么我们只用拿出大的那个值同最后一个值比较
if(a > b){
if(a > c){
max = a ;
}else{
max = c ;
}
}else{
if(b > c){
max = b ;
}else{
max = c ;
}
}
System.out.print("三个数的最大值为:"+max);
}
/**
* 求最大值
*/
public static void max(int a,int b,int c){
if(a>=b&&a>=c)
System.out.println("最大值为:"+"a");
else if (c>=b&&c>=a) {
System.out.println("最大值为:"+"c");
}else if(b>=a&&b>=c) {
System.out.println("最大值为:"+"b");
}
}
/**
* 求最小值
*/
public static void min(int a,int b,int c){
if(a<=b&&a<=c){
System.out.println("最小值为:"+"a");
}else if (b<=a&&b<=c) {
System.out.println("最小值为:"+"b");
}else if (c<=a&&c<=b) {
System.out.println("最小值为:"+"c");
}
}
}
1、if语句嵌套
int a = 10;
int b = 30;
int c = 20;
int max;
if (a > b) {
if (a > c) {
max = a;
} else {
max = c;
}
} else {
if (b > c) {
max = b;
} else {
max = c;
}
}
2、if语句
int a = 10;
int b = 30;
int c = 20;
int max;
if (a > b) {
max = a;
} else {
max = b;
}
if (max < c) {
max = c;
}
3、if语句（假定a最大，b,c与a比较，如果比a大，则赋值给max）
int a = 10;
int b = 30;
int c = 20;
int max = a;
if (b > max) {
max = b;
}
if (c > max) {
max = c;
}
4、三元运算符
int a = 10;
int b = 30;
int c = 20;
int max = (a > b) ? a : b;
max = (max > c) ? max : c;
或者
int max = ((a > b ? a : b) > c) ? (a > b ? a : b) : c;（建议不用这种）
5、if语句 + 逻辑运算符 &&（a,b,c三个数，如果不是a最大，或者b最大，就是c最大）
int a = 10;
int b = 30;
int c = 20;
int max;
if (a > b && a > c) {
max = a;
} else if (c > a && c > b) {
max = c;
} else
max = b;1.3.3 选择语句
在JDK 1.6及以前的版本中，switch语句中表达式的值必须是整型或字符型，常量值1~n必须也是整型或字符型，但是在JDK 1.7中，switch语句的表达式的值除了整型和字符型，还可以是字符串类型，这是JDK1.7 新添的特性。
switch语句:
- A.当我们看到switch的时候,这就是一个选择语句
- B.表达式:是一个常量或者变量,byte,short,int,char,所以case取值其实与表达式的类型一致
- jdk1.5以后支持枚举， jdk1.7以后支持String
- C.case:表示的就是一个选项,取值就是选项的值
- D.执行语句:功能代码.
- E.break:switch语句的结束符.
- F.default:默认值,相当于if语句的else
【例5.9】根据指定的日期（1~7），输出相应的星期；
class SwitchWeekPractice{
public static void main(String[] args){
int day = 9 ;
switch(day){
default: //若没有一个常量的值与表达式的值相同则默认执行default,
System.out.println("请检验您的输入数字是否正确!");
//如果没有发现break,则继续执行下面的case语句直到发现break
case 1:
System.out.println("根据您输入的数字可以确定是:星期一");
break;
/*default: 一个switch语句中只能有一个default,否则会提示标签重复
System.out.println("请检验您的输入数字是否正确!");*/
case 2:
System.out.println("根据您输入的数字可以确定是:星期二");
break;
case 3:
System.out.println("根据您输入的数字可以确定是:星期三");
break;
case 4:
System.out.println("根据您输入的数字可以确定是:星期四");
break;
case 5:
System.out.println("根据您输入的数字可以确定是:星期五");
break;
case 6:
System.out.println("根据您输入的数字可以确定是:星期六");
break;
case 7:
System.out.println("根据您输入的数字可以确定是:星期日");
break;
}
}
}
Switch语句的执行过程：
【例5.10】根据输入的城市名字，查询出城市所在的省；
class ProvincePractice{
public static void main(String[] args){
String str = "洛阳";
switch(str){
case "石家庄":
System.out.println("这是河北省会;");
break;
case "济南":
System.out.println("这是山东省会;");
break;
case "郑州":
System.out.println("这是河南省会;");
break;
case "洛阳":
System.out.println("这是河南地级市;");
break;
default:
System.out.println("对不起您所查找的城市在数据库中没有发现,请检查后输入!");
}
}
}
【例5.11】根据给定的月份，判断所属的季节；冬季（12,1,2）春季（3，4，5）夏季（6，7，8）秋季（9,10,11）
class SwitchMonthPractice{
public static void main(String[] args){
int month = 9 ;
String str = "";
switch(month){
//运用Switch的省略,将break适当省略,将共性放在一处源代码
case 1:
str = "冬季";
case 2:
str = "冬季";
case 12:
str = "冬季";
break;
case 3:
str = "春季";
case 4:
str = "春季";
case 5:
str = "春季";
break;
case 6:
str = "夏季";
case 7:
str = "夏季";
case 8:
str = "夏季";
break;
case 9:
str = "秋季";
case 10:
str = "秋季";
case 11:
str = "秋季";
break;
default:
System.out.println("请检查您所输入的数字是否在范围中!");
}
System.out.print("根据您所输入的月份判断季节为:"+str);
}
}
总结：选择语句的功能通过判断语句也是可以实现的，实际上这两个语句在功能上相似，但是在进行选择操作时，switch语句能够更加清楚明了，我们在进行多项选择操作的时候，且具有明确的选择项，那么switch是个很好的选择，但往往我们在程序中并没有明了的选择项，所以if语句是常见的操作。
1.3.4 循环语句
注意：循环语句是和if语句一样常见的语句，需要重点关注一下；
1.3.4.1 while循环
【例5.12】将1到100的所有奇数都打印出来，并对他们进行求和运算；
分析：首先我们要明白这是一个累加的运算，我们在代码中涉及到的是两个变量，奇数和累加的和；对于奇数，我们对他的判断应该是除2取余为1,下面我们通过代码来分析；
class OddPractice{
public static void main(String[] args){
int i = 0 ,sum = 0; //定义一个代表1到100的变量和奇数和的变量
while(i <= 100){
if(i%2==1){
System.out.print(i+"、");
sum += i;
}
i++;//省略的话死循环,因为i值不变while后边的条件表达式永远为真
}
System.out.println("我们所求的奇数和为:"+sum);
}
}
While语句的执行过程
下面再看一个例子，计算多长时间能够存储一定数量的退休金，假定的是每年存入相同数量的金额，而且利率是固定的。
package cn.while_statement;
import java.util.Scanner;
/**
* 例子来源于 Java核心技术_卷1
* @author Yorick
* @date 2018年3月5日
* @ver 1.0
*/
public class Retirement {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("让你退休需要多少钱:");
//目标钱
double goal = in.nextDouble();
System.out.println("每年你准备存多少钱:");
double payment = in.nextDouble();
System.out.println("年利率%:");
double interestRate = in.nextDouble();
//账户余额
double balance = 0;
//需要时间-年
int years = 0;
while (balance < goal) {
balance += payment;
double interest = balance * interestRate/100;
balance += interest;
years++;
}
System.out.println("你可以在几年后退休:"+years+"years.");
}
}
1.3.4.2 do...while循环
【例5.13】比较while和do...while;
class CompareWhilePractice{
public static void main(String[] args){
int a = 100 , b = 100 ;
//鲜明的比较while和do...while的区别
while(a == 60){
System.out.println("Ok"+a);
a--;
}
do{
System.out.println("Ok"+b);
b--;
}while(b == 60);
}
}
我们对while循环中的退休金问题进行改编，首先计算账户余额，然后询问是否要退休；
package cn.while_statement;
import java.util.Scanner;
public class Retirement2 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("你每年要存多少钱:");
double payment = in.nextDouble();
System.out.println("年利率%:");
double interestRate = in.nextDouble();
double balance = 0;
int year = 0;
String input;
do {
balance += payment;
double interest = balance*interestRate/100;
balance += interest;
year++;
System.out.printf("After year %d,your balance is %,.2f%n",year,balance);
System.out.println("Ready to retire?(Y/N)");
input = in.next();
} while (input.equals("N"));//不退休就继续循环
}
}
1.3.4.3 for循环
1.3.4.3.1 for语句
小结：
- 关键字:for
- 固定格式:for(初始化表达式(3);循环条件表达式(1);循环后的操作表达式(4))(2){执行语句(5)}
- 运行顺序: 循环条件为true时 3--1--5--4--1--5
循环条件为false时 3--1 当循环条件为false时,循环终止
注意事项:
- 1、变量作用域问题：
-
- 如果后边要使用这个变量，需要定义在for循环前
- 如果后边不使用这个变量，需要定义在for循环中
- 变量作用域在一对大括号之间，两个嵌套的for循环中不能声明同名的变量，两个独立的for循环中可以声明同名的变量，但是注意仍然遵循块嵌套。
- 第一个表达式可以放置在循环体前，可以为空
- 第三个表达式可以放置在循环体中，可以为空
- 第二个表达式可以为空，不报错，但是为死循环。除非特殊业务或算法需求，否则不会出现该种情况
- 尽管Java允许在for循环的各个部分放置任何表达式，但是有一条不成文的规矩：for循环的三个部分应该对同一个计数器变量进行初始化、检查和更新。若不遵循这一规则，编写的循环可能晦涩难懂。
- 循环中对两个浮点数进行判断要格外小心，浮点数的操作，存在舍入的误差，可能得不到精确值，如：for(double x = 0; x != 10;x += 0.1)[x将从9.99999999999998跳到10.09999999999998]
【例5.14】计算1到100相加的和；
class SumPractice{
public static void main(String[] args){
int sum = 0;
for(int i = 1;i<101;i++){
sum += i;
}
System.out.println("1到100的累计相加的和为:"+sum);
}
}
注意：在编程时，有时会使用for循环的特殊语法格式来实现无限循环，语法格式为：
For（；；）{
......
}
对于这种无限循环可以通过break语句跳出循环，例如：
For（；；）{
If(i<20){
System.out.println(“无限循环”);
}
Break；
}package cn.for_test;
public class Test {
public static void main(String[] args) {
int i = 20;
for (; ; i++) {
if(i > 25){
System.out.println("通过break关键字跳出死循环!" + "--i = " + i);
break;
}
}
}
}
我们在这里,看一个抽奖的问题,这是for循环的典型示例.这个程序用来计算抽奖中奖的概率。例如，如果从1~50之间的数字中取6个数字来抽奖，那么会有（50*49*48*47*46*45）/（1*2*3*4*5*6）种可能的结果，所以中奖的几率是1/15890700。一般情况下，如果从n个数字中抽取k个数字,可以使用下列公式得到结果:
n*(n-1)*(n-2)*...*(n-k+1)/{1*2*3*...*k}
下面我们通过for循环来实现一下：
package cn.for_test;
import java.util.Scanner;
public class LotteryOdds {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("有多少个数字需要抽取:");
int k = in.nextInt();
System.out.println("你能抽到的最大的数字:");
int n = in.nextInt();
int lotteryOdds = 1;
//注意循环不能从0开始,应该从1开始,这是因为除数不能为0,所以这里i = 1
/*for (int i = 0; i < k; i++) {*/
for (int i = 1; i <= k; i++) {
lotteryOdds = lotteryOdds*(n - i + 1)/i;
}
System.out.println("Your odds are 1 in" + lotteryOdds + ". Good luck");
}
}
1.3.4.3.2 foreach语句
foreach语句是for语句的特殊简化版本，foreach语句并不能完全取代for语句，然而任何foreach语句都可以改为for语句版本。foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为foreach语句。foreach语句在遍历数组等方面为程序员提供了很大方便（在数组中我们将会讲到）。foreach语句也叫增强for循环，增强for循环是for的一种新用法！用来循环遍历数组和集合。编译器在编译时会将加强for转换为底层迭代操作，外观上看起来增强了for的语法,实际上是通过迭代器来实现的。关于foreach循环我们在这里不多做介绍，我会在一篇文章“扒掉foreach的外衣中详细探讨foreach的底层运作”！
语法格式如下
for（元素变量x:遍历对象 obj）{
引用了x的Java语句；
}x的值从数组的第一个元素一直到最后一个元素！
foreach语句中的元素变量x，不必对其进行初始化。下面通过一个小例子来说明；
【例5.15】创建一个一维数组，对其进行遍历，通过两种for循环；
public class Repetition{
public static void main(String args[]){
int arr[] = {1,2,3,4,5};
System.out.print("数组中的元素为：");
/*标准for循环
for(int i = 0;i<5;i++){
System.out.print(arr[i]+",");
}*/
for(int x:arr){
System.out.print(x+",");
//foreach语句，元素变量x为遍历数组的元素值
}
}
}
增强for的冒号左边是定义变量，右边必须是数组或集合类型。例如上例中循环遍历的arr这个int数组，增强for内部会依次把arr中的元素赋给变量i。
| 增强for * 1. 只是语法简单了一点点！ * 2. 它没有老for增大！ 特点： * 1. 只能遍历数组、集合... * 2. 在遍历时不能使用下标 * 3. 遍历只能从头到尾 * 4. 对数组和集合只能做读操作，不能做写操作！ 语法： * 1. for(元素类型 变量名 : 集合或数组对象) * 2. 每次循环，获取一个数组中的元素给左边的变量了。 增强for到底可以遍历什么： * 1. 可以遍历任何的实现了Iterable接口的实例 * 2. 增强for底层是Iterator |
1.3.4.4 循环语句小结
为了完成重复的事情，我们通常要使用循环来完成需求
| 3.1 while循环 3.2 do while 3.3 for循环 While语句格式 do{执行语句} for(初始化表达式;循环 条件表达式;循 While(条件表达式){ while(条件表达式); 环后的操作表达式){ 执行语句 } 执行语句 } |
for条件相对复杂，但是最常用,while/do while 简单易懂--具有明确的判断条件时使用
Do while循环较少使用
循环需要的内容：
1、循环条件----循环条件表达式 如果没有循环条件就会一直循环下去----存在死循环现象
2、循环体：执行语句----循环执行的代码语句
3、循环变量定义并初始化-----初始化表达式
4、循环变量的变化情况----循环后的操作表达式
如果已经可以判断出循环次数的话，使用for循环比较方便，如果不知道循环次数使用while循环比较合适。for循环只不过是while循环的一个简化形式。注意的一点是多线程中我们使用while，而不建议使用if，这个稍后在多线程中介绍。
1.3.4.5 循环语句的练习
【例5.15】将1到100中的偶数打印出来，并且对他们进行求和；
class EvenPractice{
public static void main(String[] args){
int sum = 0;
for(int i=1;i<101;i++){
if(i%2==0){
System.out.print(i+"、");
sum += i;
}
}
System.out.println("1到100的所有偶数的和为:"+sum);
}
}
对比【例5.12】while语法计算奇数和
【例5.16】珠峰高度8848m , 一张纸厚度为0.1mm ,判断将一张纸对折多少次可以达到珠峰高度，但不超过珠峰高度,并输出打印对折次数,以及对折后的纸的厚度!分别使用For循环和While循环
class PaperPractice{
public static void main(String[] args){
int x = 88480000 , y = 1 ;//定义珠峰高度和纸的厚度
int n = 0 ;//用n来表示折叠的次数
/*for(;y<=x;n++){ //for循环的运行顺序: 没有折叠时n=0,纸的厚度小于珠峰高度,纸的厚度乘2加倍,折叠次数加1,此时代表折叠了一次
y = y*2; //折叠到倒数第2次时,纸的厚度小于珠峰高度,此时继续循环,纸的厚度超出珠峰高度,次数也会比实际需求大1
}*/
/*while(y<=x){
n++; //在原有折叠次数上再折叠一次
y = y * 2 ; //折叠一次后纸的厚度翻倍
}*/
do{
y=y*2;
n++;
}while(y<=x);
System.out.println("折叠"+n+"次后纸的厚度为:"+y);
System.out.println("折叠的倒数第二次纸的厚度是:"+y/2);
}
}
分析：当我们折叠第一次时，n为1，厚度翻倍，当折叠到倒数第二次时，折叠后，此时纸的厚度仍小于珠峰高度，仍然满足循环条件，此时会再循环一次，但循环后纸的厚度超过珠峰高度，循环停止，所以如果我们求纸折叠多少次才能达到珠峰高度时，并不超过时，应该为最后得到的折叠次数减去1。另外观察我们也可以发现对于不知道循环次数的循环我们使用while循环比较容易理解！
【例5.17】给出一个整数，计算出它的阶乘；使用for和while循环
分析：阶乘：正整数阶乘指从 1 乘以 2 乘以 3 乘以 4 一直乘到所要求的数
class FactorialPractice{
public static void main(String[] args){
int x = 12 ;//定义一个我们要阶乘的数
int p = 1;//定义一个阶乘后的结果,由于是从1开始,所以我们将它定义为1
int y=1;//定义一个乘法的开始数字
/*for(;y<=x;y++){
p = p*y;
}*/
while(y<=x){
p = p*y;
y++;
}
System.out.println("我们所求的阶乘是:"+p);
}
} 
【例5.18】规则图形的打印，打印一个给定行数和给定列数的规则图形；
class FigurePractice{
public static void main(String[] args){
//打印一个给定行数给定列数的规则图形(行高9,列数12)
int line = 9 , list = 12;
for(int x=1;x<=line;x++){
//行的循环里嵌套了列的循环换
for(int y=1;y<=list;y++){
System.out.print("* ");
}
//列尾我们要注意换行
System.out.println("");
}
//打印一个直角三角形
for(int x=0;x<5;x++){
for(int q=0;q<=x;q++){
System.out.print("* ");
}
System.out.println("");
}
//打印一个倒立的正三角,实际上就是打印一个空格三角形和另一个三角形
for(int y=5;y>0;y--){//定义正三角形的边长,正三角形的边长和它的行数相同
for(int s=5;s>y;s--){//打印空格的循环和打印*的循环要注意先后,打印空格实际上就是打印一个直角三角形
System.out.print(" ");
}
for(int z=y;z>0;z--){
System.out.print("* ");
}
System.out.println("");
}
//另一种方法
int last = 5;
for(int y=0;y<last;y++){
for(int q=0;q<y;q++){
System.out.print(" ");
}
for(int z=y;z<last;z++){
System.out.print("* ");
}
System.out.println("");
}
//打印一个由数字构成的正三角形
for(int i=1;i<10;i++){
for(int j=1;j<10-i;j++){//最多的前面有八个空格
System.out.print(" ");
}
for(int j=i;j>0;j--){//数字的打印我们分两部分,第一部分从i倒序到1
System.out.print(j);
}
for(int j=1;j<i;j++){//第二部分从2打印当i
System.out.print(j+1);
}
System.out.println("");
}
}
}
【例5.19】打印一个正九九乘法表和一个倒立的九九乘法表
class TablePractice{
public static void main(String[] args){
for(int x=1;x<10;x++){ //我们要注意这和大三角形的思想是一致的,但是我们要打出来的是一些字符串的链接,
for(int y=1;y<=x;y++){//并且这些链接中包含两个变量
System.out.print(y+"*"+x+"="+x*y+" ");
}
System.out.println("");
}
for(int x=9;x>0;x--){
for(int y=1;y<=x;y++){
System.out.print(y+"*"+x+"="+x*y+" ");
}
System.out.println("");
}
}
}
【例5.20】有一对兔子,从第三个月开始产小兔子,每个月产一对,小兔子在第三个月也开始生小兔子,假设无意外情况,20个月后有多少只小兔子
分析:发现规律,做如下计算:
第一个月有兔子1对,第二个月有兔子1对,第三个月有兔子2对,第四个月有兔子3对,第五个月有兔子5对,第六个月有兔子8对......从上面我们可以看到有这么个规律“从第三个月开始腿子的对数是前两个月的兔子对数之和”，
由此我们可以对所求兔子对数进行一个规律运算；
变量分析：
通过上面的规律我们可以得出对于兔子对数我们需要3个变量，即第一个月兔子对数M1，第二个月兔子对数M2，第三个月兔子对数M3，M3=M1+M2；除此之外我们需要一个月份的变量，者用于循环；
class RabbitPractice{
public static void main(String[] args){
int M1 = 1 ,M2 = 1 ,M3 = 2 ;
//通过规律我们从第三个月开始按照规律差计算
for(int month=3;month<=20;month++){
M3 = M1 + M2;//通过前两个月兔子对数计算出第三个与兔子对数
M1 = M2; //此时向下循环的话,最早的第二个月变成了现在的第一个月,
M2 = M3; //第三个月变成了第二个月,再下次循环中的第三个月就是前两个月之和
}
System.out.print("20个月后我们共有兔子"+M3+"对;");
}
}
【例5.21】要求一个五位数个位=万位 十位=千位 个位+十位+万位+千位=百位
分析：我们从上面题目中分析出来当给定我们一个五位数时我们应该求出这个五位数的个十百千万位，然后进行运算，以一段代码为例：
int a = 98765;
System.out.println("这个数的个位是"+a%10);//整数%10,得到个位数
System.out.println("这个数的十位数是"+a/10%10);//除以10得到的结果,十位数变成了个位数,按照上面求出所需结果
System.out.println("这个数的百位数是"+a/10/10%10);
System.out.println("这个数的千位数是"+a/10/10/10%10);
System.out.println("这个数的万位数是"+a/10/10/10/10%10);从上面我们得出了个十百千位的算法，那么我们就可以在循环中进行判断，然后输出结果；我们在循环中最先开始比较的是最小的五位数直到最大的五位数；
class NumberPractice{
public static void main(String[] args){
int ud,td,hd,thd,md;//声明五个变量代表个十百千位
//System.out.print();
for(int num=10000;num<100000;num++){
ud = num%10;
td = num/10%10;
hd = num/10/10%10;
thd = num/10/10/10%10;
md = num/10/10/10/10%10;
//判断满足条件的数字
if(ud==md&&td==thd&&ud+md+td+thd==hd){
System.out.print(num+" ");
}
}
}
} 
【例5.22】水仙花问题；
1.什么是水仙花问题-----水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的n次幂之和等于它本身。
2.假定是一个三位数num,那么num%10得出的结果就是个位值g,num/10%10得出的结果就是十位值s,num/10/10%10得出的结果就是百位值b,根据需求,g*g*g+s*s*s+b*b*b==num
3.要了解什么是水仙花数，这样才能快速选择是用什么方式、方法，甚至算法来解决问题，在这里我们来计算一下4位数的水仙花问题；
class DaffodilPractice{
public static void main(String[] args){
int ud,td,hd,thd;//声明个十百千位
for(int num=1000;num<10000;num++){
ud=num%10;
td=num/10%10;
hd=num/10/10%10;
thd=num/10/10/10%10;
if(ud*ud*ud*ud+td*td*td*td+hd*hd*hd*hd+thd*thd*thd*thd==num){
System.out.print(num+" ");
}
}
}
}
【例5.23】打印一个空心菱形和一个实心菱形
分析:打印菱形我们知道,无非就是打印三角,那么打印空心菱形呢?我们是不是可以按照同样的思路来分析呢?我们可以将菱形分为打印直三角空格,打印星号,打印正三角空格,打印星号;
下面通过代码来实现;
package cn.practice;
public class Diamond {
public static void main(String[] args) {
fun1(9);
}
public static void fun1(int hangshu){
//根据行数判断循环次数,如果行数是奇数那么循环此数就是column/2+1,如果是偶数,那么空心菱形只能打印奇数,要做出提示
int yiban = hangshu / 2 + 1;
int yibanduo = hangshu / 2;
if(hangshu%2==1){
System.out.println("空心菱形：");
for(int k = 1;k <= yiban;k++){
for(int i = 1;i <= (yiban - k);i++){
System.out.print(" ");
}
System.out.print("*");
for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){
System.out.print(" ");
}
if(k != 1){
System.out.print("*");
}
System.out.println();
}
for(int k = yibanduo;k >=1;k--){
for(int i = 1;i <= (yiban - k);i++){
System.out.print(" ");
}
System.out.print("*");
for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){
System.out.print(" ");
}
if(k != 1){
System.out.print("*");
}
System.out.println();
}
System.out.println("实心菱形：");
for(int i = 1;i <= hangshu;i++){
if(i <= hangshu/2 + 1){
for(int k = 1;k <= hangshu/2 + 1- i;k++){
System.out.print(" ");
}
for(int k = 1;k <= i;k++){
System.out.print("* ");
}
System.out.println();
}else{
for(int k =1;k <= (i -(hangshu/2 + 1));k++){
System.out.print(" ");
}
for(int k = 1;k <= (2 *(hangshu/2 + 1) - i);k++){
System.out.print("* ");
}
System.out.println();
}
}
}else {
System.out.println("对不起,空心菱形行数应该为大于0的奇数,请确认输出!");
}
}
}
【例5.24】打印杨辉三角；
分析:在代码实现之前我们先来看一下什么是杨辉三角,
杨辉三角，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的优美结合。实现结果如下图所示:
分析:杨辉三角的规则是:每一行的第一个值为1,每一行的最后一个值为1,当前数=上一行的数+上一行的数的前一个数;明白了规则我们就来分析一下,我们看杨慧三角是不是很像一个二维数组呢?数组的长度为列数,二维数组中角标0对应的是一个长度为1的数组,二维数组角标1对应的是一个长度为2的数组;根据这个我们下面来通过代码实现;
package cn.practice;
public class YangHui {
public static void main(String[] args) {
fun1(8);
}
/**
* 杨慧三角:
* 1.每行的头一个数是1;
* 2.每行的最后一个数是1;
* 3.当前数是上一行的数+其前一个数
*/
public static void fun1(int column){
/*创建二维数组,来作为杨慧三角中的元素的容器,二维数组的长度是杨慧三角的列数,
* 二维数组中的一维数组的长度是当前行的元素个数+空格数*/
int[][] intArr = new int[column][column];
for (int i = 0; i < intArr.length; i++) {
//动态开辟空间,每一行的空间大小和行号是相同的
intArr[i] = new int[i+1];
}
//为数组填充元素
for (int i = 0; i < intArr.length; i++) {
//每一行第一个是1,最后一个也是1
intArr[i][0] = 1;
intArr[i][i] = 1;
//注意杨慧三角的运算是从第二行开始的
for (int j = 1; j < i; j++) {
//当前数是上一行的数+其前一个数,实际上只有到了第三行才会运算
intArr[i][j] = intArr[i-1][j]+intArr[i-1][j-1];
}
}
//循环过滤
for (int j = 0; j < intArr.length; j++) {
for (int j2 = 0; j2 < intArr[j].length; j2++) {
System.out.print(intArr[j][j2]+"\t");
}
//打印完一行换行
System.out.println();
}
}
}
1.3.5 条件语句在计算机中的操作
我们知道冯诺依曼提出的存储程序概念要求顺序执行程序,可如果所有的程序都按步照班的一条条的顺序执行,那么就缺少了用户交互,程序缺少了灵活性,所以出现了流程控制语句,那么程序在计算机中的执行又有什么不同了呢?这其实就牵涉到了程序计数器,下面我们通过了解程序计数器来了解一下"顺序执行";
当程序转移时(即流程控制语句)，转移指令执行的最终结果就是要改变PC的值，此PC值就是转去的目 标地址。处理器总是按照PC 指向取指、译码、执行，以此实现了程序转移。
1.4 break、continue和循环标号&&return
Java语句除了流程控制语句用于跳转外,还提供了3中跳转语句，分别是break语句、continue语句和return语句。下面对这三种跳转语句进行详细介绍。
1.4.1 break
break语句我们应该都不会陌生,在介绍switch语句时已经应用过了。在switch语句中，break语句用于终止下面case语句的比较。实际上，break语句还可以应用在for、while和do...while循环语句,用于强行退出循环块，也就是忽略循环块体中任何其他语句和循环条件的限制。
break关键字它的常见作用在于跳出当前循环(即break所在的循环,如果存在for(){for(){break;}},那么break只是跳出内存循环,外层循环继续;)，应用范围为循环语句，选择语句。
【例5.25】计算1到100的所有偶数的和，要求当和大于250时跳出，并输出这个和；
class SumDemoPractice{
public static void main(String[] args){
int sum = 0 , i=1; for(;i<101;i++){ if(i%2==0){ sum+=i; } //当和大于250时，break语句跳出循环, if(sum>250){ break; } } //最后一次的相加和已经大于了250,在下面的输出中会体现出来 System.out.print("从1到"+i+"的偶数相加的和为:"+sum); } } 
1.4.2 continue
Continue语句只能应用在for、while和do...while循环语句中，用于让程序直接跳过其后面的语句进行下一次循环。Continue关键字作用是跳出当前循环进行下次循环，整个循环不结束,那么break和continue有什么不同呢?下面我们来对比一下:
- 这两个语句离开应用范围，存在是没有意义的。
- 这两个语句单独存在下面都不可以有语句，因为执行不到。
- Continue语句是结束本次循环执行下次循环，break是结束循环体进行循环后面的语句。
- 标号的出现，可以让这两个语句作用于指定的范围。
- Break只能用于循环和switch语句，continue使用于循环，普通函数这两个关键字不适用。
【例5.25】打印出1到20中的所有奇数，但是13被认为是一个不吉祥的数，不打印
class SumDemo1Practice{
public static void main(String[] args){ int sum = 0 , i = 0; while(i<=20){ i++; if(i%2==1){ if(i==13) continue; System.out.print(i+" "); } } } }
1.4.3 循环标号
Break和continue跳转语句它的作用范围仅在当前循环，那么如果多层循环中我们想break跳出指定循环该怎么操作呢？这时就引出了标号的概念；标号是为循环起一个名字，或者叫做为循环做一个标记，可以通过break 标记达到直接跳出该标记循环的目的,注意标号是需要":"和循环在一起使用的。下面我们举例说明；
【例5.26】打印一个矩形*；
class RectanglePractice{
public static void main(String[] args){ int a = 4 , b = 5 ; for(int i=1;i<=a;i++){ for(int j=1;j<=b;j++){ System.out.print("*"); } System.out.println(""); } } }
打印一个矩形*，当出现一行里超过第三个*时，打印结束；
class RectanglePractice{
public static void main(String[] args){ int a = 4 , b = 5 ; out:for(int i=1;i<=a;i++){ inner:for(int j=1;j<=b;j++){ System.out.print("*"); if(j==3){ //当j==3时,它打印的是第三颗*,此时跳出循环,但他跳出的只是内循环, //我们如何跳出外循环呢,这时就用到了标号,为循环标号,跳出标号循环 break out; } } System.out.println(""); } } } 
1.4.4 return
return关键字有两个功能：1是结束函数，2是返回（值会对象）。有返回值的return和返回内容构成返回语句，如果没有返回值，那么就仅仅是停止该函数。return 语句可以使其从当前方法中退出，返回到调用该方法的语句处，继续程序的执行。返回语句有两种格式。
* return expression: 返回一个值给调用该方法的语句，返回值的数据类型必须与方法声明中的返回值类型一致。可以使用强制类型转换来使类型一致。 =
* return: 当方法说明中用 void 声明返回类型为空时，应使用这种格式不返回任何值。 此时return是可以省略的。
return语句通常用在一个方法体的最后，以退出该方法并返回一个值。在Java语言中，单独的return语句用在一个方法体的中间时，会产生编译错误【return语句后面不能有代码】，因为这样会有一些语句执行不到。但可以通过把return语句嵌入某些语句（如 if…else）来使程序在未执行完方法中的所有语句时退出，例如：
void method(int iVar){
if( iVar>0 ){ return; 怪蜀黍 }else{ System.out.println(iVar); } } Java中的return语句使用总结
1、return语句的作用：a、返回一个值，这个值可以是任意类型。b、使程序返回到操作系统（即终止程序）
2、java中对于一个函数，不论有没有返回值类型，都可以带有return 语句。但是区别在于，return语句是否可以返回一个值（这取决于该函数的返回值类型）。
a、如果函数有返回值类型（即返回值类型不为void ），则必须带有返回相应类型值的return 语句。
b、如果函数没有返回值（即返回值类型为void ），则函数中return 语句（如果存在return语句！）的后面不能加任何的变量。（该情况下的函数中也可以没有return 语句，但是如果有的话，return 只能作为返回操作系统的作用使用。）
例如：
1、有返回值
public int getAge(){
return age; //返回int 类型的变量age的值 }2、无返回值 //函数不带return 语句
public void putAge(){
System.out.println(age);
}3、返回到操作系统
//函数无返回值，但是带有return语句public void put(int a) {
if (a > 0)
return; //return语句后不带返回值，作用是退出该程序的运行
else
System.out.println("fasfsa");
} 1.5 总结
我们本节内容进行到了这里,也就进行到了尾声,关于语句总结了很多,其中大部分是例子,对于一些例子.初始写的时候需要思考,再次看的时候,仍不能很快又思路,所以都贴了出来,可以以后随时看看,本节内容也较为浅显,但是用于学习使用已经是可以了,望各位阅读者,不吝指教,共同进步!
来源：oschina
链接：https://my.oschina.net/u/4261075/blog/4250842