Java入门级每日总结（3）：字节、数据类型与运算符

目录

1.字节

2.数据类型

2.1 八大基本数据类型

2.1.1 数据类型相关信息

2.1.2 不同数据类型的转换

2.1.3 基本类型转为引用数据类型

2.2 引用数据类型

2.3 常见转义字符

2.4 数据类型的默认值

3.运算符

3.1 算数运算符+ - * /  %

3.2 增量赋值运算+=  *=  /=  %=

3.3 自增和自减运算符++  --

3.4 关系运算符==  !=  <  >  <=  >=

3.5 逻辑运算符&&  ||  !

3.6位运算符

3.7 移位运算<<  >>  >>>

3.8 条件运算符

3.9运算符的优先级

---

1.字节

        什么是字节?

        字节是计算机中表示空间大小的基本单位。计算机使用二进制表示数据。我们认为 8 个二进制位(bit) 为一个字节(byte)。

其中：1byte = 8bit ，二进制的每一位就是一个bit位

          1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB。

2.数据类型

        Java和C++都属于强类型的语言，定义一个变量时，必须指定这个变量的类型，这个变量在之后赋值的过程中，只能赋值为相应类型的值。

2.1 八大基本数据类型

2.1.1 数据类型相关信息

类型	符号	长度	范围
字节型	byte	1byte	[-2^7——2^7-1]
短整型	short	2byte	[-2^15——2^15-1]
整型	int	4byte	[-2^31——2^31-1]
长整型	long	8byte	[-2^63——2^63-1]
单精度浮点型	float	4byte	略
双精度浮点型	double	8byte	略
字符型	char	2byte	[-2^15——2^15-1]
布尔型	boolean	无固定长度	无固定

        字节型：-128~-1（共128个数）加上0~127（共128个数）——>取值范围是-2^7~2^7-1

        字符型：采用Unicode编码，16进制，支持所有语言。

        布尔型：只有两个值true、false，不能和其他类型转换。

2.1.2 不同数据类型的转换

a.小类型转大类型

int 和 long 相互赋值

int a = 10;    //10有隐藏的类型int
               //整型字面量默认为int
long b = 20;    
a = b;         //long变量赋值给int，编译出错, 提示可能会损失精度
b = a;         //编译通过

int a = Integer.MAX_VALUE;
long b = a + 1;           //a + 1溢出，变成整型的最小值，接着赋值给b
system.out.println(b);    //输出-2147483648

---

int 和 double 相互赋值

int a = 10;
double b = 1.0;
a = b;    // 大给小，编译出错, 提示可能会损失精度
b = a;    // 编译通过

---

int 和 boolean 相互赋值

int a = 10;
boolean b = true;
b = a;    // 编译出错, 提示不兼容的类型
a = b;    // 编译出错, 提示不兼容的类型

        结论：int 和 boolean 是毫不相干的两种类型, 不能相互赋值。

---

int字面值常量 给 byte 赋值

byte a = 100;    // 编译通过，byte范围[-128——127]
byte b = 256;    // 编译报错，提示 从int转换到byte可能会有损失

int c = 20;
byte d = c;      //编译报错，把int变量赋值给byte时，无论是否超出保存范围，都需要强转

byte a1 = 10;    //10提升为整型保存
byte a2 = 20;    //20提升为整型保存
byte a3 = a1 + a2;    //编译报错，提示 从int转换到byte可能会有损失

        注意：对于数值型和字符型来说，小于4字节的数据类型（byte、char、short），在存储时会转为4字节。byte类型在保存时会转为int类型。

        当把byte类型保存区间之内的整数赋值给byte时，可以直接赋值，超出byte的范围仍然需要强制类型转换。 

---

final byte a = 10;         //final修饰
final byte b = 20;
byte c = a + b;
System.out. println(c);    //编译成功，输出30

        注意：被final修饰的变量除了数据值不能改，类型也不能提升。final byte a = 10;存储时，仍然是byte类型。

---

int 和 char 相互赋值

char a = 'a';
int b = a;    //char -> int自动提升，按照Unicode编码将'a'转为int
char c = 'A';
int d = c;    
system.out.println(b);    //输出97
System.out.println(d);    //输出65

