Java学习笔记03 - Java语言程序结构

最新推荐文章于 2021-07-23 16:41:49 发布

法随

最新推荐文章于 2021-07-23 16:41:49 发布

阅读量238

点赞数

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/Class013/article/details/104728150

版权

Java学习笔记专栏收录该内容

20 篇文章 1 订阅

订阅专栏

一、程序结构

程序的基本结构包括顺序结构、分支结构和循环结构。顺序结构按照语句的书写次序顺序执行。选择结构根据条件是否满足来选择执行对应的程序段，Java语言提供了if和switch语句用来开发分支结构的程序。循环结构在给定条件下重复执行一些程序段，Java语言提供了while、do-while、for语句实现循环结构。

二、分支结构

程序中有些程序段的执行是有条件的，当条件成立时，执行一些程序段，当条件不成立时执行另一些程序段或者不执行，这种结构成为分支结构，也叫选择结构。

1、单分支if语句

单一的if语句是最常用的单分支结构，使用一个布尔表达式进行条件判断。如果布尔表达式的值为true,表示条件满足，则执行if后面紧跟的{}中的代码块。

单分支`if`语句的语法格式如下：
if (布尔表达式) {
   // 如果布尔表达式为true将执行的语句
}

实例：

public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        if (num1 < 20) {
            System.out.println("这是 if 语句块中的代码");
        }
    }
}

2、双分支结构

2.1、if…else语句

双分支if…else语句，使用一个布尔表达式进行条件判断。如果布尔表达式的值为true，表示条件满足，则执行if语句后面紧跟的{}中的代码块=，如果布尔表达式的值为false，表示条件不满足，则执行else后面紧跟的{}中的代码块。

双分支if...else语句格式如下：

if (布尔表达式) {
	// 如果布尔表达式为true将执行的语句
} else {
	// 如果布尔表达式为false将执行的语句
}

实例：

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int likuiScore, yanqingScore;
        System.out.println("请输入新兵李逵的得分：");
        likuiScore = input.nextInt();
        System.out.println("请输入新兵燕青的得分：");
        yanqingScore = input.nextInt();
        if (likuiScore > yanqingScore) {
            System.out.println("新兵李逵被选为新兵标兵");
        } else {
            System.out.println("新兵燕青被选为新兵标兵");
        }
    }
}

2.2、条件运算符（三元运算符）

条件运算符（三元运算符）也可以实现双分支结构。
实例1：

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int class1Score, class2Score, maxScore;
        System.out.println("请输入一班的比赛成绩：");
        class1Score = input.nextInt();
        System.out.println("请输入二班的比赛成绩：");
        class2Score = input.nextInt();
        if (class1Score > class2Score) {
            maxScore = class1Score;
        } else {
            maxScore = class2Score;
        }
        System.out.println("优胜班的成绩是：" + maxScore);
    }
}

实例2：

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int class1Score, class2Score, maxScore;
        System.out.println("请输入一班的比赛成绩：");
        class1Score = input.nextInt();
        System.out.println("请输入二班的比赛成绩：");
        class2Score = input.nextInt();
        maxScore = (class1Score > class2Score) ? class1Score : class2Score; // 使用 三元运算符 实现双分支结构
        System.out.println("优胜班的成绩是：" + maxScore);
    }
}

说明：

