【JavaSE】Java中的数据类型与运算符

前言

大家好！Java是一种优秀的程序设计语言，Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。由于它拥有非常丰富的数据类型和运算符，使得它具有令人赏心悦目的语法和易于理解的语义。所以本篇将给大家介绍一下强类型语言Java的基本数据类型和运算符。

1.变量、常量和基本类型

1.1 变量

变量指的是程序运行时可变的量. 相当于开辟一块内存空间来保存一些数据 。

int i = 19;
char c = 'a';
double d = 1.0;
//其中的i、c、d即为变量

1.1.1 变量的作用域

变量的作用域指的是该变量能生效的范围, 一般是变量定义所在的代码块 (大括号)

public class TestDemo
{
    public static void main(String[] args) {
        {
            int a = 19;
            System.out.println(a);//编译通过
        }
        System.out.println(a);//编译不通过
    }
}

1.1.2 变量的命名规则

硬性指标:

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. 变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量.
   注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是 强烈 不推荐这样做.

软性指标:

1. 变量命名要具有描述性, 见名知意.
2. 变量名不宜使用拼音(但是不绝对).
3. 变量名的词性推荐使用名词.
4. 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.

int maxNum = 19;//小驼峰
TestDemo//大驼峰，一般用于类的命名

1.2 常量

常量指的是运行时类型不能发生改变，主要有两种形式：

1.2 .1 字面值常量

数值	字面值常量
19	int（十进制）
019	int（八进制）由数字0开头
0x19	int（十六进制）由数字0x开头
19L	long
1.0	double
2.5e5	double，相当于2.5 * 10^5
1.0f	float
true	boolean，还有一个false
‘a’	char
“abcde”	String（字符串常量）

1.2.2 final修饰的常量

final int a = 19;
a = 20;//编译报错，无法为最终变量a赋值

Java中被final修饰的变量只能初始化一次，被赋值后不能再改变。

1.3 字符类型变量

Java中char类型占2个字节，即16个bit位。

基本格式：char 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        char ch = 'a';
        char ret = 'A';
        System.out.println(ch);
        System.out.println(ret);
    }
}

注意事项：

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

1.4 整型类型变量

类型	所占字节	包装类	取值范围
byte	1	Byte	-27 ~ 27-1
short	2	Short	-215 ~ 215-1
int	4	Integer	-231 ~ 231-1
long	8	Long	-263 ~ 263-1

1.4.1 字节型

Java中的字节型byte占1个字节，即8个bit位，byte类型只能存放-128~127的数据，超过这个范围编译会报错。

基本格式：byte 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        byte b = 19;
        System.out.println(b);
        System.out.println(Byte.MAX_VALUE);//最大值
        System.out.println(Byte.MIN_VALUE);//最小值
    }

运行结果：

19
127
-128

Process finished with exit code 0

注意事项：在Java中字节类型byte只占1个字节，而字符类型char占2个字节，这两个类型是互不相干的

1.4.2 短整型

Java中的短整型占2个字节，即16个bit位，取值范围为：-32768~32767。

基本格式：short 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        short s = 19;
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }
}

运行结果：

32767
-32768

Process finished with exit code 0

注意事项：因为short表示的范围比较小，一般不推荐使用，大多数情况下用int类型。

1.4.3 整型

Java中的整型int占4个字节，即32个bit位，取值范围为：-2147483648~2147483647。其实不管在多少位的操作系统下，int类型都是占4个字节，其它类型也是固定的，表明Java是一门强类型语言，它的移植性比较好。

基本格式：int 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        int a = 19;
        System.out.println(a);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

运行结果：

2147483647
-2147483648

Process finished with exit code 0

注意事项：如果运算中超过了范围，编译会报错，为了防止溢出，可以使用更大范围的long类型

1.4.4 长整型

Java中长整型long占8个字节，即64个bit位，取值范围为：-9223372036854775808~9223372036854775807。

