Java 完整版基础教程（2026版）

〇、学习路线图

环境搭建 → 语法基础 → OOP（重中之重）→ 核心API → 异常/泛型/集合 → IO流 → 多线程 → 网络编程 → 反射/注解 → 新特性 → 项目实战

一、Java 概述与环境搭建

1.1 Java 三大版本

1.2 JDK 安装（以JDK 17 LTS为例）

1. 下载 Oracle JDK 或 OpenJDK

2. 配置环境变量：

   • JAVA_HOME = C:\Program Files\Java\jdk-17

   • PATH添加%JAVA_HOME%\bin

3. 验证：java -version和javac -version

1.3 第一个程序 HelloWorld

public class HelloWorld {
// main方法是程序入口，固定写法
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}

编译运行：

javac HelloWorld.java # 编译成字节码 .class
java HelloWorld # 运行

二、Java 语法基础（变量、运算符、流程控制）

2.1 标识符、关键字、注释

• 标识符：字母、数字、_、$ 组成，不能以数字开头，不能是关键字

• 关键字：public、class、static、void、if等（共50+）

• 注释：

// 单行
/* 多行 */
/** 文档注释，生成API文档 */

2.2 数据类型（8大基本类型 + 引用类型）

引用类型：类、接口、数组、枚举、String

2.3 类型转换

• 自动类型转换（小→大）：int → long → float → double

• 强制类型转换（大→小）：(int)3.14→ 3（精度丢失）

• 注意：byte/short/char运算时自动转为int

2.4 运算符

// 算术：+ - * / % ++ --
// 赋值：= += -= *= /= %=
// 比较：== != > < >= <=（结果boolean）
// 逻辑：&& || !（短路）
// 位运算：& | ^ ~ << >> >>>
// 三元：条件 ? 值1 : 值2
int max = (a > b) ? a : b;

2.5 流程控制

// 1. if-else if-else
if (score >= 90) {
grade = 'A';
} else if (score >= 60) {
grade = 'B';
} else {
grade = 'C';
}

// 2. switch（支持int, String, enum）
switch (day) {
case 1 -> System.out.println("周一"); // JDK12+ 箭头语法
case 2 -> System.out.println("周二");
default -> System.out.println("其他");
}

// 3. for
for (int i = 0; i < 10; i++) { ... }

// 增强for（遍历数组/集合）
for (String s : arr) { ... }

// 4. while / do-while
while (i < 5) { i++; }
do { i--; } while (i > 0);

三、面向对象编程（OOP）—— 重中之重

3.1 类与对象

// 定义类
class Student {
// 属性（成员变量）
String name;
int age;

// 构造方法（与类同名，无返回值）
public Student(String name, int age) {
this.name = name; // this指向当前对象
this.age = age;
}

// 方法
public void study() {
System.out.println(name + " 正在学习");
}
}

// 使用
Student s = new Student("张三", 20);
s.study();

3.2 三大特性：封装、继承、多态

3.2.1 封装（private + getter/setter）

