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; } }
|