第三天
今日任务
1、位运算（了解）
2、三元运算符
3、程序运行流程&顺序结构
4、判断结构(if)（掌握）
5、多分支结构(switch )
6、循环结构(while&do-while)（掌握）
7、循环结构(for)（掌握）
8、嵌套循环（必须掌握）
9、流程控制(continue,break)
课堂笔记
1、位运算
位运算：二进制数位的运算。需要把数据转成二进制再进行运算。二进制运算是所有运算中速度最快的运算。
1.1、运算符符号
&：按位与运算
|：按位或运算
^：按位异或运算
<<：左移运算
>>：右移运算
>>>：无符号右移运算
&（按位与运算）：运算规则：
相同的二进制数位上，都是1的时候，结果为1，否则为零。
十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100
&
-----------------------------------------------------------------------------------------------
8 0000 0000 0000 0000 0000 0000 0000 1000
|（按位或运算）：运算规则：
相同的二进制数位上，都是0的时候，结果为0，否则为1。
十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100
|
-----------------------------------------------------------------------------------------------
13 0000 0000 0000 0000 0000 0000 0000 1101
^（按位异或运算）：运算规则：
相同的二进制数位上，数字相同，结果为0，不同为1。
十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100
^
-----------------------------------------------------------------------------------------------
5 0000 0000 0000 0000 0000 0000 0000 0101
<<（左移运算）：运算规则：
就是把当前这个二进制数向左移动多少位。低位空出的补零。高位移出的舍弃
9 << 2 = 36 向左移动几位 ，相当于给原数乘以2的多少次方
9 0000 0000 0000 0000 0000 0000 0000 1001
0000 0000 0000 0000 0000 0000 0000 100100
>>（有符号右移符号）：运算规则：
就是把当前这个二进制数向右移动多少位。在使用>>移动的时候，高位空出的来，需要根据原来最高位是什么，就补什么。低位移除的舍弃。
9>>2 =2
9 0000 0000 0000 0000 0000 0000 0000 1001
000000 0000 0000 0000 0000 0000 0000 1001
>>>（无符号右移）：运算规则：
就是把当前这个二进制数向右移动多少位。在使用 >>> 移动的时候，高位空出来的全部用零补。低位移除的舍弃。
位运算图解：
1.2、位运算与逻辑运算区别
如果在程序中 出现了 & | ^ 这时他们到底是逻辑运算还是位运算。注意，运算符两侧的数据类型。如果是boolean类型，就是逻辑运算，如果是数值类型，他们都是位运算。
2、三元运算符
2.1、三元运算符的格式
三元运算：三目运算。
格式：
表达式1 ? 表达式2 ： 表达式3;
2.2、三元运算符的运算原则
要求表达式1 运行的结果必须是一个boolean的结果。通过表达式1的这个结果确定到底是执行表达式2还是表达式3.
当表达式1为true，就把表达式2的结果作为三元运算的结果。
当表达式1为false的时候，把表达式3的结果作为三元运算的结果。
注意：三元运算符运算后必须有结果。
2.3、三元运算符举例
三元运算练习：
比较两个数的大小，并打印出最大数的值。
class Demo3
{
public static void main(String[] args)
{
/*
利用三元运算算出最大值
*/
//定义变量
int a=3;
int b=5;
int max;
max=a>b ? a:b;
System.out.println(max);
}
}
在运行上面程序的时候，JVM遇到了三元运算，这时JVM 会先执行 a > b 这个表达式，3 > 5不成立
这时JVM 就会把变量b=5的结果作为三元运算的结果，赋值给max
3、程序运行流程&顺序结构
程序的执行顺序：
书写的.java文件，称为Java的源代码（源程序）。
源代码需要使用JDK 中提供的 javac 命令进行编译。在dos窗口中输入的javac 源文件名.java 这时是在启动编译器，然后让编译器去检查当前的源代码有没有语法错误。没有语法错误，就会生成class文件。
然后我们在dos窗口中输入java class文件名 这时会启动JVM。启动JVM之后，JVM会在我们的内存中划分出空间，来运行当前的Java程序。JVM会先把硬盘上的class文件加载到内存划分好的空间中。JVM开始在当前这个class文件中找main方法运行。然后开始运行main方法。
在main方法中：开始执行main方法中的代码，从上往下逐行执行。在执行的过程中，JVM遇到不同的关键字，需要做不同的事情。
程序是按照顺序结构在执行。
注意：程序在执行的过程中，不可能完全按照行的方式，每行都执行。在执行的过程中，应该加入一些复杂的条件，保证在满足的情况下，执行某些动作或者命令，如果不满足，就跳过执行其他的程序或者还有一种情况就是重复的一直执行某块代码。
4、判断结构(if)
程序在执行的过程中，需要加入一些条件，然后根据条件的真假，确定应该执行哪些代码，不应该执行哪些代码， 要完成这个需求，就必须使用Java中的判断结构。
4.1、if判断第一种格式
if( 判断的条件)
{
判断成立后应该执行的动作;
}
注意： 这里的判断条件最后必须是一个boolean值,如果判断条件是true，则执行if后面的{}中的内容；如果判断条件是false，则跳过大括号中的内容，向下继续执行其他内容。
案例：判断一个整数是偶数还是奇数
4.2、if判断第二种格式
if( 判断的条件 )注意： 这里的判断条件最后必须是一个boolean值,如果判断条件是true，则执行if后面的{}中的内容；如果判断条件是false，则跳过大括号中的内容，执行else后面的大括号中的内容。
{
判断条件成立后执行的语句;
}
else //注意：只有当if的条件不成立时，才会执行else
{
判断不成立后执行的语句；
}
执行顺序：当JVM遇到 if else 结构的判断时，会先执行if的条件，如果if条件成立就执行if后面的语句，如果if的条件不成立，就自动的去执行else 的语句。
注意：如果if成立了，执行完if后面的语句之后，直接跳过else，不会执行else后面大括号中的内容，而是往下继续执行。
案例：比较两个数的大小。
class IfElseDemo
{
public static void main(String[] args)
{
//if else 举例
int a = 3;
int b = 6;
//假设不考虑 a 和 b 相等的情况
if( a > b )
{
System.out.println("a大于b");
}
else
{
System.out.println("b大于a");
}
System.out.println("Hello World!");
}
}
注意：else 的语句执行时间是if判断的条件不成立时。else不需要书写条件。
在程序中只要有else，必然上方有if条件，但是有if条件，就不一定有else 了。
4.3、三元运算符可以简化if-else格式
三元运算它属于运算表达式，要求运算后必须有一个明确的结果出现。
if-else 属于Java中的语句，它执行完，可以没有具体的结果。
只有当if-else结果执行之后，有一个具体的结果的时候，可以使用三元运算代替。
练习：找出2个数中的最大值，并将最大值的结果输出打印出来。
class IfElseDemo2
{
public static void main(String[] args)
{
/*
三元运算和if else的区别
*/
//比较两个数的大小
int a=3;
int b=6;
int max;
//不考虑a和b相等的情况
//三元运算算法
max=a > b ? a:b;
//if-else结构
/*if(a>b){
max=a;
}else{
max=b;
}*/
System.out.println("max="+max);
}
}
结论：
if-else语句和三元运算符的区别：
三元运算符中必须有一个接收表达式结果的变量，而if-else语句中不一定要有接收表达式结果的变量。
4.4、if判断第三种格式
当在程序中有多个条件的时候，每个if只能列出其中的一种可能条件，这时在else中就会隐含其他的所有条件，对剩余的条件，还要进行更加具体的细化，这时可以在else 后面继续使用if，区分出其他的各种情况
if( 判断的条件 )
{
判断成立后执行的语句；
}
else if( 判断的条件 )
{
判断成立后执行的语句；
}
else if( 判断的条件 )
{
判断成立后执行的语句；
}
else if( 判断的条件 )
{
判断成立后执行的语句；
}
else if( 判断的条件 )
{
判断成立后执行的语句；
}
.....
else
{
上述的所有判断都不成立之后执行的语句；
}
4.5、if-elseif练习
需求：对学生的成绩进行划分等级
90~100 -----》 A
80~89 -----》B
70~79 -----》C
60~69 -----》D
0~59 -----》E
int x=98
x>=90 && x<=100
分析：
1、有一个成绩，就需要一个变量先保存这个成绩
2、题目要求对成绩进行不同区间的划分，划分区间就需要使用比较运算结合 逻辑运算完成
3、由于有多个区间，并且输出的内容都不一样，这时就需要使用if对这些区间进行逐一的区分
可以使用if esle if else 结构
4、在哪个if判断成立之后，就输出对应的等级
步骤：
1、定义变量，保存成绩
2、使用判断进行区分
3、判断成立打印等级
/*
需求：对学生的成绩进行划分等级
90~100 -----》 A
80~89 -----》B
70~79 -----》C
60~69 -----》D
0~59 -----》E
1.定义一个变量，并且给变量赋值。
2.划分分数区间
*/
class IfElseDemo3
{
public static void main(String[] args)
{
//定义变量
int score=67;
//划分区间
if(score>=90 && score<=100)
{
System.out.println("A");
}else if(score>=80 && score<=89){
System.out.println("B");
}else if(score>=70 && score<=79){
System.out.println("C");
}else if(score>=60 && score<=69){
System.out.println("D");
}else{
System.out.println("E");
}
System.out.println("Hello World!");
}
}
5、多分支结构/选择结构(switch )
5.1、switch语句格式
switch( 表达式 )
{
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
case 常量3:
语句3;
break;
case 常量4:
语句4;
break;
........
default :
语句;
break;
}
要求这个表达式最后必须能计算出一个准确的结果，并且这个结果的类型只能是 byte short int char ，在JDK5 增加了 枚举类型 在JDK7增加了字符串类型。
break的作用是结束switch语句，跳出switch语句。
5.2、代码演示
案例：判断一个整数是偶数还是奇数。
//演示Switch的执行过程
class SwitchDemo
{
public static void main(String[] args)
{
int a = 4;
switch( a % 2 )
{
case 0:
System.out.println("a是偶数");
break;
case 1:
System.out.println("a是奇数");
break;
default:
System.out.println("没这样的奇偶数");
break;
}
System.out.println("Hello World!");
}
}
5.3、switch语句执行顺序
switch语句在执行的时候，JVM是通过switch中的表达式的计算结果和case后面的常量进行比较，相等就代表找到的执行switch后面case的入口，这时如果程序没有break关键字，JVM就会把从入口开始往下的所有代码，全部执行，而不管下面的case 后的常量是否和计算的结果一致。
5.4、switch练习
//需求：根据指定的天数，打印星期。
/*
需求：根据指定的天数，打印星期。
*/
class SwitchTest
{
public static void main(String[] args)
{
int day=5;
switch(day){
case 1:
System.out.println("星期一");
break;
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;
default:
System.out.println("没有这个星期");
break;
}
System.out.println("Hello World!");
}
}
5.5使用switch语句时需要注意的事项：
1、在switch语句中case语句和default语句在书写上没有先后顺序。但是，会先执行case语句
2、switch语句只有遇到两个情况才会结束整个switch语句。1：遇到break语句； 2：执行到整个switch语句的末尾（switch语句匹配的最后的右大括号）
3、在switch语句中，是可以省略default语句的，而且default语句中的break同样也是可以省略的(前提：default语句必须书写switch语句的最后一个)
4、在switch语句的书写上，是可以省略break语句的。但是在执行时，如果没有break语句，程序会向下继续执行可执行的代码
5.6、if和switch的区别
if和switch可以互换，但是if它主要完成的条件的判断，switch主要是对数据的结果分支执行。
if可以在条件中书写判断的区间，而switch只能接受固定类型的数据，最后还要求必须是常量。
6、循环结构(while&do-while)
在生活中有时我们做某些事情，需要重复往复性的做好多次，根据具体的情况，最后才能决定是否还需要继续做这件事。
我们要想把生活中的这些重复性的动作在Java中体现出来，这时就需要使用Java提供的循环。
6.1、循环结构
Java中提供的循环有三种：
while循环、do-while循环、for循环。
6.2、while循环介绍
格式：
while( 循环条件 )
{
循环条件成立后要执行的语句; // 循环体
}
if和while的区别：
if( 判断条件 )
{
判断成立后执行的语句;
}
JVM在执行程序的时候，遇到if关键字，这时就会自动的去指定if身后小括号中的表达式，最后根据这个表达式的真假确定是否执行if控制的语句。不管判断是否成立，当前的if只执行一次。
while循环的执行顺序：
当JVM在执行程序的过程中，遇到while关键字，这时也会先执行while身后小括号中的表达式， 然后根据表达式的真假确定是否执行while后面大括号中的代码。
当while的条件是true的时候，JVM就会去执行while身后大括号中的语句，当把大括号中的所有语句执行完之后，这时JVM会返回到while的循环条件地方继续判断。直到while的条件为false的时候，这时这个循环才能结束，继续往下执行和循环并列的语句，如果这里的循环永远不能结束，程序就在这里一直循环。
6.3、while代码举例
案例：使用while循环打印1-10的数字
/*
演示while循环代码的执行过程
*/
class WhileDemo
{
public static void main(String[] args)
{
//定义变量
int a=1;
while(a<=10){
System.out.println("a="+a);
a++;//a=a+1;a+=1
}
System.out.println("Hello World!");
}
}
（提示：如果程序在运行时出现死循环。可以通过ctrl+c键 停止死循环）
6.4、while练习
需求：输出1~50之间所有的偶数
思路：
1、题目要求1~50之间的数据，首先就要思考怎么把1~50之间的每个数字先提供出来。
2、要提供1~50之间的每一个数字，就是一个重复性的动作，重复的动作可以使用循环提供。（使用while解决）。
3、这时就需要对循环提供的数字进行过滤，就需要对提供的每个数字进行判断。对数字进行判断， 符合条件的就打印，不符合就不处理。
4、怎么判断？什么是偶数，偶数就是对2进行取模结果等于0的数。
if( x %2 == 0 )
{
}
5、循环的三个要素：
1）循环初始值 int x=1;
2）循环的条件 x<=50
3）循环条件的修改 x= x+1;//x++;x+=1;
步骤：
1、定义变量提供1~50之间的起始数字，
2、使用while循环提供1~50之间的每个数字
3、在while中加入判断进行数据的筛选
4、判断成立打印数据
/*
步骤：
1、定义变量提供1~50之间的起始数字，
2、使用while循环提供1~50之间的每个数字
3、在while中加入判断进行数据的筛选
4、判断成立打印数据
*/
class WhileTest
{
public static void main(String[] args)
{
//定义变量提供1-50之间的数字
int x=1;
//开始循环取得1-50之间的数字
while(x<=50){//循环条件
//对数据加判断进行筛选
if(x%2==0){
//说明x是偶数，打印
System.out.println(x);
}
//循环条件的修改
x++;
}
}
}
6.5、do-while循环(了解)
格式：
do
{
循环体语句;
}while( 循环条件 );
注意：while后面的小括号后面必须得有英文分号（;）。
代码举例：
需求：打印1~10的数据。
/*
do~while的练习
需求：打印1~10的数据。
*/
class DoWhileDemo
{
public static void main(String[] args)
{
int x=1;
do{
System.out.println("x="+x);
x++;
}while(x<=10);//小括号后面必须得有分号
System.out.println("Hello World!");
}
}
6.6、while和do-while对比
while循环它是先进行循环条件的判断，判断成立才能进入循环体，如果判断不成立，就直接跳过循环体执行和循环并列的语句。
do-while循环，它是先要把循环体执行一次，然后再去判断，如果判断成立继续执行循环体。直到判断不成立， 再去执行和循环并列的语句。
代码演示while和 do-while的区别：
/*
while和do-while区别
*/
class WhileAndDoWhile
{
public static void main(String[] args)
{
//定义变量
int x=13;
while(x<=10){
System.out.println("x="+x);
x++;
}
System.out.println("--------------------");
int y=13;
do{
System.out.println("y="+y);
y++;
}while(y<=10);
System.out.println("haha");
}
}
do-while循环使用的场景：
当不管循环的条件是否成立，都需要把循环体先执行一次，这时就可以使用do-while循环。
7、循环结构(for)
7.1、for循环格式
for(循环初始值 ; 循环条件 ; 修改循环条件)
{
//重复执行的代码----》循环体。
}
在for循环的小括号中需要三个表达式，三个表达式之间需要使用英文分号隔开。
循环初始值：一般是一个定义赋值的表达式。可以省略
循环条件：for循环的条件表达式，循环条件最后计算的结果必须是一个boolean值。可以省略，默认是true
修改循环条件：一般是循环变量的更新表达式。可以省略
for循环的执行过程：
7.2、for循环代码举例
需求：使用for循环打印1~10之间的数字
练习一：需求：打印1~100之间的能够被3整除的所有数字。
分析：
1、题目要求1~100之间的数据，首先就要思考怎么把1~100之间的每个数字先提供出来。
2、要提供1~100之间的每一个数字，就是一个重复性的动作，重复的动作可以使用
循环提供。
3、可以从1开始提供，到100结束，在循环的过程中，我们可以提供出1~100之间的每个数字
可是题目并不需要1~100之间的所有数字，而只需要能够被3 整除的数字，
4、这时就需要对循环提供的数字进行过滤，就需要对提供的每个数字进行判断。
对数字进行判断， 符合条件的就打印，不符合就不处理。
5、怎么判断？什么是整除，整除就是被除数 除以 除数 余数为零
if( x % 3 == 0)
{
}
步骤：
1、使用for循环提供1~100之间的每个数字
2、在for中加入判断进行数据的筛选
3、判断成立打印数据
//需求：打印1~100之间的能够被3整除的所有数字。
/*
练习一：需求：打印1~100之间的能够被3整除的所有数字。
*/
class ForTest
{
public static void main(String[] args)
{
//使用for循环取得1~100之间的数字
for(int x=1;x<=100;x++)
{
//筛选数字%3==0的数字
if(x%3==0){
//说明x能被3整除
System.out.println("x="+x);
}
}
System.out.println("Hello World!");
}
}
7.3、无限循环（了解）
无限循环，也称为死循环。程序一直在执行这个循环，而永远不会停止。
一般我们书写循环的时候，都需要定义有效的变量，保证这个循环可以正常的结束。
无限循环的书写格式：
while的格式：
while( true )
{
循环体;
}
for的格式：
for( ; ; )
{
循环体;
}
注意：只要使用无限循环，那么在循环的下面不要再写任何的语句。
（提示：如果程序在运行时出现死循环。可以通过ctrl+c键 停止死循环）
8、嵌套循环(掌握)
嵌套循环：在循环中还有循环。学习过的所有的语句，都可以互相的嵌套。
嵌套for循环的格式：
for(循环初始值;循环条件;循环条件修改) //外层循环
{
//外层循环体
for(循环初始值;循环条件;循环条件修改) //内层循环
{
//内层循环体
//重复执行的代码
}
}
注意：在开发中，通常嵌套for循环就是两层。（不建议书写超过两层以上的嵌套循环）
8.1、嵌套循环代码演示
/*
循环嵌套
*/
class ForForDemo
{
public static void main(String[] args)
{
//外层循环
for (int i=1;i<=2;i++)
{
//内层循环
for (int j=1;j<=2;j++)
{
System.out.println("i="+i+",j="+j);
}
}
System.out.println("Hello World!");
}
}
总结：
针对循环嵌套：外循环执行一次，内部的循环要从头到尾彻底执行结束。如果在执行的过程中，内部循环没有执行完，是不会去执行外部循环的。
特别注意：内部循环的循环体执行完之后，需要进入到内部循环的表达式3(修改循环条件)中去继续执行。
8.2、循环嵌套练习
练习一：
需求：在屏幕上打印5行5列的星号。要求只能写一个输出语句并且每个输出语句只能打印一个星号。
打印如下图形：
*****
*****
*****
*****
*****
分析：需要打印5行，肯定需要使用打印语句，并且打印语句要执行5次
使用for循环可以控制打印的次数
需要控制到底这一行需要输出几个星号
这里就需要再次使用循环控制在每行中到底打印的星号个数
/*
需求：在屏幕上打印5行5列的星号。要求每个输出语句只能打印一个星号。
打印如下图形：
*****
*****
*****
*****
*****
*/
class ForForTest1
{
public static void main(String[] args)
{
//需要打印5行，肯定需要使用打印语句，并且打印语句要执行5次
//使用循环可以控制打印的次数
for (int i=1;i<=5;i++ )//控制打印几行的
{
//需要控制到底这一行需要输出几个星号
// 这里就需要再次使用循环控制在每行中到底打印的星号个数
for (int j=1;j<=5 ;j++ )//控制一行打印几个星号
{
System.out.print("*");
}
//循环结束，表示这一行中打印的星号全部结束，下次需要在新的一行打印
System.out.println();//打印空行，起到换行的作用
}
}
}
练习二：
需求：打印如下图形：
*
**
***
****
*****
分析：上述的图形，我们先不考虑每行几个星号，先看最多有几个星号。
那么我们就可以先打印每行都有5个星号的图形。
for ( int i = 1 ; i < =5 ; i++ ) //控制打印几行
{
for ( int j = 1 ; j < =5 ; j++ ) //可以在一行中打印5个星号
{
System.out.print("*");
}
System.out.println();
}
上述代码可以打印5行5列的星号，但是题目要求，每行中的星号随着行数的增加在增加。
我们需要控制每行到底能够打印几个星号。
在第一行中只能打印1个星号，第二行打印2个 以此类推 第五行 打印5个
随着行数的增加，打印的星号个数也在增加。
/*
需求：打印如下图形：
*
**
***
****
*****
*/
class ForForTest2
{
public static void main(String[] args)
{
for (int i=1;i<=5;i++ )//控制打印几行的
{
for (int j=1;j<=i ;j++ )//控制一行打印几个星号
{
System.out.print("*");
}
//循环结束，表示这一行中打印的星号全部结束，下次需要在新的一行打印
System.out.println();//打印空行，起到换行的作用
}
}
}
9、流程控制(break,continue)
在循环的执行过程中，有时我们需要对循环进行控制，而不是让循环从头到尾彻底执行完。这时我们需要在程序加入流程控制的关键字。
9.1、break语句
break：它主要是在程序中跳出当前正在执行的代码。
break，它主要用在switch的case中，或者用在循环中。
当用在switch中的时候，在程序执行switch中的代码时候，遇到break，会导致当前这个switch代码彻底结束，而去执行和switch结构上并列的语句。
当break使用在循环中的时候，只要JVM遇见break，就立刻让当前循环结束，不管循环条件是否还成立，循环都会强制结束。
break语句举例:
/*
需求：在屏幕上打印5行5列的星号。要求每个输出语句只能打印一个星号。
打印如下图形：
*****
*****
*****
*****
*****
*/
class ForForTest1
{
public static void main(String[] args)
{
//需要打印5行，肯定需要使用打印语句，并且打印语句要执行5次
//使用循环可以控制打印的次数
for (int i=1;i<=5;i++ )//控制打印几行的
{
//需要控制到底这一行需要输出几个星号
// 这里就需要再次使用循环控制在每行中到底打印的星号个数
for (int j=1;j<=5 ;j++ )//控制一行打印几个星号
{
System.out.print("*");
break;//跳出内层for循环，继续执行下面的语句
}
//循环结束，表示这一行中打印的星号全部结束，下次需要在新的一行打印
System.out.println();//打印空行，起到换行的作用
}
}
}
break语句执行过程图解：
9.2、continue语句
continue（继续）：它主要用在循环中，不能使用在其他地方。（跳过本次循环，执行下一次的循环）
continue：它的执行原理：当在循环中遇到的continue，这时JVM 就不会再执行continue下面属于本循环的其他语句，而直接进入下次循环。
continue语句举例一：
/*
需求：在屏幕上打印5行5列的星号。要求每个输出语句只能打印一个星号。
打印如下图形：
*****
*****
*****
*****
*****
*/
class ForForTest1
{
public static void main(String[] args)
{
//需要打印5行，肯定需要使用打印语句，并且打印语句要执行5次
//使用循环可以控制打印的次数
for (int i=1;i<=5;i++ )//控制打印几行的
{
//需要控制到底这一行需要输出几个星号
// 这里就需要再次使用循环控制在每行中到底打印的星号个数
for (int j=1;j<=5 ;j++ )//控制一行打印几个星号
{
System.out.print("*");
//break;//跳出内层for循环，继续执行下面的语句
continue;//不会执行内层循环中下面的代码，而是执行修改循环条件，j++
}
//循环结束，表示这一行中打印的星号全部结束，下次需要在新的一行打印
System.out.println("haha");//打印空行，起到换行的作用
}
}
}
continue语句执行过程图解：
9.3、break语句和continue语句区别
break和continue在循环语句中的区别：
break用来结束循环，循环就停止了
continue用来跳过当前循环，循环不会停止，会继续下一次的循环
课后作业（会整理）
前言作业：
-
整理当天讲解的知识点（按着重点去整理）
-
把课堂上所有的代码全部练习一遍
提示：建议先练习重点知识点的代码
1、 判断给定的年份是否为闰年？[提示：闰年的计算方法: 年份可以被4整除不能被100整除是闰年，或者能被400整除也是闰年]
分析：用一个变量来保存给定的年份，定义一个变量year，并初始化值。
判断年份是否为闰年，使用if语句
if((year%4==0 && year%100!=0) || year%400==0)
根据结果输出信息。
步骤：
-
定义年份变量 int year
-
判断年份是否为闰年
-
根据判断的结果输出信息
2、根据给定的月份，使用if结构和switch结构 输出对应的季节
3、需求：要求在屏幕上显示如下内容