基本格式：long 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        long a = 19L;
        System.out.println(a);
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }

运行结果：

19
-9223372036854775808
9223372036854775807

Process finished with exit code 0

注意事项：long类型定义的初始值后面加L（小写l也可以，但不推荐，容易看成数字1）

1.5 布尔类型变量

Java中的布尔类型boolean的初始值只有两种，用true表示真，false表示假。

基本格式：boolean 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a);
        System.out.println(b);
    }
}

运行结果：

true
false

Process finished with exit code 0

注意事项：

1. Java 的 boolean 类型和其他类型之间不能相互转换 ，也不存在C语言中的0表示假，非0表示真
2. boolean类型有些JVM占1个字节，有些占1个bit位，Java中没有明确规定
3. 顺序结构和循环结构中的判断条件必须是布尔表达式

1.6 浮点型类型变量

类型	所占字节	包装类
float	4	Float
double	8	Double

1.6.1 单精度浮点型

Java中的单精度浮点型float占4个字节，即32个bit位。

基本格式：float 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        float f = 1.0f;
        System.out.println(f);
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
    }
}

运行结果：

3.4028235E38
1.4E-45

Process finished with exit code 0

注意事项：float类型后面一定要加f，大写F也行，因为初始值为小数的时候，编译器默认它为double类型的，如果不加f，会报错double转换到float可能会有损失。

1.6.2 双精度浮点型

Java中的双精度浮点型double占8个字节，即64个bit位。

基本格式：double 变量名 = 初始值;
public class TestDemo {
    public static void main(String[] args) {
        double d = 1.0;
        System.out.println(d);
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);
    }
}

运行结果：

1.7976931348623157E308
4.9E-324

Process finished with exit code 0

注意事项：初始值不加后缀会默认为double类型

1.7 类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验。让我们看几个例子：

int和long的相互赋值

int x = 10;
long y = 19L;
y = x;//编译通过
x = y;//编译报错，提示不兼容的类型: 从long转换到int可能会有损失

int和byte的相互赋值

byte a = 1;
int i = 100;
a = i;//编译报错，提示不兼容的类型: 从int转换到byte可能会有损失
byte b = 128;//因为byte只能存-128~127的数字，所以会编译报错，提示不兼容的类型: 从int转换到byte可能会有损失

结论：

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行 。
2. 使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理，不合理会直接报错 。

int和boolean的相互赋值

int a = 19;
boolean b = true;
a = b;//编译错误，boolean无法转换为int
b = a;//编译错误，int无法转换为boolean

因为布尔类型是逻辑值，只有true真，false假，而其它类型是数值，和布尔类型是完全不相干的类型，所以布尔类型不能与其它类型相互赋值，用强制类型转换也无法相互赋值。

强制类型转换

如果就是想要把表示范围较大的类型转换成范围较小的类型，其实也是可以的，就是用强制类型转换。

基本格式：(要转换的类型)

int a = 10;
long b = 20L;
a = (int)b;//编译通过


int a = 10;
double b = 20.5;
a = (int)b;
System.out.println(a);//输出结果为20

以上我们可知double强制类型转换为int时，20.5变成了20，后面的小数点没有了，因为int整型，不带小数。

结论：

1. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是有风险，精度可能会丢失
2. 强制类型转换不是一定能成功, 互不相干的类型之间无法强转，布尔类型与其它类型之间

1.8 数值提升

因为计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算。

int和long的混合运算

int a = 10;
long b = 20L;
int c = a + b;//编译报错，从long转换到int可能会有损失
long d = a + b;//编译通过

结论：当 int 和 long 混合运算的时候, int会提升成long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换 。

byte和byte的运算

byte a = 1;
byte b = 2;
byte c = a + b;//编译报错，从int转换到byte可能会有损失

虽然a和b都是byte类型，但是运算a + b会把a和b都提升成int，再进行运算，运算的结果也是int，赋值给byte类型的c会报错。所以只能把a + b强制类型转换成byte再赋值给c。

