java中数据类型与运算符

最新推荐文章于 2022-10-25 08:48:20 发布

封笺.

最新推荐文章于 2022-10-25 08:48:20 发布

阅读量217

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/m0_69298879/article/details/125586501

版权

1.3 增量赋值运算符：+= -= *= /= %=

一、变量和类型

1. 整形变量

基本语法格式：

int 变量名 = 初始值;

代码示例：

int num = 10; // 定义一个整型变量
System.out.println(num);

注意事项：

int 表示变量的类型是一个整型
变量名是变量的标识，后续都是通过这个名字来使用变量
Java 中 = 表示赋值(和数学不一样)，意思是给变量赋一个初始值
初始化操作是可选的，但是建议创建变量的时候都初始化
最后不要忘记分号，否则会编译失败
// 表示注释，注释作为代码的解释说明部分，不参与编译运行
在 Java 中，一个 int 变量占 4 个字节，和操作系统没有直接关系

什么是字节?
字节是计算机中表示空间大小的基本单位
计算机使用二进制表示数据，我们认为 8 个二进制位(bit) 为一个字节(Byte)
我们平时的计算机为 8GB 内存，意思是 8G 个字节
其中 1KB = 1024 Byte，1MB = 1024 KB, 1GB = 1024 MB
所以 8GB 相当于 80 多亿个字节

2. 短整型变量

基本语法格式：

short 变量名 = 初始值;

代码示例：

short value = 0;
System.out.println(value);

注意事项：

short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767
这个表示范围比较小, 一般不推荐使用

3. 长整形变量

基本语法格式：

long 变量名 = 初始值;

代码示例：

long num = 10L; // 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1).
System.out.println(num);

注意事项：

基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long
初始化设定的值为 10L , 表示一个长整型的数字 10l 也可以
使用 10 初始化也可以, 10 的类型是 int, 10L 的类型是 long, 使用 10 L 或者 10 l 更好一些

4. 双精度浮点型变量

基本语法格式：

double 变量名 = 初始值;

代码示例：

double num = 1.0;
System.out.println(num);

Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围
Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差

代码示例：

double num = 1.1;
System.out.println(num * num)
// 执行结果
1.2100000000000002

5. 单精度浮点型变量

基本语法格式：

float 变量名 = 初始值;

代码示例：

float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);

注意事项：

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float

6. 字符型变量

基本语法格式：

char 变量名 = 初始值;

代码示例：

char ch = 'A';

注意事项：

Java 中使用单引号 + 单个字母的形式表示字符字面值
计算机中的字符本质上是一个整数，在 C 语言中使用 ASCII 表示字符，而 Java 中使用 Unicode 表示字符，因此一个字符占用两个字节，表示的字符种类更多，包括中文

7. 字节型变量

基本语法格式：

byte 变量名 = 初始值;

代码示例：

byte value = 0;
System.out.println(value);

注意事项：

字节类型表示的也是整数只占一个字节, 表示范围较小 ( -128 -> +127 )
字节类型和字符类型互不相干

8. 字符串类型变量

基本语法格式：

String 变量名 = "初始值";

代码示例：

String name = "zhangsan";
System.out.println(name);

注意事项：

Java 使用双引号 + 若干字符的方式表示字符串字面值
和上面的类型不同, String 不是基本类型, 而是引用类型(后面重点解释)
字符串中的一些特定的不太方便直接表示的字符需要进行转义

9. 布尔类型变量

基本语法格式：

boolean 变量名 = 初始值;

代码示例：

boolean value = true;
System.out.println(value);

注意事项：

boolean 类型的变量只有两种取值, true 表示真, false 表示假
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法
boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定

二、运算符

1. 算数运算符

1.1 四则运算符：+ - * /

四则运算符与数学上的四则运算基本一致，除数同样不能为0，并且：

int / int 结果还是 int，需要使用 double 来计算

int a = 1;
int b = 2;
System.out.println(a / b);
// 结果为 0

1.2 取模运算符：%

% 其实就是取两个数相除之后的余数，不仅仅可以对 int 求模, 也能对 double 来求模

System.out.println(11.5%2.0);
System.out.println(11%2);

// 执行结果
1.5
1

1.3 增量赋值运算符：+= -= *= /= %=

int a = 10;
a += 1; // 等价于 a = a + 1
System.out.println(a);

// 执行结果
11

1.4 自增/自减运算符：++ --

int a = 10;
int b = ++a;
System.out.println(b);
int c = a++;
System.out.println(c);

// 执行结果
11
11

结论:

如果不取自增运算的表达式的返回值，则前置自增和后置自增没有区别
如果取表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值是自增之前的值
自减与自增的运算是一样的，只不过自增是+1，自减则-1

2. 关系运算符

关系运算符主要有六个：== != < > <= >=

int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);

// 执行结果
true
false
true
false

注意: 关系运算符的表达式返回值都是 boolean 类型

