java语言基础 : 变量和数据类型

变量和数据类型

一、变量（重中之重）

1、变量的基本概念

​ • 当需要在程序中记录单个数据内容时，则声明一个变量即可，而声明变量的本质就是在内存中申请一个存储单元，由于该存 储单元中的数据内容可以发生改变，因此得名为"变量"。

​ • 由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在Java语言中使用数据类型加以描述，为了便于下次访 问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。

图解：

2、变量的声明方式

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

​ • 其中=初始值可以省略，但;不可以省略

3、变量的注意事项

​ • Java是强类型语言，变量在使用前必须声明来指明其数据类型。

		 //1、声明一个变量并初始化  数据类型  变量名 = 初始值；
		 int age = 22;
		 //2、打印变量的数值   + 字符串  用于将两边的内容进行拼接、连接起来结果还是字符串
		 System.out.println("age = "+age); //age = 22
		//3、使用变量的注意事项
		//3.1 使用变量之前需要声明
		System.out.println("name = "+ name);  //错误: 找不到符号  编译时错误

​ • 变量在使用之前必须初始化。

 		 //3.2 使用变量之前需要初始化
		 String name ;
		 System.out.println("name = "+ name); //错误: 可能尚未初始化变量name 编译时错误

​ • 变量不能重复声明

 		 //3.3 变量不能重复声明
		 //int age = 18 ;  //错误: 已在方法 main(String[])中定义了变量 age  编译时错误
		 int AGE = 18 ; // 这个可以 Java语言区分大小写不算重复声明
		 int dadasdasdasdasdadadasdsadfdfdgdgdfgdgdfgdf = 10; //java声明变量名长度没有限制但不宜过长 难以阅读
		 String 锺仔 = "帅哥";    // java声明变量名支持中文 但是一般不用 
		 System.out.println("锺仔 = "+ 锺仔); //name = 帅哥

整体代码：

/*
 *  项目名称：变量测试使用
 *  项目功能：实现变量的声明和使用
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现变量的声明和使用
 */ 
 public class VarTest{
	 public static void main(String[] args){
		 
		 //1、声明一个变量并初始化  数据类型  变量名 = 初始值；
		 int age = 22;
		 //2、打印变量的数值   + 字符串  用于将两边的内容进行拼接、连接起来结果还是字符串
		 System.out.println("age = "+age); //age = 22
		 
		 System.out.println("--------------------------------------------------------");
		 //3、使用变量的注意事项
		 //3.1 使用变量之前需要声明
		 //System.out.println("name = "+ name);  //错误: 找不到符号  编译时错误
		  System.out.println("--------------------------------------------------------");
		  
		 //3.2 使用变量之前需要初始化
		 //String name ;
		 //System.out.println("name = "+ name); //错误: 可能尚未初始化变量name 编译时错误
	
		 String name = "锺仔" ;
		 System.out.println("name = "+ name); //name = 锺仔
		 System.out.println("--------------------------------------------------------");
		 
		 //3.3 变量不能重复声明
		 //int age = 18 ;  //错误: 已在方法 main(String[])中定义了变量 age  编译时错误
		 int AGE = 18 ; // 这个可以 Java语言区分大小写不算重复声明
		 int dadasdasdasdasdadadasdsadfdfdgdgdfgdgdfgdf = 10; //java声明变量名长度没有限制但不宜过长 难以阅读
		 String 锺仔 = "帅哥";    // java声明变量名支持中文 但是一般不用 
		 System.out.println("锺仔 = "+ 锺仔); //name = 帅哥
	 }
 }

4、标识符的命名法则（笔试）

​ • 由数字、字母、下划线以及$等组成，其中数字不能开头。

​ • 不能使用Java语言的关键字，所谓关键字就是Java语言用于表示特殊含义的单词。（其实就是Java语言已经征用的单词）

​ • 区分大小写，长度没有限制但不宜过长。

​ • 尽量做到见名知意，支持中文但不推荐使用。

​ • 标识符可以给类/变量/属性/方法/包 起名字。

​ java中的关键字：

5、案例题目

• 提示用户从键盘输入自己的姓名和年龄信息并打印出来。

分析步骤：
① 提示用户从键盘输入自己的姓名和年龄
②将用户输入的内容打印出来

