JAVA基础知识

1、标识符
1.标识符含义

标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，
标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。
标识符通常由字母和数字以及其它字符构成。

2.Java标识符定义

1、Java 中包名、类名、方法名、参数名、变量名等其他用户定义项所定义的名称，这些符号被称为标识符。
2、标识符可以有一个或多个字符。
3、标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于
0xC0 的所有符号组合构成。
4、各符号之间没有空格。
5、标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
（既标识符不能以数字开头，不能是java中的关键字,而且不能赋予标识符任何标准的方法名。）
6、Java 区分大小写，因此 myvar 和 MyVar 是两个不同的标识符。

3.标识符分为两类

分别为关键字和用户自定义标识符。
关键字是有特殊含义的标识符，如 true、false 表示逻辑的真假。
用户自定义标识符是由用户按标识符构成规则生成的非保留字的标识符，如 abc 就是一个标识符。
提示：使用标识符时一定要注意，或者使用关键字，或者使用自定义的非关键字标识符。此外，标识符可以包
含关键字，但不能与关键字重名。

例如以下合法与不合法标识符。
合法标识符：date、_date、D_date、Username、user_name 等。
不合法的标识符：123.com、2com、for、if 、else、class、Hell Data、Source等。

标识符用来命名常量、变量、类和类的对象等。因此，一个良好的编程习惯要求命名标识符时，应赋予它一
个有意义或有用途的名字。
2、关键字

1、常用关键字
1. public：
  表明类、方法或变量是公开的，可以从任何地方访问。
2. private：
  表明类、方法或变量只能在定义它的类中访问。
3. protected：
  表明类、方法或变量可以在同一包或子类中访问。
4. static：
  表明方法或变量属于类而不是对象，可以直接通过类名访问。
5. final：
  表明类不能被继承，方法不能被重写，变量值不能改变。
6. void：
  表明方法不返回任何值。
7. return：
  用于从方法返回一个值。
8. if, else, switch：
  控制流语句，用于条件判断和分支执行。
9. for, while：
  循环控制结构，重复执行一段代码直到满足终止条件。
10. try, catch, finally：
  异常处理结构，用于捕获和处理程序运行时发生的错误。
11. new：
  用于创建对象的实例。
12. instanceof：
  用于检查对象是否属于特定的类或接口。
13. this：
  指向当前对象的引用。
14. super：
  指向父类的引用，用于调用父类的构造器或方法。
15. abstract：
  表明类或方法是抽象的，不能被实例化，必须被子类实现或重写。
16. interface：
  定义一组方法的签名，没有实现细节。
17. implements：
  用于类声明中，表明类实现了特定的接口。
18. package：
  用于组织类和接口的命名空间。
19. import：
  用于导入其他包中的类或接口，以便在当前文件中使用。
20. break, continue：
  控制循环的流程，break用于提前跳出循环，continue用于跳过当前迭代。
2、按字母顺序排列
1. abstract
  用于声明抽象类和抽象方法。类声明或方法声明
2. assert
  用于断言条件在调试期间必须为真。方法体
3. boolean
  基本数据类型，表示true或false。变量声明
4. break
  终止循环或switch语句。循环体或switch语句
5. byte
  基本数据类型，8位有符号整数。变量声明
6. case switch
  语句的一部分，用于匹配表达式的值。 switch语句
7. catch
  捕获并处理异常。 try-catch-finally语句
8. char
  基本数据类型，16位Unicode字符。变量声明
9. class
  定义一个类。类声明
10. const
  保留关键字，未在语言中使用。 -
11. continue
  跳过当前循环迭代，继续下一次迭代。循环体
12. default
  在switch语句中用于指定默认要执行的代码块。 switch语句
13. do
  开始一个do-while循环。 do-while语句
14. double
  基本数据类型，双精度浮点数。变量声明
15. else if
  语句的可选部分，当if条件不满足时执行。 if-else语句
16. enum
  定义枚举类型。枚举类型声明
17. extends
  表示类继承或接口实现。类声明或接口实现
18. final
  修饰类、方法或变量，防止被修改或覆盖。类、方法、变量声明
19. finally
  异常处理中，无论是否抛出异常都会执行的代码块。 try-catch-finally语句
20. float
  基本数据类型，单精度浮点数。变量声明
