备案号:蜀ICP备2026035467号-3 | 网址:www.xservx.com

java重要基础知识点|夯实根基,精进技术

Java作为全球应用最广泛的编程语言之一,其核心价值不仅在于跨平台能力,更在于其强大而严谨的**基础体系**。对于初学者而言,扎实掌握**java重要基础知识点**是避免“知其然不知其所以然”困境的关键;对于资深开发者而言,定期回顾底层原理与细节机制,是突破技术瓶颈、提升系统级设计能力的必经之路。

本页以系统化知识结构为纲,以真实工程场景为基,全面梳理**java重要基础知识点**及其延伸内容,覆盖语言核心语法、面向对象机制、集合框架、并发编程、异常处理、JVM运行时、反射与注解、常用设计模式等八大模块,并穿插高频面试题、易错陷阱、性能优化技巧及最佳实践,力求构建完整、清晰、可落地的知识图谱。

全站采用语义化结构设计,所有导航均为锚点跳转,内容深度适配多端设备,确保您在PC端高效查阅,在移动端流畅阅读。以下内容严格遵循Java语言规范(Java Language Specification, JLS)及HotSpot虚拟机实现规范,所有代码示例均在JDK 17环境下验证通过,可直接运行。

一、语言基础:变量、数据类型与控制流程

所有Java程序的起点是**main方法**,而程序的起点单元是**变量**与**数据类型**。理解基本类型、引用类型、自动装箱/拆箱、类型转换规则,是编写健壮代码的第一步。

〈1〉变量声明与作用域

变量按声明位置可分为三类:
① 局部变量:定义于方法、构造器或代码块内,作用域仅限当前块,必须显式初始化;
② 实例变量:定义于类中但不在方法内,随对象创建而分配内存,有默认值(int→0,boolean→false,引用→null);
③ 类变量(静态变量):用static修饰,属于类本身,所有实例共享,类加载时初始化。

⚠️ 注意:同名变量遵循“就近原则”,局部变量会遮蔽同名实例变量;访问被遮蔽的实例变量需使用this关键字。

〈2〉数据类型体系

Java数据类型分为两大类:原始类型(Primitive Types)与引用类型(Reference Types)。

类型分类包含类型默认值存储大小
整数型byte、short、int、long01/2/4/8字节
浮点型float、double0.04/8字节
字符型char'\u0000'2字节(UTF-16)
布尔型booleanfalse1位(实际存储因JVM实现而异)
引用类型类、接口、数组null32位或64位指针

▶ 示例:浮点数精度问题与解决方案

// 问题:0.1 + 0.2 ≠ 0.3
double a = 0.1;
double b = 0.2;
System.out.println(a + b == 0.3); // false
// 解决:使用BigDecimal(金融计算)或设置误差阈值(科学计算)
BigDecimal x = new BigDecimal("0.1");
BigDecimal y = new BigDecimal("0.2");
System.out.println(x.add(y).compareTo(new BigDecimal("0.3")) == 0); // true
// 科学计算容错方案
double sum = a + b;
double epsilon = 1e-10;
boolean equal = Math.abs(sum - 0.3) < epsilon; // true

〈3〉控制流程结构

Java控制流程包括:
① 顺序结构:自上而下执行;
② 分支结构:if-else、switch;
③ 循环结构:for、while、do-while;
④ 跳转语句:break、continue、return。

▶ switch增强(JDK 7+):

  • 支持String类型(内部通过hashCode()与equals()实现);
  • 支持枚举类型(通过ordinal()与valueOf()映射);
  • 必须显式使用break防止fall-through,或使用yield返回值(JDK 12+)。
String status = "ACTIVE";
switch (status) {
    case "ACTIVE" -> System.out.println("运行中");
    case "INACTIVE" -> System.out.println("已停用");
    default -> System.out.println("未知状态");
}

二、面向对象核心:封装、继承、多态

Java是纯面向对象语言,所有代码必须定义在类中。理解OOP三大特性,是构建高内聚、低耦合系统的基础。

