Java（二）数据类型与变量以及运算符

二、数据类型与变量（重要）

2.数据类型

在实际运用会有，不同的应用就诞生了不同的数据需求，从而衍生出了一些基本的数据类型。

2.1 基本数据类型

1byte=8bit（内存最小单位）（也叫二进制位）

通常计算机表示数据用二进制表示

数据类型	关键字	内存占用	范围（可以用的范围）
字节型	byte	1 字节	-128 ~ 127
短整型	short	2 字节	-32768 ~ 32767
整型	int	4 字节	-2^31 ~ 2^31-1
长整型	long	8 字节	-2^63 ~ 2^63-1
单精度浮点数	float	4 字节	有范围，一般不关注
双精度浮点数	double	8 字节	有范围，一般不关注
字符型	char	2 字节	0 ~ 65535
布尔型	boolean	没有明确规定	true 和 false

可以看见数据类型共分有8种基本类型。而八种基本类型中又分4种大类型

四类：整型、浮点型、字符型，布尔型

特点：注意

1. 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
2. 整形和浮点型都是带有符号的
3. 整型默认为int型，浮点型默认为double

1.变量与常量

在实际应用中，有始终不变的常量，如太阳的升起的位置，而有些内容可能会经常改变，比如人的身高，它会随着人的生长而发生变化。

1.1常量（字面常量）

常量	例子
字符串常量	由 " " 括起来的，比如“12345”、“hello”、“你好”。
整形常量	程序中直接写的数字，比如：1235456,1000 (注意没有小数点)
浮点数常量	程序中直接写的小数，比如：3.14
字符常量	由 单引号 括起来的当个字符，比如：‘a、‘2’（ASCII码上都是）
布尔常量	只有两种true和false
空常量	null（简单而言没有任何数据的量，甚至连0都不是）

注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型

1.2变量

故名思意，就是会变得量，如何定义一个变量？

数据类型 变量名 = 初始值;

一个变量在内存中如何存储？我们用int类型来举例：一个变量在内存中存储，会转换为二进制。

数据在内存上的存储

不同种类的数据类型进行交叉保存会怎么样？比如：int类型的变量去保存short类型，而short类型去保存int类型。

由上面视频和基本类型的存储空间大小就可以知道，int的存储大小为4个字节，short的存储大小为2个字节。所以可以得出结论，存储的数据一定不能超出类型的存储大小。

再看看这个例子。

我们打印一下看看

哎？数据变了，是不是很有意思。按道理来说，b的值是999999赋值给t了，t应该是999999才对啊。就算只有t只有两个字节，那么他的大小也该是32767，不应该是16959才对啊。

咱们再看一个视频

强制类型装换的危害

在括号里加上类型，叫做强制数据类型转换，而这种情况就有可能会向视屏中的样子一样丢失数据。从而使运算结果发生变化。

数据类型小总结

1. 由基本类型存储空间就可以了解到，他们的存储大小不同。存储的数据量也有所不同
2. 强制类型装换：小—>大（可以），大—>小（可能可以，危险度高）
3. 引用数据类型（后面讲）可以提一下：String就是引用数据类型
4. String（俗称字符串类型）不是基本数据类型
   

三、运算符

计算机诞生之初就是为了计算，复杂而庞大的数据。比如严格意义上第一个电子计算设备是图灵为了在二战中抵御德军侵略，创造出的计算德军情报密钥的机器。这台设备在二战中发挥了不可替代的作用。而如何计算，就要用到逻辑的运算符

1.运算符号（重要）

对操作数进行操作时的符号，不同运算符操作的含义不同

1.1计算运算符

我们先定义两个元素（我们这里先不考虑类型）：a=5 ，b =2

计算机运算符	数学计算逻辑	机器计算逻辑	结论
+	a + b = 7	a+b=7	取整
-	b - a = - 2	b - a = - 2	取整
*	a * b =10	a * b =10	取整
/	a / b = 2.5	a / b = 2	取整
%	没有这个计算逻辑	a % b = 5	取余数化整
演化一下%	a % b = 2…1	a % b = 1	取余

特点：

1. 除法在计算机中分为两种：
   一种叫做取整“ / ”，会将小数点前面的留下并丢弃小数点后面的。
   一种叫做取余（也有叫法一个数磨一个数）“ % ”，除去整数后,会保留余下来的数。
