java八大基本数据类型与运算符
??变量和类型
变量指的是用于存储可变数据的一个量，程序运行前创建，开辟一块内存空间来保存一些数据.类型则是对变量的种类进行了划分, 不同的类型的变量用于存储不同的数据，具有不同的属性.,这些变量是在计算机的内存储器上创建的，程序的运行也是在内存储器上运行的，而我们平时所产生的音频，图片视频等内容是存储在计算机的外存储器上的，外存储器简单的说就是我们的硬盘，u盘，光盘等器件。现在的计算机都是依据冯诺依曼体系来工作的，下面我们简单的来看一下冯诺依曼体系结构：
基本数据类型介绍：
| 数据类型 | 所占的字节数 | 默认值 | 取值范围 | 封装器类 |
|---|---|---|---|---|
| byte | 1 | 0 | -2^7— 2^7-1 | Byte |
| short | 2 | 0 | -2^15— 2^15-1 | Short |
| int | 4 | 0 | -2^31— 2^31-1 | Integer |
| long | 8 | 0 | -2^63— 2^63-1 | Long |
| float | 4 | 0.0 | 3.4e-45~1.4e38 | Float |
| double | 8 | 0.0 | 4.9e-324~1.8e308 | Double |
| char | 1 | 空 | 0—2^16-1 | Character |
| boolean | JVM标准并未说明大小，没有明确的大小 | false | true 或者false | Boolean |
上面的表格要记住，下面的这张图更要截图保存了（哈哈）
?? 整型变量(重点)
基本语法格式
int 变量名 = 初始值;
代码示例:
int num = 10; // 定义一个整型变量
System.out.println(num) ;
注意事项:
- int 表示变量的类型是一个整型
- 变量名是变量的标识. 后续都是通过这个名字来使用变量
- Java 中 = 表示赋值(和数学不一样), 意思是给变量设置一个初始值.
- 初始化操作是可选的, 但是建议创建变量的时候都显式初始化.局部变量在使用的时候一定要初始化不初始化编译不能通过。
- 在 Java 中, 一个 int 变量占 4 个字节. 和使用的机器位数操没有直接关系，含Int型变量的代码，只要在安装jvm的机器上都能跑起来。，这样java的可移植性就很强。
什么是字节?
字节是计算机中表示空间大小的基本单位.计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).其中 1KB
= 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB. 在 Java 中, 一个 int 变量占 4 个字节，java中没有无符号的整形，都是有符号的（如short,long,byte）。
使用相应类型的包装类可以查看相应的数据的取值范围，包装类其实就是原始数据类型的一个升级版，它们定义的数据类型是一致的， Java 中的整型数据范围可通过如下代码打印:
System.out.println(Integer.MAX_VALUE); // int 的最大值
System.out.println(Integer.MIN_VALUE); // int 的最小值
🎇🔍??给任何的数据类型赋值的时候字面值是一定不能超过这种类型的取值范围，否则会发生溢出产生编译错误，其次任意类型的数据，最大值加一就变成了最小值，最小值加一也就变成了最大值，这是一个规律可以记住，记忆的时候可以参照我上面画的图。
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE;
System.out.println(maxValue);//最大值
int a=Integer.MAX_VALUE+1;;
System.out.println(a);
int b=2147483647+1;
//int c=2147483648;代码编译错误
System.out.println(maxValue);
int minValue = Integer.MIN_VALUE;
System.out.println(minValue-1);
}
运行结果如下：
??长整型变量
基本语法格式:
long 变量名 = 初始值;
代码示例：
long num = 10L; // 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1).
System.out.println(num) ;
注意事项:
- 基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long
- 初始化设定的值为 10L , 表示一个长整型的数字. 10l 也可以.
- 使用 10 初始化也可以, 10 的类型是 int, 10L 的类型是 long, 使用 10 L 或者 10 l 更好一些.
Java 中的长整型数据范围，这个数据范围远超过 int 的表示范围. 足够绝大部分的场景使用.
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE)
// 运行结果
9223372036854775807
-9223372036854775808
??双精度浮点型变量(重点)
基本语法格式
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 的形式表示数据范围.**float精确表示6位小数,doubie精确表示到小数点后11位，**小数只能精确到几位，超过精确的值就是不精确的。
double num = 1.1;
System.out.println(num * num)
// 执行结果
1.2100000000000002
??单精度浮点型变量
基本格式:
float 变量名 = 初始值;
代码示例：
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);
float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float.
💣💥?float类型的数据，后面表示数据类型的的字母不能省略，浮点型数据的默认类型为double，如果省略,在定义的时候出现类型差异就会报错，而整形的默认类型为int，后面的字母可以省略，如下代码；
float num = 1.0; //编译出错，可写成1.0f或者1.0F
System.out.println(num);
long num=4;
??字符类型变量
基本格式：
char 变量名 = 初始值;
代码示例：
char ch = 'A';
char cp="好"
注意事项:
- Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
- 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
- 💣💥?char在java中表示一种无符号类型，也就是说不能存负数，没有什么unsigned类型,都是正数。
??字节类型变量
基本语法格式:
byte 变量名 = 初始值;
代码示例:
byte value = 0;
System.out.println(value);
注意事项:
💣💥?1. 字节类型表示的也是整数. 只占一个字节, 表示的大小和c语言的char类型表示的范围是一样的。
2. 字节类型和字符类型互不相干
??短整型变量
基本语法格式:
short 变量名 = 初始值;
代码示例：
short value = 0;
System.out.println(value);
注意事项:
- short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767（-2^15 —2^15）。
- 这个表示范围比较小, 一般不推荐使用，实际中int的使用大于short的使用。
??布尔类型变量
基本语法格式:
boolean 变量名 = 初始值;
代码示例：
boolean value = true;
System.out.println(value);
注意事项:
> 1. boolean 类型的变量只有两种取值, true 表示真, false 表示假，它也不能和其他的类型进行转换。
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
3. boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定
??字符串类型变量(重点)
把一些字符放到一起就构成了字符串，它属于引用数据类型。
基本语法格式：
String 变量名 = "初始值";
//在这里的变量名，是一个引用变量，存的是这个字符串的地址，该变量指向这个字符串对象
代码示例：
String name = "zhangsan";
System.out.println(name);
注意事项:
- Java 使用 双引号 + 若干字符 的方式表示字符串字面值.
- 和上面的类型不同, String 不是基本类型, 而是引用类型(后面博客重点解释).
- 字符串中的一些特定的不太方便直接表示的字符需要进行转义.
| 转义字符 | 解释 |
|---|---|
| \n | 换行 |
| \t | 水平制表符 |
| \’ | 单引号 |
| \" | 双引号 |
| \\ | 反斜杆 |
常用的转义字符：
转义字符示例：
// 创建一个字符串 My name is "张三"
String name = "My name is \"张三\"";//中间的两个引号被解析为转义字符，最外面的两个引号包含一串字符串
💣💥?字符串的 + 操作, 表示字符串拼接，字符串和任意类型的数据使用加号拼接后其结果也是字符串
String a = "hello";
String b = "world";
String c = a + b;
System.out.println(c);
结果为：
💣💥?还可以用字符串和整数进行拼接:当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为：
String str = "result = ";
int a = 10;
int b = 20;
String result = str + a + b+"hello";
System.out.println(result);
// 结果为result = 1020hello
💣💥?在进行拼接的时候要注意，如果数字前面没有字符，那么数字是会执行加法运算后，再进行拼接的
String str = "result = ";
int a = 10;
int b = 20;
String result = a + b+str + "hello";
System.out.println(result);
String result1="world"+a + b+str + "hello";
System.out.println(result1);
如图：
??变量的作用域和变量的命名规则
也就是该变量能生效的范围, 一般是变量定义所在的代码块 (大括号)，如果在代码块内部定义，在外部访问就会出错。局部变量定义在函数体内，它的作用范围就是这个函数体内部。
class Test {
public static void main(String[] args) {
{
int x = 10;
System.out.println(x); // 编译通过;
}
System.out.println(x); // 编译失败, 找不到变量 x.
}
}
命名规则： 硬性指标:
- 一个变量名只能包含数字, 字母, 下划线,美元符号
- 数字不能开头.
- 变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量. 注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是 强烈 不推荐这样 软性指标:
- 变量命名要具有描述性, 见名知意.
- 变量名不宜使用拼音(但是不绝对).
- 变量名的词性推荐使用名词.
- 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写，大驼峰命名是用来命名类接口的，每个单词的首字母都是大写的： 大小驼峰命名示例:
int zuidazhi//不能这样命名
int maxValue = 100;
String studentName = "张三";
public TestDemo//类命名
??常量
上面讨论的都是各种规则的变量, 每种类型的变量也对应着一种相同类型的常量，如int类型对应的常量就是就是int类型的常量.常量指的是运行时类型不能发生改变。
常量主要有以下两种体现形式:
??字面值常量
- 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 // float 字面值常量, 也可以写作 1.0F
- true // boolen 字面值常量, 同样的还有 false
- ‘a’ // char 字面值常量, 单引号中只能有一个字符
- “abc” // String 字面值常量, 双引号中可以有多个字符
.
??final 关键字修饰的常量
java中用final修饰一个变量，将其转换为常量，常量在程序运行过程中不可以修改，💣💥?一般也用大写字母表示变量名。
final int a = 10;
a = 20; // 编译出错. 提示 无法为最终变量a分配值
final int SIZE ;
SIZE = 99;
System.out.println(SIZE);
??类型转换与数值提升
类型转换
Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.先看以下几个代码场景:
int 和 long/double 相互赋值
int a = 10;
long b = 20;
a = b; // 编译出错, 提示可能会损失精度.之后的代码就不执行了
b = a; // 编译通过.
——————————————————————————————————————————————————————————————
int a = 10;
double b = 1.0;
a = b; // 编译出错, 提示可能会损失精度.
b = a; // 编译通
long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.
double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int
💣💥?结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行.
int 和 boolean 相互赋值
int a = 10;
boolean b = true;
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型
结论: boolean 类型的变量只有两种取值, true 表示真, false 表示假. int 和 boolean 是毫不相干的两种类型, 不能相互赋值
int字面值常量 给 byte 赋值
byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失
注意: byte 表示的数据范围是 -128 —+127, 256 已经超过范围, 而 100 还在范围之内.
结论: 使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理.
int 和 String 之间的相互转换
int 转成 String
int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);//使用valueOf函数转换
String 转成 int
String str = "100";
int num = Integer.parseInt(str);//使用parseInt函数转换
System.out.println(num);//结果为100
使用强制类型转换
int a = 0;
double b = 10.5;
a = (int)b;
int a = 10;
boolean b = false;
b = (boolean)a; // 编译出错, 提示不兼容的类型.
结论:
- 使用 (类型) 的方式可以将 double 类型强制转成 int. 但是
强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略.- 强制类型转换不是一定能成功, 互不相干的类型之间无法强转(如boolean何其他类型之间的转换)
类型转换小结
1.如果两种数据表示的精度不一样时，要向表示精度大的数据类型转换，不能向精度小的方向转换。
3. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
4. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
5. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查.
数值提升
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 来接收结果, 就需要使用强制类型转换，转换为Int类型
byte 和 byte 的运算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
结论: 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);
类型提升小结:
- 不同类型的数据混合运算, 范围小的会提升成范围大的.
- 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算
📖运算符
📖算术运算符
基本四则运算符 + - * / %
int / int 结果还是 int,如需得到小数要使用 double 来计算
int a = 1;
int b = 2;
System.out.println(a / b);
// 结果为 0
% 表示取余, 不仅仅可以对 int 求模, 也能对 double 来求模
System.out.println(11.5 % 2.0);
// 运行结果
//1.5
*🔺?👀增量赋值运算符 += -= = /= %=，复合运算符有个特点就是自动的帮我们进行类型转换。
如+=
int a = 10;
a += 1; // 等价于 a = a + 1
System.out.println(a);//结果11
short c=2;
c+=1;//自动进行类型转换=》c=(short)(c+1);
🔺?👀自增/自减运算符 ++ –
前置++是先加1再使用，后置++是先使用在自增1的（前置后置就是看++放在变量的前后位置）和语言是一样的
//后置
public static void main(String[] args) {
int a = 10;
int b = a++;// b = a a = a+1;
System.out.println(a);//11
System.out.println(b);//10
//前置
/* int a = 10;*/
/* int b = ++a;//a = a+1 b = a;*/
/* System.out.println(a);//11*/
/* System.out.println(b);//11*/
}
🔺?👀但后面有一个特例如，如下代码的结果和c不一样，结果为10，c里面是11（厉害吧，解释这个问题需要看汇编代码，我们这里就不讨论了）
public static void main(String[] args) {
int a = 10;
a = a++;
System.out.println(a);
}
📖关系运算符
关系运算符主要有六个:：== != < > <= >=
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);
System.out.println(a >= b);
🔺?👀注意: 关系运算符的表达式返回值都是 boolean 类型之后我们写一些条件语句时，判断条件都是关系运算后的boolean类型的值，而不是0和非0的区别了。
📖逻辑运算符(重点)
逻辑运算符主要有三个:
&& || !
逻辑与&&
规则: 两个操作数都为 true, 结果为 true, 否则结果为 false
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);
逻辑或 ||
规则: 两个操作数都为 false, 结果为 false, 否则结果为 true
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;
System.out.println(!a < b);
短路求值
- 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式
- 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式.
//我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
📖位运算符
位运算符主要有四个: & | ~ ^
🔺?👀位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(二进制位是01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算，操作的是数据的补码
按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0
int a = 10;
int b = 20;
System.out.println(a & b);//结果为0
进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 1010（正数的原反补相同）,如图：
按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
int a=-1;
int b=2;
System.out.println(a|b);
🔺?👀注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.
按位取反 ~: 操作地是数字的二进制补码，如果该位为 0 则转为 1, 如果该位为 1 则转为 0，操作的也是二进制位。
按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
int a = 1;
int b = 2;
System.out.printf("%d\n", a ^ b);//0011结果为3
📖移位运算(了解)
移位运算符有三个，都是按照二进制位的补码来运算 << >> >>>
左移 <<: 最左侧位不要了, 最右侧补 0.
右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
无符号右移 >>>: 最右侧位不要了, 最左侧补 0.，和右侧一样只是补的都是0
注意:
- 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
- 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
- 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
- 移动负数位或者移位位数过大都没有意义.
📖条件运算符
条件运算符只有一个，也是 Java 中唯一的一个 三目运算符
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
📖小结
- % 操作再 Java 中也能针对 double 来计算.
- 需要区分清楚 前置自增 和 后置自增之间的区别.
- 由于 Java 是强类型语言, 因此对于类型检查较严格, 因此像 && 之类的运算操作数必须是 boolean.
- 要区分清楚 & 和 | 什么时候是表示按位运算, 什么时候表示逻辑运算.
整体来看, Java 的运算符的基本规则和 C 语言基本一致.
感🦀👍🏻🍹持，??你呦