三亩地 三亩地SAN MU DI · CODE DIARY
交流投稿
ARTICLE DETAIL

日记详情

真实记录编程学习的某一天，欢迎挑你感兴趣的翻一翻。

首页/学习日记/日记详情

Java编程入门到精通：从环境搭建到JVM调优的完整知识体系

发布时间：2026/8/12 21:28:37 三亩地 编程学习日记
Java编程入门到精通：从环境搭建到JVM调优的完整知识体系

1. 项目概述：为什么“Java基础”值得你投入时间？

如果你刚打开电脑，准备敲下第一行public static void main(String[] args)，或者已经写了几个月代码，但总觉得对Java的理解浮于表面，那这篇内容就是为你准备的。我们常说的“Java基础编程”，远不止是学会if-else和for循环。它是一套构建健壮、可维护软件的地基，涵盖了从环境搭建、核心语法、面向对象思想，到内存管理、异常处理和常用工具库的完整知识体系。很多开发者工作几年后遇到的瓶颈，比如看不懂框架源码、调优无从下手、设计模式用不起来，追根溯源，往往都是基础不够扎实。

我见过太多人，包括早期的我自己，急于求成，跳过基础直奔Spring Boot、微服务。结果就是，遇到一个NullPointerException要排查半天，不理解集合的底层实现导致性能问题，更别提去设计一个优雅的类结构了。所以，无论你是零基础的在校学生，还是希望夯实根基的初级开发者，花时间把Java基础打牢，是性价比最高的投资。它决定了你未来技术道路的宽度和高度。接下来，我不会照本宣科，而是结合我十多年踩过的坑和项目经验，带你重新梳理一遍那些“看似简单，实则暗藏玄机”的Java基础核心。

2. 核心基石：环境搭建与第一个程序背后的门道

几乎所有教程都会教你下载JDK、配置环境变量、然后写个“Hello World”。但为什么这么做？以及怎么做才能一劳永逸？这里面的细节决定了你后续的学习体验是顺畅还是磕绊。

2.1 JDK选型与安装：不是越新越好

打开Oracle官网，你可能会被琳琅满目的JDK版本搞晕。我的建议是：对于学习和大多数生产环境，选择LTS（长期支持）版本。比如Java 8、Java 11、Java 17。Java 8依然是目前市场占有率最高、生态最成熟的版本，无数线上系统在运行。Java 11和17是后续的LTS版本，引入了很多有用的新特性，如局部变量类型推断（var）、新的HTTP客户端、ZGC垃圾收集器等。对于初学者，我推荐从Java 11开始，它在语法和API上比Java 8现代，又比Java 17更稳定，避开了早期新版本的一些兼容性问题。

安装时，请务必记住你的JDK安装路径。在Windows上，我习惯安装到C:\Java\jdk-11这样的非中文、无空格的目录下。在macOS或Linux上，使用包管理器（如Homebrew, apt）安装会更方便。

2.2 环境变量配置：理解CLASSPATH的今生前世

配置JAVA_HOME和PATH是必须的。JAVA_HOME指向你的JDK安装目录，很多Java应用（如Maven、Tomcat）和IDE（如IntelliJ IDEA）都依赖这个变量来定位Java。

PATH变量是为了让系统在任何位置都能识别java和javac命令。将%JAVA_HOME%\bin(Windows) 或$JAVA_HOME/bin(Unix-like) 添加到PATH中。

至于CLASSPATH，这是一个历史包袱。在早期，你需要手动设置它来告诉JVM去哪里找你自定义的类文件（.class）和第三方jar包。但现在，对于绝大多数情况，你都不需要手动设置全局的CLASSPATH。现代构建工具（Maven、Gradle）和IDE会自动管理依赖的类路径。如果你在命令行编译运行一个简单的程序，可以使用-cp参数来指定。手动设置全局CLASSPATH很容易引发类冲突和找不到类的错误。

注意：在配置环境变量后，一定要打开新的命令行窗口测试。因为环境变量的更改只对新启动的进程生效。使用java -version和javac -version来验证是否配置成功。

2.3 第一个程序：从“Hello World”理解编译与解释

让我们写下经典的HelloWorld.java：

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }

在命令行中，进入文件所在目录，执行：

javac HelloWorld.java # 编译，生成 HelloWorld.class 字节码文件 java HelloWorld # 运行，注意这里没有 .class 后缀