2. 如果要保留小数，只需要在定义变量时加上浮点类型就行。
3. 在计算时符合数学逻辑，所以被除数不能为0，
   10 % 0（x）
   10 / 0 (x)

1.2增量运算符

+=	- =	*=	%=	/=

 int a=1;

        a+=1; //相当于a=a+1;
        System.out.println(a);//结果等于2
        //*****************************
        a-=1;//相当于a=a-1;
        //*****************************
        a*=3;//a=a*3
        //*****************************
        a%=10;//a=a%10
        //*****************************
        a/=3;// a=a/3;

注意：

1. ‘ = ’ ：等号的意思是，将右边的值赋予左边。
2. 程序是由上倒下运行的，所以如果我这个代码在编译器执行，会直接扰乱我们想要的结果。这里只是方面你们观察。

1.3 自增或自检运算符

（++，–）

++	- -

        int b=0;
        //这个叫后置++，他会先使用原来的值，然后再进行+1
        b++;//此时值为：1
        //这个叫前置++，他会先进行+1计算，然后在使用原来的值
        ++b;//此时值为：2
        //************************************************
        System.out.println(b++);//会输出：2
        System.out.println(b);//会输出：3

同样的减减也是

       int b=0;
        //这个叫后置--，他会先使用原来的值，然后再进行-1
        b--;//此时值为：-1
        //这个叫前置++，他会先进行-1计算，然后在使用原来的值
        --b;//此时值为：-2
        //************************************************
        System.out.println(b--);//会输出：-2
        System.out.println(--b);//会输出：-4

1.4关系运算符

运算符	计算结果
==	true 或者 false
!=	true 或者 false
>	true 或者 false
<	true 或者 false
<=	true 或者 false
>=	true 或者 false

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
//a是不是不等于b，是，逻辑上返回true
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

注意：

计算机中是无法识别 0<a<50,必需要分开写，并且加上逻辑运算符符号

2.逻辑符号（重要）

符号	运算结果（boolean类型）	理解
&&	true 或者 false	并且
！	true 或者 false	否

这里csd中||有特殊含有，打不出，就用图片代替了

2.1&&的语法结构：表达式 1 && 表达式 2

两真为真，一假全假

表达式1	表达式2	结果
真（true）	真（true）	真（true）
真（true）	假（false）	假（false）
假（false）	真（true）	假（false）
假（false）	假（false）	假（false）

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

2.2 || 的语法结构：表达式 1 || 表达式 2

全假为假，一真为真

表达式1	表达式2	结果
真（true）	真（true）	真（true）
真（true）	假（false）	真（true）
假（false）	真（true）	真（true）
假 （false）	假 （false）	假（false）

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

2.3 ！ 的语法结构：** ！表达式 **

真变假，假变真

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

注意

1. 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
2. 对于 || , 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.

3.位运算符(重要但是看实际需要)

3.1按位与 &

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

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

3.2按位或 |

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

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

3.3按位取反 ~

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

int a = 0xf;//16进制
System.out.printf("%x\n", ~a)//printf 能够格式化输出内容, %x 表示按照十六进制输出

3.4按位异或 ^

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

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);//0

4.移位运算符

符号	实现逻辑
<<	最左侧位不要了, 最右侧补 0
>>	最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
>>>	最右侧位不要了, 最左侧补 0

一个二进制位的数的最左边一个位置是不用来计数的，通常叫做符号位，代表一个数的正负情况。
0：代表这个数为正
1：代表这个数为负

4.1 左移<<
这些图片的格子本该有32位，但是怕读者大人看不清，就用一个INT的位数来举例
向左移位时，丢弃的是符号位，因此正数左移可能会变成负数

int a = 0x10;
System.out.printf("%x\n", a << 1);

4.2 右移>>

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

int a = 0x10;
System.out.printf("%x\n", a >> 1);

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

int a = 0x10;
System.out.printf("%x\n", a >>> 1)

注意

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

5.条件运算符（三目运算符）

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

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

运算符小总结

1. 在运算中为了不必要的歧异，我建议在复杂运算时最好加上（），以到达你想要的算数优先级