Java 标识符
Java 中的标识符是赋予变量、类、方法、包、接口等的名称。这些是唯一的名称，每个 Java 变量都必须使用唯一名称进行标识。
例：
public class Test
{public static void main(String[] args){int a = 20;}
}
在上面的 Java 代码中，我们有 5 个标识符，如下所示：
- 测试：类名
- main：方法名称
- 字符串：预定义的类名
- args：变量名称
- a：变量名称
Java 标识符命名规则
定义有效的 Java 标识符有一定的规则。必须遵守这些规则，否则会出现编译时错误。这些规则也适用于其他语言，如 C 和 C++。
- 标识符仅允许使用字母数字字符（[A-Z]、[a-z]、[0-9]）、“$”（美元符号）和“_”（下划线）。例如，“geek@”不是有效的 Java 标识符，因为它包含特殊字符“@”。
- 标识符不应以数字（[0-9]） 开头。例如，“123eliane” 不是有效的 Java 标识符。
- Java 标识符区分大小写。
- 标识符的长度没有限制，但建议仅使用 4 到 15 个字母的最佳长度。
- Reserved Words 不能用作标识符。例如，“int while = 20;” 是无效语句，因为 while 是保留字。 Java 中有 53 个保留字。
有效标识符示例：
MyVariable
MYVARIABLE
myvariable
x
i
x1
i1
_myvariable
$myvariable
sum_of_array
geeks123
无效标识符示例：
My Variable // 包含空格
123geeks // 以数字开头
a+c // 加号不是字母数字字符
variable-2 // 连字符不是字母数字字符
sum_&_difference // 连字符不是字母数字字符
Java 中的保留字
任何编程语言都会保留一些单词来表示该语言定义的功能。这些字称为 保留字。它们可以简要地分为两部分：关键字（50） 和 文本（3）。关键字定义功能，文本定义值。标识符由符号表在编译器体系结构的各个分析阶段（如词法、语法和语义）中使用。
| abstract | continue | for | protected | transient |
|---|---|---|---|---|
| Assert | Default | Goto | public | Try |
| Boolean | Do | If | Static | throws |
| break | double | implements | strictfp | Package |
| byte | else | import | super | Private |
| case | enum | Interface | Short | switch |
| Catch | Extends | instanceof | return | void |
| Char | Final | Int | synchronized | volatile |
| class | finally | long | throw | Date |
| const | float | Native | This | while |
Java 关键字
在 Java 中，关键字是编程语言中的保留字，用于某些内部流程或表示某些预定义作。因此，不允许将这些单词用作**变量**名称或对象。
例：
// Java 关键字class GFG
{public static void main(String[] args){// Using final and int keywordfinal int x = 10;// Using if and else keywordsif(x>10){System.out.println("Failed");}else{System.out.println("Succesful Demonstration"+" of keywords");}}
}
输出
Succesful Demonstration of keywordsJava 关键字列表
Java 包含关键字或保留字列表，这些关键字或保留字也以不同的颜色突出显示，无论是 IDE 还是编辑器，以区分灵活字和保留字之间的差异。它们列在下表中，并附有与它们相关的主要操作。
| Keyword | 用法 |
|---|---|
| abstract | 用于创建抽象类和抽象方法 |
| assert | 用于测试开发者认为应该在程序中为真的条件的工具 |
| boolean | 只能保存 True 和 False 值的数据类型 |
| break | 用于打破循环的控制语句。 |
| byte | 可以保存 8 位数据值的数据类型 |
| case | 在 switch 语句中用于标记文本块 |
| catch | 捕获 try 语句生成的异常 |
| char | 保存无符号 16 位字符的数据类型 |
| calss | 声明一个新类 |
| continue | 将控制权发送回循环外部 |
| default | 指定 switch 语句中的默认代码块 |
| do | 启动 do-while 循环 |
| double | 保存 64 位浮点数的数据类型 |
| else | 可以保存 64 位浮点数的数据类型 |
| enum | Java 关键字用于声明枚举类型 |
| extends | 指示一个类派生自另一个类或接口 |
| final | 指示变量保持常量值或不会覆盖方法 |
| finally | 指示将始终执行的 try-catch 结构中的代码块 |
| float | 保存 32 位浮点数的数据类型 |
| for | 用于启动 for 循环 |
| if | 测试 true/false 表达式并相应地进行分支 |
| implements | 指定类实现接口 |
| import | 引用其他类 |
| instanceof | 指示对象是特定类的实例还是实现接口 |
| int | 可以保存 32 位有符号整数的数据类型 |
| interface | 声明一个接口 |
| long | 一种包含 64 位整数的数据类型 |
| native | 指定使用本机（特定于平台的）代码实现方法 |
| new | 创建新对象 |
| null | 这表示引用不引用任何内容 |
| package | 声明 Java 包 |
| private | 一个访问说明符，指示只能在声明方法或变量的类中访问 |
| protected | 一个访问说明符，指示一个方法或变量只能在声明它的类（或声明它的类的子类或同一包中的其他类）中访问 |
| public | 用于类、接口、方法和变量的访问说明符，指示项在整个应用程序中可访问（或定义它的类可访问） |
| return | 从调用的方法发送回控制权和可能的返回值 |
| short | 可以保存 16 位整数的数据类型 |
| static | 指示变量或方法是类方法（而不是仅限于一个特定对象） |
| strictfp | Java 关键字用于限制浮点计算的精度和舍入，以确保可移植性。 |
| super | 引用类的基类（在方法或类构造函数中使用） |
| switch | 根据测试值执行代码的语句 |
| synchronized | 指定多线程代码中的关键部分或方法 |
| this | 引用方法或构造函数中的当前对象 |
| throw | 创建异常 |
| throws | 指示方法可能引发的异常 |
| transient | 指定变量不是对象的持久状态的一部分 |
| try | 启动将进行异常测试的代码块 |
| void | 没有返回值 |
| volatile | 这表示变量可能会异步更改 |
| while | 启动 while 循环 |
| sealed | sealed 关键字用于将类声明为 “sealed”，这意味着它限制哪些类可以扩展它。 |
| permits | permits 关键字在 sealed 类声明中使用，以指定允许扩展它的子类。 |
示例：使用关键字作为变量名称。它将给出一个错误，如图所示。
// Java 程序如果使用关键字作为变量名会怎样?class GFG
{public static void main(String[] args){// Note "this" is a reserved// word in javaString this = "Hello World!";System.out.println(this);}
}输出：
./HelloWorld.java:6: error: not a statementString this = "Hello World!"; System.out.println(this);^
./HelloWorld.java:6: error: ';' expectedString this = "Hello World!"; System.out.println(this);^
2 errors
Java 数据类型
Java 是静态类型的，也是一种强类型语言，因为在 Java 中，每种类型的数据（如整数、字符、十六进制、打包十进制等）都预定义为编程语言的一部分，并且为给定程序定义的所有常量或变量都必须使用其中一种 Java 数据类型进行描述。
Java 中的数据类型具有不同的大小和值，可以存储在根据方便和情况制作的变量中，以涵盖所有测试用例。Java 有两类数据类型被隔离
- 基本数据类型： 如 boolean、char、int、short、byte、long、float 和 double。大写 B 的 Boolean 是 Java 中基本数据类型 boolean 的包装类。
- 非基本数据类型或对象数据类型： 如 String、Array 等。
例：
// Java 程序演示 int 数据类型
import java.io.*;class GFG
{public static void main (String[] args) {// 声明两个 int 变量int a = 15;int b = 20;System.out.println( a + b );}
}
输出
35现在，探索不同类型的基本和非基本数据类型。
JAVA 中的数据类型
Java 中的基本数据类型
原始数据只是单个值，没有特殊功能。有 8 种原始数据类型。它们在下面以表格格式描述如下：
| 类型 | 描述 | Default | 大小 | 示例 | 值范围 |
|---|---|---|---|---|---|
| boolean | 对或错 | false | 8 bits | true, false | true, false |
| byte | 二进制补码整数 | 0 | 8 bits | (无) | -128 to 127 |
| char | Unicode 字符 | \u0000 | 16 bits | ‘a’, ‘\u0041’, ‘\101’, ‘\\’, ‘\’, ‘\n’, ‘β’ | 0 to 255 |
| short | 二进制补码整数 | 0 | 16 bits | (无) | -32,768 to 32,767 |
| int | 二进制补码整数 | 0 | 32 bits | -2,-1,0,1,2 | -2147483648 to 2147483647 |
| long | 二进制补码整数 | 0 | 64 bits | -2L,-1L,0L,1L,2L | -9,223,372,036,854,775,808 to 9223372036854775808 |
| float | 浮点数 | 0.0 | 32 bits | 1.23e100f , -1.23e-100f , .3f ,3.14F | 最多7个十进制数字 |
| double | 双精度浮点数 | 0.0 | 64 bits | 1.23456e300d , -123456e-300d , 1e1d | 最多16个十进制数字 |
基本数据类型
1. boolean 数据类型
boolean 数据类型表示可以为真或假的逻辑值。从概念上讲，它表示单个信息位，但虚拟机使用的实际大小取决于实现，通常至少为一个字节（8 位）。boolean 类型的值不会使用强制类型转换隐式或显式转换为任何其他类型。但是，程序员可以根据需要编写转换代码。
语法：
boolean booleanVar;
大小 ：取决于虚拟机（通常为 1 字节，8 位）
2. byte 数据类型
byte 数据类型是 8 位有符号二进制补码整数。byte 数据类型可用于节省大型数组中的内存。
语法：
byte byteVar;
大小 ： 1 字节 （8 位）
3. short 数据类型
short 数据类型是 16 位有符号二进制补码整数。与字节类似，当内存节省很重要时，会使用短整型，尤其是在空间受限的大型数组中。
语法：
short shortVar;
大小 ： 2 字节 （16 位）
4. int 数据类型
一个 32 位有符号二进制补码整数。
语法：
int intVar;
大小 ： 4 字节 （ 32 位 ）
在 Java SE 8 及更高版本中，可以使用 int 数据类型来表示无符号 32 位整数，其值在 [0， 2 32-1]。使用 Integer 类将 int 数据类型用作无符号整数。
5. long 数据类型
long 数据类型是一个 64 位有符号二进制补码整数。当 int 不足以容纳值时使用它，提供更广泛的范围。
语法：
long longVar;
大小 ： 8 字节（64 位）
在 Java SE 8 及更高版本中，您可以使用 long 数据类型来表示无符号的 64 位 long，其最小值为 0，最大值为 2 64-1。Long 类还包含比较 Unsigned、除以 Unsigned 等方法，以支持 unsigned long 的算术运算。
6. float 数据类型
float 数据类型是单精度 32 位浮点数。如果需要在大型浮点数数组中节省内存，请使用 float （而不是 double）。float 数据类型的大小为 4 字节（32 位）。
语法：
float floatVar;
大小 ： 4 字节（32 位）
7. double 数据类型
double 数据类型是双精度 64 位浮点数。对于十进制值，此数据类型通常是默认选择。double 数据类型的大小为 8 个字节或 64 位。
语法：
double doubleVar;
大小 ： 8 字节（64 位）
float 和 double 数据类型都是专为科学计算而设计的，其中近似误差是可以接受的。如果准确性是首要考虑因素，则建议不要使用这些数据类型，而应使用 BigDecimal 类。
8. char 数据类型
char 数据类型是单个 16 位 Unicode 字符，大小为 2 字节（16 位）。
语法：
char charVar;
大小 ： 2 字节 （16 位）
为什么 Java 中 char 的大小是 2 个字节？
与使用 ASCII 字符集的语言（如 C 或 C++）不同 ，Java 使用 Unicode 字符集来支持国际化。Unicode 需要 8 位以上的位来表示来自不同语言的各种字符，包括拉丁语、希腊语、西里尔语、中文、阿拉伯语等。因此，Java 使用 2 个字节来存储一个字符，确保它可以表示任何 Unicode 字符。
例：
// Java 程序演示 Char 基本数据类型class GFG
{public static void main(String args[]){// 创建和初始化自定义字符char a = 'G';// 整数数据类型通常用于数值// used for numeric valuesint i = 89;// 如果内存受限，请使用 byte 和 shortbyte b = 4;// 由于数字大于字节范围，因此这将导致错误// byte b1 = 7888888955;short s = 56;// 由于数字大于字节范围，因此这将导致错误// short s1 = 87878787878;// 默认情况下，Java 中的分数值为双精度double d = 4.355453532;// 对于浮点数，标准后缀为“f”float f = 4.7333434f;// 需要保存大范围的数字，那么我们需要这种数据类型long l = 12121;System.out.println("char: " + a);System.out.println("integer: " + i);System.out.println("byte: " + b);System.out.println("short: " + s);System.out.println("float: " + f);System.out.println("double: " + d);System.out.println("long: " + l);}
}
输出
char: G
integer: 89
byte: 4
short: 56
float: 4.7333436
double: 4.355453532
long: 12121非基本 （引用） 数据类型
非基本（引用）数据类型将包含变量值的内存地址，因为引用类型不会将变量值直接存储在内存中。它们是字符串、对象、数组等。
1. 字符串
字符串 定义为字符数组。Java 中字符数组和字符串之间的区别在于，字符串旨在在单个变量中保存字符序列，而字符数组是单独的 char 类型实体的集合。与 C/C++ 不同，Java 字符串不以 null 字符结尾。
语法： 声明字符串
<String_Type> <string_variable> = “<sequence_of_string>”;
例：
// 不使用 new 运算符声明字符串
String s = "GeeksforGeeks";
// 使用 new 运算符声明字符串
String s1 = new String("GeeksforGeeks");
2. 类
类是用户定义的蓝图或原型，从中创建对象。它表示一种类型的所有对象通用的属性或方法集。通常，类声明可以按顺序包含这些组件：
- 修饰符：类可以是公共的或具有默认访问权限。
- 类名： 名称应以首字母开头（按照惯例大写）。
- 超类（如果有）： 类的父类（超类）的名称（如果有），前面有关键字 extends。一个类只能扩展（子类）一个父类。
- 接口（如果有）： 由类实现的接口的逗号分隔列表（如果有），前面是关键字 implements。一个类可以实现多个接口。
- 主体： 类 主体由大括号 { } 括起来。
3. 对象
对象是面向对象编程的基本单位，代表现实生活中的实体。典型的 Java 程序会创建许多对象，您知道，这些对象通过调用方法进行交互。对象由以下部分组成：
- 状态：它由对象的属性表示。它还反映了对象的属性。
- 行为：它由对象的方法表示。它还反映了对象对其他对象的响应。
- 标识：它为对象提供唯一名称，并使一个对象能够与其他对象交互。
4. 接口
与类一样， 接口 可以具有方法和变量，但在接口中声明的方法默认是抽象的（只有方法签名，没有正文）。
- 接口指定类必须做什么，而不是如何做。它是该类的蓝图。
- 接口与功能有关，例如 Player 可能是一个接口，并且任何实现 Player 的类都必须能够（或必须实现）move()。因此，它指定了类必须实现的一组方法。
- 如果类实现了接口，但没有为接口中指定的所有函数提供方法主体，则必须将该类声明为抽象的。
- Java 库的一个示例是 Comparator 接口。如果某个类实现了此接口，则可以使用它对集合进行排序。
5. 数组
数组是一组类型相同的变量，它们由一个通用名称引用。Java 中的数组的工作方式与 C/C++ 中的不同。以下是有关 Java 数组的一些要点。
- 在 Java 中，所有数组都是动态分配的。
- 由于数组在 Java 中是对象，我们可以使用 member length 来找到它们的长度。这与 C/C++ 不同，在 C/ 中，我们使用 size 来查找 length。
- Java 数组变量也可以像其他变量一样在数据类型后使用 [] 声明。
- 数组中的变量是有序的，每个变量都有一个以 0 开头的索引。
- Java 数组还可以用作静态字段、局部变量或方法参数。
- 数组的大小必须由 int 值指定，而不是 long 或 short。
- 数组类型的直接超类是 Object。
- 每个数组类型都实现接口 Cloneable 和 java.io.Serializable。
要记住的关键点
- 强类型：Java 在编译时强制执行严格的类型检查，从而减少运行时错误。
- 内存效率：根据所需的范围和精度选择正确的数据类型有助于高效的内存管理。
- 字符串的不变性：Java 中的字符串一旦创建就无法更改，从而确保多线程环境中的安全性。
- 数组长度：Java 中数组的长度一旦声明就固定了，可以使用 属性
length
了解 Java 的数据类型是高效编程的基础。每种数据类型都有特定的用例和约束，因此必须为手头的任务选择正确的类型。这确保了最佳的内存使用和程序性能，同时利用 Java 的强大类型系统在开发过程的早期捕获错误。
