Java基础笔记——Java基本语法
二、Java基础语法 (2)
目录
二、Java基础语法 (2)
5、程序流程控制
6、分支结构
一、if-else结构
二、if-else 使用说明
三、switch-case 结构
四、switch-case 使用说明
五、循环结构
六、for循环
七、while循环
八、do-while循环
九、“无限”循环
十、循环嵌套
十一、特殊关键字 break、continue
5、程序流程控制
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
三种基本流程结构：
- 顺序结构
- 分支结构
- 循环结构
顺序结构：
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构：
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
循环结构：
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
6、分支结构
一、if-else结构
if的三种格式：
1、
if(条件表达式){
执行表达式
}
2、二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
3、n 选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
...
else{
执行表达式n
}
二、if-else 使用说明
1. else 结构是可选的。
2. 针对于条件表达式：
> 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
> 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
> 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
3. if-else结构是可以相互嵌套的。
4. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
if-else练习：
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入
一个两位数，然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
import java.util.Scanner;
class IfExer1{
public static void main(String[] args){
//一个两位的随机数
int num = (int)(Math.random()*90+10);//[10,99]
System.out.println(num);
int numShi = num/10;
int numGe = num%10;
//获取用户的猜测值
Scanner scan = new Scanner(System.in);
System.out.println("请输入你猜测的数值：(10-99)");
int guess = scan.nextInt();
int guessShi = guess/10;
int guessGe = guess%10;
if(guess == num){
System.out.println("奖金10 000美元");
}else if(guessShi == numGe && guessGe == numShi){
System.out.println("奖金3 000美元");
}else if(guessShi == numShi || guessGe == numGe){
System.out.println("奖金1 000美元");
}else if(guessShi == numGe || guessGe == numShi){
System.out.println("奖金5 00美元");
}else{
System.out.println("没中奖");
}
}
}
三、switch-case 结构
1.格式：
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句 2;
//break;
....
default:
执行语句n;
//break;
}
四、switch-case 使用说明
1、根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构，调用其执行语句。 当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构 末尾结束为止。
2、switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
3、case子句中的值必须是常量，不能是变量名或不确定的表达式值；
4、break语句用来在执行完一个case分支后使程序跳出switch语句块；如 果没有break，程序会顺序执行到switch结尾
5、default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时， 执行default
6、如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
switch和if语句的对比：
如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
switch-case 练习：
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
import java.util.Scanner;
class SwitchCaseTest5{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入year");
int year = scan.nextInt();
System.out.println("请输入month");
int month = scan.nextInt();
System.out.println("请输入day");
int day = scan.nextInt();
//定义一个变量来保存天数
int sumDays = 0;
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//sumDays += 28;
//判断是否为闰年
if((year%4 == 0 && year%100 != 0) || year%400 == 0){
sumDays += 29;
}else{
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year + "年 " + month +"月 " +day+ "日是当年的第 " +sumDays+"天");
}
}
五、循环结构
循环结构：在某些条件满足的情况下，反复执行特定代码的功能。
循环语句分类：
1.for循环
2.while循环
3.do-while循环
循环语句的4个组成部分：
1.初始换部分
2.循环条件部分
3.循环体部分
4.迭代部分
六、for循环
语法格式：
for(①初始化条件 ; ②循环条件 ; ④迭代条件){
③循环体;
}
执行过程：①-②-③-④-②-③-④-②-③-④-.....-②
说明：
- ②循环条件部分为boolean类型表达式，当值为false时，退出循环。
- ①初始化部分可以声明多个变量，但必须是同一类型的，用逗号, 隔开
- ④可以有多个变量更新，用逗号分隔。
练习一：
/*
1.打印1~100之间所有奇数的和
2.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数
器的思想）
3.输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数
字立方和等于其本身。
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
*/
class ForExer{
public static void main(String[] args){
//练习1
int sum = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 != 0){
sum += i;
}
}
System.out.println(sum);
System.out.println();
//练习2
int sum2 = 0;
int count = 0;
for(int i = 0;i <= 100;i++){
if(i % 7 == 0){
sum2 += i;
count++;
}
}
System.out.println(sum2);
System.out.println(count);
System.out.println();
//练习3
for(int i = 100;i < 1000;i++){
int bai = i/100;
int shi = i%100/10;
int ge = i%10;
int num = bai*bai*bai + shi*shi*shi + ge*ge*ge;
if(i == num){
System.out.println(i);
}
}
}
}
练习二：
/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
*/
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数
//1.获取两个数的最小值
int min = (m <= n)? m : n;
//2.遍历
for(int i = min;i >= 0; i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为：" + i);
break;//一旦循环中，执行到break就跳出循环
}
}
//获取最小公倍数
//1.获取最大值
int max = (m > n)? m:n;
//2.遍历
for(int i = max;i < m*n;i++){
if(i%m == 0 && i%n == 0){
System.out.println("最小公倍数为：" + i);
break;
}
};
}
}七、while循环
语法格式：
①初始化部分
while(②循环条件部分){
③循环体部分;
④迭代部分;
}
执行过程：①-②-③-④-②-③-④-②-③-④-...-②
说明：
- 注意不要忘记声明跌代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换
练习一：
//遍历100以内所有的偶数
class WhileTest{
public static void main(String[] args){
//遍历100以内所有的偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while仍然可以调用
System.out.println(i);
}
}
八、do-while循环
语法格式：
①初始化部分;
do{
③循环体;
④跌代部分;
}while(②循环条件部分);
执行过程：①-③-④-②-③-④-②-③-④-...②
说明：
- do-while循环至少执行一次循环体
- 2.开发中，使用for和while更多一些。较少使用do-while
//遍历100以内的偶数，并计算总和以及偶数的个数
int sum = 0;
int count = 0;
int i = 1;
do{
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
i++;
}while(i <= 100);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);九、“无限”循环
最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不 知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。
说明：
1.不在循环条件部分限制循环次数的结构：while(true)，for(;;)
2.结束循环的方式：
方式一：循环条件部分返回false；
方式二：循环结构中执行break；
/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为0时结束程序。
*/
Scanner scan = new Scanner(System.in);
int positiveNum = 0;//记录正数的个数
int negativeNum = 0;//记录负数个数
while(true){
System.out.println("请输入一个整数：");
int num = scan.nextInt();
if(num > 0){
positiveNum ++;
}else if(num < 0){
negativeNum ++;
}else{
//System.out.println("结束");
break;//跳出循环
}
}
System.out.println("输入的正数的个数：" + positiveNum);
System.out.println("输入的负数的个数：" + negativeNum);十、循环嵌套
嵌套循环：将一个循环结构A放在另一个循环结构B中的循环体内，就构成了嵌套循环。
外层循环：循环结构B
内层循环：循环结构A
说明：
① 内层循环遍历一遍，相当于外层循环循环体执行了一遍
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环体循环体一共执行了m*n次
技巧：外层循环控制行数，内层循环控制列数
练习：
1）九九乘法表
2）100以内的所有质数
/*
九九乘法表
*/
class NineNineTable{
public static void main(String[] args){
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + i*j + " ");
}
System.out.println();
}
}
}
/*
100以内的所有质数
质数：素数，只能被1和它本身整除的自然数。 ---从2到n-1都不能整除这个数
最小的质数是2
*/
class PrimeNumberTest{
public static void main(String[] args){
boolean isFlag = true;//标识i是否被j整除，一旦除尽，修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二：对本身是质数的自然数是有效的
//for(int j = 2;j < i;j++){
for(int j = 2;j < Math.sqrt(i);j++){//对i开方 根号i
if(i % j == 0){
isFlag = false;//i被j整除
break;//优化一：只对本身非质数的自然数是有效的
}
}
if(isFlag){
//System.out.println(i);
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//15615
//去除输出时间
//未优化：11633 优化一：1187 优化二：16
}
}
十一、特殊关键字 break、continue
break 语句：
- break语句用于终止某个语句块的执行
- break出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一个语句块
continue 语句：
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
break和continue关键字的使用：
适用范围 循环中使用的作用(不同点) 相同点
break: switch-case,
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue： 循环结构中 结束当次循环 关键字后面不能声明执行语句
lable:for(int j = 1;j <= 4; j++){
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;
//break lable;//结束指定标识的一层循环结构
continue lable;//结束指定标识的一层循环结构的当次循环
}
System.out.print(i);
}
System.out.println();
}