JavaSE：第2章 Java基本语法(上)：变量与运算符

Java基本语法

Java基本语法（上）：变量与运算符

2.1 关键字和保留字

✔ 关键字(keyword)的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

用于定义数据类型的关键字
class	interface	enum	byte	short
int	long	float	double	char
boolean	void

用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return

用于定义访问权限修饰符的关键字
private	protected	public

用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized

用于定义类与类之间关系的关键字
extends	implements

用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instanceof

用于异常处理的关键字
try	catch	finally	throw	throws

用于包的关键字
package	import

其他修饰符关键字
native	strictfp	transient	volatile	assert

* 用于定义数据类型值的字面值
true	false	null

✔ 保留字(reserved word)

• Java保留字：

现有Java版本尚未使用，但以后版本可能会作为关键字使
用。自己命名标识符时要避免使用这些保留字
goto 、const

2.2 标识符

✔ 标识符概念：

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧：凡是自己可以起名字的地方都叫标识符。

✔ 定义合法标识符规则：

由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

✔ Java中的名称命名规范:

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个
单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
__ 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
__ 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

2.3 变 量

基本数据类型
基本数据类型变量间转换
基本数据类型与String间转换
进制与进制间的转换

✔ 变量的概念：

内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

✔ 变量的作用：

用于在内存中保存数据

✔ 使用变量注意：

Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一对{ }内
变量只有在其作用域内才有效
同一个作用域内，不能定义重名的变量

public class KeyWord {
       
             public static void main(String[] args) {
             //变量的定义
             int myAge = 12;
             //变量的使用
             System.out.println(myAge);
             //下行编译错误：使用myNumber之前未定义过
             //System.out.println(myNumber);
             //变量的声明
             int myNumber;
             //编译错误：使用muNumber之前并未赋值给myNumber
             //System.out.println(myNumber);
             //变量的赋值
             myNumber = 1001;
             //编译不通过：不在作用域范围内
             //System.out.println(myClass);
             //不可以定义同名的变量
             //int myAge = 22;
             }
             
             public void method(){
             //作用域适用本方法体
             int myClass = 1;
             }
       
}

✔ 声明变量

 语法：<数据类型> <变量名称>
 例如：int var;

✔ 变量的赋值

 语法：<变量名称> = <值>
 例如：var = 10;

✔ 声明和赋值变量

 语法： <数据类型> <变量名> = <初始化值>
 例如：int var = 10;

✔ 变量的分类-按数据类型

对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分
配了不同大小的内存空间。

补充：变量的分类-按声明的位置的不同
 在方法体外，类体内声明的变量称为成员变量。
 在方法体内部声明的变量称为局部变量。

●注意：二者在初始化值方面的异同:
同：都有生命周期 异：局部变量除形参外，需显式初始化。

💧 整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保
证java程序的可移植性。
java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

类 型	占用存储空间	表数范围
byte	1字节=8bit位	-128 ~ 127
short	2字节	-2^15 ~ 2^15 - 1
int	4字节	-2^31 ~ 2^31 - 1（约21亿）
long	8字节	-2^63 ~ 2^63 - 1

500MB 1MB = 1024KB 1KB= 1024B B= byte ? bit?
bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。

💧 浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作
系统的影响。
浮点型常量有两种表示形式：
 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
 科学计数法形式:如：5.12e2 512E2 100E-2
 float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

类 型	占用存储空间	表数范围
单精度float	4字节	-3.403E38 ~ 3.403E38
双精度double	8字节	-1.798E308 ~ 1.798E308

public class DoubleTest {
       public static void main(String[] args) {
             
             //①byte范围：-128 ~ 127
             byte b1 = 12;
             byte b2 = -128;
             //b2 = 128: //编译不通过
             System.out.println(b1); //12
             System.out.println(b2); //-128
             short s1 = 128;
             int i1 = 1234;
             long l1 = 3414234324L;
             System.out.println(l1); //3414234324
             //2.浮点型：float（4字节）\ double（8字节）
             //①浮点型，表示带小数点的数值
             //②float表示数值的范围比long还大
             double d1 = 123.3;
             System.out.println(d1 + 1); //124.3
             //①定义float类型变量时，变量要以"f"或"F"结尾
             float f1 = 12.3f;
             System.out.println(f1);    //      12.3
       }
}

