数据类型和运算符和流程控制——Java教案（二）

数据类型和运算符和流程控制

数据类型和运算符

1. 注释

为什么要写注释？

我们在写程序时应添加注释为方便团队中其它人可以读懂你的代码，也方便自已日后阅读、重用代码。

注释和说明文档有什么区别？

注释：关键逻辑

说明文档：详细

在什么地方写注释？

1. 类上（说明类的创建日期和作者）
2. 特殊作用的变量或常量上（解释变量的作用）
3. 每个方法上 （方法的作用，参数的解释，创建时间，作者）
4. 具体业务中（方法中某一关键变量或使用特别的算法等）

三类：

1. 单行注释 //
2. 多行注释 / * 注释内容 * /
3. 文档注释 / * * 内容 */
   1. java程序源代码添加了合适的文档注释，通过JDK提供的javadoc工具可以直接将源代码里的文档注释提取成一份系统的API文档。

一定要有善意的提醒

2. 标识符和关键字

标识符

标识符指用户自已起的类名、变量名、方法名等。也就是用户定义的名称。

JAVA命名标识符的规则：

1. 区分大小写、标识符长度不限。

2. 英文、中文、韩文、下划线、美元符号（$）均可用，但不能以数字开头。

3. 不能使用Java关键字，例如：class void System等

4. 标识符不能包含空格

关键字

java中一些具有特殊用途的单词。

保留关键字：goto，const 现在不用，将来可能用（面试题哦）

三个特殊类型的直接量：true，false，null

3. 数据类型分类

Java语言是强类型语言

意味着每个变量和表达式都有一个在编译时确定的类型。类型限制了一个变量能被赋予的值，限制了一个表达式可以产生的值，限制了这些值的操作。

1. 特点

   1. 所有变量必须先声明，后使用；

   2. 指定类型的变量只能接受类型与之匹配的值。

2. 好处

   1. 编译时进行严格的语法检查，减少编程锁雾
   2. 声明变量的语法简单，只需要指明变量类型和变量名。

弱类型语言

var a = “123” + 123; ->123123

4. 基本数据类型

无符号数：只探讨整数，不会探讨小数。

1. 没有符号位
2. 相当于数的绝对值
3. 取值范围：0-255（2^8-1）

有符号数：0 表示正数 ，1表示负数

1. 定点整数
1. 定点小数
1. 原码，反码，补码来表示定点整数和定点小数
1. 移码来表示定点整数

整形

byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

package lessonone;

public class DemoOne {
	public static void main(String[] args) {
		//byte
		byte b1= 100;
		System.out.println(b1);
	    //short
		short s1 =100;
        System.out.println(s1);
		//long
		long l1=100;
		long l2=100000000000000000L;
		System.out.println(l1);
		System.out.println(l2);
		
		//int
		//十进制
		int value1 = 100;
		//二进制
		int value2 = 0B100;
		int value3 = 0b100;
		//八进制
		int value4 = 0100;
		//十六进制
		int value5 = 0x100;
		int value6 = 0X100;
		System.out.println(value1);
		System.out.println(value2);
		System.out.println(value3);
		System.out.println(value4);
		System.out.println(value5);
		System.out.println(value6);
		
	}

}

浮点型

float：

• float 数据类型是单精度、4字节，32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

第一位是符号位，接下来8位表示指数，接下来23位表示尾数。

5.12*10^2。 5.12表示尾数，2表示指数，10表示基数

double（默认）：

• double 数据类型是双精度、8字节，64 位、符合 IEEE 754 标准的浮点数；

• 浮点数的默认类型为 double 类型；

• double类型同样不能表示精确的值，如货币；

• 默认值是 0.0d；

• 例子：

  double   d1  = 7D ;
  double   d2  = 7.; 
  double   d3  =  8.0; 
  double   d4  =  8.D; 
  double   d5  =  12.9867; 
  

  7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

第一位是符号位，接下来的11位表示指数，接下来的52位表示尾数。

浮点数的表示方式

