【自学Java SE笔记】第三章 Java基本程序设计结构

前言
3.Java基本程序设计结构
- 3.1 运算符
- - 3.1.1 算数运算符
  - 3.1.2 “+”做连接符
  - 3.1.3 自增自减运算符
  - 【拓展案例】自增自减运算符
  - 3.1.4 赋值运算符
  - 3.1.5 关系运算符
  - 3.1.6 逻辑运算符
  - 3.1.7 三元运算符
  - 【拓展案例】三元运算符
  - 3.1.8 运算符优先级
- 【案例知识】键盘录入技术——Scanner类
- 3.2 程序流程控制
- - 3.2.1 顺序结构
  - 3.2.2 分支结构——if
  - 3.2.3 分支结构——switch
  - 【switch案例】月份查看器——switch穿透性
  - 3.2.4 循环结构——for
  - 【for循环案例1】1-5之间的数据求和
  - 【for循环案例2】求1-10之间的奇数和
  - 【for循环案例3】水仙花数
  - 3.2.5 循环结构——while
  - 【while循环案例】珠穆朗玛峰
  - 3.2.6 循环结构——do-while
  - 3.2.7 死循环
  - 【死循环案例】密码验证
  - 3.2.8 跳转控制语句
- 【案例知识】随机数技术——Random类
- - 【Random类】生成随机数
  - 【Random案例】猜数字游戏

前言

该文章为Java基础自学笔记，同时附有学习工具等资源，供大家使用
其他内容：Java基础学习笔记目录
Java基础学习视频：Java入门基础视频教程，java零基础自学首选黑马程序员Java入门教程
学习用书：
《Java核心技术卷Ⅰ 基础知识（第10版）》提取码：2022
《Java经典编程300例》提取码：2022

3.Java基本程序设计结构 3.1 运算符

对字面量或变量进行操作的符号

3.1.1 算数运算符

符号	作用	说明
+	加
-	减
*	乘
/	除	与“÷”相同，注意：在Java中两个整数相除结果是整数
%	取余	获取两个数据做除法的余数

3.1.2 “+”做连接符

“+”符号与字符串运算时作连接符，结果是一个字符串
能算则算，不能算就在一起

	int a = 5；
	System.out.println(a + "a"); // 5a
	System.out.println(a + 'a'); // 102

3.1.3 自增自减运算符

符号	作用	说明
++	自增	变量的值加1
–	自减	变量的值减1

注意事项：

++、–只能操作变量，不能操作字面量
++、–如果不是单独使用（如在表达式中、或同时有其他操作），放在变量前后有明显区别：
放在变量前面，先对变量进行自增自减，再对变量的值进行计算

	int a = 10;
	int rs = ++a; // rs = 11, a=11

放在变量后面，先对变量的值进行计算，再对变量进行自增自减

	int b = 10;
	int rs = b++; // rs = 10, b=11

【拓展案例】自增自减运算符

	int k = 3;
	int p = 5;
	int rs = k++ + ++k - --p + p-- - k-- + ++p + 2; // rs=9, k=4, p=4

变量	k++	+	++k	-	–p	+	p–	-	k–	+	++p	+	2	结果
rs	3	+	5	-	4	+	4	-	5	+	4	+	2	9
k=3	4		5						4					4
p=5					4		3				4			4

3.1.4 赋值运算符

基本赋值运算符：“ = ”
扩展赋值运算符：

符号	作用	说明
+=	加后赋值	a += b 等价于 a = (a的数据类型)(a + b)，将a + b的值赋给a
-=	减后赋值	a -= b 等价于 a = (a的数据类型)(a - b)，将a - b的值赋给a
*=	乘后赋值	a = b 等价于 a = (a的数据类型)(a b)，将a * b的值赋给a
/=	除后赋值	a /= b 等价于 a = (a的数据类型)(a / b)，将a / b的值赋给a
%=	取余后赋值	a %=b 等价于 a = (a的数据类型)(a % b)，将a % b的值赋给a

注意：扩展赋值运算符隐含了强制类型转换

	byte i = 10;
	byte j = 20;
	int rs = i + j; // byte在表达式中直接转换成int参与运算
	i += j; // i = (byte)(i + j);

3.1.5 关系运算符

对数据进行条件判断的符号，最终返回一个比较的布尔结果（false，true）

符号	说明
==	a == b，判断a和b的值是否相等，成立返回true，不成立返回false
!=	a. != b，判断a和b的值是否不相等，成立返回true，不成立返回false
>	a > b，判断a是否大于b，成立返回true，不成立返回false
>=	a >= b，判断a是否大于等于b，成立返回true，不成立返回false
<	a < b，判断a是否小于b，成立返回true，不成立返回false
<=	a <= b，判断a是否小于等于b，成立返回true，不成立返回false

	int a = 5;
	int b = 10;
	System.out.println(a == b); // false
	System.out.println(a = b); // 10

3.1.6 逻辑运算符

把多个条件的布尔结果放在一起运算，最终返回一个布尔结果