21. for
  开始一个for循环。 for语句
22. goto
  保留关键字，未在语言中使用。 -
23. if
  执行条件语句。 if语句
24. implements
  表示一个类实现了特定的接口。类声明
25. import
  导入包中的类或接口。程序顶部
26. instanceof
  测试对象是否为特定类型的实例。表达式
27. int
  基本数据类型，32位有符号整数。变量声明
28. interface
  定义接口。接口声明
29. long
  基本数据类型，64位有符号整数。变量声明
30. native
  标记方法为本地方法，由非Java代码实现。方法声明
31. new
  创建新的对象实例。表达式
32. package
  定义包名。程序顶部
33. private
  访问修饰符，限制访问仅限于当前类。类成员
34. protected
  访问修饰符，限制访问仅限于当前类、子类及同一包内的其他类。类成员
35. public
  访问修饰符，允许从任何地方访问。类成员
36. return
  从方法返回值或终止方法执行。方法体
37. short
  基本数据类型，16位有符号整数。变量声明
38. static
  修饰类成员，表示其属于类而不是对象。类成员
39. strictfp
  强制浮点运算遵守IEEE 754标准，确保不同平台的一致性。类或方法声明
40. super
  访问超类的属性或方法。方法体或构造函数
41. switch
  选择多个可能的代码块之一来执行。 switch语句
42. synchronized
  修饰方法或代码块，确保线程安全。方法或代码块
43. this
  当前对象的引用。方法体或构造函数
44. throw
  抛出一个异常。方法体
45. throws
  声明方法可能抛出的异常。方法声明
46. transient
  标记字段，在序列化过程中不会被保存。类成员
47. try
  异常处理的开始。 try-catch-finally语句
48. void
  方法没有返回值。方法声明
49. volatile
  标记字段以确保多线程间的可见性和一致性。类成员
50. while
  开始一个while循环。 while语句
3、按使用频率排列
1. public
  访问修饰符，允许从任何地方访问。类、方法、变量声明
2. class
  定义一个类。类声明
3. void
  方法没有返回值。方法声明
4. int
  基本数据类型，32位有符号整数。变量声明
5. if
  执行条件语句。 if语句
6. for
  开始一个for循环。 for语句
7. new
  创建新的对象实例。表达式
8. return
  从方法返回值或终止方法执行。方法体
9. private
  访问修饰符，限制访问仅限于当前类。类成员
10. static
  修饰类成员，表示其属于类而不是对象。类成员
11. try
  异常处理的开始。 try-catch-finally语句
12. catch
  捕获并处理异常。 try-catch-finally语句
13. this
  当前对象的引用。方法体或构造函数
14. super
  访问超类的属性或方法。方法体或构造函数
15. while
  开始一个while循环。 while语句
16. String
  字符串类型，虽然不是关键字，但使用频率非常高。变量声明
17. boolean
  基本数据类型，表示true或false。变量声明
18. break
  终止循环或switch语句。循环体或switch语句
19. continue
  跳过当前循环迭代，继续下一次迭代。循环体
20. final
  修饰类、方法或变量，防止被修改或覆盖。类、方法、变量声明
21. double
  基本数据类型，双精度浮点数。变量声明
22. float
  基本数据类型，单精度浮点数。变量声明
23. long
  基本数据类型，64位有符号整数。变量声明
24. char
  基本数据类型，16位Unicode字符。变量声明
25. throws
  声明方法可能抛出的异常。方法声明
26. interface
  定义接口。接口声明
27. null
  特殊值，表示空引用。表达式
28. short
  基本数据类型，16位有符号整数。变量声明
29. byte
  基本数据类型，8位有符号整数。变量声明
30. volatile
  标记字段以确保多线程间的可见性和一致性。类成员
31. synchronized
  修饰方法或代码块，确保线程安全。方法或代码块
32. protected
  访问修饰符，限制访问仅限于当前类、子类及同一包内的其他类。类成员
33. transient
  标记字段，在序列化过程中不会被保存。类成员
34. native
  标记方法为本地方法，由非Java代码实现。方法声明
35. strictfp
  强制浮点运算遵守IEEE 754标准，确保不同平台的一致性。类或方法声明
36. assert
  用于断言条件在调试期间必须为真。方法体
