一、java基础知识点总结归纳:知识体系全景
Java作为一门跨平台、面向对象、多线程的编程语言,其基础体系涵盖从语法结构到运行机制的完整闭环。本部分系统梳理java基础知识点,构建清晰学习路径图谱,为进阶开发奠定坚实根基。
Java语言核心特征
- 跨平台性:通过JVM实现“一次编译,到处运行”,底层依赖字节码(.class)而非机器码
- 面向对象:封装、继承、多态三大特性,支持类与接口机制
- 自动内存管理:垃圾回收机制(GC)自动释放无引用对象
- 强类型检查:变量类型在编译期确定,防止类型误用
- 多线程支持:内置Thread类与synchronized关键字,保障并发安全
Java开发环境配置要点
安装JDK(Java Development Kit)后需配置以下环境变量:
- JAVA_HOME:JDK安装路径(如
C:\Program Files\Java\jdk-17) - PATH:追加
%JAVA_HOME%\bin(Windows)或$JAVA_HOME/bin(Linux/macOS) - CLASSPATH:通常设为
.(当前目录),现代开发中可省略
验证配置:终端执行 java -version 和 javac -version,确保输出版本一致(如17.0.2)。
从HelloWorld看Java程序结构
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
关键要素:
- 类名与文件名必须完全一致(区分大小写)
- main方法是程序入口:public static void main(String[] args)
- 每条语句以分号结尾
- Java严格区分大小写:System ≠ system
二、java核心语法体系
1. 变量与数据类型
Java数据类型分为基本类型(8种)与引用类型(类、接口、数组)。
| 类型 | 字节数 | 取值范围 | 默认值 |
|---|---|---|---|
| byte | 1 | -128 ~ 127 | 0 |
| short | 2 | -32768 ~ 32767 | 0 |
| int | 4 | -2³¹ ~ 2³¹-1 | 0 |
| long | 8 | -2⁶³ ~ 2⁶³-1 | 0L |
| float | 4 | ±3.4029E+38F | 0.0f |
| double | 8 | ±1.7977E+308 | 0.0d |
| char | 2 | 0 ~ 65535 | \u0000 |
| boolean | 1位 | true / false | false |
注意:整数默认为int,浮点默认为double;字符用单引号,字符串用双引号;long类型值需加L后缀(如123L)。
int a = 10; // int类型字面量 long b = 10000000000L; // long需加L float c = 3.14f; // float需加f double d = 3.1415926; // 默认double char e = 'A'; // 单引号 String f = "Hello"; // 双引号,引用类型
2. 运算符
Java运算符分为算术、关系、逻辑、位、赋值、条件六类,重点注意:
- 短路逻辑:&&与||遇false/true立即停止计算,提升效率
- 位运算:左移<< n位相当于乘2ⁿ(如a<<2 = a*4),右移>>保留符号位
- 字符串拼接:+号遇字符串即转为拼接(如"结果:" + 5 → "结果:5")
- 自增陷阱:int x=5; int y=x++; → y=5, x=6;int y=++x; → y=6, x=6
int x = 5; int y = ++x; // 先自增:x=6, y=6 int z = x++; // 后自增:z=6, x=7 boolean flag = (x > 6) && (x++ > 7); // 短路:第二条件不执行,x仍为7
3. 流程控制
分支结构:if-else、switch;循环结构:for、while、do-while;跳转:break、continue、return
switch增强(JDK 14+):
int day = 3;
String result = switch (day) {
case 1, 2, 3, 4, 5 -> "工作日";
case 6, 7 -> "周末";
default -> "无效日期";
};
for-each循环(增强for):
int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
System.out.println(num);
}
⚠️ 注意:for-each无法获取索引,修改数组元素需用传统for循环。
三、java面向对象编程(OOP)
封装、继承、多态是OOP三大支柱,通过类(class)与对象(object)组织代码。
1. 封装:隐藏实现细节,暴露访问接口
- 使用private修饰符隐藏属性
- 提供public的getter/setter方法操作属性
- 构造器保证对象初始化一致性
public class Person {
private String name;
private int age;
// 构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter/Setter
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) {
if (age >= 0 && age <= 150) this.age = age;
}
}
2. 继承:extends关键字,单继承+多层继承
- 子类继承父类非private成员
- super()调用父类构造器(必须在第一行)
- 方法重写(override)需满足:方法名、参数列表、返回类型相同
public class Student extends Person {
private String studentId;
public Student(String name, int age, String id) {
super(name, age); // 调用父类构造器
this.studentId = id;
}
// 重写toString方法
@Override
public String toString() {
return "Student{name='" + getName() + "', age=" + getAge() + ", id='" + studentId + "'}";
}
}
3. 多态:父类引用指向子类对象
核心条件:继承、重写、父类引用指向子类对象
Person p = new Student("张三", 20, "S001");
System.out.println(p.toString()); // 调用子类重写方法
// p.studentId; // 编译错误:父类引用无子类成员
类型转换:
- 向上转型(自动):子类 → 父类
- 向下转型(强制):父类 → 子类,需instanceof判断
4. 抽象类与接口
抽象类(abstract class):
- 可包含抽象方法(无方法体)和具体方法
- 子类必须实现所有抽象方法,除非子类也是抽象类
- 不能实例化,但可定义引用变量
public abstract class Animal {
public abstract void sound(); // 抽象方法
public void sleep() { System.out.println("动物睡觉"); } // 具体方法
}
接口(interface):
- JDK 8+:可含默认方法(default)、静态方法
- JDK 9+:可含私有方法
- 类实现接口(implements)需重写所有抽象方法
public interface Flyable {
void fly(); // 默认public abstract
default void land() { System.out.println("着陆中..."); }
static void info() { System.out.println("可飞行能力接口"); }
}
四、java数组:连续内存存储结构
1. 数组声明与初始化
静态初始化:指定元素值,长度自动计算
int[] arr1 = {1, 2, 3, 4, 5}; // 简洁写法
int[] arr2 = new int[]{1, 2, 3}; // 标准写法
动态初始化:指定长度,元素默认值初始化
int[] arr = new int[5]; // [0,0,0,0,0] String[] names = new String[3]; // [null,null,null]
2. 二维数组:数组的数组
规则二维数组:每行长度相同
int[][] matrix = new int[2][3]; // 2行3列 matrix[0][1] = 5;
不规则二维数组:每行长度可不同
int[][] jagged = new int[3][]; jagged[0] = new int[2]; // 第一行2个元素 jagged[1] = new int[4]; // 第二行4个元素 jagged[2] = new int[1]; // 第三行1个元素
3. 常用操作
- 长度:arr.length(非方法)
- 复制:System.arraycopy(src, srcPos, dest, destPos, length)
- 排序:Arrays.sort(arr)(升序)
- 查找:Arrays.binarySearch(sortedArr, key)
- 转字符串:Arrays.toString(arr)
int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 1, dest, 2, 3); // 复制src[1..3]到dest[2..4]
System.out.println(Arrays.toString(dest)); // [0,0,2,3,4]
五、java方法:代码复用单元
1. 方法定义格式
public static int add(int a, int b) {
return a + b;
}
要素:权限修饰符(public) + 静态标识(static) + 返回类型(int) + 方法名(add) + 参数列表(int a, int b) + 方法体
2. 方法重载(Overload)
同一类中,方法名相同,参数列表不同(类型/个数/顺序),与返回类型无关
int max(int a, int b) double max(double a, double b) int max(int a, int b, int c)
调用时根据实参类型自动匹配
3. 可变参数(Varargs)
语法:类型... 参数名(必须位于参数列表末尾)
int sum(int... nums) {
int total = 0;
for (int num : nums) total += num;
return total;
}
sum(1,2,3); // 6
sum(new int[]{1,2,3}); // 6
4. 递归调用
方法直接/间接调用自身,需满足:
- 有终止条件(否则栈溢出)
- 每次递归向终止条件逼近
int factorial(int n) {
if (n == 1) return 1; // 终止条件
return n * factorial(n - 1);
}
⚠️ 注意:递归效率较低,深度过大可能导致StackOverflowError
六、java异常处理机制
1. 异常体系结构
- Throwable(根类)
- Error:严重错误(如OutOfMemoryError),程序无法处理
- Exception:可处理异常
- RuntimeException:运行时异常(如NullPointerException),可处理可不处理
- Checked Exception:受检异常(如IOException),必须处理(try-catch或throws)
2. 异常处理方式
try-catch-finally
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("除零异常:" + e.getMessage());
} finally {
System.out.println("清理资源(总是执行)");
}
throws声明异常
public static void readFile() throws IOException {
FileReader fr = new FileReader("test.txt"); // 可能抛出IOException
}
3. 自定义异常
继承Exception(受检)或RuntimeException(非受检)
public class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
public void setAge(int age) throws AgeException {
if (age < 0 || age > 150) {
throw new AgeException("年龄非法:" + age);
}
this.age = age;
}
七、java集合框架体系
1. 集合框架总览
- Collection(单列集合)
- List(有序可重复):ArrayList(动态数组)、LinkedList(链表)、Vector(线程安全)
- Set(无序不重复):HashSet(哈希表)、LinkedHashSet(有序)、TreeSet(排序)
- Map(双列集合):HashMap(哈希表)、LinkedHashMap(有序)、TreeMap(排序)、Hashtable(线程安全)
2. List核心操作
Listlist = new ArrayList<>(); list.add("Java"); list.add(1, "Python"); // 在索引1插入 list.set(0, "C++"); // 替换 System.out.println(list.get(1)); // 获取 for (String s : list) { ... } // 增强for
⚠️ 注意:ArrayList随机访问快(O(1)),增删慢(O(n));LinkedList增删快(O(1)),随机访问慢(O(n))
3. Set去重原理
HashSet通过hashCode()和equals()保证元素唯一性:
- 添加元素时先计算hashCode
- 若hashCode相同,再调用equals比较
- 两者均相同则视为重复元素
class Student {
String name;
int age;
// 重写hashCode和equals(基于name和age)
}
TreeSet通过compareTo()或Comparator实现排序
4. Map常用操作
Mapmap = new HashMap<>(); map.put("张三", 90); map.put("李四", 85); System.out.println(map.get("张三")); // 90 map.containsKey("王五"); // false map.remove("李四"); for (Map.Entry entry : map.entrySet()) { System.out.println(entry.getKey() + " = " + entry.getValue()); }
八、java IO流体系
1. IO流分类
- 按方向:输入流(InputStream/Reader)、输出流(OutputStream/Writer)
- 按单位:字节流(8位)、字符流(16位,支持中文)
- 按功能:节点流(直接连接)、处理流(包装节点流)
2. 字节流操作
// 文件复制
FileInputStream fis = new FileInputStream("src.jpg");
FileOutputStream fos = new FileOutputStream("dest.jpg");
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
fis.close();
fos.close();
3. 字符流操作
// 文本文件读取
BufferedReader br = new BufferedReader(new FileReader("test.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
// 写入文本
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
bw.write("Hello World");
bw.newLine(); // 换行
bw.close();
4. 对象流与序列化
实现Serializable接口的对象可被序列化(对象→字节流)
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
String name;
int age;
}
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
oos.writeObject(new Person("张三", 20));
oos.close();
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"));
Person p = (Person) ois.readObject();
ois.close();
九、java多线程编程
1. 创建线程的两种方式
方式1:继承Thread类
class MyThread extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread: " + i);
}
}
}
new MyThread().start();
方式2:实现Runnable接口
class MyRunnable implements Runnable {
public void run() {
// 线程执行体
}
}
new Thread(new MyRunnable()).start();
✅ 推荐Runnable:避免单继承局限,适合多线程共享资源
2. 线程同步机制
synchronized关键字
// 同步代码块
synchronized (lockObject) {
// 临界区
}
// 同步方法
public synchronized void increment() {
count++;
}
Lock显式锁(JUC包)
Lock lock = new ReentrantLock();
lock.lock();
try {
// 临界区
} finally {
lock.unlock();
}
3. 线程通信
wait()/notify()必须在synchronized中使用
// 生产者-消费者模式
public synchronized void produce() {
while (buffer.isFull()) wait();
buffer.add(item);
notifyAll();
}
public synchronized void consume() {
while (buffer.isEmpty()) wait();
buffer.remove();
notifyAll();
}
4. 线程池(ExecutorService)
避免频繁创建线程,提高资源利用率
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
pool.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 执行任务");
});
}
pool.shutdown(); // 优雅关闭
十、java虚拟机(JVM)核心原理
1. JVM内存区域划分
- 程序计数器:线程私有,记录当前指令地址
- 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等)
- 本地方法栈:线程私有,服务native方法
- 堆:线程共享,存放对象实例(GC主要区域)
- 方法区:线程共享,存储类信息、常量、静态变量
2. 对象创建过程
1. 类加载检查 → 2. 分配内存(指针碰撞/空闲列表) → 3. 初始化零值 → 4. 设置对象头 → 5. 执行init方法
Person p = new Person("张三");
// 对象在堆中创建,引用p在栈中
3. 垃圾回收机制(GC)
判断对象存活:
- 引用计数法(Java未采用,因循环引用问题)
- 可达性分析(GC Roots起点)
GC算法:
- 标记-清除:标记→清除,产生碎片
- 复制:新生代(Eden:From:To=8:1:1)
- 标记-整理:老年代,移动对象避免碎片
System.gc(); // 建议GC,不保证立即执行
4. 常见JVM参数
- -Xms256m:堆初始大小256MB
- -Xmx1g:堆最大大小1GB
- -XX:NewRatio=2:新生代/老年代比例1:2
- -XX:+PrintGCDetails:打印GC日志
十一、网友最关心的10个问题深度解答
==:比较基本类型值是否相等;比较引用类型时比较地址值是否相同
equals():Object类方法,默认行为与==相同;但String、Integer等类重写了equals(),比较内容是否相等
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false(地址不同)
System.out.println(s1.equals(s2)); // true(内容相同)
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true(-128~127缓存)
Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false(超出缓存范围)
- String:不可变字符序列(底层final char[]),频繁修改效率低
- StringBuilder:可变字符序列,线程不安全(JDK 5+),单线程推荐
- StringBuffer:可变字符序列,线程安全(方法同步),多线程使用
String s = "a";
s += "b"; // 创建新对象(效率低)
StringBuilder sb = new StringBuilder();
sb.append("a").append("b"); // 修改原对象(高效)
- ArrayList:基于动态数组,随机访问快O(1),增删慢O(n)(需移动元素)
- LinkedList:基于双向链表,增删快O(1)(仅修改指针),随机访问慢O(n)
- 内存占用:LinkedList每节点额外存储前后指针
✅ 选择建议:频繁查询用ArrayList;频繁增删用LinkedList
- 线程安全:Hashtable线程安全(方法同步),HashMap线程不安全
- 空值支持:HashMap允许null键/值(仅1个null键),Hashtable不允许null
- 性能:HashMap效率更高
- 初始容量:HashMap默认16,Hashtable默认11
✅ 现代开发推荐:ConcurrentHashMap替代Hashtable
Java规范要求:相等对象必须有相同hashCode
- 若a.equals(b)为true → a.hashCode()必须等于b.hashCode()
- 若hashCode不同 → equals()一定为false
HashMap/HashSet依赖hashCode定位存储位置,若只重写equals()会导致逻辑错误
class Person {
String name;
// 重写equals()仅比较name
@Override
public boolean equals(Object o) { ... }
// 未重写hashCode() → 默认地址hashCode
}
Map map = new HashMap<>();
map.put(new Person("张三"), 90);
map.get(new Person("张三")); // 可能返回null(hashCode不同)
- final:修饰类(不可继承)、方法(不可重写)、变量(不可变)
- finally:try-catch的finally块,无论是否异常都执行(除System.exit())
- finalize:Object方法,GC调用前执行清理(JDK 9+已弃用)
Thread.State枚举定义6种状态:
- NEW:线程刚创建,未启动
- RUNNABLE:运行中(含就绪和运行中)
- BLOCKED:等待monitor锁进入同步块
- WAITING:无限期等待(Object.wait()、Thread.join())
- TIMED_WAITING:限期等待(Thread.sleep()、wait(1000))
- TERMINATED:线程执行完毕
浅拷贝:复制对象本身,引用类型字段仍指向原对象
深拷贝:递归复制所有层级对象,完全独立
// 浅拷贝示例
class Student implements Cloneable {
String name;
School school; // 引用类型
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅拷贝
}
}
Student s1 = new Student();
Student s2 = (Student)s1.clone();
s2.school.name = "北大"; // s1.school.name也被修改
通过异常的cause属性包装原始异常,保留完整异常链
try {
// 可能抛出IOException
} catch (IOException e) {
throw new ServiceLayerException("服务层错误", e); // 包装原始异常
}
调用getCause()可获取原始异常
Java泛型只存在于编译期,运行时泛型信息被擦除为原始类型(类型擦除)
Listlist = new ArrayList<>(); list.add("hello"); // 运行时:list.getClass() == List.class(泛型信息丢失)
影响:无法在运行时获取泛型类型(如list.getClass().getGenericSuperclass())