Java基础知识:标识符、关键字、数据类型

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 keyword
        final int x = 10;
      
          // Using if and else keywords
          if(x>10){
           System.out.println("Failed");
        }
          else{
           System.out.println("Succesful Demonstration"
                              +" of keywords");
        }
    }
}

输出

Succesful Demonstration of keywords

Java 关键字列表

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 java
        String this = "Hello World!";
        System.out.println(this);
    }
}

输出：

./HelloWorld.java:6: error: not a statement
        String this = "Hello World!";         System.out.println(this);
        ^
./HelloWorld.java:6: error: ';' expected
        String this = "Hello World!";         System.out.println(this);
              ^
2 errors

Java 数据类型

Java 是静态类型的，也是一种强类型语言，因为在 Java 中，每种类型的数据（如整数、字符、十六进制、打包十进制等）都预定义为编程语言的一部分，并且为给定程序定义的所有常量或变量都必须使用其中一种 Java 数据类型进行描述。

Java 中的数据类型具有不同的大小和值，可以存储在根据方便和情况制作的变量中，以涵盖所有测试用例。Java 有两类数据类型被隔离

1. 基本数据类型： 如 boolean、char、int、short、byte、long、float 和 double。大写 B 的 Boolean 是 Java 中基本数据类型 boolean 的包装类。
2. 非基本数据类型或对象数据类型： 如 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 ³²-1]。使用 Integer 类将 int 数据类型用作无符号整数。

5. long 数据类型

long 数据类型是一个 64 位有符号二进制补码整数。当 int 不足以容纳值时使用它，提供更广泛的范围。

语法：

long longVar;

大小 ： 8 字节（64 位）

在 Java SE 8 及更高版本中，您可以使用 long 数据类型来表示无符号的 64 位 long，其最小值为 0，最大值为 2 ⁶⁴-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 values
        int i = 89;

        // 如果内存受限，请使用 byte 和 short
        byte 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. 类

类是用户定义的蓝图或原型，从中创建对象。它表示一种类型的所有对象通用的属性或方法集。通常，类声明可以按顺序包含这些组件：

1. 修饰符：类可以是公共的或具有默认访问权限。
2. 类名： 名称应以首字母开头（按照惯例大写）。
3. 超类（如果有）： 类的父类（超类）的名称（如果有），前面有关键字 extends。一个类只能扩展（子类）一个父类。
4. 接口（如果有）： 由类实现的接口的逗号分隔列表（如果有），前面是关键字 implements。一个类可以实现多个接口。
5. 主体： 类 主体由大括号 { } 括起来。

3. 对象

对象是面向对象编程的基本单位，代表现实生活中的实体。典型的 Java 程序会创建许多对象，您知道，这些对象通过调用方法进行交互。对象由以下部分组成：

1. 状态：它由对象的属性表示。它还反映了对象的属性。
2. 行为：它由对象的方法表示。它还反映了对象对其他对象的响应。
3. 标识：它为对象提供唯一名称，并使一个对象能够与其他对象交互。

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 的强大类型系统在开发过程的早期捕获错误。