上面的两段代码实现的功能一致，可以看出，双分支结构中判断条件（布尔表达式）与要执行的语句都比较简单时，使用条件运算符(三元运算符）代码会更加简单优雅。

3、嵌套的if…else语句

if语句后面紧跟的{}中的代码块中和else后面紧跟的{}中的代码块中，都可以继续嵌套if...else语句，用以完成跟复杂的分支结构。
实例：

public class Test {
	public static void main(String[] args) {
		/*
		  判断闰年的逻辑：
		  整百的年份可以被400整除,为闰年,否则不是；其他年份被4整除为闰年,否则不是
		 */
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = scanner.nextInt();
		if (year % 100 == 0) {
			if (year % 400 == 0) {
				System.out.println(year + " 是闰年");
			} else {
				System.out.println(year + " 不是闰年");
			}
		} else {
			if (year % 4 == 0) {
				System.out.println(year + " 是闰年");
			} else {
				System.out.println(year + " 不是闰年");
			}
		}
	}
}

4、多分支if…else if…else语句

当判断条件比较多时，可以使用多分支if...else if...else语句。

多分支if..else if...else语句的语法格式如下：

if (布尔表达式1) {
	// 如果布尔表达式1为true将执行的语句
} else if (布尔表达式2) {
	// 如果布尔表达式2为true将执行的语句
} else if (布尔表达式3) {
	// 如果布尔表达式3为true将执行的语句
} [else {
	// 以上分支都没有进入时将执行的语句
}]

实例：

public class Test {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入成绩：");
		int score = scanner.nextInt();
		if (score >= 90) {
			System.out.println("成绩为：A");
		} else if (score >= 80) {
			System.out.println("成绩为：B");
		} else if (score >= 70) {
			System.out.println("成绩为：C");
		} else if (score >= 60) {
			System.out.println("成绩为：D");
		} else {
			System.out.println("成绩为：E");
		}
	}
}

说明：

在多分支if...else if...else语句中，当某一个作为判断条件的布尔表达式返回true时，即进入对应分支，之后其他分支中的布尔表达式不再进行运算，分支中的语句也不会被执行。
在多分支if...else if...else语句中，else...if语句可以出现多次，最后的else语句是可选项。

5、switch语句

对于Java中的多分支结构，除了使用多分支if...else if...else语句外，还可以使用switch语句，switch语句能够根据给定的表达式的值，从多个分支中选择一个分支来执行。相当于if...else if...else语句，switch语句可读性更强。
switch语句的语法格式如下：

switch (表达式) {
	case 常量1:
		语句1;
		Break;
	case 常量2:
		语句2;
		Break;
	[...]
	[default:
		语句n;]
}

实例：

public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入成绩：");
		int score = scanner.nextInt();
		int result = score / 10;
		switch (result) {
			case 9:
				System.out.println("成绩为：A");
				break;
			case 8:
				System.out.println("成绩为：B");
				break;
			case 7:
				System.out.println("成绩为：C");
				break;
			case 6:
				System.out.println("成绩为：D");
				break;
			default:
				System.out.println("成绩为：E");
		}
	}

说明：

表达式返回结果的数据类型可以是byte、char、short、int、enum、String。
case语句可以出现多次。
break语句和default语句是可选项。
switch语句首先计算表达式的值，如果表达式的值和某个case语句后面的常量值相等，就执行该case对应的语句块，直到遇到break语句为止，没有遇到break语句的话，会继续执行后续的case语句对应的语句块，直到遇到break语句为止。如果没有一个常量值与表达式的值相等，则执行default语句对应的语句块。如果没有default语句，switch语句不执行任何操作。

6、综合案例

判断用户输入的某一年月有多少天：

public class Test {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = scanner.nextInt();
		System.out.println("请输入月份：");
		int month = scanner.nextInt();
		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 % 400 == 0){
					System.out.println(year + "年" + month + "月有" + 29 + "天");
				}else if (year % 4 == 0 && year % 100 != 0){
					System.out.println(year + "年" + month + "月有" + 29 + "天");
				}else {
					System.out.println(year + "年" + month + "月有" + 28 + "天");
				}
				break;
			default:
				System.out.println("输入的月份有误");
		}
	}
}

三、循环结构

有些程序段需要在某些条件下重复执行多次，称为循环结构程序。Java提供了3种循环语句实现循环结构，包括while循环语句、do-while循环语句、for循环语句。它们的共同点是根据给定条件来判断是否继续执行指定的程序段。如果满足执行条件，就继续执行循环体，否则就不再执行循环体，结束循环结构，继续执行后面的语句

1、while循环语句

