引言：

哈喽，各位读者老爷们大家好呀,long time no see!这里是小堇Java小课堂，在本课堂中我们将继续分享Java中的数据类型与变量，标识符，关键字等知识，那我们启程咯！

数据类型与变量

1.字面变量

在上一篇博客当中，System.out.println("hello world");语句不论程序何时运行，输出的都是"hello world",其实"hello world"就是所说的字面变量。

常量即程序运行期间，固定不变的量称为常量。看下列代码示例：

public class Main{public static void main(String[] args){System.out.println("100");System.out.println("10.5");System.out.println("ok");System.out.println("true");}
}

这里我们输出的这些结果都称为字面变量。

字面变量分型：

1.字符串常量：使用" "包含起来的一切内容

2.整形常量：没有小数点的数，包括负数

3.浮点数常量：带有小数点的数

4.布尔常量：true与false

5.字符常量：使用' '包含起来的单个字符

6.空常量：null

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

2.数据类型

在Java中数据类型分为两类：基本数据类型与引用数据类型

基本数据类型有四类八种：

1.四类：整形，浮点型，字符型以及布尔型。

2.八种：

数据类型	关键字	内存占用	范围
字节型	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

 注意：

1.不论是64位系统还是32位系统int都占用4个字节的大小，long都占用8个字节的大小

2.整形和浮点数都是带有符号的

3.整形默认是int型，浮点数默认为double

4.字符串属于引用数据类型，后面会单独出一篇博客讲解

3.变量

3.1变量概念

在程序中除了那些不会改变的量之外，有一些量可能经常会改变，对于这些经常改变的内容，Java中称为变量，而数据类型就是用来定义不同种类的变量的。

3.2语法格式

数据类型 变量名 = 初始值 

eg:

public class Main {public static void main(String[] args) {int n = 10;int m=30.7;double a=10.3;byte b=9;short c=88;boolean d=true;}
}

3.3整形变量

public class Day13 {public static void main(String[] args) {//方式一：在定义时给定初值int a=10;System.out.println(a);//方式二：在定义时没有给初始值，但使用前必须设置初值int b;b=20;System.out.println(b);//int型能表示的最大范围表示：System.out.println(Integer.MIN_VALUE);System.out.println(Integer.MAX_VALUE);//注意：在定义数据时，不要定义一个超过int范围的值int c=100000000000000000000000000;//程序报错long d=10L;//long定义的长整形变量byte e=1;short f=10;}
}

注意事项：

1.int不论在何种系统下都是四字节

2.推荐使用方式一来定义数据

3.在定义设置初值时不要超过了int范围

4.变量在使用前需要赋初值
5.int的包装类型为Integer

6.长整形变量在使用时初值一般在末位加上'L'或'l'

7.long的包装类型是Long

8.short的包装类型是Short

9.byte的包装类型是Byte

 3.4浮点数变量

public class Main {public static void main(String[] args) {int a=1;int b=2;System.out.println(a/b);//0double c=1.0;double d=2.0;System.out.println(c/d);//0.5double num=1.1;System.out.println(num*num);//1.2100000000000002float e=1.0f;float f=2.3F;System.out.println(e+f);//3.3}
}

注意事项：

1.double在任何系统下都占8个字节

2.浮点数与整数在内存中存储方式不同，不能单纯使用2^n来计算

3.double的包装类型为Double

4.double类型的内存分布遵守IEEE754标准，尝试使用有限的空间表示可能无限的小数，势必会存在一些误差，因此浮点数是一个近似值而不是精确值

5.float占用四个字节一般工程上使用到浮点数都优先使用double

6.float的包装类型为Float

