分支结构+循环结构

我们自从开始写Java代码,就一直说方法方法,main方法啦,print方法啦,那到底什么是方法呢,我们现在就来具体学习一下

1.流程控制概述

第一种: 顺序结构
是指按照代码的书写顺序,从上往下执行
默认所有代码都是按照顺序结构来执行
第二种: 分支结构
if分支结构
switch分支结构(了解)
第三种: 循环结构
如果有某一行代码或者某些行代码需要重复的执行若干次,这样的结构叫做循环结构
for循环
while循环
do…while循环(了解)
foreach循环(增强for循环)

2.分支结构(重点掌握)

2.1. if(重点掌握)

2.1.1.概述

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构

2.1.2.形式

当我们遇到一种情况需要判断是还是不是的时候,就可以使用单分支判断,举个例子,如果XXX同学是男生就应该去男厕所

格式1: 单分支
if(布尔表达式){
	//代码...
}
判断条件执行成立时
如果if后面的表达式为true,就会执行大括号{}里面的代码
if和else后面的大括号({})可以省略,但省略后在执行时只会执行if和else后面的第一行代码。
if(布尔表达式)
	//代码1，如果上面的布尔表达式为true，只会执行代码1
//代码2，如果上面的布尔表达式为true，代码2执行不到

代码示例

package cn.tedu;
/**
 * 单条件分支结构
 * if(条件表达式){
 * 	 //满足条件执行的代码
 * }
 * @author Administrator
 *
 */
public class SingleIfDemo {

	public static void main(String[] args) {
		int score = 59;
		//百分制中分数大于60就是及格
		if(score > 60) { //满足条件才执行
			System.out.println("及格!!!");
		}
	}
}

但是我们生活中,并不是总是这种单分支判断,比如我们也会有这样的抉择,如果XXX同学是男生就应该去男厕所,否则就应该去女厕所,那么这种就是两种判断了对吧

格式2: 多分支
if(布尔表达式){
	//代码若干行...
}else{
	//代码若干行...
}
如果if后面的表达式为true,就会执行if后面大括号{}里面的代码
如果表达式为false,就会执行else后面大括号{}里面的代码

代码示例:

package cn.tedu;
/**
 * 多分支if-else
 * if(表达式){
 * 		//满足执行条件的代码
 * }else{
 * 	   //不满足条件执行的代码
 * }
 * @author Administrator
 */
public class IfElseDemo {
	public static void main(String[] args) {
		int score  = 19;
		if(score > 60) { //满足
			System.out.println("及格");
		}else {  //不满足
			System.out.println("不及格,得努力学习");
		}
	}
}

当然啦,还有更多的可能,比如XXX同学是男生就要去男厕所,如果是女生就去女厕所,如果不是男的也不是女的就应该去哪里呢?但是确实是有多种情况会发生

格式3: 嵌套分支
if(布尔表达式1){ 
	//代码若干行...
}else if(布尔表达式2){ 
	//代码若干行...
}else if(布尔表达式3){
	//代码若干行...
}else if(布尔表达式n){
	//代码若干行...
}else{
	//代码若干行...
}
如果if后面的表达式1为true,就会执行if后面大括号{}里面的代码
如果else if后面的表达式2为true,就会执行else if后面大括号{}里面的代码
...
如果上面的条件都不满足,最后会执行else后面大括号里面的代码

3.案例练习

接收用户输入的原价。
满1000打9折。
满2000打8折。
满5000打5折。

package cn.tedu.ifdemo;
import java.util.Scanner;
//这个类用来测试商品打折案例
public class Test1_If {
       public static void main(String[] args) {
              //1、接收用户输入的原价
              double price = new Scanner(System.in).nextDouble();
              //2、计算折后价
              double count = price;//用来保存折后价
              if(price> = 5000){//满5000。
                     count = price * 0.5;//打5折
              }else if(price >= 2000){ //满2000
                     count = price * 0.8;//打8折
              }else if(price >= 1000){ //满1000打9折
                     count = price * 0.9;
              }
              System.out.println("原价是："+price+"，折后价是："+count);
       }
}

BMI指数计算