1. 十进制数形式 5.12
2. 科学计数形式 5.12e2 或5.12E2 表示（5.12*10^2）

注意：

1. 浮点数取的是接近值，但是接近并不是等于，因此当数值足够大的时候，小的误差不影响两个数的判断。因此，浮点数通常不能用作比较。

	    //浮點型
	    float  f1 = 1.10f;
	    double d2 = 1.10;
	    System.out.println(f1==d2);//false  二者的精确度不一样
	    float f2 =22222222222222222222222222222222f;
	    float f3 =f2+1;
	    System.out.println(f2);  //2.2222223E31
	    System.out.println(f3);  //2.2222223E31
	    System.out.println(f3==f2); //true

布尔类型

boolean：

• boolean数据类型表示一位的信息； 但是大部分计算机分配内存时最小内存代为是字节8位，因此boolean实际占用8位。
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

字符型

字符类型:Java语言用16位（两字节）的Unicode编码集作为编码方式，而Unicode被设计成支持世界上所有书面语言的字符，包括中文字符，因此Java程序支持各种语言的字符。

字符集表示形式

1、用单引号表示.如(‘a’,‘中’)，可表示中文，汉字，以及数字（0-65535）

2、用转义字符’\n’,’\r’等

3、直接用Unicode表示,’\u0008’，表示一个十六进制的整数。

char类型的变量，值完全可以参加加减乘除等数学运算，也可以比较大小。

char：

• char 类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（十进制等效值为 0）；
• 最大值是 \uffff（即为 65535=2^16）；
• char 数据类型可以储存任何字符；
• 例子：char letter = ‘A’;。

	//字符型
		char aChar = 'a';
		System.out.println(aChar);
		char enterChar = '\r';
		System.out.println(enterChar);
		char ch = '\u00FF';
		System.out.println(ch);
		char zhong = '疯';
	    System.out.println(zhong);
		int zhongValue = zhong;
		System.out.println(zhongValue);
	    char c = 97;
	    System.out.println(c);

char类型与int类型的转换，要联想ascii码

必须要记忆的ascii码

‘0’	48
‘9’	57
‘A’	65
‘Z’	90
‘a’	97
‘z’	122

5. 基本类型的类型转换

自动类型转换

把某种基本类型的值直接赋给另一种基本类型的变量，这种方式成为自动类型转换。

一个表数范围小的数值或变量直接赋给另一个表数范围大的变量时，系统可以进行自动的类型转换，否则就需要强制类型转换。

package lessonone;

public class DemoTwo {
	public static void main(String[] args) {
		int a = 6;
		float f = a;
		//int类型可以自动转换成float类型
		System.out.println(a);
		byte b= 9;
//		char c = b; //报错
//		System.out.println(c);
		double d =b;	
		System.out.println(b);
	}

}

转换为字符串，文字后面直接拼接“”即可

		System.out.println(3+4+"hello");

程序会先进行3+4运算，这是执行两个数之间的加法，得到7，7+hello，会把7作为字符串处理，得到4Hello!

强制类型转换

与自动类型转换相反，表数范围大的数向表数范围小的方向转。

	int qi2 =233;
	float qf1=11.11f;
	int  qf2 =(int)qf1;
	System.out.println(qf2);// 11
    int qi1 =111;
	byte qb1 = (byte)qi1;
	System.out.println(qb1);// 111
	byte qb2 = (byte)qi2;
	System.out.println(qb2);// -23

32位int 00000000 00000000 00000000 11101001

8位byte 11101001

11101001左边为1表示负数，负数以补码的形式存在，因此需要换成原码。

补码-1得到反码（11101000），再将反码转换成原码（10010111）这个byte类型的值为-23

注意

当一个表达式中包含多个基本类型的值时，整个表达式的数据类型将发生自动提升：

1、所有byte、short和char型将被提升到int型。

2、整个表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型.

课堂练习