〈1〉封装:信息隐藏与访问控制

封装通过private字段+publicgetter/setter实现,配合final、static修饰符增强安全性与语义清晰度。

▶ 高级封装技巧:

  • 使用record(JDK 14+)自动生成构造器、getter、equals()、hashCode()、toString();
  • 构造器私有化实现单例模式;
  • 使用Objects.requireNonNull()避免空指针。
public record User(String name, int age) {}
// 自动生成:User u = new User("张三", 25);
System.out.println(u.name()); // 张三

〈2〉继承:is-a关系与方法重写

Java仅支持单继承(extends),通过接口(implements)实现多重继承效果。

⚠️ 注意:

  • 子类构造器必须调用父类构造器(隐式super()或显式super(args));
  • 重写方法需满足:权限不缩小、返回类型兼容、异常不扩大;
  • 避免在构造器中调用可被重写的方法(防止子类字段未初始化)。
class Animal {
    public void speak() {
        System.out.println("动物发声");
    }
}
class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("汪汪");
    }
}

〈3〉多态:动态绑定与方法调用

多态 = 父类引用指向子类对象 + 方法重写 + 动态绑定。

▶ 编译时绑定 vs 运行时绑定:

  • 编译时绑定:静态方法、final方法、private方法;
  • 运行时绑定:实例方法(通过虚方法表vtable实现)。
Animal a = new Dog();
a.speak(); // 输出:汪汪(运行时绑定)

〈4〉接口与抽象类对比

特性接口(interface)抽象类(abstract class)
构造器无可有(供子类调用)
字段默认public static final可有普通字段
方法实现JDK 8+可有default/static方法可有抽象/具体方法
继承限制支持多实现仅单继承
设计目的定义行为契约代码复用与模板

三、集合框架:数据结构与算法的工程化

Java集合框架(JCF)是开发中使用最频繁的API之一。理解其设计思想、性能特征与适用场景,是编写高效程序的关键。

〈1〉List:有序可重复集合

  • ArrayList:基于动态数组,随机访问快(O(1)),插入/删除慢(O(n)),线程不安全;
  • LinkedList:基于双向链表,插入/删除快(O(1)),随机访问慢(O(n)),支持栈/队列操作;
  • Vector:线程安全版ArrayList(同步方法),已过时,建议用Collections.synchronizedList()或CopyOnWriteArrayList。

▶ 示例:List遍历性能对比(100万数据)

long start = System.nanoTime();
for (int i = 0; i < list.size(); i++) {
    list.get(i);
}
long arrayTime = System.nanoTime() - start;
// ArrayList:~5ms;LinkedList:~1200ms(随机访问)

〈2〉Set:无序不可重复集合

  • HashSet:基于HashMap实现,元素必须重写equals()与hashCode();
  • LinkedHashSet:保持插入顺序,内部用LinkedHashMap;
  • TreeSet:有序(自然排序或定制排序),基于红黑树,支持范围查询(subSet()、headSet())。

⚠️ 注意:TreeSet要求元素实现Comparable或传入Comparator,否则抛ClassCastException。

〈3〉Map:键值对映射

  • HashMap:非线程安全,允许null键值(仅1个null键),JDK 8+链表转红黑树(阈值8);
  • LinkedHashMap:保持插入顺序或访问顺序(LRU缓存);
  • TreeMap:有序键集合,基于红黑树;
  • ConcurrentHashMap:线程安全,分段锁(JDK 7)或CAS+synchronized(JDK 8+)。

▶ 示例:HashMap死循环问题(JDK 7)与解决方案

在多线程并发put时,JDK 7的HashMap可能因链表头插法形成环形链表,导致get操作死循环。JDK 8已修复(尾插法+树化),但仍建议使用ConcurrentHashMap或Collections.synchronizedMap()。

〈4〉Queue/Deque:队列与双端队列

  • LinkedList:实现Queue/Deque接口,支持FIFO、LIFO操作;
  • PriorityQueue:优先队列(小顶堆),不保证顺序,仅保证堆顶最小;
  • ArrayDeque:基于循环数组,性能优于LinkedList,推荐优先使用;
  • BlockingQueue:线程安全队列(如LinkedBlockingQueue、ArrayBlockingQueue),用于生产者-消费者模型。