代码实现：

/*
 *  项目名称：变量输入输出测试
 *  项目功能：实现变量的输入输出
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现实现变量的输入输出
 */ 
 
 // 导入java目录中util目录的Scanner类
import java.util.Scanner; 
public class VarIOTest{
	public static void main(String[] args){
		
		//1、声明两个变量用于记录姓名与年龄
		//String name;   //优化：变量随使用随声明
		//int age ;
		
		//2、提示用户从键盘输入姓名和年龄信息并放入变量中	
		System.out.println("请输入您的姓名和年龄信息：");
		//创建一个扫描器来扫描键盘输入的内容  System.in 代表键盘输入
		Scanner sc = new Scanner(System.in);
		//通过扫描器读取一个字符串数据放入变量name中
	    String name = sc.next();   //优化：变量随使用随声明
		//通过扫描器读取一个整数数据放入变量age中
		int age = sc.nextInt(); //优化：变量随使用随声明
		
		//3、打印变量的数值   尽可能减少重复的代码
		//System.out.println("name = " + name);
		//System.out.println("age = " + age);
		System.out.println("name = " + name + ", age = " + age);
	}
}

官方库的使用

​ • JDK中带有大量的API类, 是有Java系统带来的工具库, 这些工具数以万计! 是Java官方程序员的技术积累。(案例中用到的扫描器 （ Scanner）就是其中之一)。

​ • 使用这些类可以大大简化编程, 提高开发效率。

​ • 具体的API类功能, 可以参阅Java的参考手册

二、数据类型（重中之重）

1、数据类型的分类

• 在Java语言中数据类型主要分为两大类：

  ​ • （1）基本数据类型（记住） ： byte、short、int、long、float、double、boolean、char

  ​ • （2）引用数据类型（了解） ：数组、类、接口、枚举、标注

2、常用的进制

• 在日常生活中采用十进制进行数据的描述，逢十进一，十进制权重是：10^0、101、10^2、…

• 在计算机的底层采用0和1组成的二进制序列进行数据的描述，逢二进一，二进制的权重是2^0、21、2^2、…

• 二进制中的最高位（最左边）用于代表符号位，若该位是0则表示非负数，若该位是1则表示负数。

• 八进制和十六进制其实都是二进制的简写

权重概念图解：

3、进制之间的转换

正十进制转换为二进制的方式

​ a.除2取余法，使用十进制整数不断地除以2取出余数，直到商为0时将余数逆序排序。

​ 图解：十进制45转换为二进制 让45不断的除以2取余数 直到商为0 停止 将所有余数倒序就是换为的二进制

​ b.拆分法，将十进制整数拆分为若干个二进制权重的和，有该权重下面写1，否则写0。

​ 图解：十进制45转换为二进制 将45拆分为若干个二进制权重的和 即：45 = 2^5 + 2^3 + 2^2 + 2^0
​ 在相应有的二进制权重位写1 没有的二进制权重位写0

正二进制转换为十进制的方式

​ a.加权法，使用二进制中的每个数字乘以当前位的权重再累加起来。
​ 图解：正二进制转换为十进制就是将权重位为1的位乘于位上的权重然后相加

负十进制转换为二进制的方式

​ a.先将十进制的绝对值转换为二进制，然后进行按位取反再加1。

• 负数的需要补码(负数存放在计算机是以补码形式存放)：按位取反，再加1

原码, 反码, 补码的基础概念

1. 原码

原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:

[+1]原 = 0000 0001

[-1]原 = 1000 0001

第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:

[1111 1111 , 0111 1111]

即

[-127 , 127]

原码是人脑最容易理解和计算的表示方式.

2. 反码

反码的表示方法是:

正数的反码是其本身

负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反

可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.

3. 补码

补码的表示方法是:

正数的补码就是其本身

负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

[+1] = [00000001]原 = [00000001]反 = [00000001]补

[-1] = [10000001]原 = [11111110]反 = [11111111]补

对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

负十进制转换为二进制图解：-45 先将绝对值45转换为二进制：0010 1101
按位取反：1101 0010
加1： 1101 0011

负二进制转换为十进制的方式