package day0302;

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		System.out.print("体重：");
		//获得输入的值，再保存到变量 w
		
		//局部变量，作用域在他定义的代码块内有效
		double w = new Scanner(System.in).nextDouble();
		
		System.out.print("身高：");
		double h = new Scanner(System.in).nextDouble();
		
		//调用 f() 方法，根据 w 和 h 的值，求出 bmi 指数
		f(w, h);
	}//main结束
	
	static void f(double weight, double height) {
		double bmi = weight / (height*height);
		String r = ""; //用来保存最终结果的变量
		//根据 bmi 指数范围，来给r重新赋值
		if(bmi < 18.5) {
			r = "过轻";
		} else if(bmi <= 22.9) {
			r = "正常";
		} else if(bmi <= 24.9) {
			r = "偏胖";
		} else if(bmi <= 29.9) {
			r = "肥胖";
		} else if(bmi <= 40) {
			r = "重度肥胖";
		} else {
			r = "极度肥胖";
		}
		System.out.println("BMI指数："+bmi);
		System.out.println("您的体重属于："+r);
	}
	
}

年龄段划分

/*
*  根据年龄判断年龄段
*  青年人：20(包括) ~ 40(不包括)
*  中年人：40(包括) ~ 60(不包括)
*  老年人：60(包括)以上
*/
public class IfDemo1 {
	public static void main(String[] args) {
		System.out.println( "请输入您的年龄:" );
		byte age = new Scanner(System.in).nextByte();
		if( age>=18 && age<40 ) {
			System.out.println( "您属于青年人!" );
		}else if( age>=40 && age<60 ) {
			System.out.println( "您属于中年人!" );
		}else if( age>=60 ) {
			System.out.println( "您属于老年人!" );
		}else if( age>=0 && age < 18 ){
			System.out.println( "您属于未成年人!" );
		}else {
			System.out.println( "您输入的年龄有误!" );
		}
	}
}

成绩转换

/* 
* 实现一个分数评级小程序：提示用户在控制台输入考试成绩，如果成绩：
* 大于90，小于等于100，为 "优秀"；
* 大于80，小于等于90，为 "良好"；
* 大于70，小于等于80，为 "中等"；
* 大于等于60，小于等于70，为 "及格"；
* 小于60为 "不及格"；
* 如果以上都不是，则提示 "输入有误"
*/
public class IfDemo2 {
	public static void main(String[] args) {
		System.out.println( "请输入您的成绩(百分制):" );
		byte score= new Scanner(System.in).nextByte();
		if( score>=90 && score<100 ) {
			System.out.println( "优秀!" );
		}else if( score>=80 && score<90 ) {
			System.out.println( "良好!" );
		}else if( score>=70 && score<80) {
			System.out.println( "中等!" );
		}else if(score>=60 && score<70){
			System.out.println( "及格!" );
		}else if( score>=0 &&score<60 ){
			System.out.println( "不及格!" );
		}else {
			System.out.println( "您输入的成绩有误!" );
		}
	}
}

4.switch

4.1.概述

switch分支在开发中用的并不多！
switch分支用于判断一个变量的值,与case中的某个值是否相等,如果相等,则执行该case中的代码
switch可以接收的类型有: byte,short,int,char,String(JDK1.7)

4.2.形式

switch( x ){
	case value1:{
		//代码...
		break; //防止穿透
	}
	case value2:
		//代码...
		break; 
		...
	case valueN:{
		//代码...
		break; 
	}
	default: {
		//代码...
	}
}

执行规则如下:
1)传入switch语句的变量类型可以是: byte/short/int/char,jdk1.7之后开始支持String类型
2)当执行switch语句时,会拿着传过来的变量值 和 case 后的每一个值进行比较,如果相等,就会执行该case后的代码
3)每一个case中的break关键字可以防止穿透效果
4)如果所有case后的值都不匹配, 最后会执行default中的代码。
5)case value:后面的大括号可以省略,也可以加上,两者没有任何区别

5.switch案例

数字匹配

package cn.tedu.ifdemo;
//这个类用来测试switch分支结构
public class Test2_Switch {
    public static void main(String[] args) {
       int a = 20;
       //a--可以支持5种类型：byte short int char jdk1.5后支持String
       switch(a) {
       case 1:System.out.println(1);
       case 2:System.out.println(2);break;
       case 3:System.out.println(3);
       case 4:System.out.println(4);
       //1、当成功匹配到case会执行代码，并继续向后穿透所有case包括default
       //2、break的作用用来结束程序
       //3、当没有匹配到任何case时，只会执行default的代码
       default:System.out.println(0);
       }
    }
}

