第七周总结

Java 学习第七周总结
一、学习概述
本周学习内容涵盖 Java 基础强化、集合框架深入、IO 流与多线程编程，以及 Kubernetes 容器编排基础。在 Java 基础方面，深入理解了抽象类与接口的差异、多态实现及异常处理机制；集合框架部分对比了 ArrayList 与 LinkedList 的性能特点，分析了 HashMap 与 ConcurrentHashMap 的线程安全实现；IO 流与多线程部分梳理了字节流与字符流的应用场景，复习了线程创建方式与反射核心操作；容器编排方面学习了 Kubernetes 的核心概念，并实践了 Spring Boot 应用的 K8s 部署。
二、Java 基础强化
（一）抽象类与接口对比

特性 抽象类 接口
继承方式 extends（单继承） implements（多实现）
成员变量 任意类型 默认 public static final
方法实现 可有具体方法 Java 8 + 支持默认方法
构造方法 有 无
核心差异：抽象类用于定义 "是什么" 的类型（如 Animal 抽象类），接口用于定义 "能做什么" 的能力（如 Flyable 接口）。实际开发中，接口因多实现特性更符合组合复用原则，抽象类则适用于代码复用场景。
（二）多态实现机制

// 父类定义
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}
// 子类重写
class Dog extends Animal {
@Override
void sound() {
System.out.println("Bark!");
}
}
// 多态应用
Animal myDog = new Dog(); // 父类引用指向子类对象
myDog.sound(); // 动态绑定调用子类方法（输出"Bark!"）
关键点：多态通过 "动态绑定" 实现运行时方法调用，需满足 "继承 + 方法重写 + 父类引用" 三个条件。实际开发中，多态是设计模式的基础（如策略模式、模板方法模式）。
（三）异常处理最佳实践

try {
// 可能抛出异常的核心逻辑（如文件读取）
FileInputStream fis = new FileInputStream("data.txt");
} catch (FileNotFoundException e) {
// 处理特定异常（文件不存在）
log.error("文件不存在", e);
} catch (IOException e) {
// 处理更通用的IO异常
log.error("IO操作失败", e);
} catch (Exception e) {
// 最后捕获所有异常
log.error("未知错误", e);
} finally {
// 资源释放（如关闭文件流）
fis.close();
}
异常金字塔原则：捕获异常时应遵循 "先具体后通用" 的顺序，避免先捕获 Exception 类导致子类异常被屏蔽。finally 块用于确保资源释放，即使 try/catch 中存在 return 语句，finally 仍会执行。
三、集合框架深入
（一）ArrayList vs. LinkedList

特性 ArrayList LinkedList
数据结构 动态数组 双向链表
随机访问 O (1)（直接通过索引访问） O (n)（从头遍历）
插入删除 尾部 O (1)，中间 O (n)（需移动元素） 头尾 O (1)，中间 O (n)（仅需修改指针）
内存占用 连续空间（数组预分配） 每个节点含数据 + 前后指针
应用场景：

  1. ArrayList：适合频繁随机访问的场景（如分页查询结果集）
  2. LinkedList：适合频繁插入删除的场景（如消息队列、链表操作）
    （二）HashMap vs. ConcurrentHashMap
  3. HashMap
  4. 非线程安全：多线程环境下可能出现死循环（JDK 1.8 通过 CAS 优化了扩容逻辑，但仍不建议多线程使用）
  5. 底层结构：
  6. JDK 1.7：数组 + 链表
  7. JDK 1.8：数组 + 链表（链表长度≥8）→ 红黑树
  8. 关键参数：
  9. 初始容量：16（默认）
  10. 负载因子：0.75（超过时扩容为 2 倍）
  11. ConcurrentHashMap
  12. 线程安全：
  13. JDK 1.7：分段锁（Segment 数组，每个 Segment 是一个 ReentrantLock）
  14. JDK 1.8：CAS + synchronized（仅锁定单个 Node 节点）
  15. 性能优化：
  16. 读操作无锁（通过 volatile 保证可见性）
  17. 写操作仅锁定当前桶（粒度更细）
  18. 适用场景：高并发读写场景（如缓存容器、计数器）
    （三）Fail-Fast vs. Fail-Safe
  19. Fail-Fast：
  20. 示例：ArrayList、HashMap 的迭代器
  21. 机制：遍历时检测 modCount 与 expectedModCount 是否一致，不一致则抛出 ConcurrentModificationException
  22. Fail-Safe：
  23. 示例：CopyOnWriteArrayList、ConcurrentHashMap
  24. 机制：遍历时基于集合副本操作，原集合修改不影响遍历
    四、IO 流与多线程
    （一）字节流 vs. 字符流

特性 字节流（InputStream/OutputStream） 字符流（Reader/Writer）
处理单位 8 位字节（byte） 16 位字符（char）
适用场景 二进制文件（图片、视频、压缩包） 文本文件（.txt、.json、.xml）
缓冲实现 BufferedInputStream BufferedReader
编码支持 无自动编码转换 支持 Charset（如 UTF-8、GBK）
最佳实践：处理文本时优先使用字符流（如 BufferedReader），并指定字符集；处理二进制数据时使用字节流（如 FileInputStream），配合缓冲流提升性能。
（二）线程创建方式对比

  1. 继承 Thread 类