class Person {
private String name; // 私有，外部不可直接访问

public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

3.2.2 继承（extends）

• Java单继承（一个类只能有一个父类）

• super调用父类构造/方法

• 所有类默认继承Object

class Teacher extends Person {
private String subject;

public Teacher(String name, String subject) {
super(name); // 调用父类构造器
this.subject = subject;
}

@Override // 重写父类方法（注解非必须，但推荐）
public String toString() {
return "教师：" + getName() + "，科目：" + subject;
}
}

3.2.3 多态（向上转型 + 动态绑定）

Person p = new Teacher("李四", "数学");
// 编译看左边（Person），运行看右边（Teacher）
System.out.println(p.toString()); // 调用Teacher的toString

3.3 抽象类与接口

// 接口
interface Flyable {
void fly(); // 抽象方法（默认 public abstract）

default void land() { // JDK8默认方法
System.out.println("降落");
}
}

// 实现类
class Bird implements Flyable {
@Override
public void fly() {
System.out.println("鸟儿飞");
}
}

3.4 内部类（了解）

• 成员内部类、静态内部类、局部内部类、匿名内部类（常用于事件监听）

四、核心 API

4.1 String（最常用）

String s = "Hello";
s.length(); // 长度
s.charAt(0); // 'H'
s.substring(1, 3); // "el"（左闭右开）
s.indexOf("l"); // 2
s.replace("l", "w"); // "Hewwo"
s.toLowerCase(); // 小写
s.trim(); // 去首尾空格
s.equals("Hello"); // true（比较内容，==比较地址）
String[] parts = s.split(",");

⚠️String 不可变：每次修改都生成新对象，大量拼接用StringBuilder。

4.2 StringBuilder / StringBuffer

• StringBuilder（线程不安全，效率高）

• StringBuffer（线程安全，效率略低）

StringBuilder sb = new StringBuilder();
sb.append("a").append("b").append(123);
sb.insert(1, "X");
sb.reverse();

4.3 包装类（Integer, Double, Boolean等）

// 装箱（基本→包装）
Integer i = Integer.valueOf(10); // 或自动装箱：Integer i = 10;
// 拆箱（包装→基本）
int n = i.intValue(); // 或自动拆箱：int n = i;

// 字符串转数字
int num = Integer.parseInt("123");

4.4 日期时间（JDK8+）

import java.time.*;

// 本地日期
LocalDate date = LocalDate.now();
LocalDate future = date.plusDays(7);
// 本地时间
LocalTime time = LocalTime.now();
// 日期时间
LocalDateTime dt = LocalDateTime.now();
// 格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
String formatted = dt.format(formatter);

五、异常处理（Exception）

5.1 异常体系

Throwable
├── Error（严重错误，如OutOfMemoryError，程序无法处理）
└── Exception
├── RuntimeException（运行时异常，非受检，如NullPointerException）
└── 其他（受检异常，如IOException，必须处理）

5.2 try-catch-finally / try-with-resources

// 方式1：try-catch-finally
try {
int[] arr = {1,2,3};
System.out.println(arr[5]); // 数组越界
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println("捕获异常：" + e.getMessage());
} finally {
System.out.println("无论是否异常，都会执行");
}

// 方式2：try-with-resources（自动关闭资源，JDK7+）
try (FileInputStream fis = new FileInputStream("test.txt")) {
// 使用fis
} catch (IOException e) {
e.printStackTrace();
}

// 抛出异常
public void div(int a, int b) throws ArithmeticException {
if (b == 0) throw new ArithmeticException("除数不能为0");
}

六、泛型（Generics）

6.1 泛型类/方法

// 泛型类
class Box<T> {
private T value;
public void set(T t) { this.value = t; }
public T get() { return value; }
}

// 泛型方法
public static <E> void printArray(E[] array) {
for (E e : array) System.out.print(e + " ");
}

// 使用
Box<String> box = new Box<>();
box.set("Hello");
String s = box.get(); // 无需强制转换

6.2 通配符（?）

• ? extends T：上界通配符（T及子类）

• ? super T：下界通配符（T及父类）

七、集合框架（Collection / Map）—— 必会

7.1 体系结构

Collection接口
├── List（有序，可重复）
│ ├── ArrayList（数组，查询快，增删慢）
│ └── LinkedList（双向链表，增删快，查询慢）
├── Set（无序，不可重复）
│ ├── HashSet（哈希表，无顺序）
│ └── TreeSet（红黑树，自动排序）
└── Queue（队列）

Map接口（键值对）
├── HashMap（哈希表，无序，允许null）
├── TreeMap（红黑树，按键排序）
└── LinkedHashMap（保持插入顺序）

7.2 核心代码示例

import java.util.*;

// List
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.get(0);
list.remove(1);
list.size();

// Set
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(10); // 不会重复
set.contains(10);

// Map
Map<String, Integer> map = new HashMap<>();
map.put("张三", 90);
map.put("李四", 85);
int score = map.get("张三"); // 90
for (String key : map.keySet()) {
System.out.println(key + "=" + map.get(key));
}
// 遍历Entry
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}

7.3 Collections 工具类

Collections.sort(list); // 排序
Collections.reverse(list); // 反转
Collections.shuffle(list); // 打乱
int max = Collections.max(list); // 最大值

八、IO 流（文件读写）

8.1 字节流 vs 字符流

8.2 文件读写示例

import java.io.*;

// 1. 字节流读写文件（复制文件）
try (FileInputStream fis = new FileInputStream("src.jpg");
FileOutputStream fos = new FileOutputStream("dst.jpg")) {
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}

// 2. 字符流读写文本
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}

8.3 NIO（非阻塞IO，面试常问）

核心：Channel+Buffer+Selector（了解即可）

九、多线程（并发编程）

9.1 创建线程的3种方式

// 方式1：继承Thread
class MyThread extends Thread {
@Override
public void run() { System.out.println("继承Thread"); }
}
new MyThread().start();

// 方式2：实现Runnable（推荐，因单继承限制）
class MyRunnable implements Runnable {
@Override
public void run() { System.out.println("实现Runnable"); }
}
new Thread(new MyRunnable()).start();

// 方式3：Callable + Future（有返回值）
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
Thread.sleep(1000);
return 123;
});
System.out.println(future.get()); // 阻塞获取结果
executor.shutdown();

9.2 线程生命周期

新建 → 就绪 → 运行 → 阻塞/等待/超时等待 → 终止

9.3 线程同步（synchronized / Lock）

// 同步方法
public synchronized void add() { count++; }

// 同步代码块
synchronized (this) { count++; }

// ReentrantLock（更灵活）
Lock lock = new ReentrantLock();
lock.lock();
try {
count++;
} finally {
lock.unlock();
}

9.4 线程通信（wait/notify/notifyAll）

