千锋教育2218期2022.10.20日-CSDN博客

本文链接：https://blog.csdn.net/weixin_66648840/article/details/127436345

文章目录

复习

计算机数据存储
	数据存储单位
		计算机中最小的存储单位是 字节 byte 一个字节包含8个 bit (比特位)
	Widows 操作系统 进制单位是1024
		KB MB GB TB PB EB
	macos 或者说硬件生产 进制单位是1000


	常用的数据进制
		十进制 二进制 八进制 十六进制
		涉及到进制转换操作计算器操作完成
		八进制数据展示要求
			0 开头 例如 0777 0775 0755
			在特殊情况下可以舍去 0 
		十六进制数据展示要求
			0x 开头 例如 0x1234 0xabcd 0xABCD
			十六进制不区分大小写，并且在特殊情况下可以舍去0x

常量：
	整数		10 20 30 
	浮点数		3.14 0.618
	字符
		要去使用英文单引号包含的单个元素 ''
		'A' '您'
	字符串
		要求使用英文双引号包含的所有数据内容""
		"郑州加油！！！"
	布尔类型/真假关系
		true
		false
		
	字符集
		常用字符集 UTF-8 GBK
		字符集提供的信息
			1.数字字符顺序'0' ~ '9'
			2.英文大写字母的编码值小于小写字母
			3.英文字母顺序'A'-'Z' 'a'-'z'
			4.大写英文字母和小写英文字母之间有其他标点符号
		使用字符要求
			1. 字符操作有且只允许使用字符本身，不允许使用编码值
			2.严格遵守【数据类型一致化】要求

变量：
	Java重定义变量的格式：
		数据类型 变量名 = 初始化数据;
	
	数据类型 八大基本数据类型
		整型
			byte 1字节 short 2字节 int 4字节 long 8字节
		浮点型
			单精度浮点数 float   4字节
			双精度浮点数 double  8字节
		字符型
			char  可以支持中文   2字节
		布尔类型
			boolean  【true false】 视情况而定
			
	定义变量常见问题
		1. float 类型变量赋值操作，要求常量必须使用大写 F 明确当期那数据为 float 类型
			float 类型没有 double 类型精准和完整
		2. 变量未定义不能使用
			常见于 a. 真的没定义 b. 拼写错误
		3. 变量未赋值不能参与除赋值之外的其他操作
		4. 字符类型常量有且只能使用字符本身
		5.long类型变量复制建议，常量使用大写 L 明确告知编译器当前数据类型为long类型

Java标识符命名规则，运算符，分支结构

1. Java标识符命名规则

1.1 命名规则案例

163邮箱，注册邮箱名限制
	6~18个字符，可使用字母，数字，下划线，需要以字母开头
	
	
命名规则分析
	1. 有长度限制
	2. 可用字符限制(字母，数字，下划线)
	3. 起始限制 要去用字母开头

1.2 基于阿里巴巴Java开发规约限制的标识符命名规范

标识符是什么？？？
	程序员在代码开发中，可以用于自定义的名称信息，包括变量名，方法名，类名，接口名....
	