​ a.先减1再按位取反，合并为十进制整数后添加负号（是负十进制转换为二进制的逆运算）

​ 图解： 负数二进制：1101 0011
​ 减一：1101 0010
​ 按位取反： 0010 1101
​ 转为十进制： 45
​ 添加负号： -45

4、单个字节表示的整数范围(重中之重)

​ 单个字节表示的正整数：正整数符号位为0
​ 一个字节8位除去符号位不变：表示最小的数二进制为 0000 0000 转为十进制为 0 。
​ 表示最大的数二进制为 0111 1111 转为十进制为 127 。
单个字节表示的正整数范围： 0 ~ 127（0 ~ 2^7-1）

单个字节表示的负整数：负整数符号位为1
一个字节8位除去符号位不变：表示最小的数二进制为 1000 0000 转为十进制： 二进制先减一： 0111 1111
按位取反： 1000 0000
转为十进制： 128
添加负号：-128
一个字节8位除去符号位不变：表示最大的数二进制为 1111 1111 转为十进制： 二进制先减一： 1111 1110
按位取反： 0000 0001
转为十进制： 1
添加负号：-1
单个字节表示的负整数范围： -128 ~ -1（-2^7 ~ -2^0）

总结：单个字节表示的整数范围 为 -128 ~ 127 （-2^7 ~ 2^7-1）

图解：

5、整数类型

• Java语言中描述整数数据的类型有：byte、short、int、long，荐int类型

• 其中byte类型在内存空间中占1个字节，表示范围是：-2^7 ~ 2^7-1.

• 其中short类型在内存空间中占2个字节，表示范围是：-2^15 ~ 2^15-1.

• 其中int类型在内存空间中占4个字节，表示范围是：-2^31 ~ 2^31-1.

• 其中long类型在内存空间中占8个字节，表示范围是：-2^63 ~ 2^63-1.

• 在Java程序中直接写出的整数数据叫做直接量/字面值/常量，默认为int类型。若希望表达更大的直接量，则在直接量的后面加上l或者L，推荐L。

其中各个类型的表示范围可以类比单个字节表示的整数范围进行推理。

例如：int 占四个字节：

​ 四个字节表示的正整数：正整数符号位为0
​ 四个字节32位除去符号位不变：表示最小的数二进制为 0000 … 0000 (32个) 转为十进制为 0 。
​ 表示最大的数二进制为 0111 …1111 (31个1) 转为十进制为 2,147,483,647 即 2^31-1。
四个字节表示的正整数范围： 0 ~ 2,147,483,647（0 ~ 2^31-1）

四个字节表示的负整数：负整数符号位为1
四个字节32位除去符号位不变：表示最小的数二进制为 1000 … 0000 (31个0) 转为十进制：二进制先减一： 0111 … 1111(31个1)
按位取反： 1000 …0000 (31个0)
转为十进制： 2,147,483,6478
添加负号：-2,147,483,6478
四个字节32位除去符号位不变：表示最大的数二进制为 1111 … 1111 (32个1)转为十进制： 二进制先减一： 1111…1110(31个1)
按位取反： 0000 …0001(31个0)
转为十进制： 1
添加负号：-1
四个字节表示的负整数范围： -2,147,483,6478~ -1（-2^31 ~ -2^0）

总结：四个字节表示的整数范围 为 -2,147,483,6478~ 2,147,483,6477（-2^31 ~ 2^31-1）

注意：在代码中250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型

常见错误：

错误: 不兼容的类型: 从int转换到byte可能会有损失

byte b1 = 250;     // 错误: 不兼容的类型: 从int转换到byte可能会有损失  250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型 

int i2 = 25;
byte b2 = i2;  // 错误: 不兼容的类型: 从int转换到byte可能会有损失

错误：不兼容的类型：从int转换到short可能会有损失

short s1 = 250250;  // 错误：不兼容的类型：从int转换到short可能会有损失

错误: 过大的整数: 250250250250

int i2 = 250250250250; // 错误: 过大的整数: 250250250250 编译时错误 默认为int类型 这个数据自身已经出错

错误: 不兼容的类型: 从long转换到int可能会有损失

int i3 = 250250250250L;  //错误: 不兼容的类型: 从long转换到int可能会有损失 编译时错误

整体代码：

