Java基础知识点(必备)
Java第一阶段
一、语言基础
<> Java 开发环境：
编译期： .java 的源文件经过编译，生成 .class 字节码文件
运行期： .class 的字节码文件由 JVM 加载并运行，生成（
0 和 1 ）；
1. JVM
Java 虚拟机，加载 .class 文件并运行 .class 文件
2. JRE
Java 运行环境，除了包含 JVM 外，还包含了运行 Java 程序所必须的环境
JRE = JVM + 系统类库小零件
运行 Java 程序的最小环境为 JRE
3. JDK
Java 集成开发环境除了包含 JRE 外，还集成了一些为开发 Java 程序所需的基本命令工具。
JDK=JRE+ 编译、运行等命令工具
开发程序的最小环境为 JDK
<> IDEA
JetBrains 公司的，分为社区版（免费）和终极版（收费）
<>
开发步骤：
1. 新建项目
2. 新建包：建议“小驼峰命名法”
3. 新建类：建议“大驼峰命名法”
<>
注释符：注释信息，计算机不运行
- “// ”单行注释
2. “/* */ ”多行注释
3. “/** */ ”文档注释
<> 变量：代词，存数的，指代里面的数字
1. 声明变量，如 int a ；
2. 初始化变量，即第一次赋值，如 int a = 5 ；
3. 使用变量，就是使用变量指代的数，如， a = 10;
4. 使用变量前，必须声明并初始化
<> 命名：（标识符）
1. 只能包含数字，字母，下划线和 $ 符号，并且，不能以数字开头
2. 严格区分大小写
3. 不能使用关键字
4. 允许中文，但不建议，英文的见名知意
<> 八大基本数据类型：
1. byte, 字节型，专门存储整数，占 1 个字节，范围是 -128~127 ；
2. short 短整型，专门存储整数，占 2 个字节，范围是 -32768~32767 ；
3. int 整型，专门存储整数，占 4 个字节，范围是 -2 的 31 次幂 ~2 的 31 次幂减 1
4. long 长整型，专门存储整数，占 8 个字节，范围是 -3 的 63 次幂到 3 的 63 次幂减 1
5. float 单精度浮点型，专门存储小数，占 4 个字节
6. double 双精度浮点数，专门存储小数，占 8 个字节
7. Boolean 布尔型，存储 true 和 false, 占 1 个字节
Data type Char is a fundamental data type that encodes single characters using the Unicode character set, also known as universal code. Each character occupies a specific number of bits in memory, ensuring efficient storage and retrieval.
2 个字节，范围是 0~65535
<> 类型间的转换：
1. 自动类型转行
小型到大型
2. 强制类型转换
大型到小型
语法：（要转成的数据类型）变量
注意要点：强转可能会发生溢出或丢失精度
3. 两点规则：
1）整数值类型被赋值给 byte, short, char 类型变量，则必须确保其数值大小受限于其数据类型的最大容量。
2 ） byte, short,char 参与运算时，系统一律将其转换为 int 类型再运算
<> 运算符：
1. 算数运算符
“ + ”
“ - ”
“ * ”
“ / ”
“ % ”
“ ++ ”
“ -- ”
% 取余或取模，余数为 0 为整数
++/-- 自增 1 或子减 1 ，放在变量名前后所得值不同，例如， ++a 和 a++, 单独使用时值相同，
被使用时，值不同， a++, 先取值后增 1 ， ++a, 先增 1 ，后取值
2. 关系运算符
“ > ” “ < ” “ >= ” “ <= ” “ == ” “！ = ”
关系运算的结果为 boolean 类型，结果返回真为 true, 假为 false
3. 逻辑运算符
“ && ”“ || ”“！”
逻辑运算的结果为 boolean 型
逻辑与，见 false 为 false
逻辑或，见 true 则 true
逻辑非，结果值取反
4. 赋值
“ = ”“ += ”“
-= ”“ *= ”“
/= ”“ %= ”
简单赋值运算符： =
扩展赋值运算符，如“ += ” a+=b 为 a=a+b, 其余同理
注意要点：扩展赋值运算符自带强转功能
Short s = 10;
s += 10;( 编译正确 )
s = s+10( 编译错误 ) ，应为 s = (short)(s+10)
5. 字符串连接
“ + ”
若两遍都是数字，直接相加
当输入数据为字符串格式时，则执行特定的连接操作。任何与之相关的连接操作的结果将被视为字符串类型，并被称为...类型。
同化作用
<> 条件 / 三目运算
语法： Boolean? 数目 1 ：数目 2 判断条件，为真取数目 1 ，为假取数目 2
<> 分支结构
1. 单条分支结构： ( 如果为真，输出语句块 )
If( 条件 1 ){
语句块 1
}
2. 两条分支：（如果为真，输出语句块 1 ，如果为假，输出语句块 2 ）
If(boolean 条件 1){
语句块 1
}else{
语句块 2
}
3. 多条分支
1 ） If…elseif 结构
if( 条件 1 ){
语句块 1
}else if ( 条件 2){
语句块 2
}else if( 条件 3){
语句块 3
}else{
语句块 4
}
2 ） switch case 结构
Switch （command ） {
case 1:
Syestem.out.println();
break;
case 2:
Syestem.out.println();
break;
case 3:
Syestem.out.println();
break;
default:
说明：默认情况下可以在分支条件的任何位置设置或省略不写；其中 break 用于跳出循环结构，在未使用时会继续执行后续代码
要点： switch 作用于的数据类型， byte , short, int, char, String, 枚举类型
Switch case的优点在于高效且逻辑分明；其不足之处在于仅适用于整型数据类型；当确定为整型时，则会简化操作流程。
用 switch case 结构
<> 循环结构（ 三要素：循环变量初始化，循环控制条件，循环变量的改变 ）
1 ） while 循环，先循环，后判断，可能一次也不执行
初始化；
while(Boolean 条件 ) {
循环体
循环变量的改变；
}
2 ） do while 循环，先执行后判断，至少执行一次
do{
循环体
}while( 循环控制条件 )
3 ） for 循环
for( 循环变量初始化；循环控制条件；循环变量的改变 ){
循环体；
}
要点：当明确确定循环次数时，请优先选择for循环；而当第一个和第三个元素相同时，则同样适用此方法。
do while 循环，其次选 while 循环
break 跳出循环； continue 跳出剩余语句进入下次循环
接收器：
Import java.util.Scanner;
Scanner scan = new Scanner(System.in);
Int a = scan.nextInt();
随机数：
Import java.util.Random;
Random rand = new Random;
Int b = rand.nextInt( ); 注：改值生成的随机数是 0.00 到 0.99..
<> 嵌套循环：
1 ） 多行多列时使用，外环控制行，内行控制列
2 ） 外环走一次，内环走所有次
3 ） 嵌套次数越少越好
4 ） break 只能跳出当前一层循环
<> 数组
1. 是一种引用数据类型
2. 相同数据类型元素的集合
三种定义方式：
Int [] a = new int [5];
Int [] a1 = new int []{
};
Int [] a2 = {1,2,3 }; 3. 给数组的元素做初始化
Int [] a = new int [3];
a [0] = 1;
a [1] = 2;
a [2]=3;
4. 数组的访问
获取的是数组中的各项；利用 数组名.length 获取其长度属性；即代表该数组所包含的具体项的数量。
数组第一个元素从下标 0 开始访问，最大到数组的长度 -1 ，即，数组名 .length-1
5. 遍历 / 迭代
for 循环，从头至尾，将所有数据全部输出一遍
6. 数组的复制
1 ） System.arraycopy(a,1,b,2,4); 更灵活
解析：复制源 a 数组，从 a 的下标 1 开始 4 个元素到 b 数组，下标为 2 的位置复制
注：容易发生数组下标越界异常
2 ） int [] b = Arrays.copyOf( a,6); 常常扩容缩容时使用
解析：将源 a 数组，从下标为 0 开始， 6 个元素复制给数组 b
7. 数组的排序
Arrays.sort(arr); 升序排列
<> 方法
1. 又叫函数，过程
2. 封装一段特定的业务逻辑功能
3. 尽可能独立，一个方法只做一件事
4. 方法可以被反复多次被调用
5. 减少代码量，有利于代码复用，有利于代码维护
定义方法的 5 要素：
修饰词 返回值类型 方法名 参数列表 方法体（具体的功能实现）
要点：定义一个方法明确两个点：
1 ） 返回值类型
2 ） 有无参数
调用方法
1 ） 无返回值： 方法名（有参传参）
2 ） 有返回值： 数据类型 变量 方法名（有参传参）
6. Return
有返回值时，
return 值 ; 结束方法执行，将结果返回给调用方
无返回值时，
return ; 结束方法执行
二、面向对象
类：现实生活由很多很多对象组成，基于对象抽出了类
对象：软件中真实存在的单个个体 / 东西
关系：类是对象的模子，对象是类的具体实现
特点：类中可以包含对象的属性和特征，即成员变量
类中可以包含对象的行为功能和动作，即方法
如何创建类
如何创建对象
如何访问成员
<> 方法的重载（
overload/overloading ）
只看方法的签名：即方法名和参数列表，与其他无关
方法重载，方法名必须相同，参数列表不同
编译器在编译时，会根据方法的签名自动绑定方法，更加方便用户的访问
<> 构造方法
1 ）定义：又叫构造器，构建器
2 ）作用：复用给成员变量赋初值代码
3 ）与类同名，没有返回值类型，连 void 都没有
4 ）在创建（
new ）对象时自动调用
5）当自行未定义constructFunction时，默认情况下编译器将生成一个没有参数的函数；或者如果自行编写了相应的constructFunction。
法，则默认不再提供
6 ）构造方法可以被重载
<> this 指代当前对象，哪个对象调用方法，就指哪个对象
只能用在方法中，方法中访问成员变量之前默认有个 this
This 的用法：
This. 成员变量名 ------- 访问成员变量
注：成员变量与局部变量同名时，若想访问成员变量， this 不能省略
This. 方法（），调用方法
This( ). 调用构造方法
Null 表示空，没有指向任何对象
若变量的值为 null，则该变量无法执行任何属性访问操作；若尝试执行则会引发空指针异常。
<> 引用类型数组：
1. 与基本类型数组的区别
1 ） 给数组元素复制时，必须 new 一下
2 ） 若想访问数组元素，要通过数组元素打点
<> 面向对象三大特征：
1. 封装
封装类：封装对象的属性，方法的行为
封装方法：封装特定的业务逻辑实现
访问控制修饰符，控制访问权限，保证数据的安全 Public 任何类
Protected 本类，同包，派生类
默认的，本类，同包
Private 私有的，本类
访问权限从大到小： public protected 默认的 private
作用是为了代码复用
2. 继承（
extends ）实现（
implements ）
作用是代码复用
通过 extends （继承）实现
超类（父类）和派生类（子类）
超类中存放所有派生类共有的行为
接口中存放部分派生类共有的行为
派生类（子类）存放特定的行为
派生类既能访问自己的也能访问超类的，超类只能访问自己的
方法重写，派生类的方法访问权限要大于或等于超累的
一个超类可以有多个派生类，一个派生类只能有一个超类，单一继承
同一个接口能够由多个类来实施同一个类能够同时支持多个 interfaces 通过逗号分隔的方式进行标识该系统能够支持多个不同的 interfaces 通过逗号分隔的方式进行标识该系统能够同时支持多种不同的 interfaces 通过分号分隔的方式进行标识
传递性
Object 是所有类的超类（所有类都直接或间接继承了超类）
接口可以继承接口，如果一个类既有继承又有实现，先继承后实现
3. 多态
所有抽象方法均具有多态性，在程序设计中我们通常会在行为与功能不一致时进行改写的情况包括多种不同的情况
形态时）发生在代码复用时
2）任何一个对象都具有多态性，在这种情况下至少存在两种类型：其一是自身类型；其二是 object 类型。这是因为所有的 class 都直接或间接继承自 object 类型。
间接继承了 object ，放生在向上造型时
3 ） 强制类型转换，与 instanceOf 配套使用，强转成功的条件只有两种
a. 引用所指向的对象就是该类型
b. 引用所指向的对象继承该类或实现了该接口
在强制类型转换时若不满足前述要求，则会导致 ClassCastException 异常类型
<> Super
指代当前对象的超类对象
Super 的用法：
Super. 成员变量名，访问成员变量
Super. 方法名（），调用超类的方法
Super( ), 调用超类的构造方法
< > 方法的重写：
遵循两同，两小，一大的原则
方法签名：方法名相同，参数列表相同；
返回值的数据类型：当为空指针类型或基本数据类型的时侯，请确保与调用者的一致；对于引用类型的参数来说，请确保传递的是继承关系的派生类。
方法返回值类型必须小于或等于超类的返回值类型，否则编译错误
另一小会在 API 时讲
一大指的是，派生类方法的访问权限要大于或等于超类的
<> 向上造型
定义：超类型的引用指向派生类的对象 能点出来什么要看引用的类型
<> 方法的重载与重写的区别
重载 overload ：发生在同一类中，方法名相同，参数列表不同
重写 override ：发生在父子类中，方法名相同，参数列表相同
当某个类被继承时,其内部的方法必须重新编写以确保功能的一致性;在此情况下,请特别注意可能会同时存在多个方法的重载情况,在判断时需确保逻辑的一致性.
断题中，要一一排除
<> Package 包
1. 避免与 类名冲突
2. 同包中的类不能同名，不同包中的类可以重名
3. 类的全称：包名 . 类名
4. 包名常常有层次结构，所以建议都小写
<> Import 导入
1. 同包中的类可以直接访问
2. 不同包中的类不可以直接访问，通过导人（
import ）声明类，再访问
或者用类的全称，包名 . 类名（不建议，太复杂）
<> final 修饰词，最终的，不可改变的，单独使用极低
1. 修饰变量，变量不能被改变
2. 修饰方法，方法不能被重写
3. 修饰类，类不能被继承
<> Static 修饰词，静态的
1. 静态变量
Static 修饰，存在方法区，只存储一份
通过类名点来访问
何时用：所有对象共享的东西，如图片，音频，视频
2. 静态方法
Static 修饰，存在方法区，只存一份
属于类，通过类名点来访问
静态方法中没有隐式 this 传递，不能直接访问实例成员
何时用：方法的操作与对象无关，也就是没有涉及成员变量时
3. 静态块
Static 修饰，属于类，在类被加载期间自动执行，（
.class 字节码文件生成），一个类只被加载
一次，所以静态块只执行一次
何时用：加载 / 初始化静态资源（图片，音频，视频）
静态常量
1. 必须声明同时初始化
2. 类名点来访问（遵循了 static 的原则），不能被改变（遵循了 final 的原则）
3. 建议采用以下方式命名常量名：所有字母均大写，并使用下划线分隔多词命名策略；4. 编译器在优化过程中会自动将这些常量替换为具体数值，并提高效率
5. 何时用：数据永远保持不变，经常使用时
<> 抽象方法
1. 由 abstract 修饰
2. 包含抽象方法的类，必须是抽象类
3. 抽象类不能创建对象，不能（
new ）所以没有意义，必须要被继承，继承该类的派生类
方法必须重写
4. 抽象类的意义
1 ） 封装共有的属性和行为 ---- 代码复用
2 ） 为所有的派生类提供统一的类型 ---- 向上造型
支持抽象方法为所有派生类提供一个统一的入口点，并且能够访问基类方法的行为各不相同。
但是是同一个入口，定义了一个标准
成员内部类：
<> 类中套类, 外围的类别称为外部类别, 内部的类别称为内部类别, 内部类别仅影响外围类别.
对外不具有可见性
内部类能够访问外部类成员；如私有内部类也能访问外部成员；通过一个默认的引用指向其创建的外部对象。
部类对象，外部类名 .this----------------API 时会用
匿名内部类 --- 大大简化代码
若想在Java中创建一个派生类的对象，并且确保该对象只有一个实例，则可以通过定义一个静态嵌套类来实现
2. 在匿名内部类中默认外面的变量为 final 的
<> 面试题：内部类有独立的 .class 吗？ 答：有
接口
1. 接口是一种引用数据类型
2. 由 interface 定义
3. 只能包含常量和抽象方法
尽管在理论上不能将此类 interface 实例化 （因为它是一个 abstract 类型） ，但在实际开发中仍然需要为每个 interface 创建相应的 implementation 并进行必要的修改 ，以便满足系统的功能需求
一个类可以有多个接口，用逗号隔开
<> 内存管理
内存由 JVM 来管理
1. 栈内存：引用，引用的地址，正在调用的方法中的局部变量，包括方法的参数
2. 堆内存：
1 ） new 出来的东西；实例变量；
2 ） 垃圾：没有被引用的对象垃圾回收器（ GC ）会定期从内存中清除这些未被引用的对象，并以达到内存释放的目的。
收过程是透明的，可以通过调用 System.gc 建议 JVM 尽快调度 GC 回收。
3 ） 实力变量的生命周期，创建对象时储存在堆中，对象被回收时一并被回收
4 ） 内存溢出：未被回收的资源可能会导致系统崩溃的情况，请及时清理
不再使用的对象应及时将引用指向 null
3. 方法区：由方法区负责生成对应的.class字节码（类型），每个类型只负责生成一个.class字节码；因此只有一个.class字节码被创建出来。
在单例模式下；我们定义了一个静态块和一个静态变量来管理单例实例。由于所有的单例都位于同一个类中，并且每个单例只能有一个实例被激活的状态，则每个单例只能有一个实例被激活的状态。可以通过this来访问父类的方法实例
区分具体的访问对象
< > String: 字符串类型 1. Java.lang.String 使用 final 修饰，不能被继承
Java中的String遵循Unicode字符集编码格式，并且每个字符占据两个字节的空间
3. 字符串底层封装的是一个字符数组
4. 一创建后--- 不变对象
< > 常量池
1. Java 对字符串的优化措施：字符创常量池
当再次生成具有相同字面量的对象时, 将字面量直接存入内存中的特定区域, 能够有效地复用该区域。
址
<> String 的常用方法
1. length() 获取字符串长度，接收为 int 类型
2. trim() 删除字符串左右两边的空格，接收类型为 String 类型
convert all English characters in the string content to uppercase and receive the type String.
将字符串内容中的所有英文内容改为小写，并接受参数类型为 string
5. startsWith(); 判断字符串内容是否以特定字符开头，并接受类型为 boolean 的参数
6. endsWith(); 判断字符串内容是否以特定字符结尾, 用于判断的结果类型是布尔值
7. charAt(int index); 根据下标找对应的字符内容，接收为 char 类型
8. indexOf(String s); 根据字符串内容找该字符串对应的下标，接收为 int 型
substring(int start, int length); 从输入字符串中提取出从位置start开始、长度为length的部分，并将其转换为String类型的变量
调用String.valueOf(int i)将不同类型的数据转换为String类型，并作为String类的一个静态方法使用。
<> StringBuilder 的常用方法
1. .append(, String s); 在源字符串后，追加字符串 s
2. .replace(int I, int j, String s); 在指定的源字符串的位置内容替换为 s
3. .delete(int 0, int 3); 删除指定源字符串的内容
4. .insert(int I, String s); 在源字符串指定下标，插入字符串 s
5. Reverse( ); 翻转该字符串内容
<> String 和 StringBuilder ：
1. String 用于阅读
2. StringBuilder, 用于修改，内部维护一个可变的 char 数组
<> 正则表达式：
1. 例如邮箱的正则表达式
matches();
[a-zA-Z0-9_]+@[a-zA-Z0-9]+( ./[a-zA-Z]+)+;
String email = sale@bio.com
String regex = “[a-zA-Z0-9_]+@[a-zA-Z0-9]+( ./[a-zA-Z]+)+”;
boolean match = email.matches(regex);
该函数遵循正则表达式的拆分规则，并将拆分结果以数组形式返回
如： String s = “123abc456wer789trt”;
s.spilit(“[0-9]+”)
3. ReplaceAll( );
将当前字符串中满足正则表达式的部分替换为给定的字符串
如： s.replaceAll(“[0-9]+”,”NUM”)
<> 物体/事物：当调用toString()方法时，默认按照惯例执行返回操作。
回具体的数据
使用equals()方法时，默认采用的是等于号运算符来比较对象的地址；其结果在大多数情况下没有实际意义；为了实现精确比较对象属性内容，请重新实现equals()方法
值
注意要点 1 ：
Java 的类（
String ）已经重写 equals 了，我们自己定义的类，必须重写 equals()
注意要点 2 ：两个对象必须是同一个类型，若类型不同，直接返回 false
若参数对象为 null ，直接返回 false
原则上两个对象要比较属性是否相同
<> 包装类：
Java 定义了 8 个包装类以解决基本类型不能直接参与面向对象开发的问题
得基本类型可以通过包装类的实例以对象的方式存在
在这些数据类型中（Byte, Short, Integer, Long, Float, Double）中Character和Boolean是两个特别需要注意的数据类型
直接继承自 Object 的，其余都继承自 java.lang,Number
3. 自动拆装箱 ， JDK1.5 版本后推出
如： Intger a = 10;
Int b = a;
(java 底层为我们自动转换 )
<> 二进制
逢 2 进 1
基数是 2
数字： 0,1
1
2
4
8
权是 从右往左， 2 的 0 次幂， 2 的 1 次幂， 2 的 2 次幂， 2 的 3 次幂， ….
将 2 进制的数转换为 10 进制
将 2 进制的每个 1 位置的权值累加即可
十六进一
逢 16 进 1
基数是 16
数字： 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f
权是从右往左， 16 的 0 次幂， 16 的 1 次幂， 16 的 2 次幂
从 2 进制转为 16 进制
将 2 进制从最低位开始，每 4 位 2 进制缩写为 16 进制
<> 位运算
& 与运算，有 0 则 0
| 或运算，有 1 则 1
右移位运算 , 将 2 进制数整体向右移动，低位自动溢出舍弃，高位补 0
<< 左移位运算，将 2 进制数整体向左移，高位溢出舍弃，低位补 0
总结
例如：以上就是Java语言基础理论知识