AJCG 标识符命名规范：
	1. 标识符有且只允许使用英文字母(A - Z, a - z), 数字(0 - 9), 唯一可以使用的标点符号 下划线( _ )
	2. 标识符要求必须使用英文字母开头，不允许使用其他字符
	3. Java 中的标识符严格区分大小写，大写和小写不同!!!
	4. 标识符没有严格长度限制，但是会根据实际情况，限制标识符长度。
	5. 标识符要求做到【见明知意，动宾结构】
		正确案例：
			studentName 
            学生姓名 studentAge 
            学生年龄 studentScore
            学生成绩 【见名知意】
            
			getStudentName 
            获取学生名字 setStudentName 设置学生名字 getStudentAge  获取学生年龄setStudentAge 设置学生年龄  【见名知意，动宾结构】
        错误案例：
        	含糊不清，无法分析，变量名没有明确的语义性，要去变量定义单独成行，一行一个
        		int a,b,c,d,e,f;
        	看似高阶，实则啥也不是
        		payBeiZhu 不能出现英文和拼音的混合
        		zhiFuBeiZhu 不允许， 拼音专有名词(alibaba,beijing)之外，其他不能使用
        		tsgly 绝对不允许，阅读性极差
    
	6.标识符要求使用驼峰命名法或者下划线命名法
    	驼峰命名法：
    		小驼峰
    			标识符首字母小写，之后的每一个单词首字母大写，作为区分标记
    			getStudentName 
    		常用语：
    			变量名，方法明
    		大驼峰：
    			标识符每一个单词的首字母大写
    				FirstJava Demo1’
    				ArrayIndexOutOfBoundsException
    					数组下标越界异常
    				BufferedInputStream
                   常用语：
                   	类名，接口名
                   	class之后的名称就是类名。
       下划线命名法：
       		所有单词字母全部大写，不同单词之间使用 _ 分割
         	JAVA_HOME MAX_VALUE MIN_VALUE MAX_ARRAY_SIZE DEFAULT-CAPACITY
	7. 标识符不得使用已经 Java 占用的关键字和保留字
		代码中变颜色的内容都不可以用于自定义标识符，例如 int float double
	8. 标识符在一定范围内容唯一
		163邮箱绝对不可能出现两个人账号一样！！！

2. 运算符

2.1 算术运算符

开发中使用的算术运算符：
	+ - * ÷ () = %
	
使用要求
	1. 先乘除后加减
	2. 除数不能为0
	3. 从左至右基本原则
	4. 有优先级需求，使用括号处理
	5. = 赋值号，将赋值号右侧的数据，赋值给左侧的变量
	
取余 % ：
	小学没有学分数/小数
		10 ÷ 6 = 1 ... 4
		1 是商为结果
		4 为余数
	开发中取余目标结果就是【余数】，如果按照上的案例，结果为4

除以 /:
	Java 规定，如果是整数相除，没有小数，取整！！！
	5 / 2 = 2;

小案例：
	10 / 12 = ?
		结果为 0 
	10 % 12 = ？
		结果为 10
	12 / 10 = ?
		结果为 1
	12 % 10 = ?
		结果为 2

// 算术运算符案例
public class Demo1 {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 20;
		
		num1 = num1 + num2; // num1 = 30  num2 = 20
		/*
		【注意】
			代码运行过程中，要求关注变量存储数据变化过程
			num1 目前数据存储已通过第 7 行代码存储内容变化，结果为30
			下方代码执行过程中， num1 = 30 num2 = 20 ==> num1 = 30 * 20
			num1 = 600
			*/
		num1 = num1 * num2; // num1 = 600 num2 = 20
		num1 = num1 - num2; // num1 = 580 num2 = 20
		num1 = num1 / num2; // num1 = 29  num2 = 20
		num1 = num1 % num2; // num1 = 9   num2 =20
		
		/*
		【注意】
			num2 数据存储内容在整个的运行过程中，没有任何的变化，
			因为 num2 数据存储内容没有被重新赋值
			[结论]
				变量数据存储内容，有且只有在被赋值的情况下，
				才可以修改
		*/
		System.out.println(num1);
		System.out.println(num2);S
	}
}

增强版算术运算符
	+= -= *= /= %=

int num1 = 10;
int num2 = 20;

num1 = num1 + num2; // num1 = 30 num2 = 20
num1 += num2;   	// num1 = 50 num2 = 20

/*
优势：
	1. 简化代码结构，节省代码体量
	2. 自带 buff ， 有特殊功能
*/

2.2 自增自减运算符

自增自减运算符格式：
	++ 自增 ==> 操作的变量数据内容自增 1
	-- 自减 ==> 操作的变量数据内容自减 1