手机选号

尾数8,50
尾数4,免费
其他,20
项目：day0303_手机选号
类：day0303.Test1
package day0303;
import java.util.Scanner;
public class Test1 {
	public static void main(String[] args) {
		System.out.println("输入手机号：");
		String s = new Scanner(System.in).nextLine();
		//调用f()方法，把s的值，传递到f()方法中，计算价格
		f(s);
	}//main结束
	static void f(String tel) {
		//tel的长度，必须是11
		if(tel.length() != 11) {
			System.out.println("号码格式错误");
			return;//结束方法，返回到调用位置再继续执行
		}
		/*
		 * tel =  "2313123123"
		 * 取最后一个字符
		 * char c = tel.charAt(10)
		 */
		//取第11个字符，它的下标位置是10
		char c = tel.charAt(10);
		//用来保存最终结果的变量 price
		int price = 0;
		//根据c字符的值，来为price重新赋值
		switch(c) {
		case '8': price=50; break;
		case '4': price=0; break;
		default: price=20;
		}
		//显示价格
		System.out.println("价格："+price);
	}
}

实现ATM机系统(简易)
实现一个模拟ATM机系统，根据用户输入的代码，打印不同的操作
例如, 输入操作: 1-查询余额, 2-存钱, 3-取钱, 4-退出
1:查询成功!
2:存钱成功!
3:取钱成功!
4:退出!
其他:您的输入有误，请重新输入！

public class SwitchDemo1 {
	public static void main(String[] args) {
		//1.提示用户输入相应的操作代码
		System.out.println( "欢迎使用达内ATM机系统..." );
		System.out.println( "请输入1:查询账户,2:存钱,3:取钱,4:退出" );
		//2.接收用户输入的操作代码
		int x = new Scanner(System.in).nextInt();
			//3.通过switch判断x的值,并执行相应的操作
		switch( x ) {
			case 1:
				System.out.println( "您的账户余额为1000.0元" );
				break; //防止穿透效果
			case 2:
				System.out.println( "存钱成功,账户余额为1500.0元" );
				break;
			case 3:
				System.out.println( "取钱成功,账户余额为1300.0元" );
				break;
			case 4:
				System.out.println( "退出成功,谢谢使用" );
				break;
			default:
				System.out.println( "输入错误,请重新输入!" );
		}
	}
}

实现ATM机系统(增强)
对上面练习中的ATM系统进行增强，实现查询余额、存钱、取钱操作。
例如, 输入操作: 1-查询余额, 2-存钱, 3-取钱, 4-退出
1:您的账户余额为：
2:请放入您的钞票…(输入存入的金额)：
…
存钱成功! 您的账户余额为：" + balance
3:请输入您的取款金额：
如果余额>=取款金额:
取款成功! 请收好您的钞票!
否则:您的账户余额不足!
4:请收好您的卡片，谢谢使用!
其他:您的输入有误，请重新输入！

/*
 * 实现模拟ATM机系统
 */
public class SwitchDemo2 {
	public static void main(String[] args) {
		//1.声明一个变量, 用于记录账户的余额(假设账户余额为3000)
		double balance = 3000;
		//2.提示用户输入相应的操作代码
		System.out.println( "欢迎使用达内ATM机系统..." );
		System.out.println( "请输入 1:查询账户, 2:存钱业务, 3:取钱业务, 4:退卡 " );
		//3.接收用户输入的操作代码
		int x = new Scanner(System.in).nextInt();
		//4.通过switch结构判断x的值,并执行相应的操作
		switch( x ) {
			case 1:
				System.out.println( "您的账户余额为: "+balance );
				break; //防止穿透
			case 2:
				System.out.println( "请输入要存入的金额: " );
				//接收用户存入的金额数量
				double money = new Scanner(System.in).nextDouble();
				//将用户存入的钱数 和 账户余额相加
				balance += money; //balance = blance+money;
				System.out.println("存钱成功!账户余额为"+balance+"元!" );
				break;
			case 3:
				System.out.println( "请输入要取的金额: " );
				//接收用户要取的金额
				double money2 = new Scanner(System.in).nextDouble();
				//取款金额要小于或等于账户余额
				if( money2 <= balance ) {
					balance -= money2; //balance = balance - money2;
					System.out.println("取钱成功!账户余额为"+balance+"元!" );
				}else {
					System.out.println( "取钱失败! 账户余额不足!" );
				}
				break;
			case 4:
				System.out.println( "退出成功,谢谢使用!" );
				break;
			default: 
				System.out.println( "输入代码有误, 请重新输入" );
		}
	}
}