while循环首先使用一个布尔表达式进行条件判断，如果布尔表达式的值为true，表示条件满足，则执行while语句后紧跟的{}中的代码块，这段代码即循环体，循环体执行完之后，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码。

while循环语句的语法格式如下：

while (布尔表达式) {
   // 循环体;
}

实例：

public class Test {
	public static void main(String[] args) {
		// 使用while循环，计算1+2+3+…+100的和，并显示结果
		int num = 1;
		int sum = 0;
		while (num <= 100) {
			sum += num;
			num ++;
		}
		System.out.println("sum = " + sum);
	}
}

说明：

程序中定义int类型的变量num，初始化为1，定义int类型变量sum，用于存储累加的和。在while循环条件中，当num的值小于等于100时，进入循环体，在循环体内部先将num的值累加到变量sum中，再将变量num自增。循环体执行结束后再次回到while的循环条件中，如果num的值小于等于100则再次进入循环体，否则结束循环。最后输出累加的和。
while循环的特点是先判断，再执行。

2、do-while循环语句

do-while循环的原理与while循环基本相同，不同的是，do-while循环先执行一遍循环体中的代码块，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码。

do-while循环的语法格式：

do {
   // 循环体;
} while (布尔表达式);

实例：

public class Test {
	public static void main(String[] args) {
		// 使用do-while循环，计算1+2+3+…+100的和，并显示结果
		int num = 1;
		int sum = 0;
		do {
			sum += num;
			num ++;
		} while (num <= 100);
		System.out.println("sum = " + sum);
	}
}

说明：

上面的例子中，当程序进入do-while循环时，首先进入循环体，在循环体内部先将num的值累加到变量sum中，再将变量num自增。然后判断num是否小于等于100，如果判断条件的值为true，程序就会再次进入循环体，否则退出循环。最后输出累加的和。
do-while循环的特点是先执行，再判断。

3、for循环语句

for循环语句是程序中使用最多的循环结构。for循环语句使用三个表达式，分别用来初始化循环变量，判断循环执行条件，以及改变循环变量。

for循环语句的语法格式如下：

for (表达式1; 表达式2; 表达式3) {
	// 循环体;
}

实例：

public class Test {
	public static void main(String[] args) {
		// 使用for循环，计算1+2+3+…+100的和，并显示结果
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		System.out.println("sum = " + sum);
	}
}

说明：

定义int类型变量sum，用于存储累加的和。当程序进入for循环时，首先执行表达式1，为循环变量i初始化为1，然后执行表达式2，判断 i <= 100 是否为true，如果为true进入循环体，将i的值累加到变量sum中，再执行表达式3，将循环变量的值i加1，再执行表达式2，判断 i <= 100 是否成立，如果成立再进入循环体，形成循环，否则结束for循环。最后输出累加的和。
for循环通常用在已知循环次数的情况下。
生成五位数的随机密码：

public class Test {
	public static void main(String[] args) {
		Random random = new Random();
		String password = "";
		for (int i = 0; i < 5; i++) {
			int r = random.nextInt(26);
			r += 97;
			password = password + (char) r;
		}
		System.out.println("生成的密码是：" + password);
	}
}

说明：

本例利用Java提供的随机数生成方法，配合一个循环5次的for循环语句，生成5位长度的随机密码。
Java中有两个具有生成随机数的方法的类，分别是java.lang.Math和java.util.Random。类java.lang.Math中random()方法可以生成大于等于0.0小于1.0的double类型的随机数；类java.util.Random中提供了一些列的方法可以生成指定范围的随机数，如nextInt()、nextDouble()等。
本例中代码random.nextInt(26)的作用是生成一个大于等于0，小于26之间的一个随机整数。
本例中r += 97后r的值是区间[97, 122]内的整数，这个区间的整数与ASCII中的小写字母恰好对应。而(char) r将一个整数转换成对应的字符。

4、break语句

Java中提供了break语句，可用于switch语句或while、do-while、for循环语句，如果程序执行到break语句，立即从switch语句或循环语句退出。
实例：

