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

最新推荐文章于 2024-08-30 18:40:43 发布

qq_45305145

最新推荐文章于 2024-08-30 18:40:43 发布

阅读量132

点赞数

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/qq_45305145/article/details/127435735

版权

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;
			
		看似高阶，实则低阶
		payBeizhu 不能出现英文和拼音混合
		zhiFuBeiZhu 不允许，拼音除专用名词（alibaba beijing）之外，其他不允许使用
		tsgly  绝对不允许使用，阅读性极差！！！

6.标识符要求使用驼峰命名法或下划线命名法
	驼峰命名法：
		小驼峰：
			标识符首字母小写，之后的每一个单词首字母大写，作为区分标记
			studentName  studentAge
		常用语：
			变量名，方法名
		大驼峰
			标识符每一个单词首字母大写
			FirstJava Demo1 Demo2
			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.除数不能为零
	3.从左至右基本原则
	4.有优先级需求，使用括号处理
	5.= 赋值号， 将赋值号右边的数据，赋值给左侧的变量
取余%：
	
	小学没有学分数/小数
	10 ÷ 6 = 1 ... 4
	1是商为结果
	4是余数
 	开发中取余目标结果就是余数，如果按上面的案例，结果为四
 	
 除以/：
	Java规定：如果是整数相除，没有小数，取整！！！
	 5 / 2 = 2;
	小案例：
		10 / 12 = ?
        结果为0
        10 % 12 = ?
        结果为10
        12 / 10 = ?
        结果为1 
        12 % 10  = ?
        结果为2
        25 / 3 = ?
        结果是8
        25 % 3 = ?
        结果是1
	 
	
  public class Demo1{
	public static void main(String[] args){
		
		int num1 = 10;
		int num2 = 20;
		num1 = num1 + num2; //num1 = 30
		
		/*
		【注意】
			代码运行过程中，要求关注变量存储数据变化过程。
			num1 目前数据存储通过第七行代码存储内容变化结果为30
			下方代码执行过程中，num1 = 30  num2 = 20  ==>num1 = 30 * 20 
		*/
		
		num1 = num1 * num2;  //num1 =600      num2 =20
		num1 = num1 - num2;  //num1 =580
		num1 = num1 / num2;  //num1 =29
		num1 = num1 % num2;  //num1 = 9
		
		/*
		【注意】
			num2 数据存储在整个的运算过程中，没有发生任何变化
			因为num2 数据存储内容没有被重新赋值
			[结论]
				变量数据存储内容，有且只有在被赋值的情况下，才可以修改
		*/
		System.out.println(num1);
		System.out.println(num2);
		
		
		
	}
}

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

int num1 = 10;
int num2 = 20;

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

2.2自增资减运算符

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

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

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

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

【面試題】
int num = 10;
++(num++)++
num = ?;
/*
语法错误
	有小括号先处理括号中的内容
	小括号的数据内容对于整个表达式而言是一个【值/数据】，不是变量！！
				小括号里的内容对外的结果不是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);//true
		
		ret = 5<2;java
		System.out.println(ret);//false
		
		ret = 5 >= 5;
		System.out.println(ret);//true
		
		ret = 5<= 3;
		System.out.println(ret);//false
		
		ret = (5 == 5);
		System.out.println(ret);//true
		
		ret = (5 != 15);
		System.out.println(ret); //true
		
	}
	
	
}

2.4逻辑运算符

条件叠加，多个条件整合成一个完整的条件分析逻辑运算符对外最终结果为Boolean
逻辑与
	与&&
	同真为真，有假即假
	成为会员的条件：
	充值并消费500，充值不消费，消费不充值都不可
逻辑或
	或||
	有真即真，同假即假
逻辑非
	【取反！】
	强牛，犟，真变假，假变真

//逻辑运算符演示
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 < 2;
		System.out.println(ret); //false
		
		ret = !(10 > 5);
		System.out.println(ret); // false
		
		
		
		int num1 = 66;
		boolean ret1 = (num1 % 4 == 0 && num1 % 100 != 0) || (num1 % 100 == 0);
		System.out.println(ret1);
		
	}
}

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!!
	计算机为节约资源，从ture条件开始，之后的所有表达式不在运行！！节约计算机资源。
	逻辑或短路原则 有真即真，同假即假。

*/

2.6运算符小案例

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

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

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

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

*/

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

闰年条件：
1.可以被4整除，但是不能被100整除
2.可以被400整除
	满足以上任意条件都是闰年!!!

int year = 2008;
//可以被4整除 取余 4 余数为0 
year % 4 == 0;
//不能被100整除
year % 100 != 0;
//可以被400整除
year % 400 == 0;

year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ; 
year%4==0&&year%100!=0||year%400==0;//拉胯

3.分析结构

3.1生活场景

会员等级：
  超市
  	消费满500元     黑铁VIP
  	消费满5000元    白银VIP
  	消费满50000元   黄金VIP
  	消费满500000元  钻石VIP
  	
  充值返现：
  	超市
  	 充值100        送10
  	 充值1000       送100
  	 充值10000      送1000
  	 充值100000     送10000
  	 
  学生成绩等级：
  	满分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元，送停车券一张
		tatalprice总价
		*/
		int totalPrice = 150;
		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 = 200;
		if (totalPrice >= 168) {
			System.out.println("尊贵的用户，送您一瓶小拉菲");
		} else {
			System.out.println("尊贵的用户，送你一双足力健");
		}
		System.out.println("欢迎您下次光临！！!");
		
		int price = 888;
		if (price >= 666) {
			System.out.println("欢迎光临，尊贵的某某某VIP用户");
			
		} else {
			System.out.println("欢迎光临，某某某用户");
			
		}
		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分支结构执行完成，继续执行之后的代码。

*/

// if else-if 分支结构代码演示
public class Demo7 {
	public static void main(String[] args) {
		int totalPrice = 111;
		//消费金额递增
		
		if (totalPrice >= 666 && totalPrice < 1688) {
			System.out.println("欢迎光临，尊贵的铂金VIP");
		} else if (totalPrice >= 1688 && totalPrice < 3888) {
			System.out.println("欢迎光临，尊贵的黄金VIP");
		} else if (totalPrice >= 3888 && totalPrice <8888) {
			System.out.println("欢迎光临，尊贵的钻石VIP");
		} else if (totalPrice >= 8888) {
			System.out.println("欢迎光临，尊贵的钻紫VIP");
		}else {
			System.out.println("欢迎光临，尊贵的用户");
		}
		
		/*
		消费金额递减
		对比上方的条件，递减方式
			1.if 之后条件内容没有逻辑与判断，效率高
			2.代码量降低
			3.分析条件的罗列关系
			
		*/
		
		
		int price = 1980;
		
		if (price >= 8888) {
			System.out.println("欢迎光临，尊贵的紫钻VIP");
		} else if (price >= 3888) {
			System.out.println("欢迎光临，尊贵的钻石VIP");
		} else if (price >= 1688) {
			System.out.println("欢迎光临，尊贵的黄金VIP");
		} else if (price >= 666){
			System.out.println("欢迎光临，尊贵的铂金VIP");
		} else {
			System.out.println("欢迎光临，尊贵的用户");
		}
		
	
		System.out.println("期待你的再次光临");
	}
	
}