符号	介绍	说明
&	逻辑与	必须都是true，结果才是true；只要有一个是false，结果就是false
I	逻辑或	只要有一个为true，结果就是true
！	逻辑非	你真我假，你假我真；!true=false、!false=true
^	逻辑异或	如果两个条件都是false或都是true，结果为true；两个条件不同，结果是true

短路逻辑运算符：

符号	介绍	说明
&&	短路与（双与）	判断结果与“&”相同，过程中左边为false，右边则不再执行
II	短路或（双或）	判断结果与“I”相同，过程中左边为true，右边则不再执行

注意：逻辑与“&”、逻辑或“I”，无论左边是否满足，右边都要执行

3.1.7 三元运算符

条件表达式？值1 ：值2;

执行流程：首先计算条件表达式的值，如果值为true，返回值1，如果为false，返回值2

【拓展案例】三元运算符

用三元运算符找出最大值

	int i = 10;
	int j = 30;
	int k = 50;
	int rsMax = i > j ? i > k ? i : k : j > k ? j : k; // 50

3.1.8 运算符优先级

优先级	运算符	结合性
1	.，()，[]，	从左到右
2	+（正），-（负），++，–，！	从右到左
3	*，/，%	从左到右
4	+，-	从左到右
5	<<，>>，>>>	从左到右
6	<，<=，>，>=，instanceof	从左到右
7	==，!=	从左到右
8	&	从左到右
9	^	从左到右
10	I	从左到右
11	&&	从左到右
12	II	从左到右
13	?:	从右到左
14	=，+=，-=，*=，/=，%=，&=	从右到左

	System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true
	System.out.println((10 > 3 || 10 > 3) && 10 < 3); // false

【案例知识】键盘录入技术——Scanner类

import java.util.Scanner; // 导包

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); //  获取键盘扫描器对象

        System.out.println("请输入您的年龄：");
        int age = sc.nextInt(); // 获取用户int型输入数据
        System.out.println("您的年龄是：" + age);

        System.out.println("请输入您的名称：");
        String name = sc.next(); // 获取用户String型输入数据
        System.out.println("欢迎：" + name);
    }
}

请输入您的年龄：
15
您的年龄是：15
请输入您的名称：
狗蛋儿
欢迎：狗蛋儿

3.2 程序流程控制 3.2.1 顺序结构

程序默认流程

3.2.2 分支结构——if

根据判定的结果（真或假）决定执行某个分支的代码

	if(条件表达式1){
		语句体1;
	} else if(条件表达式2){
		语句体2;
	} else {
		语句体n+1
	}

3.2.3 分支结构——switch

匹配条件执行分支

	switch(表达式){
		case 值1:
			执行代码;
			break;
		case 值n:
			执行代码;
			break;
		default:
			执行代码;
	}

执行流程：
①限制性表达式的值，使用表达式中的值与case后的值匹配
②匹配case值为true，执行后面的代码，遇到break跳出switch分支
③未匹配到case，执行default代码
if与switch分支各自适合的业务场景
- if：功能强大于switch，适合做区间匹配
- switch：适合做值匹配的分支选择、代码优雅
switch分支注意事项：
- 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long
- case的值不允许重复，只能是字面量，不能是变量
- 不要忘记break，否则会出现穿透现象
switch的穿透性
- 代码执行到没有break的case块，执行完将直接进入下一个case块（不再那行任何匹配），直到遇到break才跳出分支

【switch案例】月份查看器——switch穿透性

public class SwitchDemo {
    public static void main(String[] args) {
        int month = 2;
        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12: // 穿透性，直接执行case12中的代码
                System.out.println(month + "月是31天！");
                break;
            case 2:
                System.out.println(month + "月，闰年是29天，非闰年是28天！");
                break;
            case 4:
            case 6:
            case 9:
            case 11: // 穿透性，直接执行case11中的代码
                System.out.println(month + "月是30天！");
                break;
            default:
                System.out.println("数据有误！");
        }
    }
}

2月，闰年是29天，非闰年是28天！

3.2.4 循环结构——for

控制一段代码反复多次执行

	for(初始化语句; 循环条件; 迭代语句) {
		循环体语句（重复执行的代码）;
	}

IDEA生成for循环快捷键

	// fori 直接生成以变量i为迭代的循环语句
	for (int i = 0; i < ; i++)

【for循环案例1】1-5之间的数据求和

public class ForDemo1 {
    public static void main(String[] args) {
        // 整型变量sum用于累加求和
        int sum = 0;
        // for循环找到 1 2 3 4 5
        for (int i = 1; i <= 5; i++) {
            // 将数据累加给sum
            sum += i;
        }
        System.out.println("1-5的和是：" + sum);
    }
}

1-5的和是：15

【for循环案例2】求1-10之间的奇数和

方法一：取1-10的数筛选出奇数并求和