int a = 97;               //强制类型转换
char b = (char) a;
System.out. println(b);   //输出a

        编码是把不同的文字和符号，按照一定的规则转为数字。

---

int 和 String 相互转换

//int -> String

//1.使用String的valueOf方法
int num = 10;                    
string str1 = String.valueof(num);
system.out.println(str1);        //输出10

//2.直接使用String对象+       任意字符串和其他类型“+"，都会把其他类型转为字符串
string str2 = "" + num;
System.out.println(str2);    //输出10

//String -> int

String str = "123";             //数字字符串：都是由数字组成的字符串
int a = Integer.parseInt(str);  //把str这个字符串变量转为int
System.out.print1n(a);          //输出整型123

String str2 ="1a2b3";           //把str2这个字符串变量转为int
int a = Integer.parseInt(str);
System.out.println(a);          //由于此时str2中包含了非数字，调用这个方法时就会报错

---

类型转换小结
        1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型。
        2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失。
        3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查。

2.1.3 基本类型转为引用数据类型

        称为包装类

        int -> Integer

        char -> Character

        其他的包装类都是基本类型首字母大写。

2.2 引用数据类型

        String类：所有内容都是String的对象，使用其他类型和字符串对象 + 都可以将其他类型转为字符串，然后进行字符串拼接操作。

String str = "result = ";
int a = 10;
int b = 20;
String result = str + a + b;
System.out.println(result);

// 执行结果
result = 1020  //此处的1020，仅拼接了10 和 20

2.3 常见转义字符

转义字符	解释
\n	换行
\t	水平制表符
\'	单引号
\"	双引号
\\	反斜杠

2.4 数据类型的默认值

        在Java中，所有数据类型都有默认值。定义之后没有赋值，会有默认值(只存在于类变量中，方法中的局部变量不存在默认值)。

类型	默认值
整型	0
浮点型	0.0
字符型	\u0000  (代表一个空格)
布尔型	false
引用类型	null

3.运算符

3.1 算数运算符+ - * /  %

        a.相同数据类型进行数学运算，得到的值仍然是本类型

        b.小类型和大类型进行数学运算，先把小类型提升为大类型然后进行运算。

        c.除法中，0不能作为除数。

3.2 增量赋值运算+=  *=  /=  %=

a += 1; //等同于
a =a +1; 

3.3 自增和自减运算符++  --

        a++：先取a的值然后进行自增操作。

        ++a：先自增然后再取值。

int a = 1;

System.out.println(a++);  // 1

int b = 1;

System.out.println(++b);  // 2

3.4 关系运算符==  !=  <  >  <=  >=

int a = 5;
int b = 10;
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 类型。

3.5 逻辑运算符&&  ||  !

        逻辑与 &&

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

        逻辑或 ||

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

        逻辑非 !

操作数为 true, 结果为 false; 操作数为 false, 结果为 true(单目运算符, 只有一个操作数)。

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);     //true
System.out.println(a < b || b < c);     //true
System.out.println(!(a < b));           //false

        注意：逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean。

短路求值

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

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

        计算 10 / 0 会导致程序抛出异常。但以上代码却能正常运行, 说明 10 / 0 并没有真正被求值。

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

3.6位运算符

        直接在二进制位上进行操作的运算符。

        按位与：&

如果两个二进制位都为1，返回1，否则返回0。

        按位或：|

两个二进制位有一个1就返回1，都为0才返回0。

        按位取反：~

该位为0，转为1，该位为1，转为0。

        按位异或：^

两个二进制位相同返回0，不同返回1。

3.7 移位运算<<  >>  >>>

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

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

int a = 10;
System.out.print(a << 1);    // 运行结果20

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

int a = 10;
System.out.print(a >> 1);    // 运行结果 5

int d = -10;
System.out.print(d >> 1);    // 运行结果 -5

        无符号右移 >>>：最右侧位不要了, 最左侧补 0。

int a = 10;
System.out.print(a >>> 1);    // 运行结果 5

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

3.8 条件运算符

        Java中条件运算符只有一个:表达式1 ? 表达式2 : 表达式3
        当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值。
        它也是 Java 中唯一的一个 三目运算符,是条件判断语句的简化写法。

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;    //max = b

3.9运算符的优先级

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