1、运算符
1.1、运算符介绍
在生产、生活中，基本都会使用各种数据进行各种的运算、计算。而在Java语言中也有类似于生活中的各种计算和运算。下面就逐一来看看这些运算。
1.2、算术运算
Java中的算术运算符和生活中的数学运算基本相似。
1.2.1、算术运算符符号
1.2.2、算术运算符举例
在使用算术运算时需要注意运算两侧类型：当两侧类型不统一时，运算结果和较大类型保持一致。
class Demo
{
public static void main(String[] args)
{
int a = 3;
int b = 5;
int c = a + b; //加法运算
c = a * b; //乘法
c = a / b; //除法运算 结果为零 注意除法运算当两侧类型统一结果仍为运算数据保持一致
c = a % b; //取模运算 ，即求a/b的余值
}
}
思考：4321 / 1000 * 1000的结果？
1.2.3、算术运算符的注意问题
“+”除字符串相加功能外，还能把非字符串转换成字符串 。“+”运算符两侧的操作数中只要有一个String类型，一个是基本数据类型时，编译成class文件后，两个操作数就被连接成了一个新的String值。
思考：
1、m % 2 的结果是多少，你有什么启发？
2、System.out.println("5+5="+5+5);//打印结果是？
3、若要打印出“5+5”=10 ，上述代码怎么改？
1.2.4、自加自减
自加（++）自减（--）运算
++:自加。对原有的数据进行+1
--:自减。对原有的数据进行-1
当在一个运算表达式中包含自加运算时，当自加符号在变量右侧时，需要先将变量的值临时保存，然后给变量空间加1，接着用临时变量空间中的值去和其他运算符进行运算。当自加符号在变量左侧时，需要先给变量空间加1，然后把加1后的值和其他运算符进行运算。
class Demo
{
public static void main(String[] args)
{
int a = 4;
int b;
b = a++;
System.out.println("a="+a+",b="+b);
}
}
注意：自加自减运算单独存在时，放左放右是没有区别的。
思考：如下代码结果?
int i = 4;
i = i++;
System.out.println("i="+i);
1.3、赋值运算符
赋值运算符号：= , +=, -=, *=, /=, %=
赋值号的功能是将赋值号右侧的结果存储到左侧的变量空间中。
class Demo
{
public static void main(String[] args)
{
int a = 3 ; //将3存储到左侧a空间中
int b , c , d;
b = c = d = a; // 将a空间中的值分别存放到d，c，b 空间中
}
}
赋值号和算术运算符组合起来的混合运算符，它们即具有算术运算的特定，同时还具有赋值运算的特定。
class Demo
{
public static void main(String[] args)
{
int a = 4;
/*
相当于 a = a + 3;的运算，
即把a空间中的值和3进行加法运算，
把和值从新存放到a空间中
*/
a += 3;
}
}
注意：赋值号和算数运算符的混合运算属于一个运算符，不能拆分。并且这个符号会完成自动强转动作。
思考：以下代码有什么区别？
class Demo
{
public static void main(String[] args)
{
short s = 3;
s=s+2;
s+=2;
}
}
说明：
s=s+2//编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
s+=2//编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。
1.4、比较运算符
在生活中经常需要判断数据大小，相等不相等各种操作，在Java中同样也可以判断数据的大小。
比较运算符符号：
>大于 >=大于等于 <小于 <=小于等于 ==相等 !=不等
比较运算符运算完的结果要么true，要么false。后期学习中会根据比较的结果做出相应逻辑判断。
class Demo
{
public static void main(String[] args)
{
int a = 4;
int b = 5;
boolean c ;
c = a > b;
System.out.println(b);
}
}
注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。
1.5、逻辑运算符
当需要判断某些数据符合某个区间，比如人的年龄符合某一范围等。发现使用比较运算没法完成。Java给我们提供另外一直机制，逻辑运算。逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
1.5.1、逻辑运算符号
逻辑运算符：用来连接boolean型表达式的。
& : 与
| ：或
^ : 异或。
！：非。
&& 短路与 || 短路或
1.5.2、运算规律
class Demo
{
public static void main(String[] args)
{
int x = 7;
x>2 & x<5
x<2 | x>5
}
}
& ：两边都为true，结果是true。否则为false。两边只要有一个false。结果必然是false。
true & true = true;
true & false = false;
false & true = false;
false & false = false;
| ：两边都为false，结果是false。否则为true。两边只要有一个true。结果必然是true。
true | true = true;
true | false = true;
false | true = true;
false | false = false;
^ : 异或。两边相同为false。两边不同为true。
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
！：非：非真为假，非假为真
!true = false;
“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
1.6、位运算符
位运算：主要说的是二进制数位运算。
1.6.1、运算符符号
& 按位与运算 ，运算原则：相同二进制数位上数值为1，结果为1，否则结果为0；
3 & 5 先把 3和5以二进制表示，再进行按位于运算：
十进制 二进制 结果(十进制)
3 00000000_00000000_00000000_00000011
5 00000000_00000000_00000000_00000101
-------------------------------------------------------------------------------------------------
& : 00000000_00000000_00000000_00000001 1
所以3 & 5等于 1.
| 按位或运算，运算原则：相同二进制数位上数值为0，结果为0，否则结果为1；
3 | 5 先把 3和5以二进制表示，再进行按位于运算：
十进制 二进制 结果(十进制)
3 00000000_00000000_00000000_00000011
5 00000000_00000000_00000000_00000101
-----------------------------------------------------------------------------------------
| : 00000000_00000000_00000000_00000111 7
所以3 | 5等于 7.
2的0次方 + 2 的1次方 + 2的2次方 = 1 + 2 + 4 = 7
^ 按位异或，运算原则：参与运算的两个数相应位相同则结果为0，异号则为1；
十进制 二进制 结果(十进制)
3 00000000_00000000_00000000_00000011
5 00000000_00000000_00000000_00000101
-----------------------------------------------------------------------------------------
^ : 00000000_00000000_00000000_00000110 6
所以3 ^ 5等于 6.
~ 按位取反，运算原则：二进制数位上0变1，1变0；
十进制 二进制 结果(十进制)
5 00000000_00000000_00000000_00000101
-----------------------------------------------------------------------------------------
~ : 11111111_11111111_11111111_1111010 -6
所以~5等于 -6.
左移操作“<<”：将运算数的二进制码整体左移指定位数，左移之后的空使用“0”来补充，移出去的二进制数忽略不计。
9 << 2 :
十进制 二进制 结果(十进制)
9 00000000_00000000_00000000_00001001
-----------------------------------------------------------------------------------------
00000000_00000000_00000000_0000100100 36
所以9<<2等于 36.
规律：<<：相当于给原数乘以2的倍数
右移操作“>>”：将运算数的二进制码整体右移指定位数，右移之后的空使用“符号位”来补充。移出去的二进制数忽略不计。若是正数使用“0”补充；若是负数使用“1”补充；
9 >>2 :
十进制 二进制 结果(十进制)
9 00000000_00000000_00000000_00001001
-----------------------------------------------------------------------------------------
0000000000_00000000_00000000_00001001 2
所以9>>2等于 2.
规律：>>：相当于给原数除以2的倍数
-6 >> 2:
十进制 二进制 结果(十进制)
-6 11111111_11111111_11111111_1111010
-----------------------------------------------------------------------------------------
1111111111_11111111_11111111_1111010
所以-6>>2等于 -2.
无符号右移">>>"：将运算数的二进制码整体右移指定位数，右移之后的空使用“0”来补充
1.7、三元运算符
三元运算符，也称为三目运算符或问号冒号运算符。即有三个表达式参与的运算表达式。既然是个运算符，那么运算完必须有运算结果。
1.7.1、三元运算符的格式
(表达式1)?表达式2：表达式3；
1.7.2、三元运算符的运算原则
1）表达式1运算结果必须为boolean类型的值。
2）当表达式1的结果为true时，表达式2的运算结果就为整个三元运算符的结果。
3）当表达式1的结果为false时，表达式3的运算结果就为整个三元运算符的结果。
1.7.3、三元运算符举例
class Demo
{
public static void main(String[] args)
{
int x = 3 ;
int y ;
y = x < 10 ? 100 : 200;
System.out.println("y="+y);
}
}
使用三元运算符求两个数的最大值：
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int max ;
max = a < b ? b : a;
System.out.println("max="+max);
}
}
2、程序运行流程&顺序结构
什么是程序的流程呢？即就是代码的执行顺序。
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int sum ;
sum = a + b;
System.out.println("sum="+sum);
}
}
上述代码当在dos命令行中写入java Demo 回车之后，首先会启动JVM，JVM就会去加载当前Demo这个class文件，并执行其中的main方法。当程序执行main方法的时候会从第一行开始往下执行，直到整个代码全部执行完成。在此过程中程序按照书写的顺序，不会跳过任何一行代码。像这样的执行流程就是常见的顺序执行结构。
3、判断结构(if)
if是Java种的关键字，当程序在执行过程遇到if关键字，JVM就知道此处需要进行判断，根据判断结果需要处理相应的代码。
3.1、if判断第一种格式
if(条件表达式)
{
执行语句；
}
格式说明：if关键字后面是一对小括号，小括号后面是没有分号的，小括号中的表达式运算完的结果必须是boolean类型的值。
if流程控制执行顺序：JVM在执行代码时，遇到if关键字，首先会运算if括号中的表达式，当if中表达式的值为true时，就会执行if后面大括号中的语句。当if中表达式的值为false时，就会跳过if后面大括号中的语句，继续执行大括号下面的其他语句。
代码演示：
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
System.out.println("over");
}
}
3.2、if判断第二种格式
if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
执行说明：当if条件表达式为true时，执行if后面大括号中的语句，当if条件表达式为false时，执行else后面大括号中的语句。if-else格式组合成一条判断结构语句。要么执行if后面的语句，要么执行else后面的语句。切记，else后面的语句要能够执行，if中的条件表达式结果必须是false。
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
else
{
System.out.println("y小于等于4");
}
System.out.println("over");
}
}
3.3、三元运算符可以简化if-else格式
下面代码可以使用三元运算简化：
int a = 4 , b = 5;
int max;
if( a > b)
{
max = a;
}
else
{
max = b;
}
可以使用三元运算简化：
max = a > b ? a : b;
三元运算符是简写的if-else格式，简写是有弊端：不是所有的if-else都能简化，三元运算符运算完必须有结果，而if-else不一定运算完一定有运算结果。
3.4、if判断第三种格式
if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
class IfDemo
{
public static void main(String[] args)
{
int a = 3;
if( a > 1)
{
System.out.println("a");
}
else if( a > 2)
{
System.out.println("b");
}
else if( a > 3)
{
System.out.println("c");
}
else
{
System.out.println("d");
}
}
}
3.5、if练习
/*
需求：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
分析：
1、咋获取这个数值呢？来源有很多，不确定，只要是不确定的数据。都用变量存储。只要操作该变量即可。
2、数值不确定，如何显示对应的星期呢？那就需要对该数值进行判断。
3、咋显示呢？通过输出语句就可以显示在屏幕上。
*/
class IfTest
{
public static void main(String[] args)
{
//1，定义变量。记录数据。
int week = 9;
//2，通过判断结构语句if对该变量进行判断。
if(week == 1)
//3，根据不同的条件，通过输出语句显示不同的结果。
System.out.println(week+"对应的是星期一");
else if(week == 2)
System.out.println(week+"对应的是星期二");
else if(week == 3)
System.out.println(week+"对应的是星期三");
else if(week == 4)
System.out.println(week+"对应的是星期四");
else if(week == 5)
System.out.println(week+"对应的是星期五");
else if(week == 6)
System.out.println(week+"对应的是星期六");
else if(week == 7)
System.out.println(week+"对应的是星期日");
else
System.out.println(week+"没有对应的星期");
}
}
4、多分支结构(switch )
4.1、switch语句格式
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
……
default:
执行语句；
break；
}程序执行时，遇到switch关键字，首先会计算表达式的值，然后根据计算的值和case后面的值做比较，当case后面的值和switch表达式的值相同时，就执行case身后的所有语句，若case身后没有和switch表达式匹配的值，程序就会执行default后面的语句。
4.2、代码演示
class SwitchDemo
{
public static void main(String[] args)
{
int x = 5;
switch(x){
case 5:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
default:
System.out.println("c");
break;
}
System.out.println("Hello World!");
}
}
/*
演示Switch结构：
*/
class SwitchDemo
{
public static void main(String[] args)
{
int a = 11;
// if-else结构
if( a % 2 == 0 )
{
System.out.println("偶数");
}
else
{
System.out.println("奇数");
}
System.out.println("----------------------------");
// 使用switch结构
switch( a % 2 )
{
case 1 :
System.out.println("奇数");
break;
case 0 :
System.out.println("偶数");
break;
default :
System.out.println("其他值");
break;
}
}
}
4.3、switch语句细节
switch语句的表示支持的数据类型只有四种：byte，short，int ， char。（JDK5之前）。还支持 枚举类型enum(jdk5), String(jdk7)；
case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
结束switch语句的两种情况：遇到break，执行到switch语句结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
4.4、switch练习
//根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
class SwitchTest
{
public static void main(String[] args)
{
int week = 9;
switch(week)
{
case 1:
System.out.println(week+"对应的是星期一");
break;
case 2:
System.out.println(week+"对应的是星期二");
break;
case 3:
System.out.println(week+"对应的是星期三");
break;
case 4:
System.out.println(week+"对应的是星期四");
break;
case 5:
System.out.println(week+"对应的是星期五");
break;
case 6:
System.out.println(week+"对应的是星期六");
break;
case 7:
System.out.println(week+"对应的是星期日");
break;
default:
System.out.println(week+"没有对应的星期");
break;
}
}
}
// 使用switch结构，改造成绩划分
class SwitchTest
{
public static void main(String[] args)
{
int score = 89;
/*
100 : A 100 / 10 = 10
90 ~ 99 : A 9x / 10 = 9
80 ~ 89 : B 8x / 10 = 8
70 ~ 79 : C 7x / 10 = 7
60 ~ 69 : D 6x / 10 = 6
0 ~ 89 : E default :
*/
switch( score / 10 )
{
case 10 :
//System.out.println("A");
//break;
case 9 :
System.out.println("A");
break;
case 8 :
System.out.println("B");
break;
case 7 :
System.out.println("C");
break;
case 6 :
System.out.println("D");
break;
default :
System.out.println("E");
break;
}
}
}
4.5、if和switch的区别
if可以用于判断数值，也可以判断区间，只要运算结果是boolean类型，都可以进行判断。
switch用于对固定的几个值，进行判断。判断的值的类型有限。
5、循环结构(while&do-while)
5.1、循环结构
根据程序的需求，可以将某些代码重复执行的操作。Java中的循环结构有如下三种：
while:事先不需要知道循环执行多少次；
do-while:同上，只是至少要执行一次(先做，后判断)；
for:需要知道循环次数；
5.2、while循环
格式：
while(条件表达式)
{
执行语句；// 循环体;
}
while执行顺序：当程序遇到while关键字时，JVM首先会运算while后面的条件表达式，当条件表达式为true时，就会执行while后面大括号中的语句，当把大括号中的所有语句执行完之后，会又回到while的条件表达式处再次判断，若还为true，就继续执行大括号中的语句，若为false就跳过大括号中的所有语句，继续往下执行。
5.3、while代码举例
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )//这个程序是个死循环
{
System.out.println("i"+i);
}
System.out.println("over");
}
}
//上述循环是个无限循环（也称为死循环），主要原因是i变量一直为1，每次判断i<10都成立，导致选好条件结束不了。程序永远卡在循环这个地方执行
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )
{
System.out.println("i"+i);
i++; // 让i不断的更新，最后使循环可以结束
}
System.out.println("over");
}
}
5.4、while练习
/*
需求：运算1-10的和。
分析：
1+2+3+4+...+10
每次加的和是确定的吗？不确定。需要变量记录和值。
每次和值需要加的下一个数是确定的吗？不确定，需要变量。
求和和+下一个数在重复，说明需要执行多次，用循环。
下一个数，是有规律的。自增。
*/
class WhileTest
{
public static void main(String[] args)
{
//System.out.println(1+2+3+4+5+6+7+8+9+10);
// 起始值
int x = 1;
// 定义用于保存每次累加的空间
int sum = 0;
// 使用循环提供每个数字，然后进行相加操作
while( x <= 10000 )
{
// 计算累加和
sum = sum + x;
// 变量需要更新
x++; // ++x ; x+=1; x=x+1;
}
// 在循环结束之后，打印和值
System.out.println(sum);
}
}
class WhileDemo2
{
public static void main(String[] args)
{
/*
while( ) ; 空语句
{
}
*/
/*
需求：统计出1~100之间能够被3和7整除的数字的个数
分析：1、1~100之间的数字需要循环提供
2、能被3和7整除：也就是说循环提供的数字需要除以3的同时除以7余数为零
3、统计个数：其实就是在使用编程中的计数器思想。
定义一个变量，将其值设置为零，当找到一个符合条件的数据，就给这个空间+1
*/
int x = 1;
// 定义计数器
int count = 0;
while( x <= 100 )
{
// 使用判断结构，判断能不能被整除
if( x % 3 == 0 && x % 7 == 0 )
{
// 计数器+1
count++;
}
x++;
}
System.out.println(count);
}
}
/*
需求：报数1~100，遇到包含数字7或者7的倍数时，说出"过"，其他的数字正常报出。
*/
class WhileDemo3
{
public static void main(String[] args)
{
int x = 1;
// 循环提供每个数字
while( x <= 100 )
{
if( x % 7 == 0 )
{
System.out.println(" 过 ");
}
/*
需要判断 个位上的数字是否是7，以及十位数字是否是7
mn 代表的2位数：
mn % 10 = n
mn / 10 = m
n / 10 = n
*/
else if( x % 10 == 7 || x / 10 == 7 )
{
System.out.println(" 过 ");
}
else
{
System.out.println( x );
}
//变量更新
x++;
}
}
}
5.5、while循环注意事项
1）while循环的括号中的表达式计算结果必须为boolean类型的值。
2）while循环的括号中不能直接写false常量。
3）while循环的括号后面不要写分号，循环控制的语句的代码用大括号扩起来。
4）while循环控制的条件变量一定要更新，保证循环能够正常结束。
5.6、do-while循环
格式：
do
{
执行语句；
}while(条件表达式);
执行顺序：先执行do后面的语句，当执行完之后再进入条件表达式进行判断，若条件表达式结果为true继续执行do后面的语句，若条件表达式结果为false，则结束循环。
do while特点是无论条件是否满足，循环体至少被执行一次。
5.7、while和do-while对比
以下两个程序的执行结果：
| int x = 3; while(x<3) { System.out.println("x="+x); x++; } |
int y = 3; do { System.out.println("y="+y); y++; }while (y<3); |
6、循环结构(for)
6.1、for循环格式
for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)
{
执行语句；（4）
}
执行顺序： for里面的3个表达式运行的顺序，先执行表达式1，接着进入表达式2，如果表达式2位true，就执行循环体，一定要把循环体中的所有代码全部执行完后才能之后，进入表达式3，表达式3执行完进入表达式2，如果表达式2为true，继续循环，如果表达式2为false，for循环停止执行。
6.2、for循环代码举例
class ForDemo
{
public static void main(String[] args)
{
for(int x = 1; x<3; x++)
{
System.out.println("x="+x);
}
}
}
6.3、for和while的区别
| for(int x = 1; x<3; x++) { System.out.println("x="+x); } //System.out.println("x......"+x); |
int y = 1; while(y<3) { System.out.println("y="+y); y++; } System.out.println("y....."+y); |
while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
6.4、无限循环
最简单无限循环格式：while(true){} , for(;;){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
6.5、for的表达式细节
for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)
{
执行语句；（4）
}
表达式1：一般它是一个定义赋值的表达式。它可以省略。
表达式2：它必须是运行结果为boolean类型的表达式。也可以省略，如果省略默认是true（死循环）。
表达式3：一般是对控制循环的变量进行修改的。也可以省略。
// 下面代码编译有错，因为表达式2没有一个明确的boolean结果
for( System.out.println("A"); System.out.println("B"); System.out.println("C") )
{
System.out.println("D");
}
6.6、for循环练习
/*
需求：获取1-100之间6的倍数的个数。
分析：
1、个数是未知的，所以定义变量。
2、6的倍数咋表示？只要是对6能整除，也就是没有余数。
3、需要对1-100之间所以的数都要进行判断是不是6的倍数。如果是，需要对个数变量进行自增。
4、怎么完成1-100之间呢？使用循环。
*/
class ForTest
{
public static void main(String[] args)
{
//1，定义变量，记录个数。
int count = 0;
for (int x = 1; x<=100 ; x++ )
{
//对数值进行判断，是否是6的倍数。
if(x % 6 == 0)
count++;
}
System.out.println("count="+count);
}
}
6.7、循环练习
/*
猜数字游戏：随机产生1~100之间的一个数字，让用户猜测这个随机数是几，猜中程序结束，
如果猜的不对，给出相应的提示：
猜大：
猜小：
Java它其实内部已经将某些特定功能的代码写好，我们程序员只要学会如何去调用（使用）。
比如：
产生随机数：这个功能在Java中已经存在。因此我们直接去用就可以。
获取键盘录入的数据：这个功能也已经存在。
*/
import java.util.*; // 将需要在程序中引入的java中存在的功能提前导入到程序中
class ForTest
{
public static void main(String[] args)
{
// 调用JDK中已经存在的可以获取到随机数的那个功能
//int x = 12;
// 创建一个专门用于获取随机数的对象
Random r = new Random(); // 引用（复杂）类型
// 取出（获取）随机数
int y = r.nextInt( 100 ) + 1 ;
System.out.println("请输入您要猜的数字(1~100之间)：");
// 需要获取键盘录入的数字
Scanner sc = new Scanner( System.in );
int z = sc.nextInt();
for( ; y != z ; ){
if( y > z )
{
System.out.println("猜小啦！！！");
}
if( y < z )
{
System.out.println("猜大啦！！！");
}
// 不管是否猜大还是猜小，都需要让用户重新输入数据：
System.out.println("请重新输入数字：");
z = sc.nextInt();
}
if( y == z )
{
System.out.println("猜中了！！！");
}
}
}
6.8、循环嵌套
循环嵌套：其实就是在循环中还有循环。
6.8.1、循环嵌套代码演示
class ForForDemo
{
public static void main(String[] args)
{
for (int x=0; x<3; x++)//行
{
for(int y=0; y<4; y++)//每一行的个数。
{
System.out.print(" y="+y);
}
}
}
}
通过结果发现：在循环嵌套中，外循环执行一次，内循环要从头外尾执行完。
6.8.2、循环嵌套练习
/*
使用循环嵌套：打印如下的图形
*****
*****
*****
*****
*****
使用输出语句，每次只能打印一个*号。
*****
****
***
**
*
*
**
***
****
*****
*/
class ForForTest
{
public static void main(String[] args)
{
/*
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
*/
// 使用循环控制打印*号的个数，以及行数
for( int j = 0 ; j < 5 ; j++){
for( int i = 0 ; i < 5 ; i++ )
{
System.out.print("*");
}
System.out.println();
}
System.out.println("===============================");
//int x = 5;
for( int j = 0 ; j < 5 ; j++)
{
for( int i = 0 ; i < 5 - j ; i++ )
{
System.out.print("*");
}
System.out.println();
//x--;
}
System.out.println("===============================");
for( int j = 0 ; j < 5 ; j++)
{
for( int i = 0 ; i < j + 1 ; i++ )
{
System.out.print("*");
}
System.out.println();
}
System.out.println("===============================");
/*
打印九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
......
*/
for( int j = 1 ; j <= 10 ; j++)
{
for( int i = 1 ; i <= j ; i++ )
{
System.out.print(i+"*"+j+"="+(i*j) + "\t");
}
System.out.println();
}
}
}
6.9、流程控制(continue,break)
6.9.1、break语句、continue语句
break：两种用途：终止switch语句；终止循环执行。
continue：停止本次循环，接着进入下次循环
注：
- ：若这两个语句离开应用范围，存在是没有意义的。
- ：这个两个语句单独存在后面都不能有语句，因为执行不到。
- ：continue语句是跳过本次循环，继续下次循环。
- ：标签的出现，可以让这两个语句作用于指定的循环。
6.9.2、break语句、continue语句举例
// break是终止循环，即在程序中遇到break，那么break所属的循环将结束。
for (int x=0; x<3 ;x++ )
{
if(x==1)
break;
System.out.println("x="+x);
}
/*
演示break的使用
*/
class BreakDemo
{
public static void main(String[] args)
{
// 需要：从1开始统计能够被3和7整除的个数，当统计到第10个的时候停止。
int count = 0; // 计数器
// 循环到底提供到谁，无法确定。可以省略不写
for( int i = 1 ; ; i++ )
{
if( i % 3 == 0 && i % 7 == 0 )
{
count++;
}
// 每次计数完之后，都判断一下count有没有到10，如果到了就停止
if( count == 10 )
{
break;
}
}
System.out.println(count);
}
}
// continue是结束本次循环，继续下次循环。循环是不会结束的。
/*
演示 continue的用法： 结束本次循环，接着进入下次循环
*/
class ContinueDemo
{
public static void main(String[] args)
{
// 需求，打印1~50,之间的偶数
for( int i = 1 ; i <= 50 ; i++ )
{
if( i % 2 == 1 )
{
continue;
}
System.out.println(i);
}
}
}
6.9.3、break和continue的细节
如果在程序中break和continue没有被判断控制，它是一个独立的语句存在的时候，在break和continue的后面不能再有其他的语句，因为是执行不到的。
6.9.4、使用循环标签
在多层嵌套循环中，终止/跳过标签标记的那层循环的执行；break <标签> 或 continue <标签>；
| outer:for (int x=0; x<3 ;x++ ) { inner:for (int y=0; y<4 ;y++ ) { System.out.println("x="+x); break outer; } }
|
outer:for (int x=0; x<3 ;x++ ) { inner:for (int y=0; y<4 ;y++ ) { System.out.println("x="+x); continue outer; } }
|