public class Test {
	public static void main(String[] args) {
		/*
		  使用while循环计算1+2+3+…，当和超过100时，结束循环，
		  输出一共相加了多少个数
		*/
		int sum = 0;
		int index = 1;
		while (true) {
			sum += index;
			if (sum > 100) {
				break;
			}
			index++;
		}
		System.out.println("index = " + index);
	}
}

说明：

定义int类型变量sum，初始化为0，用于存储累加的和，定义int类型变量index，初始化为1，用于控制循环次数。
while (true)表示循环条件永远成立。
if (sum > 100)表示终止条件成立，执行break语句，即跳出循环体，执行while循环后面语句。

5、continue语句

continue语句可用于for、do-while、while语句的循环体中，如果程序执行到continue语句，则结束本次循环，回到循环条件处，判断是否执行下一次循环。
实例：

public class Test {
	public static void main(String[] args) {
		// 使用for循环计算1+2+3+…100的和，但要去除7的倍数
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			if (i % 7 == 0) {
				continue;
			}
			sum += i;
		}
		System.out.println("1+2+3+...+100去除7的倍数的和是" + sum);
	}
}

说明：

定义int类型变量sum，初始化为0，用于存储累加的和。
for循环中定义int类型变量i，初始化为1，用于控制循环次数。
当i <= 100时进入循环体。
当i % 7 == 0的值为true时，表示i的值是7的倍数，执行continue语句，即结束本次循环，进入下一次循环。

6、多重循环

如果循环语句的循环体中又包含循环语句，就形成了多重循环结构，称为循环嵌套。被包含的循环称为内循环，包含的循环称为外循环。常用的循环嵌套是二重嵌套和三重嵌套，更多重的嵌套由于代码逻辑复杂，应当尽量避免使用。循环嵌套既可以是一种循环自身的嵌套，也可以是不同循环语句相互嵌套。
实例：

public class Test {
	public static void main(String[] args) {
		// 使用双重for循环输出乘法口诀表
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(j + "x" + i + "=" + (j * i) + "\t");
			}
			System.out.println();
		}
	}
}

说明：

外循环的循环变量i初始化为1，i <= 9，共循环9次，System.out.println()可使得外循环每循环一次换一行。
内循环的循环变量j初始化为1，j <= i，故第i行会产生i列。

7、综合案例

输出对应行数的等腰三角形：

public class Test {
	public static void main(String[] args) {
		// 接收键盘输入的数字，使用for循环输出对应行数的等腰三角形
		Scanner input = new Scanner(System.in);
		System.out.println("请输入行数：");
		int row = input.nextInt();
		if (row < 2) {
			System.out.println("请输入大于2的整数");
		} else if (row > 99) {
			System.out.println("行数太大了");
		} else {
			for (int i = 1; i <= row; i++) {
				for (int j = row; j >= i; j--) {
					System.out.print(" ");
				}
				for (int k = 1; k <= 2 * i - 1; k++) {
					System.out.print("*");
				}
				System.out.println();
			}
		}
	}
}

说明：

int类型的变量row用来存储键盘输入的行数。
外循环的循环变量i初始化为1，i <= row，用来控制行数。外层循环中的System.out.println()用来控制换行。
对于第一个内循环，循环变量j初始化为row代表的行数值，当外循环的循环变量i自增时，由于j >= i，故内循环的循环次数减少，以此来控制每行前面输出的空格数量。
对于第个二内循环，循环变量k初始化为1，当外循环的循环变量i的自增时，由于k <= 2 * i - 1，故内存循环次数以1、3、5、7、…的顺序递增，依次来控制每行输出的*数量。

法随

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记03 - Java语言程序结构

一、程序结构     程序的基本结构包括顺序结构、分支结构和循环结构。顺序结构按照语句的书写次序顺序执行。选择结构根据条件是否满足来选择执行对应的程序段，Java语言提供了if和switch语句用来开发分支结构的程序。循环结构在给定条件下重复执行一些程序段，Java语言提供了while、do-while、for语句实现循环结构。二、分支结构 ...
复制链接

扫一扫