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操作流程:

  1. 计算key的hashCode → 确定桶(bucket)位置
  2. 若桶为空,直接插入
  3. 若桶非空,遍历链表/红黑树:
  4.   • 找到相同key则更新value
  5.   • 未找到则插入链表尾部
  6. 若链表长度≥8且数组长度≥64,转红黑树
  7. 若数组长度<64,优先扩容而非树化

HashMap线程安全替代方案

// 方案1:Collections.synchronizedMap(粗粒度锁)
Map syncMap = 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 :Number子类型列表(上界限定)
  • • List :Integer父类型列表(下界限定)

PECS原则(Producer Extends Consumer Super):需要读取数据用extends(生产者),需要写入数据用super(消费者)。

Web开发基础:Servlet与JSP

Servlet生命周期与请求处理

Servlet是Java Web的核心组件,实现javax.servlet.Servlet接口。典型实现方式是继承HttpServlet,重写doGet/doPost方法。生命周期由容器(如Tomcat)管理:

  1. 实例化:容器创建Servlet对象(单例)
  2. 初始化:调用init()(仅一次)
  3. 服务:每次请求调用service() → doGet/doPost
  4. 销毁:容器关闭时调用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。典型流程:

  1. 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver")
  2. 获取连接:DriverManager.getConnection(url, user, password)
  3. 创建Statement/PreparedStatement
  4. 执行SQL并处理结果
  5. 关闭资源(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)。典型用法:

List names = Arrays.asList("张三", "李四", "王五");
List result = names.stream()
    .filter(s -> s.startsWith("张"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

并行流(parallelStream)适用于CPU密集型任务,但需注意线程安全问题。