/*
 *  项目名称：java整数类型测试
 *  项目功能：实现整数类型的使用
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现整数类型的使用
 */   
 public class IntTest{
	 public static void main(String[] args){
		 
		 //1、声明一个byte类型的变量并初始化
		 byte b1 = 25;
		 //byte b2 = 250;  //错误: 不兼容的类型: 从int转换到byte可能会有损失 编译时错误
		 //2、打印变量的数值
		 System.out.println("b1 =  " + b1) ; //b1 = 25
		 
		 System.out.println("------------------------------------");
		 //3、声明一个short类型的变量并初始化
		 short s1 = 250;
		 //short s2 = 250250; //错误: 不兼容的类型: 从int转换到short可能会有损失 编译时错误
	     System.out.println("s1 =  " + s1) ; //s1 = 250
		 
		 System.out.println("------------------------------------");
		 //4、声明一个int类型的变量并初始化
		 int i1 = 250250;
		 //int i2 = 250250250250; // 错误: 过大的整数: 250250250250 编译时错误 默认为int类型 这个数据自身已经出错
		 //int i3 = 250250250250L;  //错误: 不兼容的类型: 从long转换到int可能会有损失 编译时错误 
		System.out.println("i1 = " + i1); // i1 = 250250
		
		System.out.println("---------------------------------------------");
		// 5.声明一个long类型的变量并初始化，若描述比long类型还大的数据则使用java.math.BigInteger类型
		long g1 = 2502505006L;
		System.out.println("g1 = " + g1); // g1 = 2502505006
		
		System.out.println("---------------------------------------------");
		// 6.请问下面的代码是否有错误？若有请指出并说明原因
		//int i2 = 25;
		//byte b2 = i2;  // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//System.out.println("b2 = " + b2);
	}
 }

6、浮点类型

• Java语言中用于描述小数数据的类型：float 和 double，推荐double类型

• 其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位有效数字，范围：-3.403E38~3.403E38。

• 其中double类型在内存空间占8个字节，叫做双精度浮点数，可以表示15位有效数字，范围：-1.798E308~1.798E308。

• Java程序中直接写出的小数数据叫做直接量，默认为double类型，若希望表达float类型的直接量，则需要在直接量的后面加上f或者F.

注意：在代码中3.1415926这样直接写出的小数数据叫做直接量/常量/字面值 默认为double类型

float类型一般是7位有效数字 double类型 一般是15位有效数字

常见错误：

错误: 不兼容的类型: 从double转换到float可能会有损失

float f1 = 3.1415926 ;

笔试考点：

System.out.println(0.1 + 0.2);  // 0.30000000000000004  运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型 

整体代码：

/*
 *  项目名称：java浮点类型测试
 *  项目功能：实现浮点类型的使用
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现浮点类型的使用
 */
public class DoubleTest{
	public static void main(String[] args){
		
		//1、声明一个float类型的变量并初始化
		//float f1 = 3.1415926 ;  //错误: 不兼容的类型: 从double转换到float可能会有损失  小数数据叫做直接量，默认为double类型
		float f1 = 3.1415926f;
		// 2.打印变量的数值
		System.out.println("f1 = " + f1); // f1 = 3.1415925     一般是7位有效数字
		
			
		System.out.println("---------------------------------------------------------");
		// 3.声明一个double类型的变量并初始化
		double d1 = 3.1415926;
		System.out.println("d1 = " + d1); // d1 = 3.1415926     一般是15位有效数字
		
		System.out.println("---------------------------------------------------------");
		// 4.笔试考点
		System.out.println(0.1 + 0.2);  // 0.30000000000000004  运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型 
	}
} 

7、布尔类型

• Java语言中用于描述真假信息类型有：boolean，数值只有：true 和 false。

• 布尔类型在内存空间中所占大小没有明确的规定，可以认为是1个字节。

整体代码：

/*
 *  项目名称：java布尔类型测试
 *  项目功能：实现布尔类型的使用
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现布尔类型的使用
 */
 public class BooleanTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个boolean类型的变量并初始化
		boolean b1 = true;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = true
		
		System.out.println("-------------------------------------------");
		// 3.修改变量b1的数值   = 赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量中原来的数值
		b1 = false;
		System.out.println("b1 = " + b1); // b1 = false
		
		System.out.println("-------------------------------------------");
		//b1 = 1; // 错误: 不兼容的类型: int无法转换为boolean
	}
}