public class ForDemo2 {
    public static void main(String[] args) {
        // 整型变量sum用于累加求和
        int sum = 0;
        // for循环找到 1-10的数据
        for (int i = 1; i <= 10; i++) {
            // 筛选出奇数
            if (i % 2 == 1) {
                // 将筛选出的数据累加到sum
                sum += i;
            }
        }
        System.out.println("1-10的奇数和是：" + sum);
    }
}

1-10的奇数和是：25

方法二：取1-10中的奇数并求和

		// 整型变量sum1用于累加求和
        int sum1 = 0;
        // for循环通过控制迭代语句，找到 1-10的奇数
        for (int i = 1; i <= 10; i += 2) {
            // 将数据累加到sum1
            sum1 += i;
        }
        System.out.println("1-10的奇数和是：" + sum1);

【for循环案例3】水仙花数

水仙花数：是一个三位数，满足个位、十位、百位数字的立方和等于原数

public class ForDemo3 {
    public static void main(String[] args) {
        // 整型count为计数器
        int count = 0;
        // for循环获取全部三位数
        for (int i = 100; i <= 999; i++) {
            // 获取三位数的个位数
            int ge = i % 10;
            // 获取三位数的十位数
            int shi = i / 10 % 10;
            // 获取三位数的百位数
            int bai = i / 100;
            // 判断是否为水仙花数
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                System.out.print(i + "t"); // 必须为双引号的t
                count++;
            }
        }
        System.out.println("n水仙花的个数是：" + count);
    }
}

153	370	371	407	
水仙花的个数是：4

3.2.5 循环结构——while

	初始化语句;
	while (循环条件) {
		循环体语句（被重复执行的代码）;
		迭代语句;
	}

for与while循环使用规范：
- 知道循环次数：for
- 不知道循环次数：while

【while循环案例】珠穆朗玛峰

珠穆朗玛峰高度8848.86米=8848860毫米，使用一张厚度为0.1毫米的纸，计算需折叠多少次，可以达到珠穆朗玛峰的高度（不知道循环次数，可以选择使用while循环实现）

public class WhileDemo {
    public static void main(String[] args) {
        // double型珠穆朗玛峰高度
        final double PEAK_HEIGHT = 8848860;
        // double型纸张初始高度
        double paperThickness = 0.1;
        // int型计数器
        int count = 0;
        while (paperThickness < PEAK_HEIGHT) {
            // 折叠后纸张厚度
            paperThickness *= 2;
            count++;
        }
        System.out.println("折叠次数：" + count);
        System.out.println("纸张的最终厚度：" + paperThickness);
    }
}

折叠次数：27
纸张的最终厚度：1.34217728E7

3.2.6 循环结构——do-while

先执行再判断循环条件，一定会先执行一次循环体

	初始化语句;
	do {
		循环体语句;
		迭代语句;
	} while (循环条件);

3.2.7 死循环

for死循环`

	for(;;) {}

while死循环（常用）

	while (true) {}

do-while死循环

	do {} while (true);

【死循环案例】密码验证

import java.util.Scanner;

public class DeadWhileDemo {
    public static void main(String[] args) {
        // 正确密码
        final String PASSWORD = "abc";
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入密码：");
            String password = sc.next();
            // 比较输入密码是否正确
            if (password.equals(PASSWORD)) {
                System.out.println("登录成功！");
                break;
            } else {
                System.out.println("密码错误！");
            }
        }
    }
}

请输入密码：
aaa
密码错误！
请输入密码：
abc
登录成功！

3.2.8 跳转控制语句

跳转控制语句	作用	限制
break	跳出并结束当前所在循环	只能用于结束循环或switch分支的执行
continue	跳出当前循环的当次执行，进入下一次循环	只能用于循环语句

【案例知识】随机数技术——Random类【Random类】生成随机数

nextInt(n)只能生成：0 - (n-1)之间的随机数
使用减加法nextInt(n) + m，生成m - (n-1)+m之间的随机数

public class RandomDemo1 {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println("在5-12中生成5个随机数：");
        for (int i = 0; i < 5; i++) {
            int data = r.nextInt(8) + 5; // r.nextInt(8)生成0-7不包含8的随机数
            System.out.print(data + "t");
        }
    }
}

在5-12中生成5个随机数：
10	12	5	10	6

【Random案例】猜数字游戏

随机生成一个1-100之间的数字，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束

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

public class RandomDemo2 {
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您在1-100中猜测的数字：");
            int guessNumber = sc.nextInt();
            if (guessNumber > number) {
                System.out.println("您猜测的数字过大！");
            } else if (guessNumber < number) {
                System.out.println("你猜测的数字过小！");
            } else {
                System.out.println("恭喜您，猜中了！正确数字为" + number);
                // 猜中结束循环
                break;
            }
        }
    }
}

请输入您在1-100中猜测的数字：
50
你猜测的数字过小！
请输入您在1-100中猜测的数字：
90
您猜测的数字过大！
请输入您在1-100中猜测的数字：
89
恭喜您，猜中了！正确数字为89

【自学Java SE笔记】第三章 Java基本程序设计结构

Java相关栏目本月热门文章