JAVA——数据类型与运算符

数据类型

注意事项：1.初始化操作是可选的, 但是建议创建变量的时候都显式初始化.

                  2.最后不要忘记分号, 否则会编译失败.

                  3.初始化设定的值为 10L , 表示一个长整型的数字. 10l 也可以.

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

                  5.Java 中使用 单引号 + 单个字母 的形式表示字符字面值.

                  6.计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.

                  7.字节类型和字符类型互不相干.

                  8.short表示范围比较小, 一般不推荐使用.

                  9.boolean 类型的变量只有两种取值, true 表示真, false 表示假.
                  10.Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.

                  11.Java 使用 双引号 + 若干字符 的方式表示字符串字面值.

                  12.String 不是基本类型, 而是引用类型.

什么是字节

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

各种数据类型所占的字节大小

1.整型：byte        1个字节              8个bit位；

              short       2个字节             16个bit位；

              int           4个字节              32个bit位；

              long         8个字节             64个bit位。

2.浮点型：float       4个字节            32个bit位；

                 double    8个字节           64个bit位。

3.字符型：char       2个字节            16个bit位。

4.布尔型：boolean     并未指明多少字节。

常用的转义字符

转义字符
\n	换行
\t	水平制表符
\'	单引号
\"	双引号
\?	问号
\ddd（三位八进制）	1到3位八进制数所代表的任意字符
\xhh（十六进制）	十六进制所代表的任意字符

字符串的  +   操作

+在字符串中表示拼接

示例1：

String str = "Love = ";
int a = 1314;
int b = 520;
String result = str + a + b;
System.out.println(result);

运行结果：Love=1314520

示例2：

int a = 11;
int b = 18;
System.out.println("a = " + a + ",b = " + b)

运行结果：a=11,b=18

结论：当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为.

变量的命名规则

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. num 和 Num 是两个不同的变量.
4.语法上允许使用中文/美元符($)命名变量, 但是强烈不推荐这样做.
5. 变量名推荐使用英语名词.
6.变量命名推荐小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单     词首字母都大写

小驼峰命名法示例

int maxValue=100；

String birthdayWish="暴富"；

常量

常量指的是运行时类型不能发生改变

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.0e5	double 字面值常量. 科学计数法表示. 相当于 1.0 * 10^5
1.2f	float 字面值常量, 也可以写作 1.2F
true	boolen 字面值常量, 同样的还有 false
'A'	char 字面值常量, 单引号中只能有一个字符
"abc"	String 字面值常量, 双引号中可以有多个字符.

2.final修饰的常量

final int value=10;

value=20;
编译出错. 提示 无法为最终变量value分配值

类型转换

1.隐式类型转换

int a=10;
long b=123;
long c=a+b;\\编译通过
int d=a+b;\\编译报错，提示可能会损失精度

结论：表示范围小的类型能隐式转换为表示范围大的类型，反之则不能。

2.强制类型转换

int a=123;
double b=13.14;
int c=a+b;\\编译错误，提示可能会损失精度
int d=a+(int)b;\\编译通过

注意：使用强制类型转换会使范围大的精度丢失，如b=13.14会变成13，d的值为136.

特例：

int a=12;
boolean b=true;
int c=(boolean)a;\\编译错误，提示不兼容的类型

结论：强制类型转换不是一定能成功, 互不相干的类型之间无法强转。

数值提升

int a=100;
long b=1232;
int c=a+b;\\编译错误，提示可能会丢失精度
long d=a+b;\\编译通过

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

特例：

byte a=10;
byte b=20;
byte c=a+b;\\编译错误，提示不兼容的类型: 从int转换到byte可能会有损失

为什么都是相同类型还会报错呢？

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

解决方法

byte a=10;
byte b=20;
byte c=(byte)(a+b);

只需要对结果进行强制类型转换就行。

int 和String之间的相互转换

1.int转String

int num = 10;
String str1 = num + "";\\方法一
String str2 = String.valueOf(num);\\方法二

2.String转int

String str = "100";
int num = Integer.parseInt(str);

---

运算符

1.算术运算符

基本四则运算符有：+   -    *   /    %

注意：1.int/int 结果还是int

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

           2.分子或分母只要有一方为double，结果就为double

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

            3.分母不能为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)

            4.%不仅能对int取余还能对double取余