public class Test01 {
	public static void main(String[] args) {
//		int a =1;
		
//		int b =2;
//		char c ='\u000d;
//		char ch = '\u00FF';
//		System.out.println("ab");
//		System.out.println("c"+ch+"d");
//		char a ='0';
//		char A = '1';
//		System.out.println((int)a);
//		System.out.println((int)A);
		
		char aChar = 'a';
//		System.out.println(aChar);
//		System.out.println();
//		char enterChar = '\r';
//		System.out.println(enterChar);
//		char ch = '\u00FF';
//		System.out.println(ch);
//		char zhong = '笪';
//	    System.out.println(zhong);
//		int zhongValue = zhong;
//		System.out.println(zhongValue);
//	    char c = 97;
//	    System.out.println(c);
//		int a = 6;
//		float f = a;
//		//int类型可以自动转换成float类型
//		System.out.println(f);
//		byte b= 9;
//		char c = b; //报错
//		System.out.println(c);
//		double d =b;	
//		System.out.println(b);
//		System.out.println(d);
//		int a =125;
//		byte b =(byte)a;
//		System.out.println(b);
		int qi2 =233;
		float qf1=11.11f;
		int  qf2 =(int)qf1;
		System.out.println(qf2);// 11
	    int qi1 =111;
		byte qb1 = (byte)qi1;
		System.out.println(qb1);// 111
		byte qb2 = (byte)qi2;
		System.out.println(qb2);// -23
	}

}

6. 运算符

分类

算术运算符	+，-，*，/,%,++,–
关系运算符	>,<,>=,<=,==,!= 结果为true｜false
逻辑运算符	&，|，！，＆＆，|| ，^
位运算符	>>,<<,>>>,&,|,^,~
赋值运算符	=,+=,-=,*=,/=
条件运算符	？：
其他	. [ ] instanceof new type ()

算数运算符

运算符：+，-，*，/，%，++（自减），–（自加）

package lessonone;

public class DemoThree {
public static void main(String[] args) {
	int a = 100;
	int b = 3;
	System.out.println(a+b);
	System.out.println(a-b);
	System.out.println(a*b);
	System.out.println(a/b);
	System.out.println(a%b);
	int c =50;
	System.out.println(c++);//50
	System.out.println(c--); //51
	System.out.println(c);   //50
	int d = 50;
	System.out.println(++c); //51
	System.out.println(--c); //49
	System.out.println(c);   //50
}
}

取余：结果得到余数

c++:先把c放入表达式，再进行加1

++c：先进行+1，再放入表达式

关系运算符

关系运算符 >,<,>=,<=,==,!= 结果为true｜false

逻辑运算符

逻辑运算与关系运算的关系非常密切，关系运算是运算结果为逻辑型量的运算，而逻辑运算是操作数与运算结果都是逻辑型量的运算。

异或：

两个值相同，整个表达式为false。两个值不同，整个表达式为true。

简介与，或与非简洁与，或的区别：

1. 非简洁运算必须在计算完左右两个表达式之后，才取结果值。

2. 简洁运算只计算左边的表达式而不计算右边的表达式，

   1. 对于&&，计算完左边为false就不计算右边，整个表达式为false；

   2. 对于||，计算完左边为true，就不计算右边表达式，整个表达式为true;

赋值运算符

运算符：=

	int e;
	int f;
	e=f=0;
	System.out.println("e:"+e+"f:"+f);

位运算符

运算符：

1. & 按位与。同时为1返回1
2. | 按位或。只要有一位为1即可返回1
3. ～按位非。 单目运算符，将操作数的每个位（包括符号位）全部取反。
4. ^ 按位异或。 当两位相同时返回0，不同时返回1
5. “<<” 左移运算符
6. “>>” 右移运算符
7. ">>>"无符号右移运算符

注意：使用位运算符时，需要先把需要运算的数转换成二进制，再对每一位进行相关位运算。

&:与

按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下：
00001001 (9的二进制补码)
&00000101 (5的二进制补码)
00000001 (1的二进制补码)
可见9&5=1。

用途：

按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ，保留低八位，可作a&255运算（255 的二进制数为0000000011111111）。

|：或

^：异或

~：取反

单目运算符

