第四讲 流程控制
| 课程大纲 | 课程内容 | 学习效果 | 掌握目标 |
| Java流程控制 | 多重循环 | 掌握 | 熟练掌握多重循环的使用方式 |
| String类入门 | 掌握 | 初步了解String类的使用方式 | |
| While循环 | 掌握 | 熟练掌握while循环使用方式 | |
| do while 循环 | 了解 | 了解do while循环使用方式 | |
| 随机数 | 掌握 | 熟练掌握java中生成随机数的方式 | |
| 方法 | 掌握 | 熟练掌握java方法的格式、定义和调用方式 | |
| 方法重载 | 掌握 | 熟练掌握方法重载的含义和使用方式 |
一、多重循环（嵌套循环）
1、多重循环概念：
在一次循环中，每次的循环内容（循环体）又是一个复杂的操作，是重复的操作，就需要在大循环中，定义一个小循环。称为循环的嵌套。
格式
for (初始化语句1; 条件表达式1; 初始化变量1的自增) {
for ( 初始化语句2 ; 条件表达式2 ; 初始化变量2的自增 ) {
循环体语句;
}
}执行流程：
1、初始化语句1
2、判断条件表达式1，计算如果为false，外层循环结束
3、判断条件表达式1，计算如果为true，初始化语句2
4、计算条件表达式2，计算结果为false，内循环结束，执行初始化变量1的自增，回到第2步
5、计算条件表达式2，计算结果为true，执行循环体语句，
6、执行初始化变量2的自增，回到第4步
示例代码
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 5; j++) {
System.out.println("i=" + i + ", j=" + j);
}运行结果
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=1, j=5
i=2, j=1
i=2, j=2
i=2, j=3
i=2, j=4
i=2, j=5
i=3, j=1
i=3, j=2
i=3, j=3
i=3, j=4
i=3, j=52、案例
案例1：输出图形：
*****
*****
*****
*****
public static void main(String[] args) {
//死去活来法(常量变异法)
/*
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
*/
for(int i=1;i<=4;i++){ // 输出4行
/*
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.print("*");
*/
for(int j=1;j<=5;j++){ // 每行输出5个*
System.out.print("*");
}
System.out.println(); // 输入一个换行
}
// 总结： 双重循环，输出的内容是平面。外层循环控制输出多少行，内层循环控制每行的内容
}
*案例2：输出图形：
***
*****
*******
*********
| /* ----------------------- * *** ***** ******* ********* 行数： 1 2 3 4 5 i 空格数： 4 3 2 1 0 j = 5-i 星数： 1 3 5 7 9 k = 2*i-1
----------------------- */ public static void main(String[] args) { for(int i=1;i<=5;i++){ // 控制行数 for(int j=1;j<=5-i;j++){ // 负责输出本行的空格 System.out.print(" "); } for(int k=1;k<=2*i-1;k++){ // 负责输出本行的* System.out.print("*"); } System.out.println(); // 换行 } } |
案例3：输出图形：
*
* *
* * *
* * * *
* * * * *
| /* --------------------- * * * * * * * * * * * * * * * --------------------- 行： 1 2 3 4 5 i 空： 4 3 2 1 0 j = 5-i 星： 1 2 3 4 5 k = i */ public static void main(String[] args) {
for(int i=1;i<=5;i++){ for(int j=1;j<=5-i;j++){ System.out.print(" "); } for(int k=1;k<=i;k++){ System.out.print("* "); } System.out.println(); } } |
案例4：输出99乘法表：
| public class Demo06_输出99乘法表 { public static void main(String[] args) { for(int i=1;i<=9;i++){ for(int j=1;j<=i;j++){ System.out.print(j+"*"+i+"="+(i*j)+"\t"); } System.out.println(); } } } |
二、String类型入门
1、概念
字符串：由字符组成的串，String是引用数据类型。
2、定义
定义：String s = “aaa”;
String s = “”;空串
由于字符串在java中的使用频率非常高，所以java为String类型提供了类似于基本数据类型的定义方式。
3、方法
1 获取字符串长度
| int length = s.length(); |
2 获取字符串中的某个字符
获取字符串中某个位置的字符(下标索引从0开始)，得到char类型的值。
| char c = s.charAt(0); 获得到 ‘a’ |
|
|
4、案例
案例1：获取字符串的第一个字符
| char c1 = str.charAt(0); |
案例2：获取字符串的最后一个字符
| char last= str.charAt(str.length()-1); |
案例3：分行输出字符串的每个字符
| String str = "Helloworld"; for(int i=0;i<str.length();i++){ System.out.println(str.charAt(i)); } |
案例4：String str = "aaa bbb ccc"; 去掉所有空格
| /* * 思路： 1 先拿一个空串 * 2 遍历原来的字符串（取出每个字符串），判断取出的字符是不是空格 * 3 如果不是空格，串到空串上。如果是空格，不要 * */
// 去掉字符串中的所有空格 String str = "aaa bbb ccc ddd"; String result = ""; // 空串 for(int i=0;i<str.length();i++){ char ch = str.charAt(i); if(ch!=' '){ result =result+ch; } } System.out.println(str); System.out.println(result); |
案例5：反转字符串
|
String str = "abcdefg"; String result = "";
/* 方式一 for(int i=str.length()-1;i>=0;i--){ result = result+str.charAt(i); } System.out.println(result); */
/*方式二 for(int i=0;i<str.length();i++){ result =result+str.charAt(str.length()-1-i); } System.out.println(result); */ // 方式三 for(int i=0;i<str.length();i++){ char c = str.charAt(i); result = c+result; // result= result +.... } System.out.println(result); |
三、while循环
1、概述
格式：
| 初始化表达式① while(布尔表达式②){ 循环体③ 步进表达式④ } |
执行流程：
执行顺序：①②③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句。
④循环后，循环变量的变化情况。
2、案例
案例1：输出10次 “好好学习，天天向上”
方式一：
| int count = 0; // 计数器 while(true){ // 退出循环的条件 if(count==10){ // 一直判断count的值，当达到10时，退出循环(已经执行了10次了 0-9) break; // 手动break跳出循环 } System.out.println("好好学习，天天向上"); count++; // 每执行一次循环 count就加1 } |
方式二：
| int i = 0; // 初始化表达式 while(i<10){ // 不满足条件时，自动退出循环 System.out.println("好好学习，天天向上"); i++; // 步进表达式 } |
案例2：输出1到100
| int i = 1; while(i<=100){ System.out.println(i); i++; } |
案例3：在控制台输出1,3,5,7,9
| public static void main(String[] args) { int i = 1; while(i<10){ System.out.println(i); i+=2; } } |
案例4：输出1到100之间能被3整除的数
| public static void main(String[] args) { int i = 1; while(i<=100){ if(i%3==0){ System.out.println(i); i++; } } } |
案例5：输出1到100之间能被3整除的前5个数
| public static void main(String[] args) {
int i = 1; int count = 0; // 计数器 while(true){ if(count==5){ // 找到5个后 退出循环 break; }
if(i%3==0){ // 输出所有可以被3整除的数 System.out.println(i); count++; } i++; } } |
案例6：计算1+2+3+4+5+6+7+8+9+10 的值
| int sum = 0; int i =1; while(i<=10){ sum += i; i++; } System.out.println(sum); |
3、for 和while的区别
| public static void main(String[] args) { for (int x = 0; x < 5; x++) { System.out.println("hello java"); } System.out.println(x); //x cannot be resolved to a variable
int y = 0; while (y < 5) { System.out.println("hello world"); y++; } System.out.println(y); } |
错误。
解释： x 为什么会找不到,注意变量的作用域,也就是变量的作用范围。x 只在 for 循环的大括号内有效,出了这个区域，就无效了.在内存中就消失了。x消失后,仍要访问它,肯定会报错的。
y 就不一样了，y 是定义在while 外的，while循环完毕仍有效。while的初始化动作在外边，循环结束后y 仍然存在。
当定义的y 只作为循环增量存在的话的，循环完毕后y就没有用了，但是y还是占着一块内存。所以，如果定义的变量只作为循环增量存在的话，就用for 循环可以节约内存。
其实for 和while 是可以互换的。
总结：
3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。推荐使用while(true) |
四、do while循环
- 概述
格式：
| 初始化表达式① do{ 循环体③ 步进表达式④ }while(布尔表达式②); |
执行流程
执行顺序：①③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句
④循环后，循环变量的变化情况
注意事项
1、循环条件表达式必须是boolean类型。
2、while循环条件后面，要有一个分号。
示例代码
| int i = 1; do{ System.out.println(i); i++; }while(i<=0); |
|
|
2、while 循环和do while循环的区别
while:先判断条件，只有条件满足才执行循环体。
do while: 先执行循环体，再判断条件，条件满足，再继续执行循环体。
简单一句话：do while：无论条件是否满足，循环体至少执行一次。
五、随机数
1、概述
Java中提供了Math类中的random()方法，用来生成一个0到1之间的随机数 [0,1)
另外Java通过了一个Random类专门用来生成随机数。
2、使用方式
Math 类 ：
double x = Math.random();
产生一个0到1之间的随机数，包括0，不包括1。
Random类：
1.创建实例格式：Random 变量名 = new Random();
2. import导包：所属包java.util.Random;
3. 调用方法int number = r.nextInt(10);// [0,10) 产生的数据在0到10之间，包括0，不包括10。
示例代码
使用Math.random()
| // 生成一个 m到n直接的随机数（m和n都正整数 n>m） 例如：生成 10 到20 之间的随机数 // 规律： (int)(Math.random()*(n-m+1))+m
for(int i=1;i<=100;i++){ int x = (int)(11*Math.random())+10; // ----[10,20] System.out.println(x); } |
使用Random获取0-10之间的随机数(包括0,不包括10)
| public static void main(String[] args) { Random r = new Random(); int x = r.nextInt(10); // 生成一个[0,10)之间的随机整数 } |
获取1-100之间的随机数(包括1,不包括100)
| public static void main(String[] args) { Random r = new Random(); int num = r.nextInt(99)+1; } |
3、练习
猜数字小游戏案例:系统产生一个1-100之间的随机数，请猜出这个数是多少。10次机会
思路:
1.系统生成
2.用户输入
3.比较
4.做其他的额外功能...
示例代码
| public static void main(String[] args){
Random r = new Random(); int answer = r.nextInt(100)+1; System.out.println(answer+"<<<>>>>");
Scanner sc = new Scanner(System.in);
int count = 0; while(true){ count++; if(count>5){ System.out.println("您的猜数次数已满！！！"); break; }
System.out.println("开始猜数,请输入数字："); int result = sc.nextInt(); if(result==answer){
System.out.println("恭喜猜对了"); break;
}else if(result<answer){ System.out.println("对不起，猜小了");
}else if(result>answer){ System.out.println("对不起，猜大了"); } } } } |
六、方法入门
1、概述
具有某种特定功能的代码段。
某段代码经常使用，所以使用大括号，将这段代码包起来，起个名字。以后就使用这个名字来代替这段代码。
好处：
1、提高了代码的复用性。
2、提高了代码的封装性，大括号中的内容，其他调用者看不到也无法直接访问。
3、简化了软件设计的思维难度。
2、方法的定义
格式：
| 修饰符 返回值类型 方法名称 (参数列表) { 方法体语句; return语句; } |
说明：
- 修饰符：现在全都写成public static。
- 返回值类型：方法具有功能，有可能会有一些产出，就需要将数据返回给调用者。调用者需要知道生产出来的数据的数据类型。
- 方法名称：给这段代码起的名字。只要是一个合法的标识符即可。第一个单词的首字母小写，从第二个单词开始首字母大写。动词、动宾结构。
- 参数列表：这段代码要完成功能，可能会需要一些资源。在参数列表中，需要定义一些变量，内存中表示为容器，在调用本方法的时候，会由外界传入数据，存储到这些变量容器中。使用变量符号，表示那些将来可能传入的数据。
- 方法体语句：真正要完成该方法功能的执行逻辑。
6、return语句：最终生产出来的结果，要返回给调用者，使用return语句返回。如果没有任何生产内容，就可以写一个return;用于表示方法结束。
|
|
3、方法的调用
格式：直接书写方法名称即可
方法名称(实际参数);
方法调用的三种形式：
1、直接调用：表示某些内容的执行，而没有生产结果的情况
2、输出调用：方法的返回值，需要打印。如果这个结果只打印一次，不做其他的操作。
3、赋值调用：方法的返回值，使用某个变量来接收。如果这个结果需要反复使用。
方法调用总体特点：
方法不调用，就不执行。
示例代码
| public class Demo20_方法举例 { public static void main(String[] args) { int a = 10; int b = 20; int sum = getSum(a, b);//赋值调用 System.out.println(sum);
System.out.println(getSum(100, 200));//输出调用
getSum(20, 30);//直接调用：对于这种需要获取返回值的方法，直接调用，没有意义 }
//定义一个方法，可以用于求两个整数的和 //返回值类型：生产的数据的数据类型，int //参数列表：需要获取两个要求和的整数，int a, int b public static int getSum (int a, int b) {//a = 10, b = 20 int sum = a + b; return sum; } } |
4、注意事项
方法定义：
1、方法不能嵌套定义，方法都是定义在主方法的下面。
2、方法的先后没有区别
3、方法的定义是平级关系
4、方法可以嵌套调用，甚至可以自己调用自己
参数列表：
1、形式参数：在定义方法时使用，需要加上数据类型的参数，也就是对于变量进行声明。各个变量之间，使用逗号分隔。
2、实际参数：在方法调用时使用，不能加上数据类型的参数，也就是对于变量进行赋值。各个实际参数之间，也使用逗号分隔。顺序必须和定义的方法的形式参数的顺序一致。
return语句：
1、语句表达方法结束了；表示方法的产出内容。
2、如果方法没有具体的返回内容，可以写成return; 此时的return语句可以省略。返回值类型必须写成void。
3、如果方法有具体的返回内容，那么return后面就需要加上返回的那个数据。返回值类型必须和return语句后面的数据的数据类型一致。
4、return语句返回数据，返回给调用者。谁来调用当前方法，当前方法就将数据返回给谁。
5、方法练习
（1）无参数无返回值方法
定义一个方法，打印99乘法表。
| public class Demo05_方法_无参数_无返回值 { // 主方法 public static void main(String[] args) { print99(); // 方法调用 } // 该方法用来在控制台输出99乘法表 // 当一个方法不需要返回任何数据时，使用void占位 public static void print99(){ for(int i=1;i<=9;i++){ for(int j=1;j<=i;j++){ System.out.print(j+"*"+i+"="+(i*j)+"\t"); } System.out.println(); } } } |
（2）有参数无返回值方法
定义一个方法，输出指定行数和列数的矩形 ，通过参数决定输出多少行，每行有多少个*。
| public class Demo06_方法2_有参数_无返回值 { public static void main(String[] args) { printRect(5,6); // 5,6 实际参数（实参） ----->在方法运行时，是把实参赋给形参 } public static void printRect(int row,int col){ // row 和 col 叫做形式参数（形参） for(int i=1;i<=row;i++){ for(int j=1;j<=col;j++){ System.out.print("*"); } System.out.println(); } } } |
（3）无参数有返回值方法
定义一个方法用于获取int类型的最大值是多少。
| public class Demo08_方法4_无参数_有返回值 { // 用来获取int类型的最大值 public static int getMaxInt(){ //只要是有返回值的方法就必须有return语句 return Integer.MAX_VALUE; } public static void main(String[] args) { int num = getMaxInt(); // 那 getMaxInt()方法的返回值赋给num System.out.println(num); } } |
（4）有参数有返回值方法
定义一个方法，用于计算两个int类型变量的和并返回。
| public class Demo09_方法5_有参数_有返回值的方法 { public static void main(String[] args) { System.out.println(add(1,2)); int result = add(100,200); System.out.println(result); } //定义一个方法，完成两个整数的和计算 public static int add(int a,int b){ /* int result = a+b; return result; */ return a+b; } } |
（5）方法练习
定义一个方法，判断一个整数是否为素数。
| //定义一个方法，判断一个数是否为素数 public static boolean isPrime(int x){ boolean flag = true; //假设是素数
if(x<=1){ flag = false; }else if(x==2){ flag = true; }else{ for(int i=2;i<=x/2;i++){ if(x%i==0){ flag = false; break; } } } return flag; } |
七、方法的重载-Overload
1、需求
我们假设要在程序中实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。接下来通过一个案例来实现对两个整数相加、对三个整数相加以及对两个小数相加的功能。
示例代码
| public static void main(String[] args) { // 下面是针对求和方法的调用 int sum1 = add01(1, 2); int sum2 = add02(1, 2, 3); double sum3 = add03(1.2, 2.3); // 下面的代码是打印求和的结果 System.out.println("sum1=" + sum1); System.out.println("sum2=" + sum2); System.out.println("sum3=" + sum3); } // 下面的方法实现了两个整数相加 public static int add01(int x, int y) { return x + y; } // 下面的方法实现了三个整数相加 public static int add02(int x, int y, int z) { return x + y + z; } // 下面的方法实现了两个小数相加 public static double add03(double x, double y) { return x + y; } |
2、问题分析
上面的代码确实是完成功能了,但是同样是完成加法的功能,方法名却不一样,能不能把方法名变的一样呢?
答案是:可以!
那这种同一个类中的同名方法,就叫做方法重载overload。
3、重载概念
方法重载overload：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表不同：个数不同/数据类型不同/顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
4、使用重载改进
示例代码
| public static void main(String[] args) { // 下面是针对求和方法的调用 int sum1 = add(1, 2); int sum2 = add(1, 2, 3); double sum3 = add(1.2, 2.3); // 下面的代码是打印求和的结果 System.out.println("sum1=" + sum1); System.out.println("sum2=" + sum2); System.out.println("sum3=" + sum3); }
// 下面的方法实现了两个整数相加 public static int add(int x, int y) { return x + y; } // 下面的方法实现了三个整数相加 public static int add(int x, int y, int z) { return x + y + z; } // 下面的方法实现了两个小数相加 public static double add(double x, double y) { return x + y; } |
5、重载案例
示例代码
| public class Demo11_方法重载 { /* * 在同一个类中（.java文件中），不能定义完全一样的方法。 * * "完全一样"： 是指方法名和参数列表完全相同(和返回值类型与修饰符无关) * * 方法重载(overload): 在同一个类中(.java文件中)，方法名相同，参数列表不同（参数列表：参数的个数，类型，顺序——和参数名无关） * * * */
public static void main(String[] args) {
} public static int getMax(int a,int b){ int result = a>b?a:b; return result; } public static int getMax(int a,int b,int c){ int result = a>b?(a>c?a:c):(b>c?b:c); return result; } } |
6、练习
下面哪些是重载方法?
public static void open(){}
public static void open(int a){} ✔
static void open(int a,int b){} ✔
public static void open(double a,int b){} ✔
public static void open(int a,double b){} ✔
public void open(int i,double d){}✖
public static void OPEN(){} ✖
public static void open(int i,int j){} ✖
7、总结
重载方法参数列表不同：
参数个数不同，如method(int x)与method(int x,int y)不同。
参数类型不同，如method(int x)与method(double x)不同。
参数顺序不同，如method(int x,double y)与method(double x,int y)不同。
注意:add(int x, int y) 和add(int y, int x)实际一样的。
重载只与方法名有关和参数类型相关与返回值无关。
如void method(int x)与int method(int y)不是方法重载，不能同时存在。
重载与具体的变量标识符无关。
如method(int x)与method(int y)不是方法重载，不能同时存在。
总结:方法重载只与方法名和参数列表有关,和返回值/修饰符均无关(方法重载指的是在同一个类中)
作业
1、 打印倒直角三角形
*****
****
***
**
*
/*
13打印输出
----- 行数:1 符号数:5
---- 2 4
--- 3 3
-- 4 2
- 5 1
i+j=6
*/
class Test13 {
public static void main(String[] args) {
for(int i=1; i<=5; i++){
for(int j=1;j<=6-i; j++){
System.out.print("*");//不换行输出
}
System.out.println();//换行
}
}
}2 、控制台输入一个字符串，判断这个字符串是否对称 abcba算对称 abccba也算对称
charAt(0) charAt(str.length()-1)
//1.控制台输入一个字符串，判断这个字符串是否对称 abcba算对称 abccba也算对称
import java.util.Scanner;
class Homework01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串:");
String str = sc.nextLine();
boolean flag = true;//假设对称
for(int i=0; i<=str.length()/2; i++){
if(str.charAt(i)!=str.charAt(str.length()-1-i)){
flag = false;//修正
}
}
if(flag){
System.out.println(str+"对称");
}else{
System.out.println(str+"不对称");
}
}
}3 、（1）键盘输入一个正整数，求这个数的阶乘 （2）求 1！+2！+3！+4!+5!
//12.求 1！+2！+3！+4!+5!
class Test12 {
public static void main(String[] args) {
int sum = 0;
for(int i=1; i<=5; i++){
int factorial = 1;
for(int j=1; j<=i; j++){
factorial*=j;
}
sum+=factorial;
}
System.out.println(sum);
}
}4、 使用while循环完成计算1到100之间偶数之和
//10.计算1-100之间的偶数的累加和
class Test10 {
public static void main(String[] args) {
int sum = 0;
for(int i=1; i<100;i++){
if(i%2==0){
sum+=i;
}
}
System.out.println("1-100之间的偶数的累加和是:"+sum);
}
}5、使用while循环，统计1-100范围内，有多少数字可以被7整除
/*
18使用while循环，统计出1-100之间，有多少个数可以被7整除。
打印出所有能被7整除的数字，同时5个数字为一行。
*/
class Test18 {
public static void main(String[] args) {
int count = 0;
int i = 1;
while(i<=100){
if(i%7==0){
System.out.print(i+" ");
if(i<10){
System.out.print(" ");//为了对齐
}
count++;
if(count%5==0){
System.out.println();
}
}
i++;
}
System.out.println();//输出结束换行
System.out.println("一共有"+count+"个数可以被7整除");
}
}6、 String str= "abc god 中国 java"去掉字符串中的空格。
结果：String str2 = "abcgod中国java"（上课做过）
/*
2.String str= "abc god 中国 java"去掉字符串中的空格。
结果：String str2 = "abcgod中国java"
*/
class Homework02 {
public static void main(String[] args) {
String str= "abc god 中国 java";
//定义一个空的字符串,存储结果
String str2 = "";
for(int i=0;i<str.length();i++){
if(str.charAt(i)!=' '){
//如果不是空格就拼接到str2上
str2+=str.charAt(i);
}
}
System.out.println(str2);
}
}7、 String str= "abc god 中国 java"（较难） 反转每个单词
结果： "cba dog 国中 avaj"
/*
3. String str= "abc god 中国 java"（较难） 反转每个单词
结果： "cba dog 国中 avaj"
*/
class Homework03 {
public static void main(String[] args) {
String str= "abc god 中国 java";
String result = "";
String temp = "";
str+=" ";//加上空格反转后的temp = avaj才能加到result里面
for(int i=0;i<str.length();i++){
char ch = str.charAt(i);
if(ch!=' '){
temp = ch+temp;//a ab abc
}else{
result = result+temp+" ";
temp = "";
}
}
System.out.println(str);
System.out.println(result);
}
}8、定义一个求平均数的方法 avg 传入三个int类型参数 返回这三个数的平均数 int类型
//4.定义一个求平均数的方法 avg 传入三个int类型参数 返回这三个数的平均数 int类型
class Homework04 {
public static void main(String[] args) {
System.out.println("avg="+getAvg(1,4,4));
}
//三个整数求和
public static int getSum(int a, int b, int c){
int sum = a+b+c;
return sum;
}
//求平均
public static double getAvg(int a, int b, int c){
return getSum(a,b,c)/3.0;
}
}9、输出100 到 1000之间的所有素数
/*
5.输出100 到 1000之间的所有素数
*/
class Homework05 {
public static void main(String[] args) {
getPrimes();
}
public static void getPrimes(){
int count = 0;
for(int i=100; i<=1000; i++){
int j;
for(j=2; j<=i/2; j++){
if(i%j==0){
break;
}
}
if(j==i/2+1){
System.out.print(i+" ");
count++;
if(count%5==0){
System.out.println();
}
}
}
}
}
扫一扫
1081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