// 自增自减运算符演示
public class Demo2 {
public static void main(String[] args) {
	int num = 10;
	
	/*
	自增运算符作用是操作的变量数据存储内容自增 1
	*/
	System.out.println(num++); // 10
	System.out.println(num); //11
	
	System.out.println();
	
	System.out.println(++num); //12
	System.out.println(num); //12
	
	/*
	分析：
		1. 所有的自增操作全部有效，num 数据存储结果原本是 10
		通过该两次 自增操作之后，num 目前数据存储情况为12
		2. 发现问题
			System.out.println(num++); 为什么结果为10
				当前代码运行时，num数据存储结果为10，++ 自增操作
				在变量之后， 执行流程
					a. 取值目前 num 数据内容参与代码运行， 得到数据 10 
					b. 代码当前执行完毕之后， num 完成自增操作后 num10 ==> 11
				看到的展示效果为 10 的情况， 【先取值后自增】
				
				-------------------------------------------
				
			System.out.println(++num); 为什么结果为12
				当前代码运行时，num数据存储结果为 11，++自增操作
				在变量之前，执行流程
					a. 首先 num 执行自增操作， num 11 ==>12
					b. 取值当前 num 数据存储情况，参与代码运行，得到数据 12
				看到的展示效果为 12 的情况，【先自增后取值】
			【总结】
				++ 在变量之前，【先自增后取值】
				++ 在变量之后，【先取值后自增】
				自减操作同理
				
			代码歧义性过大！！！
		*/
	
	}
}

【语法总结】
	1. 自增自减运算符有且只能操作变量，不可以操作常量！！！
	2. 自增自减运算符在变量之前和之后，操作流程不同
		在变量之前，【先操作后取值】
		在变量之后，【先取值后操作】

【使用建议】重点
	1. 自增自减歧义性过大，代码中尽量减少使用‘
	2. 如果必须要是用
		a. 单独成行
			int num = 10;
			num++;
			++num;
		b. 使用 += 1 or -= 1 替换 自增自减运算符
			++num or num++ ==> num += 1
			--num or num-- ==> num -= 1
			Swift ios开发语言中，已经禁用 自增自减运算符，避免代码歧义， 全部使用 += 1 和 -= 1 替换提高代码阅读性
			
【自增自减运算符常用位置】
	1. 循环操作
	2. 面试题

【面试题1】
int num = 5;
int ret = num++ * ++num;

num = 7;
ret = 35;
/*
num 初始化数据为 5
	自增自减运算古风是针对于变量操作，自增自减运算符存在，一定会修改对应的变量数据内容
	目前表达式中的存在 num++ 和 ++num
	针对于 num 的自增操作执行了两次
	所以 num 变量最终数据存储结果为7
	
ret 的结果是取决于 num 在表达式中的数据提供效果。
	ret = num++ * ++num；
	num++ 先取值，后自增
		针对于 ret 计算表达式的数据提供【5】
		num++ 取直之后自增， num 数据存储内容为6 
	++num 先自增， 后取值
		++num 针对于 num 数据存储修改，num 数据存储内容为7
		针对于 ret 计算机表达式的数据提供为 【7】
		
	ret = 5 *7; ==> ret = 35;
	
*/
【面试题2】
int num = 10;
++(num++)++;

num = ?;
/*
语法错误！！！
	有小括号先处理括号中的内容
	小括号中的数据内容对于整个表达式而言是一个【值/数据】，不是变量！！！
			小括号里面的内容对外的结果不是 num 变量
	自增自减运算符有且只能操作变量，不能操作【常量】，同样无法操作【值/数据】


++优先级高于*   可以说++num 是一个整体



int num = 1;
++num++;
	也不对，先执行一个++后就变成常量了，第二个++就不是变量不适用了

*/

2.3 关系运算符

判断表达式两端的数据结果是否满足关系运算符需求，对外的结果为boolean(true false)
Java 中开发使用的关系运算符：
	> < >= <= != ==

// 关系运算符演示
public class Demo3 {
	public static void main(String[] args) {
		/*
		关系运算符对外的数据结果为 boolean
		这里定义一个 Boolean 变量 ret 存储关系
		运算符结果
		*/
		boolean ret = 5 > 2;
		System.out.println(ret); // ture
		
		ret = 5 < 2;
		System.out.println(ret); // false
		
		ret = 5 >= 5;
		System.out.println(ret); // ture
		
		ret = 5 <= 3;
		System.out.println(ret); // false 
		
		ret = (15 == 5);
		System.out.println(ret); // false
		
		ret = (5 != 15);
		System.out.println(ret); // ture
	}
}

2.4 逻辑运算符