💧 字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字
母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2
= ‘中’; char c3 = ‘9’;
 Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：char c3 = ‘\n’; // '\n’表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表
一个十六进制整数。如：\u000a 表示 \n。
char类型是可以进行运算的。因为它都对应有Unicode码

💧 了解：ASCII 码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，
因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一
共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从
0000000 到 11111111。
 ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的
关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如
空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这
128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前
面的1位统一规定为0。
缺点：
__ 不能表示所有字符。
__ 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel(ג)

💧 了解： Unicode 编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因
此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，
就会出现乱码。
Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一
无二的编码，使用 Unicode 没有乱码的问题。
Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码
应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号
还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果
unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有
二到三个字节是0，这对于存储空间来说是极大的浪费。

💧 了解： UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据
不同的符号而变化字节长度。
UTF-8的编码规则：
对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于
ASCII码）。
对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一
个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的
所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

💧 布尔类型：boolean

●boolean 类型用来判断逻辑条件，一般用于程序流程控制：
__if条件控制语句；
__while循环控制语句；
__do-while循环控制语句；
__for循环控制语句；
●boolean类型数据只允许取值true和false，无null。
__不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
__Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的
boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false
用0表示。———《java虚拟机规范 8版》

public class BoolTest {
       //boolean测试
       public static void main(String[] args) {
       //①表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量
       char c5 = '\n';//换行符
       System.out.print("hello" + c5); //hello
                                                            //world
       System.out.print("world");
       c5 = '\t';//制表符
       char c6 = '\u0043';
       System.out.print("c6=" + c6); //c6=C
       //4.布尔型：bollean
       //①只能取两个值之一：true、false
       //②常常再条件判断、循环结构中使用
       boolean bb1 = true;
       System.out.println("bb1=" + bb1); //bb1=true
       boolean isMarried = true;
       if(isMarried) {
       System.out.println("你就不能参加\"单身\"party了！\\n很遗憾"); //你就不能参加"单身"party了！\n很遗憾
       } else {
       System.out.println("你可以多谈女朋友");
             }
       }
 }

💧 基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容
量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的
那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类
型的值将自动转化为字符串(String)类型。

public class VariableTest {
       public static void main(String[] args){
             byte b1 = 2;
             int i1 = 129;
             //编译不通过，范围大的不能转换为范围小的
             //byte b2 = b1 + i1;
             int i2 = b1 + i1;
             System.out.println("i2=" + i2); //i2=131131
             }
}

💧 字符串类型：String

 String不是基本数据类型，属于引用数据类型
 使用方式与基本数据类型一致。例如：String str = “abcd”;
 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + “xyz” ;
int n = 100;
str = str + n;

💧 强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使
用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可
以实现把字符串转换成基本类型。
__如： String a = “43”; int i = Integer.parseInt(a);
__boolean类型不可以转换为其它的数据类型。

✔ 进 制

世界上有10种人 ，认识和不认识二进制的。

💧 关于进制

● 所有数字在计算机底层都以二进制形式存在。
● 对于整数，有四种表示方式：
__二进制(binary)：0,1 ，满2进1.以0b或0B开头。
__十进制(decimal)：0-9 ，满10进1。
__八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
__十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如：0x21AF +1= 0X21B0

💧 二进制

●Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；
当是long类型时，二进制默认占64位，第64位是符号位
●二进制的整数有如下三种形式：
__原码：直接将一个数值换成二进制数。最高位是符号位
__负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
__负数的补码：其反码加1。
●计算机以二进制补码的形式保存所有的整数。
__正数的原码、反码、补码都相同
__负数的补码是其反码+1

• 为什么要使用原码、反码、补码表示形式呢？

计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是
人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正
数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有
减法, 这样计算机运算的设计就更简单了。

💧 进制间转化

●进制的基本转换
__十进制 二进制互转
____√ 二进制转成十进制 乘以2的幂数
____√ 十进制转成二进制 除以2取余数
__二进制 八进制互转
__二进制 十六进制互转
__十进制 八进制互转
__十进制 十六进制互转