8、字符类型

• Java语言中用于描述单个字符的数据类型：char类型。如：‘a’、'中’等。

• 其中char类型在内存空间中占2个字节并且没有符号位，表示的范围是0 ~ 65535，由于现实生活中很少有数据能够被单个字符描述，因此以后的开发中更多的使用由多个字符串起来组成的字符串，使用String类型加以描述，如：“hello”、“World”等。

• 计算机的底层只识别0和1组成的二进制序列，对于字符’a’这样的图案来说不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就可以给该数据指定一个编号，然后将编号存储起来即可，该编号就叫做ASCII。

• 要求掌握的ASCII有：'0' - 48 'A' - 65 'a' - 97 空格 - 32 换行符 - 10

ASCIl码表：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YlKhI3XK-1609210297344)(http://shaozhong.xyz/upload/2020/10/03ASCII%E7%A0%81%E8%A1%A8-198514582c424f6d83ad35b18d96323b.png)]

由于ASCIl码表只能表示128个字符，不能够将各个国家的字符包含在内，所以出现了Unicode码表。
Unicode码表前128个字符与ASCIl码表一致，可以说Unicode码表是ASCIl码表的升级和拓展。

• Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。

• 要求掌握的转义字符有：转义前 转义后
\" ===> "
\ ’ ===> ’
\\ ===> \
\t ===> 制表符
\n ===> 换行符

9、基本数据类型之间的转换

• Java语言中基本数据类型之间的转换方式：自动类型转换和强制类型转换。

• 其中自动类型转换主要指从小类型到大类型之间的转换

自动转换：

小类型到大类型 转化 ， 大类型自动接收小类型 无需干涉

强制转换：

大类型到小类型 转化 ， 因为可能会丢失精度所以 小类型不能自动接收大类型 需要人为干涉

• 其中强制类型转换主要指从大类型到小类型之间的转换，语法格式如下：目标类型 变量名 = (目标类型)源类型变量名;

• 强转有风险，操作需谨慎！

需要注意点：将大类型到小类型 转化 数值可能会发生改变 正整数 可能会变成 负整数。

例如： short s1 = 128 ; byte b1 = (byte) s1 ; 输出b1 发现结果为 -128
原因：s1 的二进制为： 128:0000 0000 1000 0000 强转为byte 字节数变少，高权重二进制位被舍弃
强转后二进制： 1000 0000 原先这个1不是最高位，现在变成了最高位，而最高位又符号位，所以这个二进制 就变成了负二进制 ，负二进制转成十进制 减一 按位取反 添加负号 所以变成了-128

整体代码：

/*
 *  项目名称：java基本数据类型之间转换的使用测试
 *  项目功能：基本数据类型之间转换的使用
 *  作    者：锺仔
 *  版    本: V1.0
 *  所 有 者：锺仔
 *  备    注：编程实现基本数据类型之间转换的使用
 */
 public class TransformTest{
	 public static void main(String[] args){
		 
		 //1、声明两个变量并初始化
		 byte b1 = 10;
		 short s1 = 20;
		 //2、打印变量的数值
		 	System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 20
		
		System.out.println("----------------------------------------------");
		// 3.实现自动类型转换的使用
		// 表示将变量b1的数值赋值给变量s1，并覆盖变量s1中原来的数值，相当于从byte类型到short类型的转换，小到大  自动转换
		s1 = b1;
		System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 10
		
		System.out.println("----------------------------------------------");
		// 4.实现强制类型转换的使用
		// 表示将变量s1的数值赋值给变量b1，并覆盖变量b1中原来的数值，相当于从short类型到byte类型的转换，大到小  强制转换
		//b1 = s1;   // 错误: 不兼容的类型: 从short转换到byte可能会有损失
		s1 = 128;    // 故意加该行代码      128:0000 0000 1000 0000  => 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
		b1 = (byte)s1;
		System.out.println("b1 = " + b1); // b1 = 10   -128 
		System.out.println("s1 = " + s1); // s1 = 10   128
	 }
 }

10、总结：