 3.5字符型变量

public class Main{public static void main(String[] args) {char c1='a';//小写字母char c2='A';//大写字母char c3='9';//数字char c4='帅';}
}

注意事项：

1.Java中使用单引号加单个字母的形式表示字符字面值

2.计算机中的字符本质上是一个整数，C语言中使用ASCLL表示，在Java中使用Unicode表示字符，因此一个字符占用两个字节，字符类型也包括中文 

3.char的包装类型为Character

在执行javac时可能会出现未结束的字符文字这一错误，我们在javac运行时加上-encoding UTF-8即可，javac-encoding UTF-8 Test.java。 

3.6布尔型变量

布尔类型常量用来表示真假，在Java中有着很广泛的使用，其中true表示真，false表示假，这里需要与传统的C/C++区分开（在C/C++中非0为真，0为假）。

public class Main {public static void main(String[] args) {boolean c=true;System.out.println(c);c=false;System.out.println(c);}
}

注意事项：

1.boolean的取值只有两种，true表示真和false表示假

2.Java中的boolean类型不能与int类型相互转换，不能用数字形式表示真假

3.在Java虚拟机中未明确表示boolean有几个字节，在Oracle公司的虚拟机实现中，boolean占1个字节 

4.boolean的包装类型为Boolean

3.7类型转换

Java作为一个强类型编程语言，当不同类型之间的变量互相赋值的时候，会有较为严格的校验。

public class Main {public static void main(String[] args) {long a=10;int b=20;a=b;//可以通过编译b=a;//编译失败}
}

3.7.1自动类型转换（隐式转换）

自动类型转换：代码不需经过任何处理，在代码编译时，编译器会自动进行处理。

特点：数据范围小的数转化为数据范围大的数会自动进行。 

public class Main {public static void main(String[] args) {long a=10;int b=20;a=b;//可以通过编译，a的范围比b更大，编译时会将b的类型提升为longb=a;//编译失败double f=3.14;float f2=4.5F;f=f2;//可以通过编译，f的范围比f2更大，编译时会将f2的类型提升为doublef2=f;//编译失败byte d=10;int e=20;e=d;//可以通过编译，e的范围比d更大，编译时会将d类型提升为intd=e;//编译失败    }
}

3.7.2强制类型转换（显示转换）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的 

public class Main {public static void main(String[] args) {long a=10;int b=20;a=b;//可以通过编译，a的范围比b更大，编译时会将b的类型提升为longb=(int)a;// 强制转换a为int型double f=3.14;float f2=4.5F;f=f2;//可以通过编译，f的范围比f2更大，编译时会将f2的类型提升为doublef2=(float) f;//强制转换f为float型byte d=10;int e=20;e=d;//可以通过编译，e的范围比d更大，编译时会将d类型提升为intd=(byte) e;//强制转换e为byte型}
}

注意事项：

1.不同数字类型之间赋值，只能将数据范围小的类型隐式转换为数据范围较大的数据

2.如果将数据范围大的数赋值给小的需要强制类型转换，但可能发生极度丢失

3.将一个字面值常量进行赋值的时候，Java会主动针对数字范围进行检查

4.强制类型转换不一定成功，不相干的类型不能相互转换 

3.8类型提升

不同数据类型之间进行相互运算，数据类型小的会被提升到数据类型大的。

1.int与long之间运算，int会被提升为long

public class Main {public static void main(String[] args) {long a = 10;int b = 20;long c = a + b;//编译成功，b自动转换为long类型参与运算int d = a + b;//编译失败    }
}

2.byte与byte之间的运算

public class Main {public static void main(String[] args) {byte a=10;byte b=20;byte c=a+b;//编译失败int d=a+b;//编译成功byte e=(byte)(a+b);//编译成功}
}