求反运算符“~ ”为单目运算符，具有右结合性。其功能是对参与运算的数的各二进位按位求反。例如~9的运算为：
~(0000000000001001)
结果为：1111111111110110 -10

左移运算

左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如：
a<<4
指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

右移运算

右移运算符“>>”是双目运算符。其功能是把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。例如：
设 a=15，
a>>2
表示把000001111右移为00000011(十进制3)。

注意：

对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，

条件运算符（常用）

java语言提供了高效简便的三元条件运算符（？：）

表达式1？表达式2：表达式3

“表达式1”是一个结果为布尔值的逻辑表达式。

该运算符的功能是：

计算“表达式1”的值，当“表达式1”的值为true时，则将“表达式2”的值作为整个表达式的值；当“表达式1”的值为false时，则将“表达式3”的值作为整个表达式的值。

        int x,y,z;
		x = 6;
		y = 2;
		z = x>y ? x-y : x+y;

7. 本章小结

流程控制

1. 顺序结构

顺序结构就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束

2. 分支结构

分支结构又称为选择结构，是一种在两种以上的多条执行路径中选择一条执行的控制结构，这里所说的执行路径是指一组语句。通常分支结构要先做一个判断，然后根据判断的结果来决定选择哪一条执行路径。

判断语句

if()

if(条件表达式){  
    执行语句；       
}

public class LessonDemo {
    public static void main(String[] args) {
        int x=10;
        if(x>8){//条件表达式
            System.out.println("这是第一种if格式");//执行语句
        }
        System.out.println(x);
    }
}

if(){}else(){}

if(条件表达式){  
    执行语句；       
}else{          
    执行语句；   
}

public class LessonDemo {
          public static void main(String args[]){
                       System.out.println("请输入你的成绩：");
     Scanner in=new Scanner(System.in);
int score=in.nextInt();
                        if(score>90){
                                 System.out.println("nice");
                        }
                       else{
                                   System.out.println("出门右转");
                       }
           }
   }

if(){}else if(){}else

if(条件表达式){
       执行语句；
}else if (条件表达式){
      执行语句；
}else{
      执行语句；
}

public class LessonDemo {
          public static void main(String args[]){
                           int ability=6000;
                if(ability<5000 && ability>0){
                    System.out.println("你很好，可是我们不合适");
                }else if(ability>=5000 && ability<10000){
                    System.out.println("你很好，但是我们更适合做朋友");
                }else if(ability>=10000 && ability<30000){
                    System.out.println("你很好，但是我不想影响学习");
                }else if(ability>=30000){
                    System.out.println("你很好，可是我有喜欢的人了");
                }else System.out.println("就这样吧，还能更惨吗？");
         }
   }

if语句嵌套

public class LessonDemo {
          public static void main(String args[]){      
        int ability=6000;
		if(ability<0){
			System.out.println("你有可能吗?");
		}else{ 
			if(ability<5000){
			System.out.println("你很好，可是我们不合适");
			}else if(ability<10000){
				System.out.println("你很好，但是我们更适合做朋友");
			}else if(ability<30000){
				System.out.println("你很好，但是我不想影响学习");
			}else{
				System.out.println("你很好，可是我有喜欢的人了");
			}
		}
                 }
       }

分支结构

switch

格式:
int x = 1;
switch (表达式){//byte,short,int,char,String 枚举

case 表达式里对应的值:
    执行语句;
break;
case 表达式里对应的值:
    执行语句;
break;
......
default:
    执行语句;
break;//最后一句的break可写可不写,因为程序已经执行到了末尾
}

实践

         Scanner scan=new Scanner(System.in);//键盘输入
         System.out.println("请输入交通信号灯（红、绿、黄）：");
         String str=scan.next();
         char L=str.charAt(0);
         switch(L){
             case '红':
                 System.out.println("有木有交警？");
                 String str1=scan.next();
                 char P=str1.charAt(0);
               /* if(P=='有'){//第一种
                     System.out.println("stop");
                 }else{
                     System.out.println("go");
                 }*/
                 switch(P){//第二种
                 case '有':
                     System.out.println("stop");
                     break;
                 default:
                     System.out.println("go");
                 }
                 break;
             case '绿':
                 System.out.println("go");
                 break;
             case '黄':
                 System.out.println("wait");
                 break;
            default:
                System.out.println("call Police!!");
         }

