流程控制就是控制代码的执行顺序
总体分为三大结构：
顺序结构、分支结构、循环结构 很简单下面为小伙伴们一一介绍
一、顺序结构：
就是程序运行的顺序是 从上到下，从左到右一行一行的去执行
//最简单的算法结构
public class ShunXuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
//任何一个算法都离不开的一种基本算法结构
}
}
二、分支结构：
根据条件选择执行路径：主要分为四类if选择结构、if双选择结构、if多选择结构和switch
① 特点：写的多，执行的少
② 语句：if语句的三种格式 switch语句
1、if选择结构
1、格式：
if(布尔表达式（boolean类型的值）){ //计算布尔条件表达式的值，要么为true，要么为false
语句体;可以是任意逻辑的代码(为true执行语句)
}
2、执行流程：
(1) 如果为true就执行语句体
(2) 如果为false就不执行语句体
注意：小括号后面不要加分号,如果if语句体之后只有一句代码，大括号可以省略，一般还是要加上
import java.util.Scanner;
class Demo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入现在天气的温度");
int c = sc.nextInt();
if(c >= 45){
System.out.println("去楼顶日光浴");
}
}
}
import java.util.Scanner;
//if单选择
//语法 if（布尔表达式）{
//为true将执行语句
// }
public class XuanZheDemo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容");
String s = scanner.nextLine();
//equals:判断字符串是否相等
if (s.equals("hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
2、if双选择结构
1、格式:
if(布尔条件表达式){
语句体1;（如果表达式为true）
}else{
语句体2;（如果表达式为false）
}
2、执行流程说明：（有else上的情况，语句体1和语句体2，必然会有一个执行，有且只能有一个执行）
(1) 计算条件表达式的值true还是false
(2) 如果为true，执行语句体1
(3) 如果为false，执行语句体2
import java.util.Scanner;
class Demo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入印度的温度");
int c = sc.nextInt();
if(c >= 45)
System.out.println("暴书源出动去抓巨蜥");
else
System.out.println("暴书源在家和巨蜥玩游戏");
System.out.println("巨蜥都快被书源抓没了");
}
}
import java.util.Scanner;
//if双选择 两个判断
//语法if（布尔表达式）{
//如果表达式为true
// }else{
//如果表达式为false
// }
public class XuanZheDemo2 {
public static void main(String[] args) {
//考试分数大于60及格，小于60分不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>=60){
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}
3、if多选择结构
1、格式：
if(布尔表达式1){
语句体1;
}else if(布尔表达式2){
语句体2;
}else if(布尔表达式3){
语句体3;
}…else{
语句体n;
}
2、执行流程：
(1) 如果第一个if后布尔表达式计算为true，执行语句体1，整个if语句就结束了
(2) 如果为false，就判断布尔表达式2的值，如果为true，执行语句体2，结束整个if语句
(3) 如果表达式2的值为false，就判断条件表达式3, 以此类推
(4) 如果1~n-1都为false，就执行else的内容，语句n
注意事项： if可以有很多判断，也可以有很多语句体，但是语句体只能执行一个，判断顺序，一定是从上到下，如果 最后不写else，可能一个语句都不会执行
import java.util.Scanner;
class Demo3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入现在的温度：");
int c = sc.nextInt();
//50度 最高气温50度
if(c >= 40 && c <= 50){//40~50之间
System.out.println("40~50度，书源在楼顶喝着热茶，晒太阳");
}else if(c >= 30){//30~40度 因为第一个条件不满足 所以隐含了条件 c< 40
//c >= 30 && c < 40;
System.out.println("30~40度，书源在教室里上课");
}else if(c >= 20){
System.out.println("20~30度，书源很舒服的在教室上课");
}else if(c >= 0){
System.out.println("0~20度，书源在被窝里找巨蜥");
}else{
System.out.println("0度以下，书源在楼顶吹一吹冷风，喝一喝冷饮");
}
}
}
import java.util.Scanner;
/*if多选择 多个判断 只会执行一个代码
语法；
if（布尔表达式1）{
如果表达式为true执行
}else if（布尔表达式2）{
如果表达式为true执行
}else{
如果以上表达都不为true执行代码
}
*/
public class XuanZhe3 {
public static void main(String[] args) {
//100~80 为A 80~60为B 60~0为不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score == 100) {
System.out.println("恭喜满分");
} else if (100 > score && score >= 80) {
System.out.println("你的成绩很棒");
} else if (80 > score && score >= 60) {
System.out.println("B");
} else if (60 > score && score >= 0) {
System.out.println("不及格");
} else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
4、switch
switch表示开关，有很多case情况
-
switch后面跟的一定是一个变量，先获取小括号中的表达式的值
-
这个变量和case后的常量进行比较，判断是否相等。
-
如果相等，则会执行对应的语句体，遇到结束条件，跳出switch语句
-
如果表达式的值和任何一个常量都不匹配，就执行
default，碰到break结束
2、格式：
(1) switch(变量){
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
…
default:
语句n;
break;
}
import java.util.Scanner;
class Demo4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//关振海 找前任复合
System.out.println("1、乔碧罗;2、候博文;3、炯妃；4、金龙；其他、巨蜥");
int n = sc.nextInt();
//n为变量
switch(n){
case 1:
System.out.println("碧罗我振海最爱你");
break;
case 2:
System.out.println("我振海不是那么挑食的人");
break;
case 3:
System.out.println("我振海的小三就是炯妃");
break;
case 4:
System.out.println("毕竟他也喜欢巨蜥，所以我喜欢他");
break;
default:
System.out.println("继金龙之后，巨蜥的又一大灾难");
break;
}
}
}
//switch多选择结构
//switch判断一个变量与一系列中的某个值是否相等，每个值称为一个分支。
//变量类型 byte shout int char
// 从SE7开始 switch支持字符串String类型
//case标签必须为字符串或者字面量
public class SwitchDemo1 {
//case穿透
public static void main(String[] args) {
char grade='F';
switch (grade){
case 'A':
System.out.println("优秀");
break;//可选
case 'B':
System.out.println("及格");
break;//可选
case 'C':
System.out.println("挂科");
break;//可选
default:
System.out.println("未知等级");
}
}
}
//JDK7的新特性，表达式结果可以是字符串！！！
//字符的本质还是数字
//反编译 java------class（字节码文件）-----反编译（i dea）
//多看源码
public class SwitchDemo2 {
public static void main(String[] args) {
String name = "书源";
switch (name){
case "书源":
System.out.println("书源");
break;
case "大大":
System.out.println("大大");
break;
default:
System.out.println("啥也不是！");
}
}
}
switch的注意事项
1、jdk1.5之前case后的常量支持：byte、short、char、int
2、jdk1.5支持枚举类型
3、java7支持String类型
4、case后只能跟常量，而常量不能重复
5、default：默认，可以在switch的任意位置，但是最后判断
6、switch的结束条件，碰到break或者右大括号
7、如果没有结束条件，会发生穿透现象，直接执行下一个语句体，而不需要判断
import java.util.Scanner;
import java.util.Random;
class Demo5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//关振海 找前任复合
System.out.println("1、乔碧罗;2、候博文;3、炯妃；4、金龙；其他、巨蜥");
//int n = sc.nextInt();
//n为变量
Random r = new Random();
int m = r.nextInt(6);
System.out.println(m);
switch(0){
default:
System.out.println("继金龙之后，巨蜥的又一大灾难");
case 1:
System.out.println("碧罗我振海最爱你");
case 2:
System.out.println("我振海不是那么挑食的人");
case 3:
System.out.println("我振海的小三就是炯妃");
case 4:
System.out.println("毕竟他也喜欢巨蜥，所以我喜欢他");
}
}
}
1、比较运算符分类
比较相等：可以比较任意类型
比较大小：只能比较数值类型
2、比较运算符优先级
相等的小于大小的
3、什么是短路现象
&&第一个值为false，则第二个不会计算
||第一个值为true，则第二个不会计算
4、三元运算符的格式是什么
布尔表达式1 ? 表达式2:表达式3;
5、三元运算符计算的结果如果要接收需要注意什么
要看表达式2和3的数据类型
6、键盘录入的步骤分别是什么
导包 import java.util.Scanner;
创建对象 Scanner sc = new Scanner(System.in);
使用对象功能 sc.nextInt();
7、产生随机数的步骤是什么
导包
创建对象
使用对象功能 sc.nextInt(10);
8、if的三种格式
if(布尔表达式){
语句体1;
}
if(布尔表达式){
语句体1
}else{
语句体2
//else包含了所有不满足布尔表达式的结果
}
if(布尔表达式1){
语句体1
}else if(布尔表达式2){
语句体2
}else if(布尔表达式3){
语句体3
}else if(布尔表达式4){
语句体4
}else{
语句体5
}
9、switch的注意事项
支持的数据类型 byte、short、char、int、枚举、String
需要注意结束条件，右大括号或者break，如果没有发生穿透
1、 A:看程序写结果：
int x = 2;
int y = 3;
switch(x){
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);//4
B:看程序写结果：
int x = 2;
int y = 3;
switch(x){
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);//6
C:看程序写结果：
boolean b = true;
if(b = false) { //b=false的作用是先将b赋值，赋值给false，然后if(b)
System.out.println("a");
}else if(b) {
System.out.println("b");
}else if(!b) {
System.out.println("c"); //c
}else
System.out.println("d");
2、用户录入三个数据，求出这三个数的最大值
(1)只能使用if语句，不能使用逻辑运算符
import java.util.Scanner;
class Demo02 {
public static void main(String[] args) {
// 2、用户录入三个数据，求出这三个数的最大值
//(1)只能使用if语句，不能使用逻辑运算符
Scanner sc = new Scanner(System.in);
System.out.println("请录入第一个整数：");
int a = sc.nextInt();
System.out.println("请录入第二个整数：");
int b = sc.nextInt();
System.out.println("请录入第三个整数：");
int c = sc.nextInt();
//思路：先获取两个整数的最大值
if(a > b){
//说明此时a大
//将a和c进行比较
if(a > c){
//a最大
System.out.println("最大值为：" + a);
}else{
//c最大
System.out.println("最大值为：" + c);
}
}else{
//说明此时b大
//将b和c进行比较
if(b > c){
//a最大
System.out.println("最大值为：" + b);
}else{
//c最大
System.out.println("最大值为：" + c);
}
}
}
}
3、输入一个年份，判断该年份是否为闰年
判断闰年的条件（能被4整除，但不能被100整除或者能被400整除）
(1)用三元运算符完成
(2)用if完成，不要使用逻辑运算符
import java.util.Scanner;
class Demo03 {
public static void main(String[] args) {
/*
3、输入一个年份，判断该年份是否为闰年
判断闰年的条件（能被4整除，但不能被100整除或者能被400整除）
(1)用三元运算符完成
(2)用if完成，不要使用逻辑运算符
条件分析：
1、能被4整除 year % 4 == 0
2、不能被100整除 year % 100 != 0
3、能被400整除 year % 400 == 0
year % 4 == 0 && year % 100 != 0 // 普通闰年：能被4整除但不能被100整除
世纪闰年：能被400整除 year % 400 == 0
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份：");
int year = sc.nextInt();
boolean b = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
System.out.println(b ? "是闰年" : "不是闰年");
//首先所有的闰年都是能被4整除的，但是2100 100 200300 不是闰年
if(year % 4 == 0){//能被4整除
//大概率是闰年
//其中包含了100 200 300 400 等年份
if(year % 100 == 0){
//整百 只有400 800等年份是闰年
if(year % 400 == 0){
System.out.println(year + "是世纪闰年");
}else{
System.out.println(year + "是平年");
}
}else{
//不能被100整除
System.out.println(year + "是普通闰年");
}
}else{
//一定不是闰年
System.out.println(year + "是平年");
}
//第二种写法
if(year % 400 == 0){
System.out.println(year + "是世纪闰年");
}else if(year % 100 == 0){
System.out.println(year + "是平年");
}else if(year % 4 == 0){//不能被100整除
System.out.println(year + "是普通闰年");
}else{
System.out.println(year + "是平年");
}
}
}
4、录入年月，打印某年某月有多少天
import java.util.Scanner;
class Demo04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//4、录入年月，打印某年某月有多少天
System.out.println("请输入一个年份:");
int year = sc.nextInt();
System.out.println("请输入一个月份:");
int month = sc.nextInt();
//某月有多少天只有2月特殊，有可能是闰年
switch(month){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(year + "年" + month + "月有31天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(year + "年" + month + "月有30天");
break;
case 2:
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
//是闰年
System.out.println(year + "年" + month + "月有29天");
}else{
System.out.println(year + "年" + month + "月有28天");
}
break;
}
}
}
三、 循环结构：
循环：相同的或者相似的逻辑在符合条件的情况下，简化的格式就是循环结构,可以多次反复的执行
① 特点：写的少，执行的多
② 语句：for语句、while语句、do…while语句
(1)for循环
1、格式：
for( 初始化语句(声明变量，记录循环次数); 循环判断条件(控制循环次数，是否继续执行，boolean类型); 初始化语句的改变(迭代更新，初始化声明变量，向着循环不能执行的方向改变)){
循环体语句(重复执行的代码);
}
2、执行流程：
(1) 执行初始化语句
(2) 计算循环判断条件，是true还是false
(3) 如果是false，结束循环
(4) 如果时候true，就执行循环体语句
(5) 执行初始化语句的改变
(6) 回到第二步
//虽然所有循环都可以用while或者do while 表示
//但是JAVA提供了另一种语句for循环，使一些循环结构变得更加简单。
//for循环是支持迭代的一种通用结构，是最有效，灵活的循环结构。
//JDK5引入，主要用于数组或者集合的增强型for循环
// 计算1-100的和
1、先获取1-100的所有的数
2、在循环外定义一个和变量 用于记录和
3、循环内进行累加
4、循环外输出结
class Demo06 {
public static void main(String[] args) {
/*
for(初始化语句; 循环判断条件; 初始化语句的改变){
循环体语句;
}
豪哥去减肥，跑步 跑三圈
每跑一圈喊，一次口号，我要减肥
初始化语句：跑步 从第几圈开始跑 从第一圈 int i = 1; i表示圈数
循环判断条件: 目标跑三圈，圈数要小于等于3 i <= 3;
循环体语句: 每跑一圈喊一次口号， 我要减肥
初始化语句的改变: 跑完一圈要给圈数+1 i++ i+=1
*/
for(int i = 1; i <= 3; i++){
System.out.println("我要减肥" + i);
}
System.out.println(i);
for( int i = 3; i >= 1; i--){
System.out.println("我要减肥" + i);
}
}
}
(2)while循环
1、格式：
初始化语句; 1
while(循环判断条件){ 2 一定是一个boolean类型的表达式 不加分号
循环体语句;3 //循环体
初始化变量的改变;4 //迭代
}
2、执行流程：
(1) 初始化语句
(2) 计算循环条件表达式的值，如果为false结束循环
(3) 如果为true，执行循环体语句
(4) 执行初始化变量的改变
(5) 回到第二步
//1.只要布尔表达式为true，循环会一直执行下去。
//2.需要一个表达式让循环停止。
//3.少部分会一直执行，比如服务器的请求响应监听等。
//4.条件一直为true，会陷入无限“死循环”，影响程序性能，或者卡死崩溃！
class Demo07 {
public static void main(String[] args) {
//如果明确知道要循环的次数，一般用for循环
//如果不知道要循环多少次，一般用while
int i = 1; //改变初始化条件
while(i <= 3){
System.out.println("马上下课啦，又可以晒太阳了"); //循环体
i++;
}
System.out.println(i); // 初始化语句中声明的变量，在循环结束后，还可以继续使用
}
}
(3)do…while
1、格式：
初始化语句;
do{
循环体语句;
初始化变量的改变;
}while(循环判断条件);
2、执行流程：
(1) 执行初始化语句
(2) 执行循环体语句
(3) 执行初始化变量的改变
(4) 计算循环条件表达式的值，如果为false，结束循环
(5) 如果为true，回到第二步
// while 和 do...while 区别是
//while先判断后执行，do...while先执行后判断
// 所以do...while最少会被执行一遍
class Demo09 {
public static void main(String[] args) {
//do...while是不管条件是否满足，先执行一次再进行判断
//至少会执行一次
int i = 1;
do{
System.out.println("出门暖和一下");
i++;
}while(i <= -3);
System.out.println(i);
}
}
(4)死循环
1、无限循环：原理就是让循环判断条件永远达不到，永远为true
2、格式：
for( ; ; ) { //在for语句中如果判断条件不写，默认就是true
循环体语句;
}
while(true){ //while 最常用的死循环格式
循环体语句
}
class Demo10 {
public static void main(String[] args) {
/*
for(;;){
System.out.println("金龙今晚想让宝玉得到他");
}
*/
//System.out.println("得到了");无法访问的语句，上面的循环不会停
int i = 1;
while(true){
//只要电脑不死，就一直说这句话
System.out.println("豪哥真帅" + i);
i++;
}
//System.out.println("豪哥真丑");
}
}
//有些时候需要死循环
public class WhileDemo2 {
public static void main(String[] args) {
while (true){
//等待客户端链接
//定时检查的任务等
//死循环
}
}
}
3、死循环的特点：
格式上虽然使用了死循环，
但是专门提供了一些结束循环break;
或者跳出循环continue; 继续下次循环
continue
//请假
//continue 也是用在循环语句中，用于终止某次循环过程，
//也就是跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
public class ContinueDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
if(i%10==0){
System.out.println("");
continue;
}
System.out.print(i);
}
}
}
break
//辞职
//break在任何循环语句的主题部分。用于强制退出循环，不执行剩余语句
public class BreakDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break;
}
}
System.out.println("123");//跳出不会终止程序
}
}
class Demo11 {
public static void main(String[] args) {
//计算1-100的偶数和
int sum = 0;
for(int i = 1; i <= 100; i++){
if(i % 2 != 0){
//是奇数，就不进行求和
continue;
}
sum += i;
System.out.println(i);
}
System.out.println(sum);
}
}
import java.util.Scanner;
class Demo12 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("宝玉啊，我书源将是你一生最爱的男人，你愿意嫁给我吗，愿意请扣1");
int i = sc.nextInt();
if(i == 1){
System.out.println("恭喜两位，喜结连理，送入洞房");
break;
}
}
System.out.println("娶个宝玉，不是简简单单？这不轻松到手？");
}
}
(5)嵌套循环
一个循环的循环体语句，是另一个循环，比如for循环的内部，还有一个for循环，这就是嵌套循环 俗称套娃
2、格式：
(1) for(初始化语句1;循环判断条件1;初始化变量1的改变){
//循环体语句1;
for(初始化语句2;循环判断条件2;初始化变量2的改变){
循环体语句2;
}
}
3、执行流程
(1) 初始化语句1
(2) 计算循环判断条件1的值，如果为false，结束整个循环
(3) 如果为true，执行初始化语句2
(4) 计算循环条件表达式2的值，如果为false，结束内层循环，执行初始化变量1的改变，回到第二步
(5) 如果计算为true，此时执行循环体语句2
(6) 执行初始化变量2的改变
(7) 回到第四步
class Demo13 {
public static void main(String[] args) {
//一周有7天，我希望每天跑3圈，保持身材
//先构建外层循环，每天要做的事情是跑三圈，一共有7天
for(int i = 1; i <= 7; i++){//i代表的是天数
//外层循环执行一次，内层循环执行3次
//总次数 = 外层循环次数 * 内层循环次数
for(int j = 1; j <= 3; j++){//j代表的是圈数
System.out.println("我要减肥，第"+ i + "天，第" + j + "圈");
}
/*
System.out.println("我要减肥");
System.out.println("我要减肥");
System.out.println("我要减肥");
*/
//第一步先构建外层循环，想明白要重复执行哪些内容
//第二步分析重复的内容， 构建出另外一个循环
}
}
}
//打印三角形 开阔思路
public class Demo {
public static void main(String[] args) {
//打印5行三角形
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++){
System.out.print("*");
}
for (int j = 1; j < i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
class Demo15 {
public static void main(String[] args) {
/*
2、打印五行五列的*组成的直角三角形
*
**
***
****
*****
*/
//一共打印了5行，每行打印的*的个数在变化
//外层循环控制行数，内层循环控制打印*的个数
for(int i = 1; i <= 5; i++){
//第一行 打印了1个星 一个换行
//第二行 打印了2个星 一个换行
//第三行 打印了3个星 一个换行
//第几行 就打印几个星
//几个星就是内层循环多少次
//次数随着行数在改变
//循环控制条件控制次数 打印次数随着i在变化
// i = 1 j <= 1
// i = 2 j <= 2
// j <= i
for(int j = 1; j <= i; j++){
System.out.print("*"); //System.out.println();带换行效果的输出
//System.out.print();不带换行效果的输出
}
System.out.println();
}
/*
System.out.println("*");
System.out.println("**");
System.out.println("***");
System.out.println("****");
System.out.println("*****");
*/
}
}
3、打印九九乘法表
1*1=1
1*2=2 2*2=4
......
1*9=9 2*9=18......9*9=81
class Demo16 {
public static void main(String[] args) {
/*
//1.打印第一列
//2.把固定的1包起来
//3.去掉重复的i<=j
//4.调整样式print 输出完不会换行
3、打印九九乘法表 学习解决问题的思路！！！！
1*1=1
1*2=2 2*2=4
......
1*9=9 2*9=18......9*9=81
九九乘法表和打印直角三角形 基本一致
如果把九九乘法表的每一个式子换成一个* 就是九行九列的直角三角形
被乘数*乘数=积
乘数是行数
被乘数是列数
j*i=i*j
*/
//i代表行
for(int i = 1; i <= 9; i++){
//j代表列
for(int j = 1; j <= i; j++){
//制表符 /t
System.out.print(j + "*" + i + "=" + (i * j)+ "\t");
}
System.out.println();
}
}
}
4、打印倒直角三角形
*****
****
***
**
*
class Demo17 {
public static void main(String[] args) {
/*
4、打印倒直角三角形
*****
****
***
**
*
原来是正的直角三角形
i代表行
原来行数是12345
现在倒过来，就是行数颠倒
*/
//i控制行
for(int i = 5; i >= 1 ; i--){
for(int j = 1; j <= i; j++){
System.out.print("*");
}
System.out.println();
}
}
}
public class Jin { //空心金字塔
public static void main(String[] args) {
int a = 10;//控制层数
for (int i = 1; i <= a; i++) {//i控制行数
for (int k = 1; k <= a - i; k++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1 || i == a) {
System.out.print("*");
} else
System.out.print(" ");
}
System.out.println(" ");
}
}
}
所以说可以用循环做很多事，下一篇介绍一下Java的方法时时刻刻都要用！！
扫一扫
922
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
