Java工程实践：从基础语法到高级特性的应用

引言

Java作为一门成熟的面向对象编程语言，在企业级应用开发中占据着重要地位。本文将带您从Java基础语法开始，逐步深入到高级特性，并通过实际工程案例展示如何将这些知识应用到真实项目中。

一、Java基础语法精要

1.1 面向对象编程基础

public class BankAccount {
    // 封装：私有字段
    private String accountNumber;
    private double balance;
    
    // 构造方法
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // 方法抽象
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("余额不足");
        }
        balance -= amount;
    }
    
    // 继承和多态将在后面展示
}

1.2 集合框架的使用

public class CollectionExamples {
    public static void main(String[] args) {
        // List示例
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.sort(String::compareTo);
        
        // Map示例
        Map<String, Integer> wordCount = new HashMap<>();
        wordCount.put("Java", 10);
        wordCount.put("Python", 5);
        
        // Java 8 Stream API
        long count = names.stream()
                         .filter(name -> name.startsWith("A"))
                         .count();
    }
}

二、Java高级特性实战

2.1 并发编程实践

public class ConcurrentBankAccount {
    private final ReentrantLock lock = new ReentrantLock();
    private double balance;
    
    public void transfer(ConcurrentBankAccount to, double amount) {
        // 避免死锁：按特定顺序获取锁
        ConcurrentBankAccount first = this.hashCode() < to.hashCode() ? this : to;
        ConcurrentBankAccount second = this.hashCode() < to.hashCode() ? to : this;
        
        first.lock.lock();
        try {
            second.lock.lock();
            try {
                if (this.balance >= amount) {
                    this.balance -= amount;
                    to.balance += amount;
                }
            } finally {
                second.lock.unlock();
            }
        } finally {
            first.lock.unlock();
        }
    }
    
    // 使用CompletableFuture进行异步处理
    public CompletableFuture<Void> asyncTransfer(ConcurrentBankAccount to, double amount) {
        return CompletableFuture.runAsync(() -> transfer(to, amount));
    }
}

2.2 Java 8函数式编程

public class FunctionalProgramming {
    public static void main(String[] args) {
        // Lambda表达式
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.forEach(n -> System.out.println(n));
        
        // 方法引用
        numbers.forEach(System.out::println);
        
        // Stream API高级用法
        Map<String, Long> wordFrequency = Files.lines(Paths.get("data.txt"))
            .flatMap(line -> Arrays.stream(line.split("\\s+")))
            .filter(word -> word.length() > 0)
            .collect(Collectors.groupingBy(
                word -> word, 
                Collectors.counting()
            ));
    }
}

三、工程实践中的设计模式应用

3.1 策略模式在支付系统中的应用

public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;
    private String cvv;
    
    @Override
    public void pay(BigDecimal amount) {
        // 信用卡支付逻辑
    }
}

public class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(BigDecimal amount) {
        strategy.pay(amount);
    }
}

// 使用示例
PaymentProcessor processor = new PaymentProcessor();
processor.setStrategy(new CreditCardPayment("1234-5678-9012-3456", "123"));
processor.executePayment(new BigDecimal("100.00"));

3.2 观察者模式实现事件通知

public class Order {
    private List<OrderObserver> observers = new ArrayList<>();
    private String status;
    
    public void addObserver(OrderObserver observer) {
        observers.add(observer);
    }
    
    public void setStatus(String newStatus) {
        this.status = newStatus;
        notifyObservers();
    }
    
    private void notifyObservers() {
        observers.forEach(observer -> observer.update(this));
    }
}

@FunctionalInterface
public interface OrderObserver {
    void update(Order order);
}

// 使用示例
Order order = new Order();
order.addObserver(o -> System.out.println("订单状态更新为: " + o.getStatus()));
order.setStatus("SHIPPED");

四、性能优化与JVM调优

4.1 内存泄漏检测与预防

public class MemoryLeakExample {
    private static final Map<Long, Object> CACHE = new HashMap<>();
    
    // 错误示范：会导致内存泄漏
    public void addToCache(Long id, Object data) {
        CACHE.put(id, data);
    }
    
    // 正确做法：使用WeakHashMap或定期清理
    private static final Map<Long, Object> SAFE_CACHE = new WeakHashMap<>();
    
    public void safeAddToCache(Long id, Object data) {
        SAFE_CACHE.put(id, data);
    }
}

// 使用Java VisualVM或JProfiler检测内存泄漏

4.2 JVM参数调优实例

# 生产环境推荐配置示例
java -Xms2g -Xmx2g \
     -XX:MaxMetaspaceSize=256m \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -jar your-application.jar

五、现代Java工程实践

5.1 模块化开发(Java 9+)

// module-info.java
module com.example.banking {
    requires java.base;
    requires java.sql;
    requires transitive com.fasterxml.jackson.databind;
    
    exports com.example.banking.api;
    exports com.example.banking.model;
    
    opens com.example.banking.internal to spring.core;
}

5.2 使用Records简化DTO(Java 14+)

public record Customer(
    Long id,
    String name,
    String email,
    LocalDate joinDate
) {}

// 自动生成equals, hashCode, toString等方法
// 使用示例
Customer customer = new Customer(1L, "Alice", "alice@example.com", LocalDate.now());

结语

Java语言经过20多年的发展，已经形成了一个丰富而成熟的生态系统。从基础语法到高级特性，Java为开发者提供了强大的工具来解决各种工程问题。掌握这些知识并合理运用，将帮助你构建更健壮、更高效的企业级应用。

在实际项目中，建议：

1. 根据团队规模选择合适的特性子集
2. 保持代码风格一致
3. 定期进行代码审查
4. 持续学习Java的新特性