6.循环结构

顺序结构的程序语句只能被执行一次。如果想要重复的(或有规律的)执行某一个操作，就需要使用循环结构。
例如：如果让你在控制台输出一百次 “Hello World！”，你将如何完成？

6.1.for

for(开始条件;循环条件;更改条件){
    循环体;
}

1）最先执行初始化步骤，且只执行一次。这里可以声明一种类型，也可以同时初始化一个或多个循环控制变量，也可以是空语句。
2）其次，检测循环条件（是一个布尔表达式）的值。如果为 true，循环体被执行；如果为false，循环终止，开始执行循环语句后面的语句。
3）在执行一次循环体后，再执行更新部分，也就是更新循环控制变量。
4）再次检测布尔表达式。重复执行2~3步骤。（当第二步中的布尔表达式为false时，停止循环）

for( int i = 0; i<100 ;i++) {
	System.out.println("HelloWorld!---"+i);
}

执行过程解析：
1)第001次执行: 先执行 int i=0;(这一部分只执行一次), 再执行 i<100(true), 执行大括号里面的内容(循环体), 最后执行i++(此时i=1)
2)第002次执行: 执行 i<100(i=1,true),再执行循环体,最后执行i++(此时i=2)
3)第003次执行: 执行 i<100(i=2,true),再执行循环体,最后执行i++(此时i=3)
…
4)第099次执行: 执行 i<100(i=98,true),再执行循环体,最后执行i++(此时i=99)
5)第100次执行:执行i<100(i=99,true),再执行循环体,最后执行i++(此时i=100)
6)第101次执行: 执行 i<100(i=100,false),循环结束

6.2.for案例

打印 1 ~ 100 之间的所有整数值，用空格隔开

for( int i = 0; i<100 ;i++) {
	System.out.print(i+1+" ");
}
//==============================
for( int i = 1; i<=100 ;i++) { //5050
	System.out.print(i+" ");
}

打印100到1

//打印100到0
for(int i = 100 ; i >= 1 ; i-- ){
    System.out.println(i);
}

求 1~100 之间所有的整数值的和，并输出到控制台

int sum = 0;
for(int i=1;i<=100;i++){ //1,2,3,4...99,100
	sum = sum+i; //sum += i
}
System.out.println( "1~100之间所有整数的和为:"+sum )

求 1~100之间所有奇数的和, 输出到控制台

int sum2 = 0;
for( int i=1; i<=100; i+=2 ) {
	sum2 = sum2 + i;
}
int sum2 = 0;
for( int i=1; i<=100; i++ ) {
	if( i % 2 == 1 ){ //如果是奇数,就累加到sum2上
		sum2 += i;
	}
}

求 1~100之间所有偶数的和, 输出到控制台

int sum3 = 0;
for( int i=0; i<=100; i+=2 ) {
	sum3 = sum3 + i;
}
System.out.println( "1~100之间所有偶数的和为:"+sum3 );//2550
-----------------------------------
int sum3 = 0;
for( int i=0; i<=100; i++ ) {
	if( i % 2 == 0 ){ //如果是偶数,就累加到sum3上
		sum3 += i;
	}
}

鸡兔同笼
鸡兔共35只
共94只脚
鸡和兔各几只
穷举法
鸡 兔
0 35
1 34
2 33
3 32
…
23 12
…
35 0

package day0305;
public class Test1 {
	public static void main(String[] args) {
		//鸡j: 0到35
		//兔t: 35到0
		for(int j=0,t=35; j<=35; j++,t--) {
			//脚的数量是94
			if(j*2 + t*4 == 94) {
				System.out.println("鸡："+j+"， 兔："+t); 
			}
		}
	}
}

随机生成十道加法题

package com.tedu;

