Java编程入门教程
本教程面向零基础学习者,系统化讲解Java语言从安装配置到实际开发的全过程,内容覆盖语法基础、面向对象编程、集合框架、异常处理、输入输出、多线程、网络编程、数据库连接等核心模块,并延伸至开发者工具使用、高频面试题解析、优质学习资源推荐、常见误区警示等实用周边知识,帮助读者建立完整的知识体系,高效入门Java开发。
Java语言自1995年由Sun公司发布以来,凭借其“一次编写,到处运行”的跨平台特性、强大的生态系统、稳健的性能表现以及活跃的社区支持,长期稳居全球主流编程语言前列。根据TIOBE指数统计,Java常年位列前三,是企业级应用开发、Android原生开发、大数据处理(如Hadoop、Spark)、微服务架构(Spring Boot/Cloud)等领域的首选语言。对于初学者而言,Java语法相对规整、类型安全、错误提示明确,是进入编程世界的理想起点。
本教程摒弃“碎片化”教学模式,采用“理论+示例+练习”三维一体结构,每章均配备可运行的完整代码示例,强调动手实践。所有代码均通过JDK 17标准编译验证,确保示例可复现性。教程特别注重初学者认知规律,对抽象概念(如JVM内存模型、反射机制、泛型擦除)采用类比与图解辅助理解,并设置“新手易错点”提示框,降低学习曲线。
学习路径建议:掌握基础语法 → 熟练面向对象 → 深入核心API → 接触开发工具 → 实战综合项目 → 拓展高级特性。每个阶段设置明确目标与验收标准,避免盲目学习。教程将持续更新,紧跟Java技术演进节奏,例如新版本中的模式匹配(Pattern Matching)、记录类(Records)、虚拟线程(Virtual Threads)等特性也将适时纳入进阶内容。
⚙️ 开发环境搭建
搭建规范、稳定的开发环境是编程学习的第一步。Java开发依赖三大核心组件:JDK(Java Development Kit,开发工具包)、JRE(Java Runtime Environment,运行环境)、JVM(Java Virtual Machine,虚拟机)。JDK包含JRE,JRE包含JVM,构成完整的Java运行与开发体系。
1. 选择JDK版本
当前主流JDK版本分为两类:长期支持版(LTS)与最新版。LTS版本每三年发布一次,提供5年免费更新,是生产环境首选;最新版每半年发布一次,包含新特性,适合尝鲜与学习。截至2025年,LTS版本包括JDK 8(2014)、JDK 11(2018)、JDK 17(2021)、JDK 21(2023);最新版为JDK 22(2024)。建议初学者从JDK 17入手,兼顾稳定性与现代特性。
主流发行版对比:
| 发行商 | 是否免费 | 更新周期 | 推荐场景 |
|---|---|---|---|
| Oracle JDK | 商业使用需付费(LTS免费至发布后1年) | 每半年 | 企业生产环境(已购买许可) |
| Adoptium (Temurin) | 完全免费 | LTS长期支持 | 个人学习、开源项目首选 |
| Amazon Corretto | 完全免费 | LTS长期支持 | AWS云环境部署 |
| Zulu (Azul) | 基础版免费 | LTS长期支持 | 跨平台企业应用 |
推荐使用Eclipse Temurin(原AdoptOpenJDK),由Eclipse基金会维护,下载地址:https://adoptium.net/。下载对应系统(Windows/macOS/Linux)的JDK 17安装包即可。
2. 配置环境变量
安装后需配置环境变量,确保命令行可识别java与javac指令:
- 右键“此电脑” → “属性” → “高级系统设置” → “环境变量”
- 新建系统变量:
- 变量名:JAVA_HOME
- 变量值:JDK安装路径(如
C:\Program Files\Eclipse Adoptium\jdk-17.0.10.7-hotspot)
- 编辑Path变量,新增:
%JAVA_HOME%\bin - 验证:打开命令提示符,输入
java -version与javac -version,应显示版本号
macOS/Linux用户:编辑~/.bashrc或~/.zshrc,添加:
export JAVA_HOME=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home export PATH=$JAVA_HOME/bin:$PATH
执行source ~/.zshrc生效后验证。
3. 选择IDE
集成开发环境(IDE)极大提升编码效率,推荐:
- IntelliJ IDEA Community(免费版):代码智能提示、自动重构、集成调试器、Maven/Gradle支持完善,适合中大型项目。
- Eclipse:老牌IDE,插件生态丰富,内存占用略高,适合Java EE开发。
- VS Code + Java Extension Pack:轻量级,适合小项目或学习练习。
建议新手从IntelliJ IDEA Community入手,下载地址:https://www.jetbrains.com/idea/download/。安装后首次启动会引导配置JDK路径,自动识别JAVA_HOME。
4. 首个Java程序:Hello World
新建项目 → New Java Class → 输入类名HelloWorld → 编写代码:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
点击运行按钮(绿色三角),控制台输出:Hello, Java!。恭喜!您已迈出编程第一步。
⚡ 基础语法核心
Java语法严谨、结构清晰,属于强类型、静态类型语言。掌握基础语法是理解后续高级特性的前提。本节系统梳理语法要点,并结合典型示例说明易错细节。
1. 数据类型与变量
Java数据类型分为两类:基本类型(8种)与引用类型(类、接口、数组)。
| 类型类别 | 类型 | 字节数 | 取值范围 |
|---|---|---|---|
| 基本类型 | byte | 1 | -128 ~ 127 |
| short | 2 | -32768 ~ 32767 | |
| int | 4 | -2³¹ ~ 2³¹-1 | |
| long | 8 | -2⁶³ ~ 2⁶³-1 | |
| float | 4 | 约±3.40282347E+38F | |
| double | 8 | 约±1.79769313486231570E+308 | |
| char | 2 | 0 ~ 65535(Unicode) | |
| boolean | 1位 | true / false |
关键规则:
- 整数默认为
int,long需加L后缀(如10000000000L) - 浮点数默认为
double,float需加F后缀(如3.14F) char使用单引号('A'),String使用双引号("Hello")- 变量声明格式:
类型 变量名 = 初始值;,如int age = 18;
2. 运算符与表达式
常见运算符分类:
- 算术运算符:
+ - * / % ++ --(注意整数除法截断:5/2 = 2) - 关系运算符:
== != > < >= <=(字符串比较用.equals()) - 逻辑运算符:
&& || !(短路特性:&&左侧为假则不执行右侧) - 位运算符:
& | ^ ~ << >> >>>(用于底层优化、权限控制) - 三元运算符:
条件 ? 表达式1 : 表达式2
典型陷阱:
int a = 1000000; int b = 1000000; long c = a * b; // 错误!a*b先以int计算,溢出后才转long,结果为负 long d = (long)a * b; // 正确:先将a转long,再乘
3. 控制流程
条件语句:
int score = 85;
if (score >= 90) {
System.out.println("A");
} else if (score >= 80) {
System.out.println("B");
} else {
System.out.println("C");
}
循环语句:
// for循环:已知循环次数
for (int i = 1; i <= 5; i++) {
System.out.println("第" + i + "次循环");
}
// while循环:未知次数,条件驱动
int count = 1;
while (count <= 3) {
System.out.println("尝试第" + count + "次");
count++;
}
增强for循环(JDK 5+):
String[] names = {"张三", "李四", "王五"};
for (String name : names) {
System.out.println(name);
}
4. 数组
数组是相同类型元素的有序集合,长度固定。声明方式:
int[] numbers = new int[5]; // 创建长度为5的整型数组
int[] primes = {2, 3, 5, 7, 11}; // 直接初始化
数组操作示例:
int[] arr = {10, 20, 30};
System.out.println(arr.length); // 输出3
System.out.println(arr[1]); // 输出20(下标从0开始)
arr[2] = 40; // 修改第三个元素
// 遍历数组(增强for)
for (int num : arr) {
System.out.print(num + " "); // 输出:10 20 40
}
多维数组:
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
System.out.println(matrix[1][2]); // 输出6
♀♂ 面向对象编程
面向对象编程(OOP)是Java的核心思想,通过封装、继承、多态三大特性,实现代码复用、模块化与可维护性。理解OOP是掌握大型项目开发的关键。
1. 类与对象
类是对象的模板,定义属性与行为;对象是类的实例。示例:Student类:
public class Student {
// 属性(成员变量)
private String name;
private int age;
private double gpa;
// 构造方法(初始化对象)
public Student(String name, int age, double gpa) {
this.name = name;
this.age = age;
this.gpa = gpa;
}
// 行为(方法)
public void study() {
System.out.println(name + "正在学习Java编程!");
}
// Getter/Setter(封装属性访问)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getGpa() {
return gpa;
}
public void setGpa(double gpa) {
if (gpa >= 0.0 && gpa <= 4.0) {
this.gpa = gpa;
}
}
}
创建对象并调用:
Student s = new Student("王小明", 20, 3.7);
s.study(); // 输出:王小明正在学习Java编程!
System.out.println(s.getName()); // 输出:王小明
s.setGpa(3.9); // 有效赋值
s.setGpa(5.0); // 无效,gpa保持3.7
2. 封装
将数据(属性)与操作(方法)绑定,并隐藏内部实现细节,仅暴露必要接口。通过private修饰符限制属性访问,用public方法提供受控读写。
封装优势:
- 防止非法数据(如年龄设为负数)
- 隐藏实现细节(如GPA计算逻辑可随时修改)
- 提高代码可维护性(修改属性逻辑不影响调用方)
3. 继承
通过extends实现类的复用与扩展。父类(超类)定义通用属性,子类添加特有属性。
public class CollegeStudent extends Student {
private String major;
public CollegeStudent(String name, int age, double gpa, String major) {
super(name, age, gpa); // 调用父类构造方法
this.major = major;
}
// 重写父类方法(多态体现)
@Override
public void study() {
System.out.println(getName() + "正在专业课" + major + "中学习!");
}
// 新增方法
public void attendLecture(String course) {
System.out.println(getName() + "在" + course + "课上专注听讲");
}
}
使用示例:
CollegeStudent cs = new CollegeStudent("李华", 21, 3.5, "计算机科学");
cs.study(); // 输出:李华正在专业课计算机科学中学习!
cs.attendLecture("数据结构"); // 输出:李华在数据结构课上专注听讲
关键点:
- 子类继承父类所有非
private成员 - 构造子类对象时,先调用父类构造方法(
super()) super与this不可同时使用(都必须在构造方法首行)
4. 多态
同一操作作用于不同对象,可产生不同效果。实现三要素:继承、重写、父类引用指向子类对象。
Student s1 = new Student("学生A", 18, 3.2);
Student s2 = new CollegeStudent("学生B", 20, 3.6, "软件工程");
// 多态调用:同一study()方法,表现不同行为
s1.study(); // 输出:学生A正在学习Java编程!
s2.study(); // 输出:学生B正在专业课软件工程中学习!
多态意义:降低耦合度,提升扩展性。新增子类(如GraduateStudent)无需修改调用方代码。
5. 抽象类与接口
抽象类(abstract class):不能实例化,可包含抽象方法(无方法体)与具体方法,用于代码复用。
public abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
// 抽象方法:强制子类实现
public abstract void makeSound();
// 具体方法:提供默认实现
public void eat() {
System.out.println(name + "正在吃东西");
}
}
接口(interface):纯抽象,仅含抽象方法(JDK 8后可有默认方法与静态方法),支持多实现,用于定义行为规范。
public interface Flyable {
void fly(); // 默认为public abstract
// JDK 8+ 默认方法
default void land() {
System.out.println("安全着陆");
}
}
实现与继承对比:
| 特性 | 继承(extends) | 实现(implements) |
|---|---|---|
| 类数限制 | 单继承(1个父类) | 多实现(多个接口) |
| 成员变量 | 可有实例变量 | 仅public static final常量 |
| 构造方法 | 有(用于初始化父类部分) | 无 |
| 设计目的 | 代码复用(is-a关系) | 行为规范(can-do关系) |
〔〕 核心类库详解
Java标准库(Java Standard Library)提供丰富的API,覆盖字符串处理、集合框架、异常机制、输入输出、多线程等核心功能。熟练掌握核心类库是高效开发的基础。
1. 字符串处理(String & StringBuilder)
String特点:不可变(immutable),每次修改生成新对象,适合频繁读取、少修改场景。
String s = "Java"; s = s + "编程"; // 创建两个对象:原"Java" + 新"Java编程" System.out.println(s); // 输出:Java编程
StringBuilder(线程不安全,高效)与StringBuffer(线程安全,效率略低)适用于频繁拼接。
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i).append(",");
}
String result = sb.toString(); // 高效拼接
常用方法:
| 方法 | 说明 | 示例 |
|---|---|---|
.length() |
字符串长度 | "Hello".length() → 5 |
.equals() |
内容比较(区分大小写) | "java".equals("Java") → false |
.equalsIgnoreCase() |
内容比较(忽略大小写) | "java".equalsIgnoreCase("Java") → true |
.substring() |
截取子串 | "Hello".substring(1, 3) → "el" |
.replace() |
替换字符/字符串 | "Java".replace('a', 'o') → "Joao" |
.split() |
按分隔符拆分 | "a,b,c".split(",") → ["a","b","c"] |
2. 集合框架(Collections Framework)
Java集合分为三大体系:Collection(单值集合)、Map(键值对集合)。核心接口及实现类:
| 接口 | 特点 | 常用实现类 | 典型场景 |
|---|---|---|---|
List |
有序、可重复 | ArrayList(数组)、LinkedList(链表) |
需要索引访问、频繁遍历 |
Set |
无序、不可重复 | HashSet(哈希)、TreeSet(排序) |
去重、集合运算 |
Map |
键值对、键唯一 | HashMap(非线程安全)、TreeMap(排序) |
键值映射、快速查找 |
List使用示例:
Listnames = new ArrayList<>(); names.add("张三"); names.add("李四"); names.add(1, "王五"); // 插入到索引1位置 System.out.println(names.get(1)); // 输出:王五 names.remove("张三"); System.out.println(names.size()); // 输出:2
Map使用示例:
Mapscores = new HashMap<>(); scores.put("语文", 92); scores.put("数学", 88); System.out.println(scores.get("数学")); // 输出:88 System.out.println(scores.containsKey("英语")); // 输出:false for (Map.Entry entry : scores.entrySet()) { System.out.println(entry.getKey() + ":" + entry.getValue()); }
3. 异常处理(Exception Handling)
Java异常体系分:Error(严重错误,如内存溢出)、Exception(可处理异常),后者又分:RuntimeException(运行时异常,如空指针)与Checked Exception(编译时异常,如IO异常)。
异常处理语法:
try {
int result = 10 / 0; // 可能抛出ArithmeticException
} catch (ArithmeticException e) {
System.out.println("除零错误:" + e.getMessage());
} finally {
System.out.println("操作结束");
}
自定义异常:
public class InvalidScoreException extends Exception {
public InvalidScoreException(String message) {
super(message);
}
}
public void setScore(int score) throws InvalidScoreException {
if (score < 0 || score > 100) {
throw new InvalidScoreException("分数必须在0~100之间");
}
this.score = score;
}
4. 输入输出(I/O)
文件读写核心类:
| 类 | 用途 | 示例 |
|---|---|---|
FileReader/FileWriter |
字符流(文本文件) | 逐字符读写 |
BufferedReader/BufferedWriter |
缓冲字符流(高效) | 支持按行读取(readLine()) |
FileInputStream/FileOutputStream |
字节流(二进制文件) | 读写图片、音频等 |
按行读取文本文件示例:
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("文件读取失败:" + e.getMessage());
}
写入文件示例:
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
bw.write("Hello, Java I/O!");
bw.newLine();
bw.write("文件写入成功");
} catch (IOException e) {
System.err.println("文件写入失败:" + e.getMessage());
}
5. 多线程(Multithreading)
Java内置多线程支持,通过Thread类或Runnable接口实现。线程状态:新建→就绪→运行→阻塞→终止。
实现方式1:继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行:" + i);
}
}
}
// 启动线程
MyThread t = new MyThread();
t.start(); // 注意:必须调用start(),直接run()是同步调用
实现方式2:实现Runnable接口(推荐)
public class MyTask implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("任务执行:" + i);
}
}
}
// 启动线程
Thread t = new Thread(new MyTask());
t.start();
线程同步:解决多线程并发访问共享资源的线程安全问题。
// 使用synchronized关键字
public synchronized void increment() {
count++;
}
// 或使用同步代码块
synchronized (lockObject) {
count++;
}
6. 网络编程(Socket)
Java通过java.net包提供网络编程支持。典型应用:客户端-服务器通信。
服务器端(Server)
ServerSocket server = new ServerSocket(8080); // 监听8080端口
Socket client = server.accept(); // 阻塞等待客户端连接
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);
String msg = in.readLine();
out.println("收到消息:" + msg);
client.close();
server.close();
客户端(Client)
Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out.println("Hello, Server!");
String response = in.readLine();
System.out.println("服务器响应:" + response);
socket.close();
〔〕 开发工具与工程化
现代Java开发依赖专业工具提升效率,本节介绍必备工具链:构建工具、版本控制、测试框架、调试技巧。
1. 构建工具:Maven与Gradle
Maven(基于XML配置):
- 核心概念:POM(Project Object Model)、依赖管理(dependencies)、生命周期(compile、test、package)
- 依赖声明示例:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.21</version>
</dependency>
</dependencies>
Gradle(基于Groovy/Kotlin DSL):
- 语法简洁,支持增量构建
- 依赖声明示例:
dependencies {
implementation 'org.springframework:spring-core:5.3.21'
}
两者均支持自动下载依赖、统一构建流程、集成CI/CD,推荐Gradle作为新项目首选。
2. 版本控制:Git
分布式版本控制系统,核心命令:
git init:初始化仓库git add .:暂存所有修改git commit -m "描述":提交到本地仓库git push origin main:推送到远程仓库git pull:拉取远程更新
分支操作:
git branch feature-login # 创建分支 git checkout feature-login # 切换分支 git merge feature-login # 合并分支到当前分支
配合GitHub/GitLab实现团队协作与代码托管。
3. 测试框架:JUnit
单元测试是保障代码质量的基石。JUnit 5核心注解:
| 注解 | 作用 | 示例 |
|---|---|---|
@Test |
标记测试方法 | @Test void testAdd() |
@BeforeEach |
每个测试前执行 | 初始化测试数据 |
@AfterEach |
每个测试后执行 | 清理资源 |
@DisplayName |
测试名称(中文友好) | @DisplayName("加法测试") |
测试示例:
@Test
@DisplayName("验证字符串长度")
void testStringLength() {
String text = "Hello";
assertEquals(5, text.length(), "长度应为5");
}
4. 调试技巧
断点调试步骤:
- 在代码行号处点击设置断点
- 右键代码 → Debug → 选择启动方式
- 使用调试控制按钮:
- Step Over(F8):执行下一行
- Step Into(F7):进入方法内部
- Step Out(Shift+F8):跳出当前方法
- Resume(F9):运行到下一断点
- 在Variables窗口查看变量值变化
日志调试:使用System.out.println()或日志框架(如Log4j2)记录关键变量值。
● 高频面试题解析
根据2024年招聘平台数据,Java岗位面试高频考点集中在以下方面,结合真实题目解析核心知识点。
Q1: Java与C++的主要区别?
答:
- 内存管理:Java有垃圾回收(GC)自动管理内存;C++需手动管理new/delete,易出内存泄漏。
- 跨平台性:Java通过JVM实现“一次编译,到处运行”;C++编译为平台特定机器码。
- 指针:Java无指针(用引用代替),更安全;C++支持指针运算,灵活但危险。
- 继承:Java单继承(类)+多实现(接口);C++多继承。
- 泛型:Java泛型为伪泛型(类型擦除);C++模板为真泛型。
Q2: 重载(Overload)与重写(Override)的区别?
答:
| 对比项 | 重载(Overload) | 重写(Override) |
|---|---|---|
| 发生位置 | 同一类中 | 子类与父类之间 |
| 方法名 | 相同 | 相同 |
| 参数列表 | 必须不同(类型/个数/顺序) | 必须相同 |
| 返回类型 | 可不同 | 相同或协变返回类型 |
| 访问修饰符 | 无限制 | 子类不能比父类更严格 |
Q1: 接口与抽象类的区别?
答:参考前文“2. 抽象类与接口”部分,重点强调:
- 设计目的:抽象类为代码复用(is-a),接口为行为规范(can-do)。
- 成员限制:接口仅能含抽象方法(JDK 8前)、常量;抽象类可有具体方法与实例变量。
- 多继承支持:类单继承但可多实现接口;抽象类不能解决多继承问题。
Q2: super与this的使用规则?
答:
super()与this()都必须在构造方法首行,因此不能同时存在。super调用父类构造方法;this调用本类其他构造方法。super.属性访问父类成员;this.属性访问本类成员(区分同名变量)。
Q1: HashMap与HashTable的区别?
答:
| 对比项 | HashMap | HashTable |
|---|---|---|
| 线程安全 | 线程不安全(高效) | 线程安全(方法synchronized) |
| 空键值 | 允许一个null键、多个null值 | 不允许null键/值 |
| 默认容量 | 16 | 11 |
| 扩容机制 | 2倍扩容 | 2n+1扩容 |
| 替代方案 | 线程安全用ConcurrentHashMap | 基本淘汰,推荐用ConcurrentHashMap |
Q2: ArrayList与LinkedList的区别?
答:
- 底层结构:ArrayList基于动态数组;LinkedList基于双向链表。
- 随机访问:ArrayList O(1)(下标直接访问);LinkedList O(n)(需遍历)。
- 插入/删除:ArrayList尾部O(1),中间/头部O(n)(需移动元素);LinkedList任意位置O(1)(修改指针)。
- 内存占用:ArrayList连续内存,空间利用率高;LinkedList节点存储额外指针,空间开销大。
Q1: synchronized与ReentrantLock的区别?
答:
| 对比项 | synchronized | ReentrantLock |
|---|---|---|
| 实现层面 | JVM关键字 | API类(java.util.concurrent.locks) |
| 锁获取 | 自动获取/释放 | 手动lock()/unlock()(需try-finally) |
| 中断响应 | 不支持 | 支持(lockInterruptibly()) |
| 超时机制 | 不支持 | 支持(tryLock(timeout)) |
| 公平锁 | 非公平 | 可选(构造传true) |
Q2: volatile关键字的作用?
答:
- 可见性:保证变量修改对所有线程立即可见(强制从主内存读写)。
- 禁止指令重排序:通过内存屏障实现。
- 不保证原子性:如
volatile int count,count++仍非原子操作。 - 典型场景:状态标志(如
volatile boolean running)、双重检查锁中的单例。
《》 优质学习资源推荐
精选国内外权威资源,覆盖视频课程、经典书籍、开源项目、技术社区,帮助学习者构建系统化知识体系。
视频课程
- 《Java核心技术 卷I》(Cay Horstmann著):配套Coursera课程,理论扎实,适合打基础。
- 慕课网《Java入门第一课》:零基础友好,代码示例丰富,节奏适中。
- YouTube:Core Java by Telusko:免费全英文系列,讲解深入浅出,含源码解析。
经典书籍
| 书名 | 作者 | 推荐理由 |
|---|---|---|
| 《Effective Java》 | Joshua Bloch | Java开发圣经,300+条最佳实践,适合进阶提升。 |
| 《Java编程思想》 | Bruce Eckel | 深入讲解OOP思想,适合建立编程范式认知。 |
| 《Java并发编程实战》 | Brian Goetz | 并发领域权威著作,深入JMM、锁机制原理。 |
开源项目
- Spring Framework:企业级开发基石,学习设计模式与IoC/AOP思想。
- Netty:高性能网络框架,掌握NIO与事件驱动模型。
- Hutool:Java工具类库,轻量级,适合学习实用技巧。
技术社区
- Stack Overflow:全球最大问答社区,搜索问题必查。
- SegmentFault:中文技术社区,问题响应快。
- GitHub:托管代码、学习优秀项目、参与开源。
【】 新手常见误区与避坑指南
基于大量初学者反馈,总结高频错误与正确做法,帮助高效学习。
错误示例:
String a = new String("java");
String b = new String("java");
System.out.println(a == b); // 输出false(比较地址)
System.out.println(a.equals(b)); // 输出true(比较内容)
正确做法:字符串内容比较必须用equals();基本类型用==。
错误示例:
List list = new ArrayList(); // 原始类型,类型不安全
list.add("Java");
list.add(123); // 编译通过,运行时可能出ClassCastException
正确做法:始终指定泛型类型:
Listlist = new ArrayList<>(); list.add("Java"); // list.add(123); // 编译错误,提前发现类型问题
错误示例:
String s = null; System.out.println(s.length()); // 直接抛NPE
正确做法:使用Objects.requireNonNull()或Optional(JDK 8+):
String s = null;
if (s != null) {
System.out.println(s.length());
} else {
System.out.println("字符串为空");
}
错误示例:
String result = "";
for (int i = 0; i < 1000; i++) {
result += i; // 每次创建新对象,效率极低
}
正确做法:使用StringBuilder:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i);
}
String result = sb.toString();