37. instanceof
  测试对象是否为特定类型的实例。表达式
38. package
  定义包名。程序顶部
39. import
  导入包中的类或接口。程序顶部
40. enum
  定义枚举类型。枚举类型声明
41. abstract
  用于声明抽象类和抽象方法。类声明或方法声明
42. case switch
  语句的一部分，用于匹配表达式的值。 switch语句
43. default
  在switch语句中用于指定默认要执行的代码块。 switch语句
44. do
  开始一个do-while循环。 do-while语句
45. throw
  抛出一个异常。方法体
46. finally
  异常处理中，无论是否抛出异常都会执行的代码块。 try-catch-finally语句
3、注释

有三种注释：单行注释，多行注释与文档注释

单行注释 //，最常用的注释其注释内容从 // 开始到本行结尾。
多行注释从 /* 开始直至第一个 */ 出现都属于多行注释，但多行注释不能嵌套，多行注释也可以注释掉不需要的代码
文档注释可以自动地生成文档，这种注释以 /** 开始，以 */ 结束
4、数据类型：
1、整型（Integer Types）：
1. byte: 8位有符号整数，取值范围为-128到127。
2. short: 16位有符号整数，取值范围为-32768到32767。
3. int: 32位有符号整数，取值范围为-2147483648到2147483647。这是最常用的整数类型。
4. long: 64位有符号整数，取值范围为-9223372036854775808到9223372036854775807。当数值很大或很小，
  超出一个int的范围时，可以使用long。
2、浮点型（Floating Point Types）：
1. float: 32位IEEE 754单精度浮点数。
2. double: 64位IEEE 754双精度浮点数。这是最常用的浮点数类型。
3、字符型（Character Types）：
1. char: 16位Unicode字符。
4、布尔型（Boolean Types）：
1. boolean: 只有两个值：true和false。
5、其他数据类型：
1. void: 表示无类型，主要用于方法的返回类型，表示方法不返回任何值。
2. String: 表示字符串类型，常用于存储和操作文本数据。
3. 数组（Array Types）: 可以存储多个同种数据类型的值。例如，int[]是一个整型数组，它可以存储多个整数值。
6、引用类型：
这些类型包括类、接口和数组。它们存储的是对象的引用，而不是对象本身。这意味着当我们声明一个引用变量
并为其分配一个对象时，该变量实际上存储的是对象的内存地址，而不是对象本身。
7、原始类型与封装类：
对于整型、浮点型、字符型和布尔型，Java提供了对应的封装类，分别是Integer、Float、Character和Boolean。
这些封装类提供了额外的功能，如自动装箱和拆箱、对象比较等。
8、自动装箱与拆箱：
Java会自动将基本数据类型（如int）和它们的封装类（如Integer）进行转换，这种转换称为装箱和拆箱。例如，
当将一个int值赋给一个Integer对象时，Java会自动将int值装箱为Integer对象；相反，当从Integer对象提取值时，
Java会自动拆箱该值。
9、可变参数（varargs）：
从Java 5开始，方法可以接受可变数量的参数。这些参数可以使用varargs关键字声明，并作为数组处理。例如，
void printAll(String... args)可以接受任意数量的String参数。
10、注解（Annotation）：
注解是用来为代码添加元数据的。它们通常用于提供编译时或运行时的信息，但不会影响代码的执行逻辑。例如，
可以使用注解来标记代码的某些部分、提供方法的参数信息或生成文档等。
11、枚举（Enum）：
枚举是一种特殊的类，它定义了一组常量值。枚举常用于表示一组固定的常量值，如一周的天数、月份等。
12、原始类型和引用类型的选择：
在大多数情况下，应该优先使用原始类型而不是它们的封装类，因为原始类型更节省内存且性能更好。但当需要
将一个原始类型的值与null进行比较或需要使用自动装箱/拆箱功能时，应该使用封装类。
5、运算符
1. 算术运算符
用于执行基本的数学运算，如加、减、乘、除等。
1. + 加法
2. - 减法
3. * 乘法
4. / 除法
5. % 求余（模）
2. 赋值运算符
用于给变量赋值。
1. = 赋值
2. += 加后赋值
3. -= 减后赋值
4. *= 乘后赋值
5. /= 除后赋值
6. %= 模后赋值
3. 关系运算符（比较运算符）
用于比较两个值。
1. == 等于
2. != 不等于
3. > 大于
4. < 小于
5. >= 大于等于
6. <= 小于等于
4. 逻辑运算符
用于根据条件进行布尔逻辑运算。
1. && 逻辑与
2. || 逻辑或
3. ! 逻辑非
5. 按位运算符
对数的二进制表示形式执行操作。
1. & 按位与
2. | 按位或
3. ^ 按位异或
4. ~ 按位取反
5. << 左移
6. >> 右移（带符号）
7. >>> 右移（无符号）
6. 条件运算符（三元运算符）
这是一个特殊的运算符，用于在单个表达式中进行条件判断。
1. 条件表达式 ? 表达式1 : 表达式2
如果条件表达式的结果为 true，则执行并返回 表达式1 的结果；否则，执行并返回 表达式2 的结果。
7. 字符串运算符
Java 中没有专门的字符串运算符，但 + 可以用于连接字符串。
1. + 用于字符串连接
8. 类型运算符
1. instanceof 用于检查对象是否是特定类型。
6、流程控制