四、并发编程:从线程到线程池

并发编程是Java的强项,也是难点。掌握线程生命周期、内存模型、同步机制与现代并发工具类,是构建高性能服务的基石。

〈1〉线程创建与状态

创建线程三种方式:

  1. 继承Thread类,重写run();
  2. 实现Runnable接口(推荐,避免单继承局限);
  3. 实现Callable接口+FutureTask(支持返回值与异常)。

线程六种状态(Thread.State):

  • NEW:未启动;
  • RUNNABLE:运行中(含操作系统就绪/运行状态);
  • BLOCKED:等待监视器锁;
  • WAITING:无限期等待(wait()、join());
  • TIMED_WAITING:限时等待(sleep()、wait(timeout));
  • TERMINATED:已结束。

〈2〉内存模型与可见性

Java内存模型(JMM)规定:
① 所有变量存储于主内存;
② 每条线程有私有工作内存(缓存主内存变量副本);
③ 线程对变量操作必须在工作内存进行;
④ 不同线程间变量值传递需通过主内存。

解决可见性问题的关键字:

  • volatile:禁止指令重排序,保证内存可见性(不保证原子性);
  • synchronized:保证原子性、可见性、有序性;
  • final:保证对象初始化完成前不被其他线程看到。
volatile boolean flag = false;
new Thread(() -> {
    try { Thread.sleep(1000); } catch (Exception e) {}
    flag = true; // 写入主内存
}).start();
// 主线程循环检测flag,volatile确保及时读到最新值

〈3〉同步机制与锁优化

常见同步工具:

  • synchronized:隐式锁,自动释放;
  • ReentrantLock:显式锁,支持公平锁、可中断、超时;
  • ReadWriteLock:读写分离锁,读读不互斥;
  • CountDownLatch:倒计时器,等待多个线程完成;
  • CyclicBarrier:循环栅栏,等待固定数量线程到达;
  • Semaphore:信号量,控制并发访问数。

▶ 锁优化技巧:

  • 减少锁粒度(分段锁);
  • 使用读写锁(读多写少场景);
  • 避免锁嵌套;
  • 使用CAS(AtomicInteger等)替代synchronized(低竞争场景)。

〈4〉线程池与Executor框架

线程池优势:降低资源消耗、提高响应速度、增强管理性。

推荐使用ThreadPoolExecutor自定义配置:

ExecutorService pool = new ThreadPoolExecutor(
    5, // corePoolSize
    10, // maximumPoolSize
    60, TimeUnit.SECONDS, // keepAliveTime
    new LinkedBlockingQueue<>(100), // workQueue
    new ThreadFactory() {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("worker-" + t.getId());
            return t;
        }
    },
    new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);

⚠️ 注意:禁止使用Executors工厂方法(如newFixedThreadPool),因其可能因无界队列导致OOM。

五、异常处理:防御性编程的艺术

Java异常体系分为三类:
• Checked Exception(编译时异常):如IOException、SQLException,必须处理;
• Unchecked Exception(运行时异常):如NullPointerException、IllegalArgumentException,可不处理;
• Error:如OutOfMemoryError,通常不处理。

〈1〉异常处理最佳实践

  • 仅捕获可恢复的异常,避免“吞异常”(空catch块);
  • 优先使用自定义异常,携带上下文信息;
  • 使用try-with-resources自动关闭资源(实现AutoCloseable接口);
  • 日志记录异常时,使用log.error("描述", e)(包含堆栈)。
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    return br.readLine();
} catch (IOException e) {
    log.error("读取文件失败: {}", e.getMessage(), e);
    throw new RuntimeException("文件读取异常", e);
}

〈2〉自定义异常设计