import java.util.Random;
import java.util.Scanner;
public class a {
	public static void main(String[] args) {
		int yesCount=0;
		int noCount=0;
		for(int i=0;i<10;i++) {
			int a = new Random().nextInt(11);
			int b = new Random().nextInt(11);
			System.out.println("第"+(i+1)+"题:"+a+"+"+b+"=?");
			int answer = new Scanner(System.in).nextInt();
			if(answer==(a+b)) {
				System.out.println("恭喜答案正确,奖励一颗糖果!!");
				yesCount++;
			}else {
				System.out.println("可惜打错!!!打屁屁");
				noCount++;
			}
			System.out.println("第"+(i+1)+"题答案:"+(a+b));
		}
		System.out.println("答对"+yesCount+"道题,打错"+noCount+"道题");
	}
}

打印8,88,888,8888

//     打印8,88,888,8888,
for(int i = 8 ; i <= 8888 ; i=i*10+8){
    System.out.print(i+",");
}

阶乘
5!=5x4x3x2x1
0!=1

package day0306;
import java.util.Scanner;
public class Test1 {
	public static void main(String[] args) {
		System.out.print("输入整数，求阶乘：");
		int n = new Scanner(System.in).nextInt();
		//调用f()方法，把n的值传递到f()方法，求阶乘
		f(n);
	}
	private static void f(int n) {
		if(n<0) {
			System.out.println("无");
			return;//方法结束，返回到调用位置继续执行
		}
		if(n == 0) {
			System.out.println("0的阶乘：1");
			return;
		}
		/*
		 * r = 5
		 * 
		 * i
		 * 4, r=r*i
		 * 3, r=r*i
		 * 2, r=r*i
		 * 1, r=r*i
		 */
		long r = n;
		for(int i=n-1; i>=1; i--) {
			r *= i;
		}
		System.out.println(n+"的阶乘："+r);
	}
}

7.嵌套for循环(重点掌握)

如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。
嵌套循环既可以是for循环嵌套for循环，也可以是while循环嵌套while循环，或者for循环嵌套while循环……即各种类型的循环都可以作为外层循环，也可以作为内层循环

for( 初始化; 循环条件; 更新) { //外层循环
	 ...外循环体
	 for( 初始化; 循环条件; 更新) { //内层循环
	    //内循环体
	}
	...外循环体
}

执行规则如下:
1）最先执行初始化步骤，且只执行一次。这里可以声明一种类型，也可以同时初始化一个或多个循环控制变量，也可以是空语句。
2）其次，检测循环条件（是一个布尔表达式）的值。如果为 true，循环体被执行；如果为false，循环终止，开始执行循环语句后面的语句。
至于循环体中包含的for循环, 则执行过程则和外层循环一样，只是外层循环每执行一次，内层循环都需要完整的执行一遍！
3）在执行一次循环体后，再执行更新部分，也就是更新循环控制变量。
4）再次检测布尔表达式。重复执行2~3步骤。（当第二步中的布尔表达式为false时，停止循环）
假设外层循环的循环次数为n次，内层循环的循环次数为m次，那么内层循环的循环体实际上需要执行n*m次

8.嵌套for循环案例

外层循环（i=1,i<=3）循环3次，内层循环（j=1,j<=5）循环5次, 在循环中输出i和j的值。

public static void main(String[] args) {
    //外层循环执行3次，i为 1、2、3
    for (int i = 1; i <= 3; i++) {
    	System.out.println( "i="+i );
    	//内层循环执行5次，j为1、2、3、4、5
    	for (int j = 1; j <= 5; j++) {
    		System.out.print( "j="+j+"\t" );
    	}
    	System.out.println();
    }
}

数字矩阵
要求：使用嵌套for循环打印如下所示效果
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
5 5 5 5 5

public class ForDemo2 {
	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
	      	//输出5遍i的值
			for (int j = 1; j <= 5; j++) {
				System.out.print( i + "\t" );
			}
	      	//换行
			System.out.println();
		}
	}
}

打印左直角三角形
在控制台打印一个由5行 “*” 组成的正立的直角三角形，如下所示。
*
**
***
****
*****

public class ForDemo3 {
	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();//换行
		}
	}
}

打印99乘法表
要求：使用嵌套for循环打印九九乘法表（9*9），如下所示。
1x1=1
1x2=2 2x2=4
1x3=3 2x3=6 3x3=9
1x4=4 2x4=8 3x4=12 4x4=16
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