注意：switch的每个分支必须有break，如果没有break，会直接进入下一分支，不论是否满足条件。

无break。

Scanner scan=new Scanner(System.in);//键盘输入
    System.out.println("请输入交通信号灯（红、绿、黄）：");
    String str=scan.next();
    char L=str.charAt(0);
    switch(L){
        case '红':
            System.out.println("有木有交警？");
            String str1=scan.next();
            char P=str1.charAt(0);
          /* if(P=='有'){//第一种
                System.out.println("stop");
            }else{
                System.out.println("go");
            }*/
            switch(P){//第二种
            case '有':
                System.out.println("stop");
                break;
            default:
                System.out.println("go");
            }
            break;
        case '绿':
            System.out.println("go");
            
        case '黄':
            System.out.println("wait");
        
//       default:
//           System.out.println("call Police!!");
    }

项目中

public enum AppStatusEnum {
    /**
     * 项目状态
     */
    //没有参与过项目的人
    ONGOING_APP(0, "开发中的项目"),
    //正在参与项目的人
    DONE_APP(1, "开发完成的项目"),
    //已参与过i项目
    PAUSED_APP(2, "暂停开发的项目"),
    MAINTAIN_APP(3,"维护中的项目");
    private final Integer status;
    private final String message;
    //项目模块的通用枚举
    AppStatusEnum(Integer status, String message) {
        this.status = status;
        this.message = message;

    }
    // 此方法是关键
    public static  AppStatusEnum getByStatus(Integer status) {
        for ( AppStatusEnum appStatus : values()) {
            if (appStatus.getStatus().equals(status)) {
                return appStatus;
            }
        }
        return null;
    }
}

Map<Integer,List<AppBaseDTO>> userBaseList = new HashMap<>();
userBaseList.put(AppStatusEnum.ONGOING_APP.getStatus(),new ArrayList<>());
userBaseList.put(AppStatusEnum.DONE_APP.getStatus(),new ArrayList<>());
userBaseList.put(AppStatusEnum.PAUSED_APP.getStatus(),new ArrayList<>());
userBaseList.put(AppStatusEnum.MAINTAIN_APP.getStatus(),new ArrayList<>());
UserBaseDTO userBaseDTO = systemMapper.selectUserJoinAppByUserId(userId);


switch(AppStatusEnum.getByStatus(app.getStatus())){
 case ONGOING_APP :
    userBaseList.get(AppStatusEnum.ONGOING_APP.getStatus()).add(app);
    break;
    case DONE_APP :
    userBaseList.get(AppStatusEnum.DONE_APP.getStatus()).add(app);
    break;
    case PAUSED_APP :
    userBaseList.get(AppStatusEnum.PAUSED_APP.getStatus()).add(app);
    break;
    case MAINTAIN_APP :
    userBaseList.get(AppStatusEnum.MAINTAIN_APP.getStatus()).add(app);
    break;
    default:
    throw  new BadRequestException("数据库或后端配置信息有误，请及时修改");
}

3. 循环结构

while

while循环在其控制条件为真时重复语句或块。

while(条件) { 
   //     执行语句;
}

 int n = 10;
 while (n > 0) {
      System.out.println("n:" + n);
      n--;
  }

debug使用

public class Main {
  public static void main(String[] args) {
    int limit = 20;
    int sum = 0;
    int i = 1;

    while (i <= limit) {
      sum += i++;
    }
    System.out.println("sum = " + sum);
  }
}

练习