int a=20;
int b=3;
double c=3.0;
double d=2.0;
System.out.println(a%b);//结果为2
System.out.println(a%c);//结果为2.0
System.out.println(c%d);//结果为1.0

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

int a=10；
a+=1;//等价于a=a+1
a-=1;//等价于a=a-1
a*=1;//等价于a=a*1
a/=1;//等价于a=a/1
a%=1;//等价于a=a%1

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

int a1=10;
int a2=10;
int a3=10;
int a4=10;
int b=a1++;//后置++，a1先将结果赋给b，然后再加1   a1=11，b=10
int c=++a2;//前置++，a2先加1，再将结果赋给c       a2=11,c=11
int d=a3--;//后置--，a3先将结果赋给d，然后再减1   a3=9,d=10
int e=--a4;//前置--，a4先减1，再将结果赋给e       a4=9,e=9

注意：在有些编译器下不取自增运算的表达式的返回值, 前置自增和后置自增没有区别（作者这里            使用的是IDEA）

2.关系运算符

      6种关系运算符==     ！=       <      >       <=        >= 

int a=10;
int b=20;
boolean ret1=(a==b);//ret1为false
boolean ret2=(a!=b);//ret2为true
boolean ret3=(a>b);//ret3为false
boolean ret4=(a<b);//ret4为true
boolean ret5=(a>=b);//ret5为false
boolean ret6=(a<=b);//ret6为false

注意：关系运算符的表达式返回值都是boolean类型（true和false）

3.逻辑运算符

逻辑与（&&）

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);//结果为true
System.out.println(b < a && b < c);//结果为false
System.out.println(a < b && c < b);//结果为false
System.out.println(b < a && c < d);//结果为false

结论：逻辑与（&&），只要有一个表达式为假，那么结果一定为假，即一假则假。

逻辑或（||）

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c);//结果为true
System.out.println(b < a || b < c);//结果为true
System.out.println(a < b || c < b);//结果为true
System.out.println(b < a || c < d);//结果为false

结论：逻辑或（||），只要有一个表达式为真，那么结果一定为真，即一真则真。

逻辑非（  ！）

int a = 10;
int b = 20;
System.out.println(!a < b);//因为a<b结果为true，！true则为false
System.out.println(!a > b);//因为a>b结果为false，！false则为true

结论：逻辑非（ ！），表达式为真则结果为假，表达式为假则结果为真

注意：1.逻辑运算符的返回值都是boolean类型

           2.逻辑与（&&）和逻辑或（||）都是双目操作符，只有逻辑非（ ！）是单目操作符

短路求值

假&&真&&假&&假&&真&&真            //结果为假

真||假||真||假||假||真||假||假               //结果为真

结论：1.当一连串表达式中只有逻辑与（&&）时，只要发现一个表达式为假，后面结果都不用                    算，结果肯定为假。

           2.当一连串表达式中只有逻辑或（||）时，只要发现一个表达式为真，后面结果都不用                      算，结果肯定为真。

4.位运算符

位运算符有   &，|，~，^ 4种

按位与（&）

int a=8;
int b=24;
System.out.println(a&b);//结果为8

结果是怎么计算的呢？

答案是：先将8和24的二进制位对其，然后相同位置都为1才为1，其余位置为0

按位或（|）

int a=8;
int b=24;
System.out.println(a|b);//结果为24

结果是怎么计算的呢？

答案是：先将8和24的二进制位对其，然后相同位置都为0才为0，其余位置为1

按位取反（~）

int a=8;
System.out.println(~a);

按位取反是将数字的二进制位的0变为1,1变为0

按位异或（^）

int a=8;
int b=24;
System.out.println(a^b);//结果为16

结果是怎么计算的呢？

答案是：先将8和24的二进制位对其，然后相同位置的数相同为0，相异为1

5.移位运算符

移位运算符有<<      >>       >>>   三种

左移 <<: 最左侧位不要了, 最右侧补 0

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

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

6.条件运算符

条件操作符只有一个，为？

基本格式为：表达式1？表达式2：表达式3

当表达式1为真时，执行表达式2；当表达式1为假时，执行表达式3.

int a=3;
int b=5;
int min=(b>a)?a:b;//找最小值

7.运算符的优先级

优先级从上往下依次递减

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