【学习笔记】Java基本语法（上）：变量与运算符

Aiden_Zhao

已于 2023-10-28 10:10:37 修改

阅读量120

点赞数

分类专栏： Java 文章标签： java

于 2021-08-12 10:04:56 首次发布

本文链接：https://blog.csdn.net/Abram_Zhao/article/details/119520091

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

2.1 关键字和保留字

2.1.1 关键字的定义和特点

定义：被Java语言赋予了特殊含义，用作专门用途的字符串
特点：关键字中所有的字母都为小写
Java中的关键字：
在这里插入图片描述

2.1.2 保留字

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

2.2 标识符

标识符：

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

定义合法标识符的规则：

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

Java中的名称命名规范：

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字符大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个开始单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时，每个单词用下划线连接：XXX_YYY_ZZZ

注意：① 在起名字时，为了提高阅读性，要尽量做到有意义，“见名知意”；② Java采用unicode字符集，因此标识符也可以使用汉字声明，但不建议使用。

2.3 变量

变量是程序中最基本的存储单元，包含变量类型、变量名和存储的值。
使用变量注意：

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

2.3.1 变量的声明和赋值

声明变量：

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

变量赋值：

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

也可以声明时直接赋值：

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

再举个栗子：

class VariableTest 
{
	public static void main(String[] args) 
	{
		//变量声明
		int myNumber;
		//变量赋值
		myNumber = 10;
		//变量使用
		System.out.println(myNumber);

		//变量声明时直接赋值
		int myAge = 12;
		//变量的使用
		System.out.println(myAge);
	}
}

2.3.2 数据类型

基本数据类型
- 数值型
  - 整数类型 byte / short / int / long
  - 浮点类型 float / double
- 字符型 char
- 布尔型 boolean
引用数据类型
- 类 class（字符串属于类）
- 接口 interface
- 数组 array

2.3.3 整数类型 byte / short / int / long

各个类型所占空间和表示范围：

类型	占用存储空间	表示范围
byte	1字节(byte) = 8位(bit)	$- 128$ ~ $127$
short	2字节	$2^{15}$ ~ $2^{15} - 1$
int	4字节	$2^{31}$ ~ $2^{31} - 1$
long	8字节	$2^{63}$ ~ $2^{63} - 1$
注意：

bit：计算机中最小的存储单位；byte：计算机中基本存储单元
Java的整型常量常用int型，声明long型常量需要在后边加上“l”或者“L”
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

2.3.4 浮点类型 float / double

各个类型所占空间及表示范围：

类型	占用存储空间	表示范围
单精度float	4字节	$- 3.403 E 38$ ~ $3.403 E 38$
双精度double	8字节	$- 1.798 E 308$ ~ $1.798 E 308$
注意：

浮点型常量有两种表示形式：
- 十进制形式，如5.12，512.0f， .512（必须要有小数点）
- 科学计数法形式：如5.12e2， 512E2，100E-3
float：单精度，尾数可以精确到七位有效数字，很多情况下，很难满足需求
double：双精度，精度是float是两倍，通常采用此种类型
Java中的浮点型常量默认为double型，声明float型常量，需要在后边加“f”或者“F”

2.3.5 字符型

Java中的所有字符都是用Unicode编码，故一个字符可以存储一个字母、一个汉字或者其他书面语的一个字符。
字符型变量的三种表现形式：

字符常量使用单引号括起来的单个字符。如，char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘2’
Java中还允许使用转义字符’'来将其后的字符转变成特殊字符型常量。如，char c1 = ‘\n’; 表示换行符
直接使用Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数，如’\u000a’ 表示 ‘n’

注：char类型是可以进行运算的

2.3.6 布尔型

布尔型数据只允许取值为 true 和 false ，无null，而且不可以使用0或非0来分别代替false和true，这一点与C语言不同。
布尔型通常用于判断逻辑条件，一般用于流程控制语句：

if条件控制语句
while循环控制语句
do-while循环控制语句
for循环控制语句

2.3.7 基本数据类型转换

1、自动类型转换
容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。（容量大小是指，表示的数的范围的大和小，比如float容量要比long容量大）
各种数据类型容量大小排序：
在这里插入图片描述
注意：

当byte、char、short三种类型的变量互相做运算时（包括同种类型做运算），结果均为int类型！
boolean类型不能与其他类型进行类型转换
当把任何基本数据类型的值和字符串（string）进行连接运算时，基本数据类型的值将自动转化为字符串（string）类型。

2、强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或者溢出，要格外注意。
boolean类型不可以转换为其他的数据类型。

3、编码过程中几种特殊情况

long类型赋值时忘记加L