public static void main(String[] args) {
		double sum =0;
		int n = 0;
		System.out.println("请输入多个数，每输入一个数后按Enter或Tab或空格键确认：");
		System.out.println("最后输入一个非数字结束输入操作");
		Scanner reader = new Scanner(System.in);
		while(reader.hasNextDouble()) {
			double x = reader.nextDouble();
			sum = sum+x;
			n++;
		}
		System.out.println("共输入了"+n+"个数，其和为："+sum);
	}

do while

要执行while循环的主体至少一次，可以使用do-while循环。

do { 
   // 执行语句
} while (条件);

public static void main(String[] args) {
		   int n = 10;
		    do {
		      System.out.println("n:" + n);
		      n--;
		    } while (n<=10);
	}    
//无限x

测试

    int n = 10;
    do {
      System.out.println("n:" + n);
      n--;
    } while (n > 0);

for

for语句是Java语言三个循环语句中功能较强，使用较广泛的一个。

for(表达式1；条件表达式；表达式2){
    循环体
}

表达式1”是用作初始化的表达式，完成初始化循环变量和其他变量的工作；

“条件表达式”的返回值为逻辑型量，用来判断循环是否继续；

“表达式2”是循环后的操作表达式，用来修改循环变量，改变循环条件。三个表达式之间用分号隔开。

求1～10的累加和。

public static void main(String[] args) {
        int b =0;
		for(int a=  0;a<10;a++) {
			b++;
		}
		System.out.println(b);
}

扩展：for循环的其他形式

1. 多个表达式1，多个条件，多个表达式2

public static void main(String[] args) {
		 for(int b =0,s=0,p=0;b<10&&s<4&&p<10;p++,b++,++s) {
			 System.out.println("b"+b);
			 System.out.println("s"+s);
			 System.out.println("p"+p);
		 }
	}

2. 两个；是必须的

 		 int a = 0;
		 for(;a<10;) {
			 a++;
			 System.out.println(a);
		 }

3. 没有条件

 for(;;) {
			 System.out.println(a);
		 }

嵌套循环

		//外层循环
		for(int a = 0;a<3;a++) {
			//内层循环
			for(int b=0;b<3;b++) {
				System.out.println(a);
				System.out.println(b);
			}
		}

练习题1：打印9*9乘法表

 //第一种
        for(int m=1;m<=9;m++){
            for(int n=1;n<=9;n++){
                System.out.print(m+" "+"X"+" "+n+" "+"="+" "+m*n+" ");
                
            }
            System.out.print("\n");
        }
        
        //第二种
        System.out.println("--------------------------------------------------");
        for(int m1=1;m1<=9;m1++){
            for(int n1=1;n1<=m1;n1++){
                System.out.print(m1+" "+"X"+" "+n1+" "+"="+" "+m1*n1+" ");
            }
            System.out.print("\n");
        }

4.控制循环结构

continue

中断本轮循环，继续下一轮循环

		//终止循环
		for(int a =0;a<10;a++) {
			if(a==2) {
				continue;
			}
			System.out.println(a);
		}

扩展：在指定位置进入下一轮循环

        outer:
		for(int a =1;a<=10;a++) {
			for(int b=1;b<=10;b++) {
				if(b==3) {
					continue outer;	
				}
				System.out.println("b"+b);
			}
		System.out.println("a"+a);
		}

break

终止循环

		for(int a =1;a<=10;a++) {
				for(int b=1;b<=10;b++) {
					if(b==3) {
						break;	
					}
				System.out.println("b"+b);
				}
		System.out.println("a"+a);
			}

扩展：在指定位置终止循环

		outer:
		for(int a =1;a<=10;a++) {
			for(int b=1;b<=10;b++) {
				if(b==3) {
					break outer;	
				}
				System.out.println("b"+b);
			}
		System.out.println("a"+a);
		}

return

结束当前方法,不论套了多少层循环

			  for(int a =1;a<=10;a++) {
					for(int b=1;b<=10;b++) {
						if(b==3) {
							return;
						}
						System.out.println("b"+b);
					}
					System.out.println("a"+a);
				}

课后练习

练习题：所谓素数（又叫质数）是指只能被1和它本身整除的数字，1除外。输入一个正整数，判断是否为素数。