本 java 基础教程 专为初学者与希望夯实基础的开发者设计,以 JDK 17(LTS)为基准,系统覆盖 Java 语言核心语法、面向对象思想、常用类库、异常处理、集合框架、输入输出、多线程编程、JVM 内存模型及主流开发工具链。内容坚持“理论精讲 + 可运行示例 + 常见误区辨析 + 工程实践建议”四维一体,避免泛泛而谈,注重代码可读性与健壮性。
我们深知:java 基础教程 不是语法罗列,而是编程思维的启蒙与工程规范的奠基。一个合格的 Java 工程师,其成长路径必然始于扎实的语法理解、深入的对象建模能力、对 JVM 行为的敬畏之心,以及对工具链的熟练掌控。本教程不承诺速成,但承诺:每一段代码都可运行、每处细节都经推敲、每项原理都附图解或类比。
全站采用语义化 HTML5 标签构建,严格遵循 W3C 规范,确保在移动端、平板、桌面端自适应显示;所有示例均经实际编译测试(javac 17.0.2),支持 Ctrl+C/V 后直接运行。建议搭配 java 基础教程 的配套练习与调试实践同步学习。
初学者常陷入“学完语法就刷题”或“只看视频不动手”的误区。我们推荐分四阶段渐进:
每个阶段结束请完成:
① 重写所有示例(不看原文)
② 修改参数观察行为变化
③ 故意制造错误并阅读报错信息
④ 用自然语言描述代码执行流程
这四步是将知识内化的关键。
Java 语法看似简单,但细节决定代码质量。以下聚焦初学者易混淆点,结合 JDK 17 实际行为说明。
Java 分为 基本类型(8种)与 引用类型(类/接口/数组)。注意:
public class DefaultValueDemo { static int staticInt; // 默认0 static boolean staticBool; // 默认false static String staticStr; // 默认null public static void main(String[] args) { int localInt; // 编译错误:变量 localInt 可能尚未初始化 System.out.println(localInt); // ❌ } }
java 基础教程 强调:String 是不可变类(immutable),其值存储在字符串常量池(String Pool)中。
public class StringPoolDemo { public static void main(String[] args) { String s1 = "Hello"; String s2 = "Hello"; String s3 = "He" + "llo"; // 编译期常量折叠 → "Hello" String s4 = new String("Hello"); String s5 = "H"; String s6 = s5 + "ello"; // 运行期拼接 → 堆中新建对象 System.out.println(s1 == s2); // true:同一常量池对象 System.out.println(s1 == s3); // true:常量折叠结果 System.out.println(s1 == s4); // false:堆中新建对象 System.out.println(s1 == s6); // false:运行期拼接 System.out.println(s1.equals(s6)); // true:内容相同 } }
⚠️ 避免在循环中用 + 拼接字符串,应使用 StringBuilder(单线程)或 StringBuffer(多线程)。
JDK 12+ 支持 switch 表达式与箭头语法:
int score = 85; String grade = switch (score / 10) { case 10, 9 → "A"; case 8 → "B"; case 7, 6 → "C"; default → "D"; }; System.out.println(grade); // 输出:B
相比传统 switch:① 支持 break 省略(箭头自动返回)② 可直接返回值 ③ case 值可重复(但逻辑需合理)
面向对象(OOP)不是语法,而是建模世界的方式。三大特征:封装、继承、多态。
封装通过 private 字段 + public 方法实现,确保数据安全与一致性。
class Student { private String name; private int age; public String getName() { return name; } public void setName(String name) { if (name == null || name.isEmpty()) throw new IllegalArgumentException("姓名不能为空"); this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age < 0 || age > 150) throw new IllegalArgumentException("年龄不合法"); this.age = age; } }
关键点:setAge 中的校验防止非法数据写入;private 阻止外部直接访问字段,保证封装完整性。
Java 单继承(一个类只能 extends 一个父类),接口多实现(implements)。避免滥用继承:
class Vehicle { public void start() { System.out.println("Vehicle started"); } } class Car extends Vehicle { public void start() { // 方法重写 System.out.println("Car engine starting..."); super.start(); // 调用父类方法 } }
⚠️ 重写时注意:① 访问修饰符不严于父类 ② 返回类型兼容 ③ 异常不扩大
多态三要素:父类引用指向子类对象 + 方法重写 + 动态绑定。
public class PolymorphismDemo { static class Animal { public void sound() { System.out.println("Animal sound"); } } static class Dog extends Animal { public void sound() { System.out.println("Woof"); } } static class Cat extends Animal { public void sound() { System.out.println("Meow"); } } public static void makeSound(Animal a) { a.sound(); // 运行时决定调用 Dog.sound() 还是 Cat.sound() } public static void main(String[] args) { makeSound(new Dog()); // 输出:Woof makeSound(new Cat()); // 输出:Meow } }
多态是框架设计的基石(如:Spring 的 BeanPostProcessor)。
集合框架是 Java 开发最常用 API,需掌握:接口层次结构 + 典型实现类特性 + 适用场景。
ArrayList:基于动态数组,随机访问快(O(1)),插入/删除慢(O(n))
LinkedList:基于双向链表,插入/删除快(O(1)),随机访问慢(O(n))
⚠️ 遍历时删除元素的正确方式:
List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); // 错误:for-each 中 remove 会抛 ConcurrentModificationException // 正确:使用迭代器或倒序遍历 for (int i = list.size() - 1; i >= 0; i--) { if (list.get(i).equals("B")) list.remove(i); } System.out.println(list); // [A, C]
HashMap:非线程安全,允许 null 键/值;JDK 8+ 链表转红黑树(阈值8)
TreeMap:有序(自然顺序或自定义 Comparator),基于红黑树
ConcurrentHashMap:线程安全,分段锁(JDK 8 改为 CAS + synchronized)
⚠️ HashMap 扩容机制:默认容量 16,负载因子 0.75。当 size > 16×0.75=12 时触发扩容(2倍)。
Map<String, Integer> map = new HashMap<>(); map.put("Apple", 1); map.put("Banana", 2); // 遍历方式1:entrySet for (var entry : map.entrySet()) { System.out.println(entry.getKey() + " → " + entry.getValue()); } // 遍历方式2:lambda map.forEach((k, v) → System.out.println(k + ": " + v));
HashSet:基于 HashMap 实现,元素作为 key 存储
LinkedHashSet:维护插入顺序
TreeSet:有序(基于红黑树),要求元素可比较
⚠️ 自定义类放入 HashSet 需重写 equals() 和 hashCode()!否则可能存入重复对象。
class Person { String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } // 错误示例:未重写 hashCode → HashSet 可能存入两个 name="Tom" 的对象 @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); // 与 equals 逻辑一致 } }
多线程是 Java 的核心能力,但也是高风险领域。必须理解:线程状态、同步机制、内存可见性。
NEW → RUNNABLE(含就绪+运行)→ BLOCKED/WAITING/TIMED_WAITING → TERMINATED
示例:sleep 不释放锁,wait 会释放锁。
三种用法:
① 实例方法:锁当前对象(this)
② 静态方法:锁 Class 对象
③ 代码块:锁指定对象
class Counter { private int count = 0; // 错误:非线程安全 // public void increment() { count++; } // 非原子操作 // 正确:同步实例方法 public synchronized void increment() { count++; } // 正确:同步代码块(推荐,粒度更细) public void decrement() { synchronized(this) { count--; } } public int getCount() { return count; } }
⚠️ 注意:同步的是对象,不同对象实例的同步方法互不影响!
保证内存可见性(线程工作内存 → 主内存立即刷新),但不保证原子性。
class VisibilityDemo { private volatile boolean flag = false; public void writer() { flag = true; // 写入主内存 } public void reader() { while (!flag) { // 读取主内存,避免死循环 Thread.yield(); } System.out.println("Flag is true"); } }
典型场景:单例模式的双重检查锁(DCL)中,实例字段必须用 volatile 修饰!
Java IO 分为字节流(InputStream/OutputStream)与字符流(Reader/Writer)。核心原则:用完即关。
FileReader reader = null; try { reader = new FileReader("input.txt"); int ch; while ((ch = reader.read()) != -1) { System.out.print((char) ch); } } catch (IOException e) { e.printStackTrace(); } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { e.printStackTrace(); } } }
问题:代码冗长、异常嵌套处理复杂。
自动调用 close()(需实现 AutoCloseable 接口):
try (FileReader reader = new FileReader("input.txt"); BufferedReader br = new BufferedReader(reader)) { String line; while ((line = br.readLine()) != null) { System.out.println(line); } } catch (IOException e) { e.printStackTrace(); }
✅ 推荐使用,避免资源泄露。
Path/Files/Paths 提供更简洁的文件操作:
// 读取文件所有行 List<String> lines = Files.readAllLines(Paths.get("input.txt"), StandardCharsets.UTF_8); // 写入文件(覆盖) Files.write(Paths.get("output.txt"), "Hello NIO".getBytes(StandardCharsets.UTF_8)); // 遍历目录 try (Stream<Path> paths = Files.walk(Paths.get("."))) { paths.filter(Files::isRegularFile) .forEach(System.out::println); }
异常分三类:
① Error:JVM 严重错误(如 OutOfMemoryError),不可恢复
② Checked Exception:编译期必须处理(如 IOException)
③ RuntimeException:运行时异常(如 NullPointerException),可不处理
捕获异常后重新抛出时,必须保留原始异常信息:
try { // 可能抛出 IOException } catch (IOException e) { throw new ServiceException("文件处理失败", e); // 保留原始异常 }
✅ 正确:e.printStackTrace() 会显示完整调用链
❌ 错误:throw new ServiceException("文件处理失败");丢失原始异常上下文
业务异常应继承 RuntimeException(避免强制 checked 处理):
public class BusinessException extends RuntimeException { public BusinessException(String message) { super(message); } public BusinessException(String message, Throwable cause) { super(message, cause); } }
使用场景:用户余额不足、库存不足等业务规则违反。
理解 JVM 内存是排查 OOM、GC 问题的基础。运行时数据区包括:
📌 典型 OOM 场景:
① 堆溢出:无限创建对象(如缓存未清理)
② 元空间溢出:动态生成大量类(如反射滥用)
③ 栈溢出:递归调用无终止条件
1. 类加载检查(是否已加载)
2. 分配内存(指针碰撞 / 空闲列表)
3. 初始化零值
4. 设置对象头(哈希码、GC 分代年龄、锁状态等)
5. 执行 init 方法(构造函数)
高效开发依赖工具链:JDK → IDE → 构建工具 → 调试技巧。
当前主流 LTS 版本:
• JDK 8:最广泛使用(2014),但已停止公开更新(商业需授权)
• JDK 11:2018,现代特性(var、HttpClient)
• JDK 17:2021,最新 LTS,支持 records/sealed classes/pattern matching
推荐新项目使用 JDK 17,老项目逐步升级(注意兼容性)。
• IntelliJ IDEA:功能最全,智能提示强,插件丰富
• Eclipse:老牌 IDE,轻量级但功能较弱
• VS Code + Java Extension Pack:轻量、跨平台,适合小项目
必备插件:
• Lombok(减少样板代码)
• Alibaba Java Coding Guidelines(代码规范检查)
• MyBatis Log Plugin(SQL 日志格式化)
• 断点类型:条件断点(右键断点 → Condition)、字段断点(Watch Field)
• 表达式求值(Evaluate Expression):实时计算表达式结果
• 日志替代:System.out → SLF4J(生产环境必须用日志框架)
以下问题均来自一线互联网公司校招/社招真题,附深度解答。
原因:
① 字符串常量池:共享字符串对象,节省内存
② 线程安全:多线程读取无需同步
③ 安全性:防止恶意代码修改关键字符串(如数据库 URL)
④ 哈希码缓存:hashCode() 可缓存,提升 HashMap 性能
可变替代:
• StringBuilder(单线程)
• StringBuffer(多线程)
HashMap 本身非线程安全!线程安全替代方案:
① ConcurrentHashMap:JDK 8+ 用 CAS + synchronized(分段锁升级)
② Collections.synchronizedMap(new HashMap<>()):全局 synchronized,性能差
③ Hashtable:过时,所有方法 synchronized,已不推荐
📌 注意:ConcurrentHashMap 的 key/value 不允许为 null!
| 特性 | volatile | synchronized |
|---|---|---|
| 可见性 | 保证 | 保证 |
| 原子性 | ❌ 不保证 | ✅ 保证 |
| 阻塞 | ❌ 无阻塞 | ✅ 线程阻塞 |
| 锁类型 | 无锁 | 对象锁/类锁 |
| 适用场景 | 状态标志、单次发布 | 复合操作、临界区 |