这个过程揭示了Java的核心特性：“编译一次，到处运行”。javac将.java源文件编译成与平台无关的.class字节码文件。java命令则启动Java虚拟机（JVM），JVM负责将字节码解释（或即时编译JIT）成特定平台的机器指令并执行。正是JVM这个中间层，实现了跨平台。

这里有几个新手常踩的坑：

  1. 文件名必须与公共类名完全一致（包括大小写）。public class HelloWorld必须保存在HelloWorld.java中。
  2. 运行命令是java HelloWorld，不是java HelloWorld.class。JVM需要的是类名。
  3. main方法的签名必须一字不差。public static void main(String[] args)是JVM约定的程序入口点。String[] args是用来接收命令行参数的。

3. 语法核心与面向对象思想：写出“Java味”的代码

掌握了基本操作，我们进入语言核心。Java是一门强类型的、纯粹的面向对象语言（尽管有基本数据类型）。理解其设计哲学，才能写出地道的Java代码。

3.1 变量、数据类型与运算符：精度与效率的权衡

Java的数据类型分为两大类：基本数据类型和引用数据类型。

基本数据类型（8种）直接存储在栈内存中，存取速度快。

  • 整型：byte(8),short(16),int(32),long(64)。默认是int，声明long需加L后缀，如long bigNum = 100L;。
  • 浮点型：float(32),double(64)。默认是double，声明float需加F后缀，如float pi = 3.14F;。特别注意：浮点数计算存在精度丢失问题，金融计算必须使用BigDecimal。
  • 字符型：char(16)，使用Unicode编码。
  • 布尔型：boolean，只有true和false。

引用数据类型（类、接口、数组）的变量存储的是对象在堆内存中的地址。例如String str = “hello”;，str这个引用变量在栈上，指向堆中的字符串对象。

运算符除了常见的算术、关系、逻辑运算符，需要特别关注：

  • ==与equals()：==对于基本类型比较值，对于引用类型比较内存地址。equals()用于比较对象的内容是否逻辑相等，但默认实现（Object类中的）也是比较地址，因此像String、Integer这些类都重写了equals()方法。比较字符串内容一定要用"str1".equals(str2)。
  • 三元运算符：条件 ? 值1 : 值2。简洁但嵌套过多会影响可读性。
  • 位运算符：&,|,^,~,<<,>>,>>>。在性能优化、权限控制等底层操作中有用。

3.2 流程控制：不仅仅是顺序执行

if-else、switch、for、while、do-while这些是构建程序逻辑的骨架。我想强调几个实践点：

  • switch表达式（Java 12+）：传统的switch是语句，容易因忘记break而引发“case穿透”。从Java 12开始，switch可以作为表达式使用，并且使用->箭头语法，无需break，更安全简洁。
    String dayType = switch (day) { case "MON", "TUE", "WED", "THU", "FRI" -> "Weekday"; case "SAT", "SUN" -> "Weekend"; default -> "Invalid"; }; // 注意这里有个分号
  • 增强for循环（for-each）：遍历数组或集合的首选，语法简洁，不易出错。
    for (String item : stringList) { System.out.println(item); }
  • 避免在循环体内定义变量：对于for (int i = 0; ...)，i的作用域仅限于循环体内，这是好的。但不要在循环体内反复创建大的临时对象，会给垃圾回收带来压力。

3.3 面向对象编程（OOP）：Java的灵魂

OOP的四大特性：封装、继承、多态、抽象。理解它们，并用好它们。

封装：将数据（属性）和行为（方法）包装在类中，并隐藏内部实现细节。通过private修饰属性，提供公共的getter和setter方法来访问和修改。这不是死板的规定，而是为了控制数据的合法性（可以在setter中校验）和保持类的稳定性。一个类应该只暴露最少必要的接口。

继承：extends关键字。子类继承父类的属性和方法，实现代码复用。但继承是“is-a”关系，要谨慎使用。过度使用继承会导致层次过深，耦合性高。优先考虑组合（has-a）而非继承。比如，Car类有一个Engine对象，而不是继承Engine。

多态：同一操作作用于不同对象，产生不同的执行结果。主要通过方法重写和接口/父类引用指向子类对象来实现。