推荐分层定义异常:

  • 基础异常:如BusinessException(业务逻辑异常);
  • 业务子异常:如UserNotFoundException、InsufficientBalanceException;
  • 异常码体系:统一管理错误码与消息(如ErrorCode.USER_NOT_FOUND)。
public class BusinessException extends RuntimeException {
    private final String errorCode;
    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
    public String getErrorCode() { return errorCode; }
}

六、JVM与性能调优:从字节码到GC

理解JVM是成为高级Java工程师的分水岭。本节聚焦运行时数据区、垃圾回收、性能诊断三方面。

〈1〉JVM内存模型

线程私有区(每个线程独占):

  • 程序计数器:当前执行字节码行号;
  • 虚拟机栈:栈帧(局部变量表、操作数栈等);
  • 本地方法栈:native方法调用。

线程共享区:

  • 堆:对象实例存储区,分新生代(Eden+S0+S1)、老年代;
  • 方法区(JDK 8+:元空间Metaspace):类元数据、常量、静态变量。

▶ 堆溢出常见原因:

  • 内存泄漏(对象被长期引用无法回收);
  • 大对象直接进入老年代;
  • 堆参数设置过小(-Xmx设置不足)。

〈2〉垃圾回收机制

GC算法核心:判断对象是否存活(引用计数→可达性分析)。

常见GC回收器:

回收器适用场景特点
Serial单核CPU,Client模式单线程,STW(Stop-The-World)
ParNew多核Server,新生代Serial的多线程版
Parallel Scavenge高吞吐量关注吞吐量,可自适应调节
CMS低延迟并发清除,浮动垃圾,内存碎片
G1大堆(>4GB),低延迟区域化(Region),可预测停顿
ZGC超大堆(TB级),极低延迟着色指针、读屏障,停顿<10ms

▶ G1调优要点:

  • 设置-XX:MaxGCPauseMillis=200(目标停顿时间);
  • 调整-XX:InitiatingHeapOccupancyPercent(IHOP)避免提前GC;
  • 避免使用-XX:+UseConcMarkSweepGC(G1已替代CMS)。

〈3〉诊断工具链

  • jps:查看Java进程;
  • jstat:监控GC与内存;
  • jmap:生成堆转储(heap dump);
  • jstack:生成线程栈(thread dump);
  • jcmd:多功能诊断工具(推荐);
  • VisualVM:可视化监控与分析。
# 生成堆转储
jmap -dump:format=b,file=heap.hprof <pid>
# 分析堆转储(用VisualVM或Eclipse MAT)

七、设计模式与编码规范

设计模式是前人经验的总结。掌握常用模式,能显著提升代码可维护性与扩展性。

〈1〉高频设计模式

模式场景关键点
单例配置中心、线程池双重检查锁(DCL)+ volatile
工厂创建复杂对象(如Spring Bean)解耦创建与使用
代理AOP、RPC调用JDK动态代理(接口)/CGLIB(类)
模板方法框架流程控制(如Servlet)父类定义骨架,子类实现细节
策略多种算法切换(如支付方式)策略接口+上下文类
观察者事件驱动(如消息订阅)发布-订阅模型

〈2〉编码规范(阿里开发手册要点)

  • 强制:类名使用UpperCamelCase,常量全大写+下划线;
  • 强制:POJO类必须写setter/getter,但布尔字段用isXxx时,getter为isXxx();
  • 强制:所有覆写方法必须加@Override;
  • 推荐:循环中避免重复调用list.size()(先缓存);
  • 推荐:使用Objects.equals()替代==比较对象;
  • 禁止:使用BigDecimal(double)构造器(用String)。

〈3〉反射与注解

反射(Reflection):运行时动态获取类信息、调用方法。常用API:

  • Class.forName("com.xxx.User"):加载类;
  • class.getDeclaredMethods():获取方法;
  • method.invoke(obj, args):调用方法。

注解(Annotation):元数据,用于配置、校验、文档生成。

自定义注解示例:

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
    String message() default "字段不能为空";
}

应用场景:Hibernate验证(@Valid)、Spring依赖注入(@Autowired)、JAX-RS路由(@GET)。