java 基础教程

本 java 基础教程 专为初学者与希望夯实基础的开发者设计,以 JDK 17(LTS)为基准,系统覆盖 Java 语言核心语法、面向对象思想、常用类库、异常处理、集合框架、输入输出、多线程编程、JVM 内存模型及主流开发工具链。内容坚持“理论精讲 + 可运行示例 + 常见误区辨析 + 工程实践建议”四维一体,避免泛泛而谈,注重代码可读性与健壮性。

我们深知:java 基础教程 不是语法罗列,而是编程思维的启蒙与工程规范的奠基。一个合格的 Java 工程师,其成长路径必然始于扎实的语法理解、深入的对象建模能力、对 JVM 行为的敬畏之心,以及对工具链的熟练掌控。本教程不承诺速成,但承诺:每一段代码都可运行、每处细节都经推敲、每项原理都附图解或类比。

全站采用语义化 HTML5 标签构建,严格遵循 W3C 规范,确保在移动端、平板、桌面端自适应显示;所有示例均经实际编译测试(javac 17.0.2),支持 Ctrl+C/V 后直接运行。建议搭配 java 基础教程 的配套练习与调试实践同步学习。

· 学习路径建议 ·

初学者常陷入“学完语法就刷题”或“只看视频不动手”的误区。我们推荐分四阶段渐进:

  1. 语法筑基(1~2周):变量、运算符、流程控制(if/for/while)、方法定义与重载、数组;重点理解“值传递”与“引用传递”的区别
  2. 面向对象(2~3周):类与对象、封装/继承/多态、抽象类与接口、内部类、枚举;用“学生-课程-成绩”建模练习封装
  3. 核心类库(2~3周):String/Wrapper/日期、Math、System;重点掌握 StringBuilder、LocalDateTime、Optional;集合框架(List/Map/Set)必须手写遍历+修改陷阱示例
  4. 进阶机制(2周+):异常体系、泛型原理、注解、反射;多线程(线程状态、synchronized、volatile、线程池)、IO/NIO;JVM 内存模型(堆/栈/方法区)是理解 GC 与 OOM 的前提

每个阶段结束请完成:
① 重写所有示例(不看原文)
② 修改参数观察行为变化
③ 故意制造错误并阅读报错信息
④ 用自然语言描述代码执行流程
这四步是将知识内化的关键。

· 本教程特色 ·

  • 深度示例驱动:每节含 2~4 个可运行示例,覆盖典型场景(如:集合遍历时删除元素的正确方式)
  • 误区警示框:标注高频错误点(如:== vs equals()、HashMap 扩容时机)
  • 性能对比表:ArrayList vs LinkedList 在不同操作下的时间复杂度实测数据
  • 工程规范嵌入:命名规范、日志使用、异常链保留、资源关闭模板
  • 面试关联点:标注常考概念(如:String 不可变性、HashMap 线程安全、volatile 原理)

一、java 基础教程:语法核心与常见陷阱

Java 语法看似简单,但细节决定代码质量。以下聚焦初学者易混淆点,结合 JDK 17 实际行为说明。

1.1 数据类型与默认值

Java 分为 基本类型(8种)与 引用类型(类/接口/数组)。注意:

  • 局部变量(方法内定义)必须显式初始化,否则编译报错
  • 成员变量(类中方法外定义)有默认值:
     整数类型 → 0;浮点 → 0.0;char → '\u0000';boolean → false;引用 → null
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);  // ❌
    }
}

常见问题

  • Q:为什么 char 类型默认值是 '\u0000' 而不是空格?
    A:'\u0000' 是 Unicode 空字符(NUL),ASCII 值为 0;空格是 ' '(ASCII 32)
  • Q:包装类型(如 Integer)默认值是什么?
    A:null!因它是引用类型,未赋值时无对象引用

1.2 字符串与常量池

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(多线程)。

1.3 流程控制:switch 新特性

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 值可重复(但逻辑需合理)

二、java 基础教程:面向对象核心思想

面向对象(OOP)不是语法,而是建模世界的方式。三大特征:封装、继承、多态。

2.1 封装:数据与操作的绑定

封装通过 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 阻止外部直接访问字段,保证封装完整性。

2.2 继承:is-a 关系的建模

Java 单继承(一个类只能 extends 一个父类),接口多实现(implements)。避免滥用继承:

  • 正确:Apple → Fruit(is-a)
  • 错误:Car → Engine(has-a,应使用组合)
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(); // 调用父类方法
    }
}

⚠️ 重写时注意:① 访问修饰符不严于父类 ② 返回类型兼容 ③ 异常不扩大

2.3 多态:同一操作,不同行为

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

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 基础教程:集合框架深度解析

集合框架是 Java 开发最常用 API,需掌握:接口层次结构 + 典型实现类特性 + 适用场景。

3.1 List:有序可重复集合

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]

3.2 Map:键值对映射

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));

3.3 Set:无序不重复集合

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 基础教程:多线程编程实战

多线程是 Java 的核心能力,但也是高风险领域。必须理解:线程状态、同步机制、内存可见性。

4.1 线程状态流转

NEW → RUNNABLE(含就绪+运行)→ BLOCKED/WAITING/TIMED_WAITING → TERMINATED

  • WAITING:调用 Object.wait()、Thread.join()、LockSupport.park()
  • TIMED_WAITING:带超时参数的 wait/join/park 或 Thread.sleep()
  • BLOCKED:等待 synchronized 锁