总结：

1. 不同类型的数据混合运算, 范围小的会提升成范围大的
2. 不同类型的数据混合运算, 范围小的会提升成范围大的

2.运算符

2.1 算数运算符

算数运算符：+ - * / %，规则比较简单，但有几个需要注意的点。

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);

运行结果：

30
-10
200
0
10

Process finished with exit code 0

注意事项：

1. int / int 结果还是 int, 需要使用 double 来计算

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

2. 0 不能作为除数

int a = 1;
int b = 0;
System.out.println(b/a);//编译通过
System.out.println(a/b);//编译报错

3. % 表示取余, 不仅仅可以对 int 求模, 也能对 double 来求模

double a = 3.0;
double b = 2.0;
System.out.println(a % b);//结果为1.0

2.2 关系运算符

关系运算符主要有六个：等于== 不等于!= 大于> 小于< 大于等于>= 小于等于<=

int a = 1;
int b = 2;
System.out.println(a == b); //false
System.out.println(a != b); //true
System.out.println(a > b);  //false
System.out.println(a < b);  //true
System.out.println(a >= b); //false
System.out.println(a <= b); //true

注意：==是判断是否相等，=是赋值，而且关系运算符的表达式返回值都是 boolean 类型

2.3 逻辑运算符

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

int a = 1;
int b = 2;
System.out.println(a < b && a != b);//true
System.out.println(a < b || a == b);//true
System.out.println(!(a > b));		//true

规则：

• 逻辑与&&，两个操作数都为 true, 结果为 true, 否则结果为 false
• 逻辑或||，两个操作数都为 false, 结果为 false, 否则结果为 true
• 逻辑非!，操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数)

短路求值

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

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

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

1. 逻辑与 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式
2. 逻辑或||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式

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

2.4 位运算符

位操作符主要在四个：按位与& 按位或| 按位取反~ 按位异或^

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

按位与&：如果两个数字对应的二进制位都是1，结果为1，否则结果为0

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

首先按位运算，把5和10转化成二进制，分别是0110和1010，按照按位与规则，结果是0。

按位或|：如果两个数字对应的二进制位都是0，结果为0，否则结果为1。

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

首先按位运算，把5和10转化成二进制，分别是0110和1010，按照按位与规则，结果是14。

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

按位取反~：将补码中的二进制数按位取反，1变成0，0变成1，包括符号位。

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

-1的原码为10000001，符号位不变，其它位按位取反得到反码11111110，反码加一得到补码11111111，再按位取反得到00000000，结果为0。

按位异或^：两个数字对应的二进制位相同则为1，相异则为0。

int a = 5;
int b = 10;
System.out.println(a ^ b);//结果为15

5的二进制位为0101,10的二进制位为1010，按位异或后得到1111，结果为15。

2.5 移位运算符

移位运算符有三个：左移操作符<< 右移操作符>> 无符号右移操作符>>> ，它们都是按照二进制中的补码来运算的。

左移<<：左边的二进制数字去掉，右边补0。

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

5的二进制位0101，右移1位变成1010，结果为10。

右移>>：右边的二进制数字去掉，左边补符号位（正数补0，负数补1）

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

5的二进制位 0101，右移1位得到0010，结果为2。

无符号右移>>>：右边的二进制数字去掉，右边补0

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

1的二进制位00000001，正数原反补码相同，无符号右移1位变成00000000，结果为0。

总结：

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

2.6 条件运算符

条件运算符只有一个：表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值。

int a = 1;
int b = 2;
int max = 1 > 2 ? 1 : 2;
System.out.println(max);//结果为2

2.7 运算符的优先级

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

3.注释

Java中的注释主要分为三种：

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

//行注释

/*
块注释
 */

/**
 * 文档注释
 */

注释规范：

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论
3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论
4. 积极向上: 注释中不要包含负能量(例如 领导 SB 等).