Java 语言中的流程控制语句主要包括以下几种：
1、if语句：用于基于某个条件执行代码块。

2、if-else语句：用于基于条件执行一个代码块，否则执行另一个代码块。


3、switch语句：用于基于不同的条件执行不同的代码块。它通常用于处理多个选择的情况。

4、while循环：用于重复执行一段代码，直到给定的条件不再满足。


  5、do-while循环：先执行一段代码，然后检查条件。如果条件为真，则重复执行。这种循环至少会执行一次。


  6、for循环：用于重复执行一段代码指定的次数。它由初始化、条件和后续三个部分组成。

  7、foreach循环：用于遍历数组或集合中的每个元素。

8、break语句：
用于提前退出循环或 switch 语句。当遇到 break 语句时，程序会立即跳出当前循环或 switch 语句。

9、continue语句：
用于跳过当前循环的剩余部分，进入下一次循环。当遇到 continue 语句时，程序会跳过本次循环的剩余部分，直接开始下一次循环。

10、return语句：
用于从方法中提前返回，并可以返回一个值。当方法执行到 return 语句时，它会立即结束方法的执行，并返回到调用该方法的代码处。如果方法有返回类型，则 return 语句必须返回一个与返回类型兼容的值。
7、类（Class）
1. 定义：
  类是一种用户定义的数据类型，它包含了一组属性和方法。属性用于描述对象的状态，而方法则定义了对象的行为。
2. 特性：
3. 结构：
对象（Object）
1. 定义：
  对象是类的实例。每个对象都是其类的一个具体表现，拥有类定义的所有属性和方法。
2. 特性：
3. 创建：
  使用类名和一个新的关键字（如Python中的new，C++中的new操作符，Java中的new关键字）来创建对象。
总结
- 类是对象的蓝图或模板，它定义了对象的属性和方法。
- 对象是类的具体实例，拥有类定义的所有属性和方法，并且每个对象的状态和行为可以是独立的。
8、异常处理
Java异常处理是Java编程语言中用于处理在程序运行时可能发生的错误的一种机制。这种机制允许程序在发生异常（即错误或意外情况）时能够优雅地处理，而不是立即崩溃。以下是一些关于Java异常处理的基本概念和使用方法：
异常类层次结构
Java中的所有异常都是Throwable类的子类。Throwable类有两个主要的子类：
1. Exception：表示应用程序级别的异常，即可以捕获并处理的异常。
2. Error：表示JVM（Java虚拟机）级别的错误，通常是严重的问题，比如内存溢出（OutOfMemoryError）或栈溢出（StackOverflowError），这些错误通常不由应用程序捕获和处理。
异常处理机制
Java的异常处理机制主要依赖于try、catch、finally和throw、throws这几个关键字。
1. try块：
2. catch块：
3. finally块：
4. throw语句：
5. throws声明：
示例代码
总结
Java的异常处理机制是一种强大的工具，它可以帮助你编写更健壮、更易于维护的代码。通过合理地使用try-catch-finally结构、throw和throws，你可以有效地处理潜在的错误，并确保程序在发生异常时能够优雅地恢复或终止。