class VariableTest
{
	public static void main(String[] args) 
	{
		// 这种情况可以成功赋值并输出
		// Java会自动将123123识别为int类型，并将其强制转换为float型
		long l1 = 123123;
		System.out.println(l1);

		// 编译失败的情况
		// 由于34354347859438572974398578已经超出int类型的表示范围，则会报错
		long l2 = 34354347859438572974398578;
		System.out.println(l2);
	}
}

float类型赋值时忘记加F（float类型赋值时必须要加上F）

class VariableTest
{
	public static void main(String[] args) 
	{
		// 编译失败
		// 报错信息：从double类型转化为float类型可能会有损失
		float f1 = 12.3;
		System.out.println(f1);

		//编译成功
		double d1 = 12.3;
		float f2 = (float)d1;
		System.out.println(f2);
	}
}

Java中默认的整数型常量时int类型，小数型常量为double类型，下面的编码则会报错：

class VariableTest4 
{
	public static void main(String[] args) 
	{
		// 编译不通过
		// 报错信息：不兼容的类型，从int类型转化为byte可能会有损失
		byte b = 12;
		byte b1 = b + 1;

		// 编译失败
		// 报错信息：不兼容的类型，从double类型转化为float类型可能会有损失
		float f1 = b + 12.3;
	}
}

2.3.8 字符型String

String类型属于引用数据类型，翻译为：字符串
声明String类型变量时，使用一对双引号
String可以和8种数据类型做运算，且只能是连接运算"+"，连接之后的结果仍然是String类型

例如：

class StringTest 
{
	public static void main(String[] args) 
	{
		String s1 = "Hello World!";
		String s2 = "";
		String s3 = "a";
		
		// 连接运算：“+”
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;
		System.out.println(info); // 输出结果：“学号：1001”
		boolean b1 = true;
		String info1 = info + b1;
		System.out.println(info1); // 输出结果：“学号：1001true”
	}
}

注意：“+”在有String类型的情况下表示连接，在其他类型中表示加法。

2.3.9 练习

class StringTest 
{
	public static void main(String[] args) 
	{
		char c = 'a';
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str); // 107hello
		System.out.println(c + str + num); // ahello10
		System.out.println(c + (num + str)); // a10hello
		System.out.println((c + num) + str); // 107hello
		System.out.println(str + num + c); // hello10a
	}
}

2.4 运算符

运算符是一种符号，表示数据的运算、赋值和比较，Java中的运算符：

算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符（开发中用的很少）
三元运算符

2.4.1 算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取余	7%5	2
++	自增（前）：先自增后运算	a=2; b=++a;	a=3; b=3
++	自增（后）：先运算后自增	a=2; b=a++;	a=3; b=2
–	自减（前）：先自减后运算	a=2; b=–a;	a=1; b=1
–	自减（后）：先运算后自减	a=2; b=a–;	a=1; b=2
+	字符串连接	“he”+“llo”	“hello”

举一些例子以及注意事项：

class AriTest 
{
	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;
		System.out.println(result4); //2.0

		double result5 = num1 / (num2 + 0.0);
		System.out.println(result5); //2.4

		double result6 = (double)num1 / num2;
		System.out.println(result6); //2.4

		// 取余：%
		// 结果的符号和被模数的符号相同
		// 开发中，经常用于判断能否被除尽的情况
		int m1 = 12;
		int n1 = 5;
		System.out.println(m1 % n1); //2

		int m2 = -12;
		int n2 = 5;
		System.out.println(m2 % n2); //-2

		int m3 = 12;
		int n3 = -5;
		System.out.println(m3 % n3); //2

		int m4 = -12;
		int n4 = -5;
		System.out.println(m4 % n4); //-2

		// 前++：先自增1，然后运算
		// 后++：先运算，然后自增1
		int a1 = 10;
		int b1 = ++a1; // a1先+1，再给b1赋值
		System.out.println("a1 = " + a1 + ", b1 = " + b1); // a1=11, b1=11

		int a2 = 10;
		int b2 = a2++; // 先给b2赋值，a2再+1
		System.out.println("a2 = " + a2 + ", b2 = " + b2); // a2=11, b2=10

		// 注意点：自增1，不会改变变量本身的数据类型
		short s1 = 10;
		//s1 = s1 + 1; // 编译失败
		s1 = (short)(s1 + 1); // 编译成功
		s1++; // 编译成功，效率更高

		// 前--：先自减1，然后运算
		// 后--：先运算，然后自减1
		int a4 = 10;
		int b4 = --a4;
		System.out.println("a4 = " + a4 + ", b4 = " + b4);
	}
}

练习：随意给出一个整数，打印显示它的个位数、十位数、百位数的值。

class AriTest1 
{
	public static void main(String[] args) 
	{
		int num = 187;

		int bai = num / 100;
		int shi = num / 10 % 10;
		int ge = num % 10;

		System.out.println("百位为：" + bai);
		System.out.println("十位为：" + shi);
		System.out.println("个位为：" + ge);
	}
}