for(int i = 1 ; i <= 9;i++){//外循环，执行9次，打印9行
   for(int j=1;j<=i;j++){//内循环,修改内循环的循环条件,让j跟随i改变就可以
		//System.out.print("3*2=6");//3是行号，2是列号，6是行列的乘积
    	System.out.print(i+"*"+j+"="+i*j+" ");
   }
   System.out.println();
}
for (int i=1;i<=9;i++){
		for (int j =1;j<=9;j++){
			if(j<=i){
				System.out.print(j+"*"+i+"="+(i*j)+"\t");
			}
		}
		System.out.println();
}

生成等腰三角形
*

---

---

---

---

package com.tedu;

import java.util.Random;
import java.util.Scanner;

public class a {
	public static void main(String[] args) {
		for(int i = 0;i<5 ;i++ ){
			for(int j = 0;j<9 ;j++ ){
				if(j>=4-i&&j<=i+4){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
			}
			System.out.println();
		}
	}
}

9.break 和 continue(重点掌握)

接下来我们来学习两个关键字,break和continue,这两个关键字都是结束循环的作用,只不过这两个关键字实现方式不一样

9.1.break关键字

break主要用在循环语句或者switch语句中,用来跳出整个语句块。
break用在循环中用于跳出/结束当前循环,并且继续执行该循环下面的语句

9.2.break示例

循环输入整数,计算所有数值的和,当输入0时结束程序,最终输出所有数值的和

public class BreakDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println( "请输入数值:");
		//声明一个变量sum,用于记录输入的所有数值的和
		int sum = 0;
		for ( ; ; ) { //死循环
			int num = sc.nextInt();
			//判断当前数值是否为0,如果为0,则结束当前整个循环,执行循环下面的语句
			if( num == 0 ) {
				break;
			}
			//如果当前数值不为0,则将数值累加到sum上
			sum = sum + num;
		}
		System.out.println( "输入的所有数的和为："+sum );
	}
}

9.3.continue关键字

continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在for循环中,continue语句使程序立即跳转到更新语句。
在while或者do…while循环中,程序立即跳转到布尔表达式的判断语句

9.4.continue示例

计算1-100之间所有奇数的和（要求：使用continue关键字）

public class ContinueDemo {
	public static void main(String[] args) {
		//声明变量 
		int oddSum = 0;
		for(int i = 1; i <= 100; i++ ) {
			//判断当前i的值,若i为偶数,若是则继续下一次循环
			if( i % 2 == 0) {
				continue; //直接进入更新部分,下面的代码不再执行
			}
			//若i为奇数,则将i的值累加给sum
			oddSum = oddSum + i;
		}
		System.out.println( "1-100之间所有奇数的和为："+oddSum );
	}
}

9.5.break和continue练习

package day0402;

public class Test1 {
	public static void main(String[] args) {
		System.out.println("\n\n---------------");
		f1();
		System.out.println("\n\n---------------");
		f2();
	}
	private static void f1() {
		// 随机浮点数,[0,1)
		//double d = Math.random();
		//System.out.println(d);
	
		// >0.999
		//i变量用来计次
		for(int i=1; ;i++) {
			double d = Math.random();
			if(d>0.999) {
				System.out.println("第"+i+"次："+d);
				break;
			}
		}
		//System.out.println("循环已经结束");
	}
	private static void f2() {
		//打印1到100,跳过尾数3,5,7
		for(int i=1;i<=100;i++) {
			int y = i%10;
			if(y==3 || y==5 || y==7) {
				continue;
			}
			System.out.println(i);
		}
	}
}

找数字88
接收用户输入的100次数字,
如果不是88继续输入,找到88就结束

package cn.tedu.method;
 
import java.util.Scanner;
 
//这个类用来测试break和continue
//总结1：break是只要遇到循环立刻结束。continue是结束当前循环可以继续下一次的循环
public class Test2_Break {
    public static void main(String[] args) {
       method();//调用method()
    }
    
    //创建method()
    public static void method() {
       for(int i = 1 ; i <= 100 ; i++) {//控制for循环可以执行100次
           //接收用户输入的100次数字
           int input = new Scanner(System.in).nextInt();
           if(input != 88) { //如果不是88
              continue;//继续输入
//            System.out.println(0);//break或者continue之后都不允许写代码,都是不可到达的代码
           }else if(input == 88) {//找到88
              System.out.println("恭喜您,猜对了！");
              break;//结束
//            System.out.println(1);
           }
       }
    }
}