Java基础系列5-Java的数据类型

今天药忘吃喽~ 2022-08-29 00:00 236阅读 0赞

### 文章目录 ###

*  一.Java的基本数据类型
 *   *  1.1 计算机存储单元
     *  1.2 基本数据类型
     *  1.3 机位数 真值
     *  1.4 原码 反码 补码
     *   *  1.4.1 原码
         *  1.4.2 反码
         *  1.4.3 补码
     *  1.5 溢出问题【数值类型】
     *  1.6 标识符
     *  1.7 类型转换
     *   *  1.7.1 隐式转换
         *  1.7.2 强制转换
         *  1.7.3 特殊转换 【字符 - 数值】
 *  二.关键字
 *  三.常量
 *  四.变量

# 一.Java的基本数据类型 #

## 1.1 计算机存储单元 ##

变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。

1B（字节） = 8bit（位）
    1KB = 1024B
    1MB = 1024KB
    1GB = 1024MB
    1TB = 1024GB

## 1.2 基本数据类型 ##

**数据类型概要图**  
![image.png][]

**基本数据类型(4类8种)**  
![image.png][image.png 1]

注：数值类型取值范围计算方法为 -2(字节数\*8)%2 ~ -2(字节数\*8)%2-1  
举例： byte为1字节 则 -2(1\*8)%2 ~ -2(1\*8)%2-1= -128~127

原理：  
1个字节有8位，而二进制每一位有（0，1）两种取值，按照排列组合原理，8位共有28=256 种可能取值。  
其中由于正负数原因，第一位要用于判断正负号，不用于计算二进制实际值，所以要%2。  
其中0归到正数范围中，所以正数取值范围要去掉0这个数，所以要-1。  
0 转二进制 => 0000 0000  
\-128转二进制 => 1000 0000  
同理 int类型  
最小值：Integer.MIN\_VALUE= -2147483648 （-2的31次方）  
最大值：Integer.MAX\_VALUE= 2147483647 （2的31次方-1）

## 1.3 机位数 真值 ##

1.  机位数  
    1)一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.  
    2)比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。  
    3)那么，这里的 00000011 和 10000011 就是机器数。
2.  真值  
    1)0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1

## 1.4 原码 反码 补码 ##

1.  概念

1.  对于一个数, 计算机要使用一定的编码方式进行存储。 原码，反码，补码是机器存储一个具体数字的编码方式。
2.  补码比源码和反码能多表示一位，是因为原码和反码中，1000 0000 表示-0，没有实际意义，补码中将其利用了起来。

### 1.4.1 原码 ###

1.  作用：用于计算机识别
2.  原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:  
    1)\[+1\]原 = 0000 0001  
    2)\[-1\]原 = 1000 0001
3.  第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:  
    \[1111 1111 , 0111 1111\]  
    即  
    \[-127 , 127\]  
    ![image.png][image.png 2]

### 1.4.2 反码 ###

作用：

1.  正数的反码是其本身
2.  负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.  
    \[+1\] = \[00000001\]原 = \[00000001\]反  
    \[-1\] = \[10000001\]原 = \[11111110\]反  
    可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.

### 1.4.3 补码 ###

1.  正数的补码就是其本身
2.  负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)  
    \[+1\] = \[00000001\]原 = \[00000001\]反 = \[00000001\]补  
    \[-1\] = \[10000001\]原 = \[11111110\]反 = \[11111111\]补
3.  对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

## 1.5 溢出问题【数值类型】 ##

以byte类型为例：

1.  在java中 byte 127 再加1等于-128，已知byte的范围为-128~127
2.  字节长度为8位，最左边的是符号位，而127的二进制为：0111 1111，所以执行++a时，0111 111变为1000 0000。最高位存放符号, 正数为0, 负数为1。
3.  在一些数据库中（没有完全测试），数值类型达到最大后再+1会溢出报错，而一些数据库会像java一样循环变为负数。

代码:

package Java_study;
    
    public class yichu {
    	public static void main(String[] args) {
    		//不可以直接给 byte 类型赋值一个溢出值，会报错
    		// byte b1 = 130
    		// 127 二进制取值为 0111 1111
    		byte b = 127;
    		// 0111 1111 + 0000 00001 = 1000 0000 = -128
    		b++;
    		System.out.println("a: " + b);
    		// 1000 0000 + 0000 0001 = 1000 0001 = -127
    		b += 1;
    		System.out.println("b: " + b);
    		// 1000 0001 + 0000 0001 = 1000 0010 = -126
    		b = (byte)(b+1);
    		System.out.println("c "+ b);
    	}
    
    }

测试记录:

a: -128
    b: -127
    c -126

## 1.6 标识符 ##

1.  作用  
    给包,类,方法,变量等起名字
2.  组成规则  
    1)由字符，下划线\_，美元符$组成  
    这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。  
    2)注意事项  
    不能以数字开头  
    不能是Java中的关键字
3.  命名规则  
    1)包  
    最好是域名倒过来,要求所有的字母小写  
    举例： com.itcast  
    2)类或者接口  
    如果是一个单词首字母大写  
    举例：User  
    如果是多个单词每个单词首字母大写(驼峰标识)  
    举例：UserOrder  
    3)方法或者变量  
    如果是一个单词全部小写  
    如果是多个单词,从第二个单词首字母大写  
    4)常量  
    如果是一个单词,所有字母大写  
    如果是多个单词,所有的单词大写,用下划线区分每个单词

## 1.7 类型转换 ##

1.  由小到大隐式转换，由大到小强制转换
2.  精度由小到大顺序：byte,short,char -> int -> long -> float -> double

### 1.7.1 隐式转换 ###

取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算

代码:

package Java_study;
    
    public class zhuanhuan1 {
    	public static void main(String[] args) {
    		//定义两个int 类型的变量
    		int a = 10;
    		int b = 20;
    		System.out.println(a + b);
    		//我可以把a+b的结果进行输出，说明这个计算的结果是没有问题
    		//那么，我应该也可以把这个结果接收一下
    		int c = a + b;
    		System.out.println(c);
    		System.out.println("---------------");
    		
    		//定义两个变量,一个 int 类型，一个 byte 类型
    		int aa = 10;
    		byte bb = 20;
    		System.out.println(aa + bb);
    		//byte cc = aa + bb;
    		int cc = aa + bb;
    		System.out.println(cc);
    	}
    
    }

测试记录:

30
    30
    ---------------
    30
    30

### 1.7.2 强制转换 ###

代码:

package Java_study;
    /*
     * 强制转换：
     * 		目标类型 变量名= (目标类型)(被转换的数据);
     * 
     * 		虽然可以做强制转换，但是不建议。因为强制转换可能会有数据的丢失。
     */
    
    public class zhuanhuan2 {
    	public static void main(String[] args) {
    		// 定义两个变量,一个int类型，一个byte类型
    		int a = 10;
    		byte b = 20;
    		int c = a + b;
    		System.out.println(c);
    		
    		byte d = 30;
    		byte e = (byte)(a + b);
    		System.out.println(e);
    	}
    }

测试记录:

30
    30

### 1.7.3 特殊转换 【字符 - 数值】 ###

代码:

