java经典实例教程——系统构建Java开发能力体系
本教程以java经典实例教程为核心,面向希望系统掌握Java开发技能的学习者,从零基础环境配置到企业级项目实战,提供完整、连贯、可执行的开发路径。教程内容严格遵循学习曲线规律,注重理论与实践的深度融合,通过大量真实可运行的代码实例,帮助读者建立扎实的编程思维与工程化能力。
当前Java技术生态已形成完整的技术栈体系:从JVM底层机制、JDK核心API,到Spring全家桶框架,再到微服务架构(Spring Cloud)、容器化部署(Docker/Kubernetes)及云原生开发,Java始终是企业级后端开发的首选语言。根据Stack Overflow 2024开发者调查,Java连续12年稳居全球最常用编程语言前五,尤其在金融、电信、电商、政务系统中占据绝对主导地位。
本教程特别强调“可执行性”:所有示例代码均经过JDK 17+环境验证,支持直接复制运行;每个技术点均配套典型应用场景与常见陷阱解析;对初学者易混淆的概念(如接口与抽象类区别、线程池参数配置、AOP代理失效场景等)进行深度对比说明,并辅以时序图、内存结构图等可视化辅助理解。
为什么选择本教程作为起点?
- • 实例驱动:每章以“需求→分析→实现→扩展”闭环展开,避免纯理论灌输
- • 版本先进:覆盖JDK 17 LTS、Spring Boot 3.x、Jakarta EE 10最新规范
- • 工程思维:融入Maven/Gradle构建、Git协作、CI/CD流水线等现代开发流程
- • 面试导向:标注高频考点(如HashMap扩容机制、线程状态流转、事务传播行为)
环境搭建与基础配置
JDK安装与版本选择策略
Java开发环境核心组件包括JDK(Java Development Kit)、JRE(Java Runtime Environment)及JVM(Java Virtual Machine)。JDK是开发者的必备工具包,包含编译器(javac)、解释器(java)、调试器(jdb)等工具链;JRE仅含运行时环境,适用于最终用户;JVM是Java跨平台特性的核心,通过字节码(.class文件)实现“一次编译,到处运行”。
当前主流JDK版本选择建议:生产环境优先选择LTS(长期支持)版本。截至2024年,JDK 8(2014年发布)仍被大量企业使用,但其公开更新已于2022年终止;JDK 11(2018年发布)为最新LTS,支持模块化、G1垃圾回收器优化;JDK 17(2021年发布)为当前最新LTS,引入ZGC低延迟GC、Pattern Matching for instanceof等新特性;JDK 21(2023年发布)为下一LTS,支持虚拟线程(Virtual Threads)大幅提升高并发处理能力。推荐新项目直接采用JDK 17,兼顾稳定性与现代特性。
OpenJDK与Oracle JDK差异对比
| 特性 | OpenJDK | Oracle JDK |
|---|---|---|
| 许可证 | GPLv2 with Classpath Exception | Oracle Technology Network License |
| 商业用途 | 免费 | 需付费(企业版) |
| 更新周期 | 每3个月新版本 | LTS每3年 |
| JVM实现 | HotSpot | HotSpot(含JRockit遗产) |
| 附加工具 | 基础工具集 | JMC(Java Mission Control)、JFR(Java Flight Recorder) |
以Ubuntu 22.04系统为例,安装OpenJDK 17的命令如下:
sudo apt update sudo apt install openjdk-17-jdk java -version # 验证安装结果:openjdk version "17.0.9" 2022-10-18
Windows用户可下载Adoptium(原AdoptOpenJDK)提供的预编译包,访问https://adoptium.net/选择对应版本下载安装。安装后需配置环境变量:JAVA_HOME指向JDK根目录,PATH添加%JAVA_HOME%\bin(Windows)或$JAVA_HOME/bin(Linux/macOS)。
开发工具推荐与配置
主流Java IDE中,IntelliJ IDEA因智能提示强大、重构功能完善、Spring集成度高,成为企业首选;Eclipse开源生态丰富但性能较弱;VS Code轻量级方案适合简单项目。推荐配置:
- • IntelliJ IDEA:安装Lombok插件(简化getter/setter生成)、CheckStyle(代码规范检查)、Save Actions(自动格式化)
- • 项目结构:Maven/Gradle标准目录结构(src/main/java、src/test/java)
- • 代码规范:启用Google Java Format插件,遵循《阿里巴巴Java开发手册》
- • 版本控制:配置Git钩子(pre-commit)自动执行CheckStyle
Java核心语法与面向对象编程
类与对象的深度解析
Java是纯面向对象语言,所有代码必须在类中定义。类(Class)是对象的模板,对象(Object)是类的实例。通过new关键字创建对象时,JVM在堆内存分配空间并调用构造方法初始化。构造方法无返回类型,名称与类名相同,支持重载(Overload)实现不同初始化策略。
以下Student类演示构造方法重载与this关键字的使用:
public class Student {
private String name;
private int age;
// 无参构造
public Student() {
this.name = "未命名";
this.age = 0;
}
// 全参构造
public Student(String name, int age) {
this.name = name; // this引用当前对象,避免与参数名冲突
this.age = age;
}
// 重载构造:仅设置姓名
public Student(String name) {
this(name, 18); // 调用另一构造方法,必须位于首行
}
// Getter/Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + "}";
}
}
运行示例:
Student s1 = new Student();
Student s2 = new Student("张三");
Student s3 = new Student("李四", 20);
System.out.println(s1); // 输出:Student{name='未命名', age=0}
注意:若未显式定义构造方法,编译器会提供默认无参构造;但一旦定义任何构造方法,默认构造将被覆盖。这是初学者常见错误源——在继承中因父类无无参构造导致子类编译失败。
继承与多态的实现机制
继承(Inheritance)通过extends关键字实现,子类复用父类属性和方法,支持单继承。多态(Polymorphism)是面向对象三大特性(封装、继承、多态)的核心,表现为“父类引用指向子类对象”,运行时动态绑定具体方法实现。
多态示例:动物叫声模拟
abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
// 抽象方法:强制子类实现
public abstract void makeSound();
public void eat() {
System.out.println(name + "正在进食");
}
}
class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + ":汪汪!");
}
}
class Cat extends Animal {
public Cat(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + ":喵~");
}
}
public class PolymorphismDemo {
public static void main(String[] args) {
Animal dog = new Dog("旺财");
Animal cat = new Cat("咪咪");
dog.makeSound(); // 动态绑定:实际调用Dog.makeSound()
cat.makeSound(); // 动态绑定:实际调用Cat.makeSound()
// 向上转型:子类转父类
Animal[] animals = {dog, cat};
for (Animal a : animals) {
a.eat(); // 调用父类方法,无多态
}
}
}
运行结果:旺财:汪喵!;咪咪:喵~;旺财正在进食;咪咪正在进食
关键点:多态仅适用于实例方法(非静态、非私有),字段访问不体现多态(编译期绑定)。例如:Animal a = new Dog(); System.out.println(a.name);始终访问Animal类的name字段。
接口与抽象类的对比应用
接口(Interface)是完全抽象的类,仅包含常量(public static final)和抽象方法(public abstract)。JDK 8起支持默认方法(default)和静态方法,JDK 9支持私有方法。接口用于定义行为规范,体现“能做什么”的契约。
抽象类(Abstract Class)可包含部分实现,支持构造方法、普通字段、非抽象方法。抽象类用于代码复用,体现“是什么”的共性。
接口 vs 抽象类选择指南
- • 需要多继承行为 → 使用接口(Java不支持多继承类)
- • 需要共享非public代码 → 使用抽象类
- • 定义稳定核心API(如Runnable、Comparable) → 接口
- • 提供部分默认实现(如AbstractList) → 抽象类
以下实现Comparable接口的Person类按年龄排序:
import java.util.*; class Person implements Comparable{ private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override public int compareTo(Person other) { return Integer.compare(this.age, other.age); // 升序排列 } @Override public String toString() { return name + "(" + age + ")"; } } public class ComparableDemo { public static void main(String[] args) { List list = Arrays.asList( new Person("王五", 25), new Person("赵六", 20), new Person("钱七", 30) ); Collections.sort(list); System.out.println(list); // 输出:[赵六(20), 王五(25), 钱七(30)] } }
注意:compareTo返回0表示相等,负值表示小于,正值表示大于。Java 8后可使用Comparator.comparingInt(Person::getAge)实现更简洁的排序。
集合框架与泛型编程
Collection体系深度剖析
Java集合框架(java.util)提供统一API操作对象组。核心接口包括:
- • List:有序可重复(如ArrayList、LinkedList)
- • Set:无序不重复(如HashSet、TreeSet)
- • Queue:队列结构(如LinkedList、PriorityQueue)
ArrayList基于动态数组实现,随机访问快(O(1)),插入/删除慢(O(n));LinkedList基于双向链表,插入/删除快(O(1)),随机访问慢(O(n))。选择建议:频繁查询用ArrayList,频繁增删用LinkedList。
ArrayList vs LinkedList性能对比
| 操作 | ArrayList | LinkedList |
|---|---|---|
| 随机访问 get(i) | O(1) | O(n) |
| 末尾添加 add(e) | 均摊O(1) | O(1) |
| 中间插入 add(i,e) | O(n-i) | O(n)(需遍历) |
| 删除 remove(i) | O(n-i) | O(n) |
| 内存开销 | 低(仅元素数组) | 高(每个节点含prev/next指针) |
以下演示ArrayList的扩容机制(JDK 1.8):
public class ArrayListDemo {
public static void main(String[] args) {
List list = new ArrayList<>(2); // 初始容量2
list.add("A");
list.add("B");
System.out.println("初始容量: " + getCapacity(list)); // 2
list.add("C"); // 超出容量,触发扩容
System.out.println("扩容后容量: " + getCapacity(list)); // 3(原容量*1.5)
}
// 反射获取ArrayList容量(仅测试用)
private static int getCapacity(List> list) {
try {
Field elementData = ArrayList.class.getDeclaredField("elementData");
elementData.setAccessible(true);
Object[] array = (Object[]) elementData.get(list);
return array.length;
} catch (Exception e) {
return -1;
}
}
}
注意:实际扩容逻辑为newCapacity = oldCapacity + (oldCapacity >> 1)(即1.5倍),但首次扩容为10。
Map接口与哈希表实现
Map存储键值对(Key-Value),常用实现类:
- • HashMap:基于哈希表,非线程安全,允许null键值
- • LinkedHashMap:HashMap+双向链表,保持插入顺序
- • TreeMap:基于红黑树,按键排序,O(log n)复杂度
HashMap的put操作流程:
- 计算key的hashCode → 确定桶(bucket)位置
- 若桶为空,直接插入
- 若桶非空,遍历链表/红黑树:
- • 找到相同key则更新value
- • 未找到则插入链表尾部
- 若链表长度≥8且数组长度≥64,转红黑树
- 若数组长度<64,优先扩容而非树化
HashMap线程安全替代方案
// 方案1:Collections.synchronizedMap(粗粒度锁) MapsyncMap = Collections.synchronizedMap(new HashMap<>()); // 方案2:ConcurrentHashMap(分段锁/CAS,高并发首选) ConcurrentHashMap concurrentMap = new ConcurrentHashMap<>(); concurrentMap.put("count", 1); concurrentMap.computeIfAbsent("count", k -> 0); // 原子操作 // 方案3:使用java.util.concurrent.locks.ReentrantLock class SafeMap { private final Map map = new HashMap<>(); private final ReentrantLock lock = new ReentrantLock(); public V put(K key, V value) { lock.lock(); try { return map.put(key, value); } finally { lock.unlock(); } } }
泛型(Generic)的类型擦除与边界
泛型是编译期特性,运行时执行类型擦除(Type Erasure),将泛型参数替换为Object或边界类型。例如:List在运行时变为List,但编译器自动插入强制转换代码。
通配符使用规则:
- •
List>:未知类型列表(只读,不能add除null外的对象) - •
List extends Number>:Number子类型列表(上界限定) - •
List super Integer>:Integer父类型列表(下界限定)
PECS原则(Producer Extends Consumer Super):需要读取数据用extends(生产者),需要写入数据用super(消费者)。
Web开发基础:Servlet与JSP
Servlet生命周期与请求处理
Servlet是Java Web的核心组件,实现javax.servlet.Servlet接口。典型实现方式是继承HttpServlet,重写doGet/doPost方法。生命周期由容器(如Tomcat)管理:
- 实例化:容器创建Servlet对象(单例)
- 初始化:调用init()(仅一次)
- 服务:每次请求调用service() → doGet/doPost
- 销毁:容器关闭时调用destroy()
以下实现简单的计数器Servlet:
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class CounterServlet extends HttpServlet {
private int count = 0; // 注意:多线程环境下需同步
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 同步处理避免线程安全问题
synchronized(this) {
count++;
}
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
out.println("");
out.println("访问次数: " + count + "
");
out.println("");
}
}
web.xml配置:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>CounterServlet</servlet-name>
<servlet-class>com.example.CounterServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CounterServlet</servlet-name>
<url-pattern>/counter</url-pattern>
</servlet-mapping>
</web-app>
注意:Servlet是单实例多线程,共享实例变量存在线程安全风险。推荐使用局部变量或Session/Request作用域存储用户数据。
JSP与EL表达式
JSP(JavaServer Pages)是简化Servlet的模板技术,允许在HTML中嵌入Java代码。JSP隐式对象包括request、response、session、application等。EL(Expression Language)表达式简化数据访问:
- •
${user.name}→ 调用user.getName() - •
${empty list}→ 判断集合是否为空 - •
${param.username}→ 获取请求参数
JSP表单处理示例
<%-- register.jsp --%>
<form action="register" method="post">
用户名:<input type="text" name="username"><br>
密码:<input type="password" name="password"><br>
<input type="submit" value="注册">
</form>
<%-- RegisterServlet.java --%>
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String username = request.getParameter("username");
String password = request.getParameter("password");
// 验证逻辑(实际项目中应加密存储)
if (username != null && !username.isEmpty() &&
password != null && password.length() >= 6) {
request.setAttribute("message", "注册成功!");
request.getRequestDispatcher("/success.jsp").forward(request, response);
} else {
request.setAttribute("error", "用户名或密码无效");
request.getRequestDispatcher("/register.jsp").forward(request, response);
}
}
注意:JSP 2.3后已不推荐直接嵌入Java代码(scriptlet),应使用EL+JSTL标签库实现逻辑分离。
Spring框架核心:IOC与AOP
控制反转(IOC)与依赖注入(DI)
Spring通过IOC容器管理对象生命周期,将对象创建权交给容器,实现松耦合。依赖注入(DI)是IOC的实现方式,包括构造器注入、Setter注入、接口注入。
以下使用注解实现DI:
// 1. 定义服务接口
public interface UserService {
void register(String username, String password);
}
// 2. 实现类
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserRepository userRepository; // 依赖注入
@Override
public void register(String username, String password) {
userRepository.save(new User(username, password));
}
}
// 3. 数据访问层
@Repository
public class UserRepository {
public void save(User user) {
System.out.println("保存用户:" + user.getUsername());
}
}
主配置类:
@Configuration
@ComponentScan("com.example")
public class AppConfig {
}
运行测试:
public class Main {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppConfig.class);
UserService service = context.getBean(UserService.class);
service.register("张三", "123456");
// 输出:保存用户:张三
}
}
面向切面编程(AOP)实战
AOP用于分离横切关注点(如日志、事务、安全),通过代理模式实现。Spring AOP基于动态代理(JDK Proxy/CGLIB)。
以下实现方法执行日志切面:
@Aspect
@Component
public class LogAspect {
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
System.out.println("方法调用:" + methodName + " 参数:" + Arrays.toString(args));
}
@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfter(JoinPoint joinPoint, Object result) {
System.out.println("方法返回:" + joinPoint.getSignature().getName() + " 结果:" + result);
}
}
运行效果:
方法调用:register 参数:[张三, 123456] 保存用户:张三 方法返回:register 结果:null
注意:Spring AOP仅支持方法级别切面,且仅对Spring容器管理的Bean生效。自调用(self-invocation)问题需通过注入自身或使用AspectJ解决。
数据库连接与事务管理
JDBC基础与连接池
JDBC(Java Database Connectivity)是Java操作数据库的标准API。典型流程:
- 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver")
- 获取连接:DriverManager.getConnection(url, user, password)
- 创建Statement/PreparedStatement
- 执行SQL并处理结果
- 关闭资源(try-with-resources自动管理)
使用连接池优化性能
// HikariCP配置(高性能连接池)
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("123456");
config.setMaximumPoolSize(10);
try (HikariDataSource dataSource = new HikariDataSource(config);
Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id=?")) {
stmt.setInt(1, 1);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getString("name"));
}
}
} // 自动关闭资源
Spring事务管理深度解析
Spring事务通过TransactionManager管理,支持编程式(TransactionTemplate)和声明式(@Transactional)两种方式。声明式事务更常用:
@Service
public class OrderService {
@Autowired
private OrderDao orderDao;
@Transactional
public void createOrder(Order order) {
orderDao.insert(order);
// 模拟异常
if (order.getAmount() > 1000) {
throw new RuntimeException("订单金额过大");
}
// 其他操作...
}
}
关键点:
- • 默认回滚条件:RuntimeException(非检查异常)
- • 可配置rollbackFor:@Transactional(rollbackFor = Exception.class)
- • 传播行为:REQUIRED(默认)、REQUIRES_NEW等
- • 事务失效场景:非public方法、自调用、异常被捕获
自调用问题解决方案:
@Service
public class OrderService {
@Autowired
private OrderService self; // 注入自身
public void createOrder(Order order) {
self.createOrderInternal(order); // 调用带事务的方法
}
@Transactional
public void createOrderInternal(Order order) {
// 真正的事务逻辑
}
}
单元测试与自动化测试
JUnit 5核心特性
JUnit 5由三个模块组成:
- • JUnit Platform:测试运行平台
- • JUnit Jupiter:编程模型(@Test、@BeforeEach等)
- • JUnit Vintage:兼容JUnit 3/4
以下演示参数化测试与断言:
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
@InjectMocks
private UserService userService;
@ParameterizedTest
@ValueSource(strings = {"zhangsan", "lisi"})
void testValidUsername(String username) {
assertTrue(username.length() >= 3);
}
@Test
void testRegister() {
doNothing().when(userRepository).save(any(User.class));
userService.register("test", "123456");
verify(userRepository, times(1)).save(argThat(user ->
user.getUsername().equals("test")));
}
}
Mockito模拟测试
Mockito用于隔离外部依赖,常见用法:
- •
when(...).thenReturn(...):模拟方法返回值 - •
doThrow().when(...):模拟异常 - •
verify(...):验证调用次数
注意:Mockito 3.4.0+支持模拟final类(需启用MockMaker)。推荐使用Mockito-inline扩展。
项目部署与运维
Maven构建与依赖管理
Maven通过POM(Project Object Model)管理项目构建。典型依赖声明:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.1.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>
构建命令:
- • mvn clean:清理target目录
- • mvn compile:编译源码
- • mvn test:执行单元测试
- • mvn package:打包JAR/WAR
- • mvn spring-boot:run:运行Spring Boot应用
Docker容器化部署
Dockerfile示例:
FROM openjdk:17-jdk-slim WORKDIR /app COPY target/app.jar app.jar EXPOSE 8080 ENTRYPOINT ["java", "-jar", "app.jar"]
构建与运行:
docker build -t java-app:latest . docker run -d -p 8080:8080 --name app java-app:latest
网友常见问题答疑
Q1:Java中==与equals的区别?
A:==比较引用地址(基本类型比较值),equals默认比较地址(Object实现),重写后可比较内容。例如String重写了equals(),但包装类如Integer在-128~127范围内有缓存,需注意:
Integer a = 100; Integer b = 100; System.out.println(a == b); // true(缓存对象) Integer c = 200; Integer d = 200; System.out.println(c == d); // false(新对象)
Q2:ArrayList和Vector的区别?
A:Vector是线程安全的(方法同步),但性能低;ArrayList非线程安全但性能高。现代开发中通常用ConcurrentHashMap或CopyOnWriteArrayList替代Vector。推荐:单线程用ArrayList,多线程用并发集合。
Q3:Java内存模型(JMM)核心概念?
A:JMM定义了线程与主内存的交互规则:
- • 主内存:所有变量存储位置
- • 工作内存:线程私有内存,保存主内存变量副本
- • 内存交互操作:read、load、use、assign、store、write、lock、unlock
- • 原子性:由volatile、synchronized保证
- • 可见性:volatile、synchronized、final
- • 有序性:volatile、synchronized
Q4:Spring事务传播行为有哪些?
A:常用传播行为:
- • REQUIRED(默认):有事务则加入,无则新建
- • REQUIRES_NEW:新建事务,挂起当前事务
- • NESTED:嵌套事务(使用Savepoint)
- • SUPPORTS:有事务则参与,无则非事务执行
- • NOT_SUPPORTED:非事务执行,挂起当前事务
Q5:Java 8的Stream API使用技巧?
A:Stream分中间操作(返回Stream)和终止操作(返回非Stream)。典型用法:
Listnames = Arrays.asList("张三", "李四", "王五"); List result = names.stream() .filter(s -> s.startsWith("张")) .map(String::toUpperCase) .collect(Collectors.toList());
并行流(parallelStream)适用于CPU密集型任务,但需注意线程安全问题。