2.4 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符

✔ 运算符：算术运算符

💧 算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是
负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只
保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的
结果是？
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如：
System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55 ?

public class test {
       //除号：/
       public static void main(String[] args) {
             int num1 = 12;
             int num2 = 5;
             int result1 = num1 /num2;
             System.out.println(result1); //2
             
             int result2 = num1 / num2 * num2;
             System.out.println(result2); //10
             
             double result3 = num1 / num2;
             System.out.println(result3); //2.0
             
             double result4 = num1 / num2 + 0.0; //2.0
             double result5 = num1 /(num2 + 0.0); //2.4
             double result6 = (double)num1 / num2; //2.4
             double result7 = (double)(num1 / num2);//2.0
             System.out.println(result5);
             System.out.println(result6);
       }
}

✔ 运算符：赋值运算符

●符号：=
__当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。
__支持连续赋值。
●扩展赋值运算符： +=, -=, *=, /=, %=

 public class test3 {
       public static void main(String[] args) {
             //（前）++:先自增1，后运算
             //（后）++:先运算，后自增1
             int a1 = 10;
             int b1 = ++a1;
             System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1 = 11,b1 = 11
             
             int a2 = 10;
             int b2 = a2++;
             System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2 = 11,b2 = 10
             
             int a3 = 10;
             ++a3; //a3++;
             int b3 = a3;
             
             //注意点:
             short s1 = 10;
             //s1 = s1 + 1;//编译失败
             //s1 = (short)(s1 + 1);// 正确
             s1++;//自增1不会改变变量本身的数据类型
             System.out.println(s1);//11
             
             short s2 = 10;
             //s2 = s2 + 2;//编译失败
             s2 += 2;//不会改变变量本身的数据类型
             System.out.println(s2);
             
             byte bb1 = 127;
             bb1++;
             System.out.println("bb1 = " + bb1);//-128
       }
}

✔ 运算符：比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==”不能误写成“=” 。

✔ 运算符：逻辑运算符

&—逻辑与 | —逻辑或 ！—逻辑非
&& —短路与 || —短路或 ^ —逻辑异或

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写
成x>3 & x<6 。
“&”和“&&”的区别：
__单&时，左边无论真假，右边都进行运算；
__双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”!

✔ *运算符：位运算符

✔ 运算符：三元运算符

格式:

 表达式1和表达式2为同种类型
 三元运算符与if-else的联系与区别：
1）三元运算符可简化if-else语句
2）三元运算符要求必须返回一个结果。
3）if后的代码块可有多个语句
练习： 获取两个数中的较大数
获取三个数中的较大数

练习： 获取两个数中的较大数
    获取三个数中的较大数
    /**
 * 1.
 *     如果表达式为true，则执行表达式1
 *     如果表达式为false，则执行表达式2
 * 2.
 *     表达式1和表达式2要求是一致的
 * 3.
 *     三元运算符可以嵌套使用
 * 4.
 *     凡是可以使用三元运算符的地方，都可以改写为if-else，反之不成立
 * 5.
 *     如果可以使用三元运算符，又可以使用if-else结构，应该首选三元运算符。原因：简洁、高效
 */
public class SanyuanTest {
       public static void main(String[] args) {
             
             //1
             //获取两个整数的较大值
             int m = 12;
             int n = 5;
             
             int max = (m > n) ? m : n;
             System.out.println(max);//12
             
             double num = (m > n)? 2:1.0;
             
             //2
             //(m > n)?2:"n大";//编译错误
             
             //*************************
             String maxStr = (m > n)? "m大": "n大";
             System.out.println(maxStr);//"m大"
       
             //3
             int n1 = 12;
             int n2 = 30;
             int n3 = -43;
             
             int max1 = (n1 > n2)? n1 : n2;
             int max2 = (max1 > n3)? max1 : n3;
             System.out.println("三个数中的最大值为：" + max2);
             
       }
}

✔ 运算符的优先级

资料来源：https://www.bilibili.com/video/BV1Kb411W75N?p=717