条件叠加，多个条件整合成一个完整的条件分析，逻辑运算符最终对外结果为boolean类型结果(true flase)
逻辑与
	与 &&
	同真为真，有假【即】假
	成为龙哥超市会员
		充值1000元并消费满500元，可以成为VIP
逻辑或
	或 ||
	有真【即】真，同假为假
		充值1000元或者消费满500元，可以成为VVIP
逻辑非
	取反 ！
	强牛，犟，真变假，假变真

// 逻辑运算符演示
public class Demo4 {
	public static void main(String[] args) {
		boolean ret = 10 > 5 && 5 > 2;
		System.out.println(ret); // true 
		
		ret = 10 > 15 && 5 > 2;
		System.out.println(ret); //false
		
		ret = 10 > 15 || 5 > 2;
		System.out.println(ret); //true
		
		ret = 10 > 15 || 5 > 20;
		System.out.println(ret); //false
		
		ret = !(10 > 5);
		System.out.println(ret); //false
	}
}

2.5 逻辑表达式短路原则

int num = 10;
boolean ret = num > 15 && ++num > 10;

num = 10;
ret = false;
/*
结果分析
	&& 同真为真，有假【即】假
	如果一个逻辑与表达式中出现一个false条件，该逻辑与表达式有没有可能成为true？？？
		绝对不可能
	逻辑与表达式，计算机在运行过程中，一旦发现false条件！！！当前逻辑与表达式已经结果明确为 false！！！
	计算机为节约资源，从false条件开始，之后的所有表达式不再运行！！
	
	【逻辑与短路原则 同真为真，有假【既】假】
*/


int num = 10;
boolean ret = num > 5 || ++num > 5;

num = 10;
ret = true;


/*
结果分析
	|| 有真【既】真，同真为真
	一个逻辑或表达式，只要存在一个条件为true，整个表达式结果已经明确为true，不可能变成false
	逻辑或表达式在运行过程中，如果发现了 true 条件，之后的所有内容不在执行，节约计算机资源。
	【逻辑或短路原则 有真【既】真，同假为假】
*/

2.6 运算符小案例

完成条件判断书写，判断一个数值是否在 0 ~ 100 之间

int num = 50;
// 0 <= num <= 100 数学规范，但是开发不支持
num >= 0 && num <= 100
// 使用逻辑与表达式连接条件，限制当前 num 数据范围在 0~100

完成条件判断书写，判断一个字符是否为数字字符

char ch = '4';
//字符变量 ch 存储 字符常量 '4' ==> 数字字符
ch >= '0' && ch <= '9';
// 使用逻辑与表达式连接条件，限制当前 ch 字符数据存储范围是 '0' ~ '9'
// 如果操作过程中涉及到字符内容，有且只允许使用字符本身

3.完成条件判断书写，判断一个字符是否为大写英文字母

char ch = 'Y';
ch >= 'A' && ch <= 'Z';

4.完成条件判断书写，判断一个字符是否为英文字母

char ch = 'h';
ch >= 'A' && ch <= 'Z'; // 大写英文字母条件
ch >= 'a' && ch <= 'z'; // 小写英文字母条件