3. 逻辑运算符

逻辑运算符主要有三个：&& || !

3.1 逻辑与：&&

规则：两个操作数都为 true, 结果为 true, 否则结果为 false

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);

// 执行结果
true

3.2 逻辑或：||

规则：两个操作数都为 false, 结果为 false, 否则结果为 true

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c);

// 执行结果
true

3.3 逻辑非：!

规则: 操作数为 true，结果为 false；操作数为 false，结果为 true

int a = 10;
int b = 20;
System.out.println(!(a < b));

// 执行结果
false

3.4 短路求值：

&& 和 || 遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

我们都知道, 计算 10 / 0 会导致程序抛出异常，但是上面的代码却能正常运行，说明 10 / 0 并没有真正被求值
结论:

对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式
对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式

3.5 & 和 |

& 和 | 如果操作数为 boolean 时, 也表示逻辑运算. 但是和 && 以及 || 相比, 它们不支持短路求值

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

4. 位运算符

位运算符主要有四个：& | ~ ^

位操作表示按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算

4.1 按位与 &：

如果两个二进制位都是 1, 则结果为 1, 否则结果为 0

int a = 10;
int b = 20;
System.out.println(a & b); // 结果为 0

// 按位 &
10的二进制： 00000000 00000000 00000000 00001010
20的二进制： 00000000 00000000 00000000 00010100
---------------------------------------------------
按位&的结果: 00000000 00000000 00000000 00000000

4.2 按位或 |：

如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

int a = 10;
int b = 20;
System.out.println(a | b); // 结果为 30

// 按位 |
10的二进制： 00000000 00000000 00000000 00001010
20的二进制： 00000000 00000000 00000000 00010100
---------------------------------------------------
按位|的结果: 00000000 00000000 00000000 00000000

注意：当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算

4.3 按位取反 ~：

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

int a = 0xf;
System.out.printf("%x\n", ~a); // 结果为 fffffff0

// 按位 ~
a的二进制：  00000000 00000000 00000000 00000001
---------------------------------------------------
按位~的结果：00000000 00000000 00000000 11111110

注意:

0x 前缀的数字为十六进制数字，十六进制可以看成是二进制的简化表示方式，一个十六进制数字对应 4 个二进制位（一个32位的二进制数可以用8位十六进制表示）
0xf 表示 10 进制的 15，也就是二进制的 1111
printf 能够格式化输出内容，%x 表示按照十六进制输出.
\n 表示换行符

4.4 按位异或 ^：

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1

int a = 1;
int b = 2;
System.out.printf(a ^ b);// 结果为 3

// 按位 ^
a的二进制：  00000000 00000000 00000000 00000001
b的二进制：  00000000 00000000 00000000 00000010
----------------------------------------------------
按位^的结果：00000000 00000000 00000000 00000011

5. 移位运算符

移位运算符有三个：<< >> >>> 都是按照二进制位来运算

5.1 左移 <<：

最左侧位不要了, 最右侧补 0

int a = 10;
System.out.println(a<<1); // 结果为 20

// 左移1位
a的二进制：00000000 00000000 00000000 00001010
-------------------------------------------------
a左移一位：00000000 00000000 00000000 00010100

5.2 右移 >>：

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 10;
System.out.println(a>>1); // 结果为 5

// 右移1位
a的二进制：00000000 00000000 00000000 00001010
-------------------------------------------------
a右移一位：00000000 00000000 00000000 00000101

5.3 无符号右移 >>>：

最右侧位不要了, 最左侧补 0

int a = -1;
System.out.println(a>>>1); // 结果为 2147483647

// 无符号右移 >>>
a 的二进制原码：10000000 00000000 00000000 00000001
a 的二进制反码：11111111 11111111 11111111 11111110
a 的二进制补码：11111111 11111111 11111111 11111111
----------------------------------------------------------
补码无符号右移：01111111 11111111 11111111 11111111

注意:

左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
计算机计算移位效率比乘除要搞, 当某个代码正好乘除 2 的N次方时可以用移位运算代替
移动负数位或者移位位数过大都没有意义

6. 条件运算符

条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值; 当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

 // 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);

// 执行结果
20

7. 运算符的优先级

先看一段代码

System.out.println(1 + 2 * 3);

结果为 7, 说明先计算了 2*3 , 再计算加法
另外一个例子

System.out.println(10 < 20 && 20 < 30);

此时明显是先计算的 10 < 20 和 20 < 30, 再计算 &&. 否则 20 && 20 这样的操作是语法上有误的(&& 的操作数只能是boolean)

结论：

运算符之间是有优先级的，具体的规则我们不必记忆，在可能存在歧义的代码中加上括号即可

三、注释

Java中的注释主要分为以下三种

单行注释：// 注释内容
多行注释：/* 注释内容*/
文档注释：/** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档

封笺.

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java中数据类型与运算符

注意：当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算。Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差。Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围。...
复制链接

扫一扫