// 父类 class Animal { void makeSound() { System.out.println("Some sound"); } } // 子类 class Dog extends Animal { @Override void makeSound() { System.out.println("Woof!"); } } Animal myAnimal = new Dog(); // 父类引用指向子类对象 myAnimal.makeSound(); // 输出 "Woof!"，体现了多态

多态是设计模式（如策略模式、工厂模式）和框架扩展性的基础。

抽象：通过抽象类（abstract class）和接口（interface）来定义规范。抽象类可以包含抽象方法（没有实现）和具体方法，用于表示一种“is-a”关系，且可能有部分共同实现。接口在Java 8之前是纯粹的契约（只有抽象方法），现在可以包含默认方法（default method）和静态方法。接口更侧重于定义一种能力或角色。现代Java开发中，倾向于使用接口而非抽象类，因为一个类可以实现多个接口，但只能继承一个类。

3.4 核心类与常用API：不要重复造轮子

Java标准库提供了丰富且强大的API，熟练使用它们能极大提升开发效率。

String、StringBuilder、StringBuffer：

  • String是不可变的。任何修改操作都会产生新的String对象。在循环中拼接字符串务必使用StringBuilder（单线程）或StringBuffer（线程安全，但性能稍差）。
  • 字符串比较用equals()，忽略大小写比较用equalsIgnoreCase()。
  • String.format()或System.out.printf()用于格式化输出，比拼接更清晰。

数组与集合框架：

  • 数组：长度固定，声明时需指定类型和大小。int[] arr = new int[10];
  • 集合框架：位于java.util包。核心接口：Collection(List, Set, Queue) 和Map。
    • List：有序、可重复。常用实现：ArrayList（基于动态数组，随机访问快，增删慢）、LinkedList（基于双向链表，增删快，随机访问慢）。
    • Set：无序、不可重复。常用实现：HashSet（基于HashMap，最快）、LinkedHashSet（保持插入顺序）、TreeSet（基于红黑树，有序）。
    • Map：键值对。常用实现：HashMap（最常用，无序）、LinkedHashMap（保持插入或访问顺序）、TreeMap（基于键排序）、ConcurrentHashMap（线程安全）。
  • 选择原则：需要快速随机访问用ArrayList；需要频繁在头部插入删除用LinkedList；需要去重用HashSet；需要键值对映射用HashMap；需要线程安全考虑ConcurrentHashMap或Collections.synchronizedXXX()包装。

日期时间API：

  • 忘记java.util.Date和java.util.Calendar！它们设计糟糕，非线程安全。
  • 使用Java 8引入的java.time包：LocalDate（日期）、LocalTime（时间）、LocalDateTime（日期时间）、ZonedDateTime（带时区）、Instant（时间戳）、Duration（时间间隔）、Period（日期间隔）。API清晰、不可变、线程安全。
    LocalDate today = LocalDate.now(); LocalDate nextWeek = today.plusDays(7); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); String formatted = today.format(formatter);

4. 深入理解：异常处理、泛型与反射

这部分内容常被认为是“进阶”基础，但它们是写出健壮、灵活代码的关键。

4.1 异常处理：不仅仅是try-catch

Java的异常是Throwable的子类，主要分为Error（系统错误，程序无法处理，如OutOfMemoryError）和Exception（程序可处理的异常）。

Exception又分为受检异常（Checked Exception，如IOException、SQLException）和非受检异常/运行时异常（Unchecked Exception， 如NullPointerException、IllegalArgumentException）。

  • 受检异常：编译器强制要求你必须处理（try-catch）或声明抛出（throws）。这体现了Java的“稳健性”设计，迫使开发者考虑错误情况。但过度使用会导致代码充斥着try-catch，影响可读性。现代框架（如Spring）倾向于使用非受检异常。
  • 非受检异常：通常表示编程错误（如空指针、数组越界、参数不合法），编译器不强制处理。我们应该通过良好的编程实践（如参数校验、使用Optional）来避免它们。

