数据类型与运算符
1.变量和类型
变量指的是程序运行时可变的量,相当于开辟一块内存空间来保存一些数据。
类型则是对变量的种类进行了划分,不同的类型的变量具有不同的类型。
1.1整型变量
基本语法格式:
int 变量名 = 初始值;
代码示例:
int num = 10;//定义一个整型变量
System.out.println(num);
注意事项:
- int表示变量的类型是一个整型
- 变量名是变量的标识,后续都是用过定义的变量名来使用这个变量
- Java中 ”=“ 表示赋值,意思是给变量设置一个初始值
- 初始化操作是可选的,但是建议创造变量的时候都显示初始化
- 最后不要忘记分号,否则会编译失败。
- //表示注释,注释作为代码的解释说明部分,不参与编译运行。
在Java中,一个int变量占4个字节,8个bit位,和操作系统没有直接关系(32位,64位)
4个字节表示的数据范围是 -2^31 – 2^31-1 ,
使用以下代码可以查看Java中的整型数据范围:
System.out.println(Integer.MAX_VALUE);// 输出int的最大值
System.out.println(Integer.MIN_VALUE);// 输出int的最小值
如果运算的结果超出了int的最大范围,就会出现溢出的情况
int maxvalue = Integer.MAX_VALUE;
System.out.println(maxvalue+1);//输出结果为 -2147483648
int minvalue = Integer.MIN_VALUE;
System.out.println(minvalue-1);//输出结果为 2147483647
1.2 长整型变量
基本语法格式:
long 变量名 = 初始值;
代码示例:
long num = 10L;//定义一个长整型变量,初始值也可以写作10l(小写的L)
System.out.println(num);
注意事项:
- 基本语法格式和创建int变量基本一致,只是把类型修改成long
- 初始化设定的值为10L(10l),表示一个长整型的数字.
- 使用10初始化也可以,10的类型是int,10L的类型是long
Java中long类型占8个字节,64个bit位,表示的数据范围: -2^63 – 2^63-1
使用以下代码查看Java中的长整型范围:
System.out.println(Long.MAX_VALUE);//输出结果为 9223372036854775807
System.out.println(Long.MIN_VALUE);//输出结果为 -9223372036854775808
1.3 短整型变量
基本语法格式:
short 变量名 = 初始值;
代码示例:
short value = 0;
System.out.println(value);
注意事项:
- short占用2个字节,表示的数据范围是 (-32768 – 32767)
- 这个表示范围比较小,一般不推荐使用
1.4 单精度浮点型变量
基本语法格式
float 变量名 = 初始值;
代码示例:
float num = 1.0f;//写作1.0F也可以
System.out.println(num);
Java中float类型占4个字节,遵守IEEE 754标准,由于表示的数据精度范围较小,一般工程上用到浮点数都优先考虑double,不太推荐使用float
1.5 双精度浮点型变量
基本语法格式:
double 变量名 = 初始值;
代码示例:
double num = 1.0;
System.out.println(num);
在Java中,int除以int的值仍然会是int(直接舍弃小数部分)例如:
int a = 1;
int b = 2;
System.out.println(a / b);
//运行结果:
0
如果想得到正确答案,需要使用double类型计算
double a = 1.0;
double b = 2.0;
System.out.println(a / b);
//运行结果:
0.5
Java中的double类型是8个字节,但是浮点数的内存布局和整数差别很大,不能单纯以2^n的形式表示数据范围,Java的double类型的内存布局遵守IEEE 754标准,尝试使用有限的内存空间表示可能无线的小数,势必会存在一定的精度误差。例如:
double num =1.1;
System.out.println(num * num);
//运行结果:
1.2100000000000002
1.6 字符类型变量
基本语法格式:
char 变量名 = 初始值;
代码示例:
char ch = 'A';
注意事项:
- Java中单引号+单个字母的形式表示字符字面值
- 计算机中的字符本质上是一个正数,在C语言中使用ASCLL表示字符,而在Java中使用Unicode表示字符,因此一个字符占用两个字节,表示的字符种类很多,包括中文。
使用一个字符表示一个汉字:
char ch = '呵呵';
System.out.println(ch);
1.7 字节类型变量
基本语法格式:
byte 变量名 = 初始值;
代码示例:
byte value = 0;
System.out.println(value);
注意事项:
- 字节类型表示的也是正数,只占一个字节,表示范围较小(-128 – 127)
- 字节类型和字符类型互不相干
1.8 布尔类型变量
基本语法格式:
boolean 变量名 = 初始值;
代码示例:
boolean value = true;
System.out.println(value);
注意事项:
- boolean类型的变量只有两种取值,true表示真,false表示假
- Java的Boolean类型和int类型不能相互转化,不存在1表示true,0表示false的用法
- boolean类型有些JVM的实现是占一个字节,有些是占一个比特,没有明确的规定
boolean value = true;
System.out.println(vlaue+1);
//代码编译会出现错误 因为boolean类型只有两种取值
1.9 字符串类型变量(把一些字符放到一起就构成了字符串)
基本语法格式:
String 变量名 = "初始值";
代码示例:
String name = "zhangsan";
System.out.println(name);
注意事项:
- Java中使用双引号+若干字符的方式表示字符串字面值
- 字符串中的一些特定的不太方便直接表示的字符需要进行转义
字符串和其他数据类型用+拼接时,输出结果为一个字符串:
String a = "hello";
String b = "world";
String c = a + b;
System.out.println(c);//结果为:helloworld
System.out.println("hello"+10+20);//结果为hello1020
System.out.println("hello"+(10+20))://结果为hello30
System.out.println(10+""+20+"hello";//结果为1020hello
String str = "resule = ";
int a = 10;
int b = 20;
String result = str + a + b;
System.out.println(result);//结果为result = 1020
//当一个+表达式中存在字符串的时候,执行字符串拼接行为
//因此我们可以使用System.out.println同时打印多个字符串或数字
int a = 10;
int b = 20;
System.out.println("a = " + a + ",b = " + b);//结果为a = a,b = b
转义字符示例:
String s1 = "\"bit\"";
String s2 = "\\bit\\";
String s3 = "\\\\bit\\\\";
System.out.println(s1);//结果为"bit"
System.out.println(s2);//结果为\bit\
System.out.println(s3);//结果为\\bit\\
常见转义字符如下:
转义字符 | 解释 |
---|---|
\n | 换行 |
\t | 水平制表符 |
\’ | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
1.11 变量的命名规则
硬性指标:
- 一个变量只能包含数字、字母、下划线、美元符
- 数字不能开头
- 变量名是大小写敏感的,即num和Num是两个不同的变量
注意:虽然语法上允许使用中文/美元符($),但是强烈建议不要这样做
软性指标
- 变量名要具有描述性,见名只意
- 变量名不宜使用拼音
- 变量名的词性推荐使用名词
- 变量名推荐小驼峰命名法,当一个变量名由多个单词构成的时候,除了第一个首单词字母,其他单词首字母要大写
小驼峰命名示例:
int maxValue = 100;
String studentName = "张三";
1.12 常量
上面讨论的都是各种规则的变量,每种类型的变量也对应着一种类型的常量
常量指的是运行时类型不能发生改变,只能初始化一次
常量主要有以下两种体现形式
1. 字面值常量
10 // int 字面值常量(十进制)
010 // int 字面值常量(八进制)由数字 0 开头,010 也就是十进制的8
0x10 // int 字面值常量(十六进制)由数字 0x 开头,0x10也就是十进制的16
10L // long 字面值常量,也可以写作10l(小写的L)
1.0 // double 字面值常量,也可以写作 1.0d 或者 1.0D
1.5e2 // double 字面值常量,科学计数法表示,相当于1.5*10^2
1.0f // double 字面值常量,也可以写作 1.0F
true // boolean 字面值常量,同样的还有false
'a' // char 字面值常量,单引号中只能有一个字符
"abc" // String 字面值常量,双引号中可以有多个字符
2.final关键字修饰的常量
final int a = 10;
a = 20;//编译出错,无法为最终变量a分配值
1.13 类型转换
Java作为一个强类型编程语言,当不同类型之间的变量相互赋值的时候,会有较严格的校验
1. int和long/double相互赋值
int a = 10;
long b = a; //小类型转换为大类型 可以
System.out.println(b);//结果为10
//long l=12;
//int c=l; //大类型转换为小类型 不行 提示可能会损失精度
int d = 10;
double e = 1.0;
//d=e; 将double转换为int 编译出错,可能会损失精度,
e = d;//编译成功 int类型可以转换为double类型
System.out.println(e);//结果为10
long表示的范围更大,可以将int赋值给long,但是不能将long赋值给int
double表示的范围更大,可以将int赋值给double,但是不能将double赋值给int
结论:不同数字类型的变量之间赋值,表示范围更小的类型能隐式转换成范围较大的类型,反之则不行
2. int和boolean相互赋值
int a = 10;
boolean b = true;
b = a; //编译出错,提示不兼容的类型
a = b; //编译出错,提示不兼容的类型
结论:int和boolean是毫不相干的两种类型,不能相互赋值
3.int字面值常量给byte赋值
byte a = 100; //编译通过
byte b = 256; //编译错误,提示从int转换到byte可能会有损失
注意:byte表示的数据范围是-128 – 127 256超过范围,100在范围之内
结论:使用字面值常量赋值的时候,Java会自动进行一些检查校验,判定赋值是否合理
4.使用强制类型转换
int a = 0;
double b = 10.5;
a = (int)b;//结果为10
int a = 10;
boolean = false;
b = (boolean)a; //编译出错,提示不兼容的类型
结论:使用(类型)的方式可以将double类型强制转换成int 但是:
强制类型转换可能会导致精度丢失,
强制类型转换不是一定能成功,互不相干的类型之间无法强制类型转换
类型转换小结
- 不同数字类型的变量之间赋值,表示范围更小的类型能隐式转换成范围更大的类型
- 如果需要把范围大的类型赋值给范围小的,需要强制类型转换,但是可能精度丢失
- 将一个字面值常量进行赋值的时候,Java会自动针对数字范围进行检查
1.14 数值提升
1. int和long混合运算
int a = 10;
long b = 20;
int c = a + b; //编译出错,提示将long转换成int会丢失精度
long d = a + b; // 编译通过
结论:当int和long混合运算的时候,int会提升成long,得到的结果仍然是long类型,需要使用long类型的变量来接受结果,如果非要用int来接受结果,就需要使用强制类型转换
2. byte和byte,int和long的运算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
int i = 10;
long l = 20;
int j = (i + j);
//编译报错,不兼容的类型,从int转换成byte可能会有损失
结论:byte和byte都是相同类型,但是出现编译错误,原因是,虽然a和b都是byte,但是计算a+b会先将a和b都提升成int类型,再进行计算,得到的结果也是int类型,赋值给c就会出现上述错误
由于计算机的CPU通常是按照4个字节为单位从内存中读写数据,为了硬件上实现方便,诸如byte和short这种低于4个字节的类型,会提升成int,再参与计算。
正确写法:
byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c); //结果为30
int i = 10;
long l = 20;
int j = (int)(i + j ); //结果为30
类型提升小结:
- 不同类型的数据混合运算,范围小的会提升成范围大的
- 对于short,byte,这种比4个字节小的类型,会先提升成4个字节的int类型,再运算
1.15 int和String之间的相互转换
int转成String
int num = 10;
String ret = String.valueOf(num); //将整数num转换为字符串
System.out.println(ret);
String ret1 = num+""; // 相当于num+"" 整体是一个字符串 不建议使用这种方法
System.out.println(ret1);
//输出结果均为10
String转成int
String str = "123";
int ret = Integer.valueOf(str); //将字符串str转换成整数
System.out.println(ret);
//输出结果为123
2. 运算符
2.1 算术运算符
基本四则运算符 + - * / %
规则比较简单,值得注意的是除法:
- int / int 结果还是 int ,需要使用double来计算
int a = 1;
int b = 2;
System.out.println("a / b");
// 结果为0
- 0不能作为除数
int a = 1;
int b = 0;
System.out.println(a / b);
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)
- % 表示取余,不仅仅可以对int求模,也能对double求模
System.out.println(11.5 % 2.0);
//结果为1.5
- 增量赋值运算符 += -= *= /= %=
int a = 10;
a += 1; // 等价于 a = a + 1
System.out.println(a);
//结果为11
- 自增/自减运算符 ++ –
int a = 10;
int b = ++a;//先++,再使用
System.out.println(a);//结果为11
System.out.println(b);//结果为11
int c = 10;
int i = c++;//先使用,再++
System.out.println(c);//结果为11
System.out.println(i);//结果为10
结论:
- 如果不取自增运算的表达式的返回值,则前置自增和后置自增没有区别
- 如果取表达式的返回值,则前置自增的返回值是自增之后的值,后置自增的返回值是自增之前的值
2.2 关系运算符
关系运算符主要有六个: == != < > <= >=
int a = 10;
int b = 20;
System.out.println(a == b); //false
System.out.println(a != b); //true
System.out.println(a < b); //true
System.out.println(a > b); //false
System.out.println(a <= b); //true
System.out.println(a >= b); //false
注意:关系运算符的表达式返回值都是boolean类型
2.3 逻辑运算符
逻辑运算符主要有三个:&& || !
注意:逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是boolean类型
- 逻辑与 &&
规则:两个操作数都是true,结果为true,否则结果为false
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c); //结果为true
- 逻辑或 ||
规则:两个操作数都为false,结果为false,否则结果为true
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c); //结果为true
- 逻辑非 !
规则:操作数为true,结果为false;操作数为false,结果为true。 !是一个单目运算符,只有一个操作数
int a = 10;
int b = 20;
System.out.println(!(a < b)); //结果为false
- 短路求值
&& 和 || 遵守短路求值的规则
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, 无需计算右侧表达式.
2.4 位运算符
Java中对数据的操作的最小单位不是字节,而是二进制位
位运算符主要有四个:& | ~ ^
位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.
按位与 & :如果两个二进制位都是1,则结果为1,否则结果为0
int a = 10; //00001010
int b = 20; //00010100
//00000000
System.out.println(a & b); //结果为0
按位或 |: 如果两个二进制位都是0,则结果为0,否则结果为1
int a = 10; //00001010
int b = 20; //00010100
//00011110
System.out.println(a | b); //结果为30
注意:当&和 | 的操作数为整数(int,short,long,byte)的时候,表示按位运算,当操作数为boolean的时候,表示逻辑运算
按位取反 ~:如果该位为0,则转为1,如果该位为1,则转为0
int a = 0xf;
System.out.printf("%x\n", ~a);
注意:
- 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位.
- 0xf 表示 10 进制的 15, 也就是二进制的 1111
- printf 能够格式化输出内容, %x 表示按照十六进制输出.
- \n 表示换行符
按位异或 ^ :如果两个数字的二进制相同,则结果为0,不同则结果为1
int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);
2.5 移位运算符
移位运算符有三个:<< >> >>> 都是按照二进制来计算
左移 <<:最左位舍弃,最右侧补0
int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20
右移 >>:最右位舍弃,最左侧补符号位(正数补0,负数补1)
int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果8(注意, 是按十六进制打印的)
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果ffff8000(注意, 是按十六进制打印的)
无符号右移 >>>:最右位舍弃,左侧补0
int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果7fffffff(注意, 是按十六进制打印的)
注意:
- 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
- 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
- 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
- 移动负数位或者移位位数过大都没有意义
2.6 条件运算符
表达式1 ? 表达式2 : 表达式3
当表达式1 的值为true时,整个表达式的值为表达式2的值,当表达式1 的值为false时,整个表达式的值为表达式3的值。 是Java中唯一一个三目运算符,是条件判断语句的简化写法
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);//结果为20
2.8 小结
- % 操作再 Java 中也能针对 double 来计算
- 需要区分清楚 前置自增 和 后置自增之间的区别
- 由于 Java 是强类型语言, 因此对于类型检查较严格, 因此像 && 之类的运算操作数必须是 boolean.
- 要区分清楚 & 和 | 什么时候是表示按位运算, 什么时候表示逻辑运算