class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread running");
}
}
new MyThread().start(); // 启动线程
限制：单继承特性，无法同时继承其他类。
2. 实现 Runnable 接口

class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable running");
}
}
new Thread(new MyRunnable()).start(); // 推荐方式
优势：支持函数式编程（Java 8 后可使用 Lambda 表达式），如new Thread(() -> System.out.println("Lambda Thread")).start();
3. 线程池（推荐）

// 创建固定大小线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
// 提交任务
executor.submit(() -> {
// 任务逻辑
});
// 优雅关闭
executor.shutdown();
核心参数：
11. corePoolSize：核心线程数（常驻线程）
12. maximumPoolSize：最大线程数
13. workQueue：任务队列（如 ArrayBlockingQueue 有界队列）
14. keepAliveTime：非核心线程存活时间
（三）反射核心操作

// 获取Class对象
Class<?> clazz = Class.forName("com.example.User");
// 创建实例（需有无参构造）
Object obj = clazz.newInstance();
// 获取私有方法
Method privateMethod = clazz.getDeclaredMethod("setPassword", String.class);
// 允许访问私有方法
privateMethod.setAccessible(true);
// 调用方法
privateMethod.invoke(obj, "123456");
// 获取私有字段
Field privateField = clazz.getDeclaredField("password");
privateField.setAccessible(true);
String password = (String) privateField.get(obj);
应用场景：
15. 框架底层（如 Spring 的 Bean 创建）
16. 动态代理（如 JDK Proxy、CGLIB）
17. 序列化与反序列化
五、Kubernetes 容器编排基础
（一）核心概念

  1. Pod
  2. 最小部署单元：一个 Pod 包含一个或多个容器（如 Spring Boot 应用 + 日志收集 Sidecar）
  3. 共享资源：同一 Pod 内的容器共享网络、存储卷
  4. Deployment
  5. 声明式部署：定义 Pod 副本数、镜像版本、更新策略
  6. 滚动更新：支持逐步替换 Pod，确保服务不中断
  7. Service
  8. 服务发现：为 Pod 提供稳定的访问地址（ClusterIP）
  9. 负载均衡：将请求分发到多个 Pod 副本
  10. 类型：ClusterIP（集群内访问）、NodePort（节点端口）、LoadBalancer（云服务商负载均衡）
  11. Ingress
  12. 七层负载均衡：基于 HTTP/HTTPS 协议的路由规则
  13. 域名路由：支持根据 URL 路径、域名转发到不同 Service
    （二）Spring Boot 应用部署实战
  14. 编写 Deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
name: order-service
spec:
replicas: 3 # 3个副本
selector:
matchLabels:
app: order-service
template:
metadata:
labels:
app: order-service
spec:
containers:
- name: order-service
image: registry.example.com/order-service:1.0 # 镜像地址
ports:
- containerPort: 8080 # 容器端口
env:
- name: SPRING_PROFILES_ACTIVE
value: prod # 环境变量
2. 编写 Service.yaml

apiVersion: v1
kind: Service
metadata:
name: order-service
spec:
selector:
app: order-service # 关联Pod标签
ports:

  • protocol: TCP
    port: 80 # 服务端口
    targetPort: 8080 # 目标Pod端口
    type: LoadBalancer # 类型（云环境自动创建负载均衡器）
  1. 部署命令

应用配置

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

查看Pod状态（实时监控）

kubectl get pods -w

查看服务

kubectl get services
实践要点：
27. 镜像需提前推送到 Docker Registry
28. 生产环境建议使用 ConfigMap 管理配置
29. 结合 HPA（Horizontal Pod Autoscaler）实现自动扩缩容
六、本周学习总结与反思
（一）学习成果

  1. 深入理解抽象类与接口的设计原则，能根据场景选择合适的继承 / 实现方式。
  2. 掌握 ArrayList/LinkedList、HashMap/ConcurrentHashMap 的性能差异，可根据业务场景选择集合类型。
  3. 熟练使用 IO 流处理不同类型文件，掌握多线程编程的最佳实践。
  4. 理解 Kubernetes 核心概念，能完成 Spring Boot 应用的 K8s 部署与服务暴露。
    （二）存在问题
  5. 反射机制的性能损耗及优化方法缺乏实践经验。
  6. Kubernetes 的网络策略（NetworkPolicy）与存储卷（PersistentVolume）配置不够熟练。
  7. 高并发场景下 ConcurrentHashMap 的底层实现（如 CAS 操作）理解不够深入。
    （三）改进方向
  8. 编写反射性能测试案例，对比反射与直接调用的效率差异。
  9. 学习 Kubernetes 网络策略与持久化存储配置，完成有状态应用部署。
  10. 研读 ConcurrentHashMap 源码，理解 JDK 1.8 的优化细节。
    （四）下周计划
  11. 学习分布式事务解决方案（Seata），理解 AT/TCC 模式。
  12. 深入研究微服务网关（Spring Cloud Gateway）的路由断言与过滤器链。
  13. 实践 Kubernetes 的有状态应用部署（如 MySQL 数据库）。
  14. 阅读《Effective Java》相关章节，提升 Java 编程素养。
posted @ 2025-06-15 20:52  执笔诉相思  阅读(7)  评论(0)    收藏  举报