 原因：byte和byte虽然是同类型，但他们在进行运算的时候都会被默认提升为int类型，再进行计算，得到的结果也是int型，这时候使用byte来接受就会编译失败。

另外，short，byte在进行运算时都会被提升为int型

4.字符串类型

在Java中使用String类定义字符串类型，比如：

public class Main {public static void main(String[] args) {String s1="hello";String s2="world";System.out.println(s1);System.out.println(s2);System.out.println(s1+s2);}
}

4.1int转成String

public class Main {public static void main(String[] args) {int num=10;//方法一：String s1=num+"";//方法二：String s2=String.valueOf(num);}
}

4.2String转成int

public class Main {public static void main(String[] args) {String s="100";int num=Integer.parseInt(s);}
}

5.标识符·

在Java中，标识符是用来标识变量、方法、类等程序元素的名称。标识符必须遵循以下规则：

1. 只能包含字母、数字、下划线和美元符号：标识符可以由字母（大小写均可）、数字、下划线（_）和美元符号（$）组成。标识符的第一个字符不能是数字。

2. 不能以数字开头：标识符的第一个字符不能是数字。

3. 不能是 Java 的保留关键字：不能使用Java的保留关键字（例如：public、class、static等）作为标识符。

4. 区分大小写：Java是大小写敏感的语言，因此大写字母和小写字母被视为不同的标识符。

5. 没有长度限制：Java标识符的长度理论上没有限制，但通常会有一些约定俗成的规范，比如一些编码规范建议标识符长度不要超过某个特定的字符数。

一些常见的命名约定包括：

• 使用有意义的名称：标识符应该能够清晰地表达其所代表的含义，使得代码易于理解和维护。
• 遵循驼峰命名法：在驼峰命名法中，除了第一个单词外，其余单词的首字母大写，例如：myVariable、calculateTotal。
• 类名通常以大写字母开头，方法和变量名通常以小写字母开头，常量名通常全部大写。

使用良好命名的标识符可以使代码更易读、易懂，并且有助于减少错误和提高代码的可维护性。

6.关键字

在Java中，关键字是预定义的具有特殊含义的单词，它们被用于定义语法结构、控制程序流程以及实现特定功能。关键字在编程中有着特殊的作用，不能被用作标识符（例如变量名、方法名等）。

以下是Java中的一些主要关键字及其作用：

1. abstract: 用于定义抽象类和抽象方法。抽象类是不能被实例化的类，抽象方法是只有方法声明而没有实现的方法，需要在子类中实现。

2. assert: 用于在代码中插入断言，用于测试条件是否为真。在开发和调试阶段用于检查代码中的假设。

3. boolean: 用于定义布尔类型，表示逻辑上的真或假。

4. break: 用于在循环语句（如for、while、do-while）和switch语句中跳出当前循环或者switch语句。

5. byte, short, int, long: 用于定义整数类型的数据。分别表示不同范围的整数。

6. case, default: 用于在switch语句中定义分支条件。

7. catch, finally: 用于异常处理，catch用于捕获异常并处理，finally用于无论是否发生异常都会执行的代码块。

8. char: 用于定义字符类型的数据。

9. class: 用于定义类。

10. const（已废弃）: 用于定义常量。在Java 1.0版本中引入，但从Java 1.1开始被废弃。

11. continue: 用于跳过循环中的剩余代码，并继续下一次循环的执行。

12. default: 用于switch语句中的默认分支。

13. do, while: 用于实现do-while循环。

14. double, float: 用于定义浮点数类型的数据。

15. else, if: 用于在条件语句中定义分支。

16. enum: 用于定义枚举类型。

17. extends, implements: 用于类的继承和接口的实现。

18. final: 用于声明常量、类的最终实现或者方法的最终实现。

19. finally: 用于异常处理中的最终执行代码块。

20. float: 用于定义单精度浮点数类型的数据。

21. for: 用于实现for循环。

22. goto（不建议使用）: 用于跳转到代码中的标签处。在Java中不推荐使用。

23. if: 用于实现条件判断。

24. implements: 用于实现接口。

25. import: 用于导入其他包中的类或者整个包。

26. instanceof: 用于判断一个对象是否是指定类的实例。

27. int: 用于定义整数类型的数据。

28. interface: 用于定义接口。

29. long: 用于定义长整型数据。

30. native（不常用）: 用于标识方法的实现是由本地代码（如C或C++）实现的。

31. new: 用于创建对象或者数组。

32. package: 用于定义包。

33. private, protected, public: 用于定义访问权限。

34. return: 用于从方法中返回值。

35. short: 用于定义短整型数据。

36. static: 用于定义静态成员，静态方法，静态代码块。

37. strictfp: 用于确保浮点运算的结果在不同平台上保持一致。

38. super: 用于引用父类的成员。

39. switch: 用于实现多分支选择结构。

40. synchronized: 用于实现同步代码块或者方法，确保在多线程环境中的线程安全。

41. this: 用于引用当前对象。

42. throw: 用于抛出异常。

43. throws: 用于声明方法可能抛出的异常。

44. transient: 用于修饰不希望被序列化的成员变量。

45. try: 用于定义可能发生异常的代码块。

46. void: 用于定义方法的返回类型，表示该方法不返回任何值。

47. volatile: 用于标识变量可能会被多个线程同时访问，确保线程安全。

48. while: 用于实现while循环。

这些是Java中的一些关键字，它们具有特殊的语法含义，对于构建Java程序来说是必不可少的。