2.4.2 赋值运算符

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

class SetValueTest 
{
	public static void main(String[] args) 
	{
		// 赋值
		int i1 = 10;
		int j1 = 10;
		
		// 连续赋值
		int i2, j2;
		i2 = j2 = 10;

		int i3 = 10, j3 = 12;
		
		// +=
		int num1 = 10;
		num1 += 2; // num1 = num1 + 2;
		System.out.println(num1);

		// %=
		int num2 = 12;
		num2 %= 5; // num2 = num2 % 5;
		System.out.println(num2);
	}
}

2.4.3 比较运算符

符号：==，!=，<，>，<=，>=，instanceof（检查是否是类的对象）
比较运算符的结果都是boolean型，要么是true，要么是false
比较运算符“==“不能误写为”=“

2.4.4 逻辑运算符

&：逻辑与
|：逻辑或
!：逻辑非
&&：短路与
||：短路或
^：异或（不同则为真，相同则为假）
逻辑运算符用于连接boolean型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6
”&“和”&&“的区别：
- ”&“和”&&“的结果相同
- ”&“：左边无论真假，右边都进行运算
- ”&&“：如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
”|“和”||“的区别：
- ”|“和”||“的结果相同
- ”|“：无论左边真假，右边都进行运算
- ”||“：左边为真，右边不参与运算

举例：”&“和”&&“的区别

class LogicTest
{
	public static void main(String[] args) 
	{
		// 区分 & 和 &&
		boolean b1 = true;
		int num1 = 10;
		if (b1 & (num1++ > 0))
		{	
			System.out.println("我现在在北京！");
		}
		else
		{
			System.out.println("我现在在南京！");
		}
		System.out.println("" + num1); // num1 = 11

		boolean b2 = true;
		int num2 = 10;
		if (b2 && (num2++ > 0))
		{	
			System.out.println("我现在在北京！");
		}
		else
		{
			System.out.println("我现在在南京！");
		}
		System.out.println(num2); // num2 = 11

		boolean b3 = false;
		int num3 = 10;
		if (b3 & (num3++ > 0))
		{	
			System.out.println("我现在在北京！");
		}
		else
		{
			System.out.println("我现在在南京！");
		}
		System.out.println(num3); // num3 = 11

		boolean b4 = false;
		int num4 = 10;
		if (b4 && (num4++ > 0))
		{	
			System.out.println("我现在在北京！");
		}
		else
		{
			System.out.println("我现在在南京！");
		}
		System.out.println(num4); // num4 = 10
	}
}

2.4.5 位运算符

在这里插入图片描述

位运算是直接对整数的二进制进行的运算
在一定范围内，每向左移一位，相当于*2；每像右移一位，相当于/2
右移>>：
- 正数：空出来的高位拿0补
- 负数：空出来的高位拿1补
无符号右移>>>：无论正数负数，空出来的高位都拿0补
取反：各二进制码按补码各位取反

2.4.6 三元运算符

语句格式：(条件表达式)? 表达式1: 表达式2
说明：

条件表达式的结果为boolean类型
根据条件表达式真或假，决定执行表达式1还是表达式2
如果条件表达式为true，则执行表达式1
如果条件表达式为false，则执行表达式2
三元运算符可以嵌套使用
凡是可以使用三元运算符的地方，都可以改成if-else，反之不成立
如果程序既可以使用三元运算符，又可以使用if-else，那么优先选择三元运算符。原因：简洁、效率高

举个栗子：

class SanYuan 
{
	public static void main(String[] args) 
	{
		// 获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m > n)? m: n;
		System.out.println(max);
		
		// 获取三个数的最大值
		int n1 = 89;
		int n2 = 30;
		int n3 = -43;
		int max1 = (n1 > n2)? ((n1 > n3)? n1: n3): ((n2 > n3)? n2: n3); // 三元运算符的嵌套
		System.out.println(max1);
	}
}

2.4.7 运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序，如下表
只有单目运算符、三元运算符、赋值运算符是从右向左运算的

Aiden_Zhao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【学习笔记】Java基本语法（上）：变量与运算符

第2章基本语法（上）：变量与运算符2.1 关键字和保留字2.1.1 关键字的定义和特点2.1.2 保留字2.2 标识符2.3 变量2.3.1 变量的声明和赋值2.3.2 数据类型2.3.3 整数类型 byte / short / int / long2.3.4 浮点类型 float / double2.3.5 字符型2.3.6 布尔型2.4 运算符2.1 关键字和保留字2.1.1 关键字的定义和特点定义：被Java语言赋予了特殊含义，用作专门用途的字符串特点：关键字中所有的字母都为小写Java中
复制链接

扫一扫

专栏目录