处理原则：

  1. 具体异常优先：不要直接捕获Exception或Throwable，这会掩盖真正的错误。捕获最具体的异常类型。
  2. 不要生吞异常：空的catch块是万恶之源。至少记录日志（e.printStackTrace()仅用于调试，生产环境要用日志框架如SLF4J+Logback）。
  3. 异常信息要明确：抛出自定义异常时，提供有意义的错误信息。
  4. 使用try-with-resources：从Java 7开始，对于实现了AutoCloseable接口的资源（如流、数据库连接），使用此语法可以自动关闭资源，避免内存泄漏。
    try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) { String line = br.readLine(); // ... } catch (IOException e) { // 处理异常 } // 无需手动调用 br.close()，即使发生异常也会自动关闭

4.2 泛型：让类型更安全

泛型提供了编译时类型安全检查，并消除了强制类型转换的麻烦。核心是类型参数化。

// 没有泛型，需要强制转换，不安全 List list = new ArrayList(); list.add("hello"); String str = (String) list.get(0); // 可能抛出ClassCastException // 使用泛型 List<String> list = new ArrayList<>(); list.add("hello"); String str = list.get(0); // 安全，自动类型推断

泛型通配符：

  • <?>：无界通配符，表示可以接受任何类型。List<?> list可以引用一个List<String>，但你不能向其中添加元素（除了null），因为编译器不知道具体类型。
  • <? extends T>：上界通配符，表示类型是T或其子类。常用于生产者（Producer），即你主要从集合中读取元素。
    void printList(List<? extends Number> list) { for (Number n : list) { // 可以安全地读取为Number System.out.println(n); } // list.add(new Integer(1)); // 编译错误！不能添加 }
  • <? super T>：下界通配符，表示类型是T或其父类。常用于消费者（Consumer），即你主要向集合中写入元素。
    void addNumbers(List<? super Integer> list) { list.add(new Integer(1)); // 可以安全地添加Integer // Integer i = list.get(0); // 编译错误！读取出来是Object }

记住PECS原则（Producer Extends, Consumer Super），它能帮你正确使用通配符。

4.3 反射：框架的基石

反射机制允许程序在运行时获取类的信息（类名、方法、字段、注解等）并操作它们。Spring、Hibernate等框架大量使用反射来实现依赖注入、对象关系映射等功能。

Class<?> clazz = Class.forName("com.example.Person"); // 获取Class对象 Object obj = clazz.newInstance(); // 创建实例（已过时，推荐getConstructor().newInstance()） Method method = clazz.getMethod("setName", String.class); // 获取方法 method.invoke(obj, "Alice"); // 调用方法 Field field = clazz.getDeclaredField("age"); // 获取字段（包括私有） field.setAccessible(true); // 设置可访问，突破私有限制 field.set(obj, 25);

反射的优缺点：

  • 优点：灵活性极高，可以实现动态创建对象、调用方法、实现通用框架。
  • 缺点：
    1. 性能开销：反射操作比直接的Java代码慢得多，因为涉及动态解析。
    2. 安全限制：可以突破私有访问限制，破坏了封装性。
    3. 内部暴露：使得代码难以理解和维护。

使用建议：在普通业务代码中尽量避免使用反射。它主要是框架和工具库的利器。如果必须用，可以考虑缓存Class、Method等对象来提升性能。

5. 内存管理与JVM基础：从“能用”到“用好”

理解Java内存模型和垃圾回收，是进行性能调优、解决内存泄漏和OOM（OutOfMemoryError）问题的前提。

5.1 JVM内存区域划分

JVM运行时数据区主要分为以下几部分：

  • 程序计数器：线程私有，指向当前线程正在执行的字节码指令地址。
  • Java虚拟机栈：线程私有，每个方法执行会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等。我们常说的“栈内存”主要指这里。StackOverflowError通常就是递归太深导致栈帧过多。
  • 本地方法栈：为Native方法服务。
  • Java堆：线程共享，几乎所有对象实例和数组都在这里分配内存。是垃圾回收的主要区域。OutOfMemoryError: Java heap space错误就发生在这里。
  • 方法区：线程共享，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等。在HotSpot VM中也被称为“永久代”（Java 7及之前）或“元空间”（Java 8+）。OutOfMemoryError: Metaspace表示元空间不足。
  • 运行时常量池：方法区的一部分，存放编译期生成的各种字面量和符号引用。

5.2 垃圾回收机制

垃圾回收（GC）自动管理堆内存，回收不再被引用的对象。核心是可达性分析算法：通过一系列称为“GC Roots”的对象作为起点，向下搜索，走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象不可用，可以被回收。

GC Roots包括：虚拟机栈中引用的对象、方法区中静态属性引用的对象、方法区中常量引用的对象、本地方法栈中JNI引用的对象等。

垃圾收集器：HotSpot JVM提供了多种收集器，如Serial、Parallel、CMS、G1、ZGC、Shenandoah。对于初学者，知道以下两点即可：

  1. 年轻代和老年代：堆内存通常分为年轻代和老年代。新创建的对象在年轻代。经历多次GC后仍存活的对象会晋升到老年代。
  2. Minor GC和Full GC：发生在年轻代的GC叫Minor GC，速度快。发生在整个堆（包括老年代和年轻代）的GC叫Full GC，速度慢，通常伴随“Stop-The-World”（STW），即所有应用线程暂停。

内存泄漏场景：即使有GC，内存泄漏也可能发生。常见原因：

  • 静态集合类：如static Map持续添加对象而不移除。
  • 连接未关闭：数据库连接、网络连接、文件流未在finally块或try-with-resources中关闭。
  • 监听器未注销：注册了事件监听器，对象不用后未注销。
  • 内部类持有外部类引用：非静态内部类会隐式持有外部类实例的引用。如果这个内部类对象被长生命周期对象引用，会导致外部类也无法被回收。

5.3 性能监控与基础调优思路

当程序变慢或出现OOM时，需要一些工具和思路。

  1. 使用JDK自带工具：

    • jps：查看Java进程ID。
    • jstat：查看JVM统计信息，如GC情况。jstat -gc <pid> 1000 10每1秒打印一次GC信息，共10次。
    • jmap：生成堆转储快照。jmap -dump:format=b,file=heap.hprof <pid>用于分析内存泄漏。
    • jstack：打印线程堆栈快照。jstack <pid>用于分析死锁、线程阻塞。
    • jconsole/jvisualvm：图形化监控工具，更直观。

  2. 分析堆转储：使用Eclipse MAT或JProfiler打开heap.hprof文件，分析哪些对象占用了大量内存，以及它们的引用链。

  3. 常见调优参数：

    • -Xms和-Xmx：设置堆的初始大小和最大大小。通常设为相同值，避免堆动态调整带来的性能波动。例如-Xms4g -Xmx4g。
    • -Xmn：设置年轻代大小。增大年轻代可以减少Minor GC频率，但会缩小老年代，可能增加Full GC频率。
    • -XX:+UseG1GC：指定使用G1垃圾收集器（JDK 9+默认）。对于大内存、低延迟要求的应用，G1是不错的选择。更前沿的ZGC和Shenandoah追求极低延迟（亚毫秒级STW）。
    • -XX:+HeapDumpOnOutOfMemoryError和-XX:HeapDumpPath：在发生OOM时自动生成堆转储文件。

注意：调优没有银弹，需要根据应用特点（如对象生命周期、吞吐量优先还是延迟优先）进行测试和调整。切忌盲目复制别人的参数。

6. 开发工具与生态：工欲善其事，必先利其器

掌握了语言本身，高效的开发工具和构建管理工具能让你事半功倍。

6.1 集成开发环境：IDEA vs Eclipse

IntelliJ IDEA目前是Java社区的事实标准，特别是Ultimate版，对Spring、微服务、数据库等企业级开发支持极好。它的智能代码补全、重构、代码分析、调试功能都非常强大。社区版对于纯Java和Android开发也足够。学习成本稍高，但一旦习惯，效率提升巨大。

Eclipse是老牌IDE，免费开源，插件生态丰富。在一些传统企业或特定领域（如嵌入式）仍有使用。它的界面和操作逻辑与IDEA有较大差异。

我的建议：新手可以从IDEA社区版开始。它的默认设置和智能提示对学习非常友好。记住一些常用快捷键（如psvm生成main方法，sout生成打印语句，Ctrl+Alt+L格式化代码）能极大提升编码速度。

6.2 构建工具：Maven与Gradle

现代Java项目几乎不再手动管理jar包和编译路径。

Maven：基于XML（pom.xml）的声明式构建工具。核心概念是坐标（groupId, artifactId, version）和仓库。它规范了项目结构，管理依赖和生命周期（clean, compile, test, package, install等）。缺点是XML比较冗长，复杂的自定义构建逻辑编写起来麻烦。

Gradle：基于Groovy或Kotlin DSL的构建工具。脚本更简洁灵活，执行效率通常比Maven高。Android开发默认使用Gradle。它的学习曲线比Maven陡峭一些。

如何选择：如果你是初学者，或者项目组统一使用Maven，那就学Maven。如果你想追求更灵活的构建和更快的速度，或者接触Android/Kotlin多，可以学Gradle。但两者思想相通，精通一个，另一个很容易上手。

6.3 单元测试：JUnit 5

写测试不是浪费时间，而是保证代码质量、促进重构、作为文档的最佳实践。JUnit是Java单元测试的标准框架。

JUnit 5架构清晰，由JUnit Platform（启动测试）、JUnit Jupiter（新编程模型）、JUnit Vintage（兼容JUnit 4）组成。

一个简单的测试示例：

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; class CalculatorTest { @Test void testAddition() { Calculator calc = new Calculator(); int result = calc.add(2, 3); assertEquals(5, result, "2 + 3 should equal 5"); } @Test @DisplayName("测试边界情况：大数相加") void testAdditionWithLargeNumbers() { Calculator calc = new Calculator(); int result = calc.add(Integer.MAX_VALUE, 0); assertEquals(Integer.MAX_VALUE, result); } }

测试要点：

  • 测试方法用@Test标注，最好是public void，方法名描述清楚测试意图。
  • 使用assertEquals,assertTrue,assertThrows等断言方法。
  • 可以使用@BeforeEach（每个测试前执行）、@AfterEach（每个测试后执行）、@BeforeAll（所有测试前执行一次）、@AfterAll（所有测试后执行一次）来初始化和清理资源。
  • 追求高测试覆盖率，但更重要的是测试用例的质量（覆盖正常路径、边界条件、异常情况）。

7. 常见问题与避坑指南实录

这里汇总了新手，甚至一些有经验的开发者常遇到的问题和解决方案。

7.1 环境与配置类问题

问题1：‘java’ 不是内部或外部命令

  • 原因：PATH环境变量未正确配置，或配置后未重启命令行。
  • 解决：检查JAVA_HOME和PATH。在命令行输入echo %JAVA_HOME%(Win) 或echo $JAVA_HOME(Mac/Linux) 查看。确保PATH中包含%JAVA_HOME%\bin。修改后关闭所有命令行窗口重新打开。

问题2：编码GBK的不可映射字符

  • 原因：源代码文件（.java）保存的编码与javac编译器使用的默认编码不一致。Windows中文系统默认GBK，而源代码可能是UTF-8。
  • 解决：
    1. 编译时指定编码：javac -encoding UTF-8 HelloWorld.java
    2. 永久设置：在IDE（如IDEA）中，将项目文件编码设置为UTF-8。File -> Settings -> Editor -> File Encodings，将Global Encoding、Project Encoding、Default encoding for properties files都设为UTF-8。

问题3：Lombok注解不生效，提示“找不到符号”或“未使用lombok支持的编译器”

  • 原因：IDE没有启用Lombok的注解处理器。
  • 解决：
    1. 确保项目中已添加Lombok依赖（Maven或Gradle）。
    2. 对于IntelliJ IDEA：需要安装Lombok插件。File -> Settings -> Plugins，搜索Lombok并安装。然后启用注解处理：Settings -> Build, Execution, Deployment -> Compiler -> Annotation Processors，勾选 “Enable annotation processing”。
    3. 对于Eclipse：需要将lombok.jar手动添加到Eclipse中（双击运行），然后重启Eclipse。

7.2 语法与运行时类问题

问题4：NullPointerException（空指针异常）

  • 原因：尝试调用一个null引用对象的方法或访问其字段。
  • 预防与排查：
    1. 防御性编程：对可能为null的参数或返回值进行判空。
    2. 使用Objects.requireNonNull()：在方法开头校验参数。
      public void process(String input) { Objects.requireNonNull(input, "input参数不能为null"); // ... 后续处理 }
    3. 使用Optional：Java 8引入，明确表示一个值可能为空，强制调用者处理空情况。
      Optional<String> optional = Optional.ofNullable(getString()); String result = optional.orElse("default"); // 如果为空，返回默认值
    4. IDE辅助：现代IDE可以对可能为null的访问给出警告。

问题5：ClassNotFoundException或NoClassDefFoundError

  • 区别：
    • ClassNotFoundException：发生在运行时尝试通过字符串名加载类时（如Class.forName()或类加载器的loadClass方法），但classpath中找不到对应的.class文件。通常是依赖缺失或路径错误。
    • NoClassDefFoundError：发生在链接阶段。JVM在编译时能找到这个类，但运行时找不到它的定义。可能的原因包括：类初始化失败（静态块抛出异常）、依赖的类文件在编译后被删除、jar包版本冲突等。
  • 解决：检查类路径（CLASSPATH），确保所有必需的jar包或目录都在其中。使用Maven/Gradle时，检查依赖是否正确声明和下载。

问题6：OutOfMemoryError: Java heap space

  • 原因：堆内存不足，无法分配新对象。
  • 排查步骤：
    1. 使用-Xmx增大堆内存（治标不治本）。
    2. 使用jmap -dump生成堆转储，用MAT等工具分析，找到内存占用最大的对象和引用链，判断是内存泄漏（对象该释放没释放）还是内存溢出（业务量太大，正常对象过多）。
    3. 常见泄漏点：大对象缓存（如本地缓存）无限增长、资源未关闭、监听器未注销、静态集合持续添加。

问题7：ConcurrentModificationException

  • 原因：在使用迭代器（如增强for循环底层就是迭代器）遍历集合时，直接通过集合的方法（非迭代器的remove方法）修改了集合的结构（增删元素）。
    List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c")); for (String s : list) { if ("b".equals(s)) { list.remove(s); // 这里会抛出 ConcurrentModificationException } }
  • 解决：
    1. 使用迭代器自己的remove方法。
      Iterator<String> it = list.iterator(); while (it.hasNext()) { String s = it.next(); if ("b".equals(s)) { it.remove(); // 正确 } }
    2. 使用Java 8的Collection.removeIf方法。
      list.removeIf(s -> "b".equals(s));
    3. 遍历时记录需要删除的元素，遍历完再统一删除（适用于非迭代器遍历）。
    4. 使用CopyOnWriteArrayList等并发集合（适用于读多写少的并发场景）。

7.3 思维与设计类问题

问题8：面向过程思维，滥用静态方法和全局变量

  • 表现：写出来的Java代码像C语言，所有逻辑都写在static方法里，大量使用静态变量在不同方法间传递状态。
  • 危害：代码耦合度高，难以测试（静态方法难以Mock），状态混乱，不符合面向对象封装的原则。
  • 改进：将相关数据和操作封装成对象。使用实例方法和实例变量。遵循“高内聚、低耦合”的原则。如果需要全局状态或工具方法，考虑使用单例模式（谨慎使用）或依赖注入框架（如Spring）。

问题9：不理解接口与抽象类的区别，滥用继承

  • 表现：为了复用代码，随意使用继承，导致类层次结构复杂、脆弱。
  • 原则：
    • “is-a”关系用继承：狗是一种动物（Dog extends Animal）。
    • “has-a”关系用组合：汽车有一个发动机（Car has an Engine）。
    • 定义行为契约用接口：会飞的行为（interface Flyable）。
  • 建议：多思考组合和聚合。优先定义接口来解耦。使用继承时，确保子类真的是父类的一种特殊化，并且要小心处理父类方法的覆盖。

问题10：忽视异常处理的正确姿势

  • 表现：要么throws Exception一抛了之，要么catch住后什么都不做（e.printStackTrace()也算“什么都不做”，因为它只是打印到控制台，生产环境看不到）。
  • 正确做法：
    • 受检异常，如果当前层级知道如何处理（如重试、返回默认值），就处理掉。
    • 如果不知道，考虑是否应转换为非受检异常向上抛。例如，DAO层的SQLException可以包装成RuntimeException或自定义的DataAccessException抛给服务层。
    • 始终记录异常日志，使用日志框架记录完整的错误堆栈和上下文信息。
    • 给用户的错误信息应该是友好的，而不是原始的异常信息。

掌握Java基础是一个持续的过程，它不仅仅是记忆语法，更是理解其设计哲学和最佳实践。从写出能运行的代码，到写出高效、健壮、易维护的代码，中间隔着对这些基础知识的深刻理解和反复实践。希望这篇结合了实战经验和避坑指南的梳理，能帮你少走弯路，更扎实地迈出Java编程的第一步。剩下的，就是在具体的项目中去应用、去踩坑、去总结了。编程没有捷径，但正确的方向和持续的努力，会让你走得更远。

编程学习 学习日记 实战经验
← 返回列表