// 生产者-消费者模式经典写法
synchronized (queue) {
while (queue.isEmpty()) {
queue.wait(); // 释放锁，等待
}
queue.notifyAll(); // 唤醒其他线程
}

9.5 线程池（Executors）

// 不建议用Executors直接创建（易OOM），推荐ThreadPoolExecutor
ExecutorService pool = new ThreadPoolExecutor(
2, 5, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10)
);
pool.execute(() -> System.out.println("任务执行"));
pool.shutdown();

十、网络编程（Socket）

// 服务端
try (ServerSocket server = new ServerSocket(8888)) {
System.out.println("等待客户端连接...");
Socket socket = server.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
String msg = in.readLine();
System.out.println("收到：" + msg);
out.println("已收到：" + msg);
} catch (IOException e) { e.printStackTrace(); }

// 客户端
try (Socket socket = new Socket("localhost", 8888)) {
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out.println("Hello Server");
System.out.println("服务端回复：" + in.readLine());
} catch (IOException e) { e.printStackTrace(); }

十一、反射（Reflection）与注解

11.1 反射（运行时获取类信息）

// 获取Class对象
Class<?> clazz = Class.forName("java.util.ArrayList");

// 获取构造器、方法、字段
Constructor<?>[] cons = clazz.getConstructors();
Method[] methods = clazz.getDeclaredMethods();
Field field = clazz.getDeclaredField("size");
field.setAccessible(true); // 突破private

// 动态调用
Object obj = clazz.getDeclaredConstructor().newInstance();
Method m = clazz.getMethod("add", Object.class);
m.invoke(obj, "test");

11.2 自定义注解（@interface）

@Retention(RetentionPolicy.RUNTIME) // 保留到运行时
@Target(ElementType.METHOD) // 作用于方法
@interface MyAnnotation {
String value() default "";
}

// 使用
@MyAnnotation("hello")
public void test() { ... }

十二、Java 8+ 新特性（必问）

12.1 Lambda 表达式

// 传统匿名内部类
Runnable r1 = new Runnable() { @Override public void run() { System.out.println("old"); } };
// Lambda
Runnable r2 = () -> System.out.println("lambda");
// 集合遍历
list.forEach(s -> System.out.println(s));
// 方法引用
list.forEach(System.out::println);

12.2 Stream API（函数式编程）

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
// 链式操作：过滤 > 3，乘以2，求和
int sum = nums.stream()
.filter(n -> n > 3)
.mapToInt(n -> n * 2)
.sum(); // 4*2 + 5*2 = 18
// 收集到List
List<String> result = list.stream()
.filter(s -> s.startsWith("J"))
.collect(Collectors.toList());

12.3 Optional（避免空指针）

Optional<String> opt = Optional.ofNullable(getName());
String name = opt.orElse("默认名称");
opt.ifPresent(System.out::println);

2.4 新的日期API（已在前文）

十三、实战项目：学生成绩管理系统（控制台版）

综合运用以上知识（类设计、集合、IO、异常、泛型等）。

import java.io.*;
import java.util.*;

// 实体类
class Student implements Serializable {
private String id;
private String name;
private double score;

public Student(String id, String name, double score) {
this.id = id;
this.name = name;
this.score = score;
}
// 省略getter/setter/toString
}

// 核心管理类
class StudentManager {
private List<Student> students = new ArrayList<>();
private static final String DATA_FILE = "students.dat";

// 添加
public void add(Student s) { students.add(s); }

// 按成绩排序（使用Comparable或Comparator）
public void sortByScore() {
students.sort(Comparator.comparingDouble(Student::getScore).reversed());
}

// 保存到文件
public void save() throws IOException {
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DATA_FILE))) {
oos.writeObject(students);
}
}

// 从文件加载
@SuppressWarnings("unchecked")
public void load() throws IOException, ClassNotFoundException {
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DATA_FILE))) {
students = (List<Student>) ois.readObject();
}
}

// 展示
public void display() {
students.forEach(System.out::println);
}
}

// 主程序（省略菜单交互）
public class Main {
public static void main(String[] args) {
StudentManager manager = new StudentManager();
// 添加测试数据、排序、保存、加载等
}
}

十四、学习建议与进阶路线

学习顺序建议

1. 先手敲：每段示例代码都自己敲一遍，不要复制粘贴

2. 做小项目：购物车、图书管理系统、聊天室

3. 刷题：LeetCode 简单+中等（Java实现）

4. 看源码：ArrayList、HashMap、Thread 源码

后续进阶方向

• Java Web：Servlet/JSP → Spring Boot → MyBatis

• 数据库：MySQL + JDBC

• 中间件：Redis、RabbitMQ

• 框架源码：Spring、Spring Cloud

• JVM调优：内存模型、GC算法

📌温馨提示：教程中的每个代码块都可以直接运行。建议你按序列顺序学习，每学完一序列就动手练习。如果需要我针对某个具体序列（比如集合、多线程）做更深入的讲解，随时告诉我。祝你Java学习顺利！ 🚀