示例:sleep 不释放锁,wait 会释放锁。

4.2 synchronized 关键字

三种用法:
① 实例方法:锁当前对象(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; }
}

⚠️ 注意:同步的是对象,不同对象实例的同步方法互不影响!

4.3 volatile 关键字

保证内存可见性(线程工作内存 → 主内存立即刷新),但不保证原子性。

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 流与资源管理

Java IO 分为字节流(InputStream/OutputStream)与字符流(Reader/Writer)。核心原则:用完即关。

5.1 传统 IO:try-finally

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(); }
    }
}

问题:代码冗长、异常嵌套处理复杂。

5.2 try-with-resources(JDK 7+)

自动调用 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();
}

✅ 推荐使用,避免资源泄露。

5.3 NIO.2(JDK 7+)

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);
}

六、java 基础教程:异常处理体系

异常分三类:
① Error:JVM 严重错误(如 OutOfMemoryError),不可恢复
② Checked Exception:编译期必须处理(如 IOException)
③ RuntimeException:运行时异常(如 NullPointerException),可不处理

6.1 异常链保留

捕获异常后重新抛出时,必须保留原始异常信息:

try {
    // 可能抛出 IOException
} catch (IOException e) {
    throw new ServiceException("文件处理失败", e); // 保留原始异常
}

✅ 正确:e.printStackTrace() 会显示完整调用链
❌ 错误:throw new ServiceException("文件处理失败");丢失原始异常上下文

6.2 自定义异常

业务异常应继承 RuntimeException(避免强制 checked 处理):

public class BusinessException extends RuntimeException {
    public BusinessException(String message) {
        super(message);
    }
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

使用场景:用户余额不足、库存不足等业务规则违反。

七、java 基础教程:JVM 内存模型详解

理解 JVM 内存是排查 OOM、GC 问题的基础。运行时数据区包括:

  • 程序计数器:线程私有,记录当前执行字节码指令地址
  • Java 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等)
      → 栈溢出(StackOverflowError):递归过深
      → 内存不足(OutOfMemoryError):线程数过多
  • 本地方法栈:为 Native 方法服务
  • 堆:线程共享,存储对象实例
      → 新生代(Eden/Survivor)、老年代
      → 内存不足 → OutOfMemoryError
  • 方法区(JDK 8+ 元空间 Metaspace):存储类元数据、常量、静态变量

📌 典型 OOM 场景:
① 堆溢出:无限创建对象(如缓存未清理)
② 元空间溢出:动态生成大量类(如反射滥用)
③ 栈溢出:递归调用无终止条件

7.1 对象创建过程

1. 类加载检查(是否已加载)
2. 分配内存(指针碰撞 / 空闲列表)
3. 初始化零值
4. 设置对象头(哈希码、GC 分代年龄、锁状态等)
5. 执行 init 方法(构造函数)

八、java 基础教程:开发工具链实战

高效开发依赖工具链:JDK → IDE → 构建工具 → 调试技巧。

8.1 JDK 版本选择

当前主流 LTS 版本:
• JDK 8:最广泛使用(2014),但已停止公开更新(商业需授权)
• JDK 11:2018,现代特性(var、HttpClient)
• JDK 17:2021,最新 LTS,支持 records/sealed classes/pattern matching

推荐新项目使用 JDK 17,老项目逐步升级(注意兼容性)。

8.2 IDE 推荐

• IntelliJ IDEA:功能最全,智能提示强,插件丰富
• Eclipse:老牌 IDE,轻量级但功能较弱
• VS Code + Java Extension Pack:轻量、跨平台,适合小项目

必备插件:
• Lombok(减少样板代码)
• Alibaba Java Coding Guidelines(代码规范检查)
• MyBatis Log Plugin(SQL 日志格式化)

8.3 调试技巧

• 断点类型:条件断点(右键断点 → Condition)、字段断点(Watch Field)
• 表达式求值(Evaluate Expression):实时计算表达式结果
• 日志替代:System.out → SLF4J(生产环境必须用日志框架)

九、java 基础教程:高频面试题解析

以下问题均来自一线互联网公司校招/社招真题,附深度解答。

9.1 String 为什么设计为不可变?

原因:
① 字符串常量池:共享字符串对象,节省内存
② 线程安全:多线程读取无需同步
③ 安全性:防止恶意代码修改关键字符串(如数据库 URL)
④ 哈希码缓存:hashCode() 可缓存,提升 HashMap 性能

可变替代:
• StringBuilder(单线程)
• StringBuffer(多线程)

9.2 HashMap 如何保证线程安全?

HashMap 本身非线程安全!线程安全替代方案:
① ConcurrentHashMap:JDK 8+ 用 CAS + synchronized(分段锁升级)
② Collections.synchronizedMap(new HashMap<>()):全局 synchronized,性能差
③ Hashtable:过时,所有方法 synchronized,已不推荐

📌 注意:ConcurrentHashMap 的 key/value 不允许为 null!

9.3 volatile 与 synchronized 区别?

特性volatilesynchronized
可见性保证保证
原子性❌ 不保证✅ 保证
阻塞❌ 无阻塞✅ 线程阻塞
锁类型无锁对象锁/类锁
适用场景状态标志、单次发布复合操作、临界区