package Java_study;
    /** 隐式转换
     *    char 隐式转换为 int时，只是将该字符的 Unicode 序号作为int值，然后输出
     * 强制转换：
     *    把 int 数做 char 强制转化时，只是转化成其在 Unicode 上的字符，然后输出
     */
    
    public class zhuanhuan3 {
    	public static void main(String[] args) {
    		//定义四个变量
    		char c = '6';
    		int i = 54;
    		
    		//隐式转换: '6'的Unicode为54,得出 i1 = 54
    		int i1 = c;
    		//强制转换: 54 在Unicode中表示字符'6',得出c1 = '6'
    		char c1 = (char)i;
    		System.out.println("======int与char的转换======");
    		System.out.println("i1:" + i1);
    		System.out.println("c1:" + c1);
    		
    		//byte与char的转换
    		byte b = 44;
    		//强制转换: '54'的unicode序号为54, 得出 b1 = 54
    		byte b1 = (byte)c;
    		//强制转换: 44在unicode中表示字符'',得出c1 = ','
    		c1 = (char)b;
    		System.out.println("======byte与char的转换======");
    		System.out.println("b1:" + b1);
    		System.out.println("c1:" + c1);
    		
    		//short与char的转换
    		short s = 34;
    		//强制转换+隐式转换： '54' 的unicode序号为54，得出 s1 = (byte)54
    		//byte 向 short 为隐式转换 所以 s1 = 54
    		short s1 = (byte)c;
    		//强制转换： '54' 的unicode序号为54，得出 s1 = 54
    		short s2 = (short)c;
    		//强制转换： 44 在Unicode中表示字符'"'，得出c1 = '"'
    		c1 = (char)s;
    		System.out.println("======short与char的转换======");
    		System.out.println("s1:" + s1);
    		System.out.println("s2:" + s2);
    		System.out.println("c1:" + c1);
    		
    		//string与int的转换
            //st = "54" =  String.valueOf(c) 
    		String st = "54";
    		int in = 54;
    		//stringC = Integer.toString(54) = "54";
    		String stringC = Integer.toString(i);
    		//inti = Integer.valueof("54") = 54;
    		int inti = Integer.valueOf(st);
    		System.out.println("=====int与string的转换======");
            System.out.println("inti:" + inti);
            System.out.println("stingC:" + stringC);
    	}
    
    }

测试记录:

======int与char的转换======
    i1:54
    c1:6
    ======byte与char的转换======
    b1:54
    c1:,
    ======short与char的转换======
    s1:54
    s2:54
    c1:"
    =====int与string的转换======
    inti:54
    stingC:54

# 二.关键字 #

关键字是被Java语言赋予特定含义的单词，不能被当成变量来使用。

关键字特点:

1.  组成关键字的字母全部小写
2.  常用的代码编辑器,针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。  
    ![image.png][image.png 3]

![image.png][image.png 4]

# 三.常量 #

常量定义:  
在程序执行的过程中，其值不可以发生改变的量

常量分类:

1.  字符串常量 用双引号括起来的内容(“HelloWorld”)
2.  整数常量 所有整数(12,-23)
3.  小数常量 所有小数(12.34)
4.  字符常量 用单引号括起来的内容(‘a’,’A’,’0’)
5.  布尔常量 较为特有，只有true和false
6.  空常量 null

代码:

package Java_study;
    
    public class changliang {
    	
    	public static void main(String[] args) {
    		//声明局部常量
    		final double x = 3.3;
    		
    		System.out.println(x);
    	}
    	
    }

测试记录:

3.3

# 四.变量 #

变量定义:  
在程序执行的过程中，在某个范围内其值可以发生改变的量.

变量定义格式:

1.  数据类型 变量名 = 初始化值;  
    eg)byte b = 127;
2.  数据类型 变量名1,变量名2,…  
    eg)byte b1,b2,b3;

代码:

package Java_study;
    
    public class bianliang {
    	public static void main(String[] args) {
    		// 定义一个变量
    		int a = 10;
    		System.out.println(a);
    		
    		int b;
    		b = 20;
    		System.out.println(b);
    		
    		{
    			// 代码块
    			int c = 30;
    			System.out.println(c);
    		}
    		
    	}
    
    }

测试记录:

10
    20
    30

[image.png]: /images/20220829/9354e0a0660a4f319902f519fdcee2f9.png
[image.png 1]: /images/20220829/3ad5cf23d3594142b353db5c2622aa84.png
[image.png 2]: /images/20220829/17ef140b568f4e778c076cbdf4c50935.png
[image.png 3]: /images/20220829/149fd243ca5548c999700b63ac7bc938.png
[image.png 4]: /images/20220829/a66c831175cc417aa33a5e3b8540a796.png