// 不可能出现一个英文字母既满足大写，又满足小写！！！满足其一即可认为是英文字母
ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z';
(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');

/*
以上两个条件都是正确条件！！！
	小括号使用可以认为是一个整体！！！从阅读性角度分析，可能优于没有括号的版本
	逻辑与运算符优先级高于逻辑或！ 无序括号限制优先级和整体性问题。
*/

完成条件判断书写，完成闰年条件判断

闰年条件：

可以被 4 整除，但是不能被 100 整除

可以被 400 整除

满足以上任意条件都是闰年！！！

int year = 2022;
// 可以被 4 整除 取余 4 余数为 0
year % 4 == 0;
// 不能被 100 整除
year % 100 !=0;
// 可以被 400 整除
year % 400 ==0;
  
year % 4 == 0 && year % 100 != 0 || year % 400 == 0;    YES！！！
year%4==0&&year%100!=0||year%400==0;   NO！！！

3. 分支结构

3.1 生活场景

会员等级：
	龙哥超市
		消费满 100 元   黑铁 VIP
		消费满 500 元   白银 VIP
		消费满 1000 元  黄金 VIP
		消费满 3000 元  砖石 VIP
		消费满 10000 元 星耀 VIP
		
充值返现：
	龙哥营业厅
		充值 1000  送 100
		充值 3000  送 500
		充值 8000  送 1000
		充值 10000 送 3000

学生成员等级：
	满分 100 分
		90 以上 秀儿
		80 以上 良儿
		70 以上 中儿
		60 以上 过儿
		60 以下 废物

3.2 if分支结构

//格式
if (/* 条件判断  boolean true or false*/) {
    // 语句体
}
/*
执行流程：
	代码运行判断 if 之后小括号里面的数据内容是否为 true，如果为 true 执行语句体内容，如果为 false 不执行。不管 if 分支结构中的语句体是否执行，代码依然会从 if 大括号之后继续执行。
*/

// if 分支结构演示
public class Demo5 {
	public static void main(String[] args) {
		/*
		用户消费满68元，送停车劵一张
			totalPrice 总价
		*/
		int  totalPrice = 100;
		
		if (totalPrice >= 68) {
			System.out.println("尊敬的用户，送您一张停车劵");
		}
		
		System.out.println("欢迎您下次光临！！！");
	}
}

3.3 if else 分支结构

//格式
if (/* 条件判断 Boolean true or false */) {
    // true 语句体
} else {
    // false 语句体
}
/*
执行流程：
		代码执行 if else 分支结构，首先判断 if 之后的小括号中的数据内容判断为 true，如果为 true 执行 if 大括号对应的 true 语句体，如果为 false 执行 else 大括号对应的 false 语句体。 执行完毕后继续执行后期代码。

开发有一个梗
		世界上最遥远的距离，不是我在你眼前，你不知道我爱你，而是我在 if 里， 你在 else 里

*/

// if else 分支结构演示
public class Demo6 {
	public static void main(String[] args) {
		/*
		周年庆大酬宾，消费满 168 元，送小拉菲一瓶，不满送 健力宝一瓶
		*/
		int totalPrice = 59;
		
		if (totalPrice >= 168) {
			System.out.println("尊敬的客户，送您一年82年的拉菲！！！");
		} else {
			System.out.println("尊敬的客户，送您22年的健力宝一瓶！！");
		}
		System.out.println("欢迎您下次光临！！");
	}
}

3.4 if else-if 分支结构

//格式
if (/* 条件匹配 1 */) {
    // 处理方式 1 
} else if (/* 条件匹配 2 */) {
    // 处理方式 2 
} else if (/* 条件匹配 3 */) {
    // 处理方式 3
} else {
    // 不满足任何条件匹配的备选处理方式
}
/*
执行流程：
	代码运行 if else-if 分支结构，自上而下匹配 if 之后小括号里面的条件，如果发现匹配项，执行对应的处理方式，跳出分值结构，如果没有任何一个 if 条件匹配，执行 else 中的备选处理方式。
	if else-if 分支结构执行完成，继续执行之后的代码
	
王者荣耀五五开黑节充值活动
充值 100  点券 ~ 300   点券，送您浓情玫瑰 5 支
充值 300  点券 ~ 1000  点券，送您改名卡一张
充值 1000 点券 ~ 5000  点券，送您任选非限定史诗皮肤一套
充值 5000 点券以上，送您任选非限定传说皮肤一套

*/

// if else-if 分支结构代码结构演示
  
/*
王者荣耀五五开黑节充值活动
充值 100  点券 ~ 300   点券，送您浓情玫瑰 5 支
充值 300  点券 ~ 1000  点券，送您改名卡一张
充值 1000 点券 ~ 5000  点券，送您任选非限定史诗皮肤一套
充值 5000 点券以上，送您任选非限定传说皮肤一套
*/
public class Demo7 {
	public static void main(String[] args) {
		int totalPrice = 999;
		// 消费金额递增
		if (totalPrice >= 100 && totalPrice <= 300) {
			System.out.println("恭喜您，送您浓情玫瑰 5 支，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice > 300 && totalPrice <= 1000) {
			System.out.println("恭喜您，送您改名卡一张，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice > 1000 && totalPrice <= 5000) {
			System.out.println("恭喜您，送您任选非限定史诗皮肤一套，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice > 5000 ) {
			System.out.println("恭喜您，送您任选非限定传说皮肤一套，24 小时到达邮箱，请注意查收！");
		} else {
			System.out.println("送您大喇叭一个，24内到达邮箱，请注意查收！");
		}
		
		
		/*
		消费金额递减
		对比上方的条件，递减条件
		
		
		*/
		
		if (totalPrice > 5000 ) {
			System.out.println("恭喜您，送您任选非限定传说皮肤一套，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice >= 1000 ) {
			System.out.println("恭喜您，送您任选非限定史诗皮肤一套，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice >= 300) {
			System.out.println("恭喜您，送您改名卡一张，24 小时到达邮箱，请注意查收！");
		} else if (totalPrice <= 300 && totalPrice >= 100) {
			System.out.println("恭喜您，送您浓情玫瑰 5 支，24 小时到达邮箱，请注意查收！");
		} else {
			System.out.println("送您大喇叭一个，24内到达邮箱，请注意查收！");
		}
	}
}

作业

//专题解答

// 小课堂
public class Demo02 {
	public static void main(String[] args) {
		int num = 10;
		num = num++;
		
		/*
		明确：
			= 赋值号优先级最低！！！
		
		流程:
			1. num++ 先取值 num 目前数据存储结果为 10，10用于赋值 num 使用
			2. num++ 自增操作执行，num 数据存储结果为 11
			3. num = 10 赋值操作，10 是 num++ 首先取值参与当前赋值操作的数据内容
		num 最终结果为 10
		*/
		
		System.out.println(num);
		
		num = ++num;
		/*
		明确：
			= 复制好优先级最低！！！
		流程：
			1. ++num. 先自增，num数据存储从 10 增长到 11
			2. ++num. 取值 num 当前数据存储使用，得到数据 11
			3. num = 11 ==> num 最终结果为11
		*/
		System.out.println(num);
	}
}

整理笔记

案例代码三遍

练习题
3.1. 判断用户提供的字符是不是英文字符，如果是输出yes，不是输出no
int num = '2';
		if (num >= 'A' && num <= 'Z' || num >= 'a' && num <= 'z') {
			System.out.println("Yes");
 		} else {
 			System.out.println("No");
 		} 
3.2. 判断用户提供的工资是不是在5000以上，如果是，输出需要缴税，如果不是，输出不需要缴税
short num = 1000;
 	if (num > 5000) {
 		System.out.println("需要缴税");
 	} else {
 		System.out.println("不需要缴税");
 	}
 
3.3. 用户提供一个年份，判断这个年份是不是一个闰年。
long year = 1600L;
		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
			System.out.println(year + "年是闰年");
		} else {
			System.out.println(year + "不是闰年");
		}
3.4. 提供两个整数，打印两数之差的绝对值。
3.5. 提供一个数, 判断是否是偶数,如果是偶数,输出YES,如果是奇数.输出NO

整理笔记

案例代码三遍

练习题
3.1. 判断用户提供的字符是不是英文字符，如果是输出yes，不是输出no
int num = '2';
		if (num >= 'A' && num <= 'Z' || num >= 'a' && num <= 'z') {
			System.out.println("Yes");
 		} else {
 			System.out.println("No");
 		} 
3.2. 判断用户提供的工资是不是在5000以上，如果是，输出需要缴税，如果不是，输出不需要缴税
short num = 1000;
 	if (num > 5000) {
 		System.out.println("需要缴税");
 	} else {
 		System.out.println("不需要缴税");
 	}
 
3.3. 用户提供一个年份，判断这个年份是不是一个闰年。
long year = 1600L;
		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
			System.out.println(year + "年是闰年");
		} else {
			System.out.println(year + "不是闰年");
		}
3.4. 提供两个整数，打印两数之差的绝对值。
3.5. 提供一个数, 判断是否是偶数,如果是偶数,输出YES,如果是奇数.输出NO
3.6. 提供一个人的年份, 检测这个是否是00后,如果是输出YES,如果不是输出NO(2000-2009年)