java期末总结

⚡ Java基础核心体系梳理

Java语言作为跨平台、面向对象的编程语言,其基础语法构成整个知识大厦的根基。从变量类型、运算符、流程控制到数组与字符串操作,每一块都需扎实掌握。尤其在期末考试中,基础题占比常达30%以上,是拿分的关键阵地。

以下为高频易错点归纳:

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true(缓存池机制:-128~127)
Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false(超出缓存,新建对象)

需牢记:==比较引用地址;equals()比较内容(但需注意重写与空指针问题)。

String s = "";
for(int i=0;i<1000;i++) s += i; // 低效:创建1000+个String对象
StringBuilder sb = new StringBuilder();
for(int i=0;i<1000;i++) sb.append(i);
String result = sb.toString(); // 高效
String grade = "B";
switch(grade) {
    case "A": System.out.println("优秀"); break;
    case "B":
    case "C": System.out.println("良好"); break;
    default: System.out.println("不及格");
}

输出:良好(B与C共享逻辑)。

【特别提醒】:数组下标越界(ArrayIndexOutOfBoundsException)与空指针异常(NullPointerException)是考试与实际开发中最常见的两类运行时异常,务必养成边界检查与空值判断习惯。

⚙️ 面向对象三大特性深度解析

面向对象编程(OOP)是Java的核心思想,其三大特性——封装、继承、多态——共同支撑起代码的可维护性与复用性。期末考试中常结合设计模式、UML图、代码分析题出现。

1. 封装(Encapsulation)

通过private属性+public getter/setter实现数据隐藏与访问控制。示例:

public class Student {
    private String name;
    private int age;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) {
        if(age >= 0 && age <= 150) this.age = age;
        else throw new IllegalArgumentException("年龄非法");
    }
}

优势:防止非法赋值、便于后期扩展(如添加日志、校验逻辑)。

2. 继承(Inheritance)

使用extends实现代码复用,Java单继承。注意:

3. 多态(Polymorphism)

核心:父类引用指向子类对象(向上转型),运行时动态绑定。示例:

class Animal {
    void speak() { System.out.println("动物发声"); }
}
class Dog extends Animal {
    void speak() { System.out.println("汪汪!"); }
    void fetch() { System.out.println("叼骨头"); }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog(); // 向上转型
        a.speak(); // 输出:汪汪!(动态绑定)
        // a.fetch(); // 编译错误:Animal无fetch()方法
        Dog d = (Dog)a; // 向下转型,需确保安全
        d.fetch(); // 可调用子类特有方法
    }
}

【考试高频点】:判断输出结果。关键看:编译看左边(引用类型),运行看右边(实际对象)。

〔集合框架〕高频考点与使用策略

集合是Java中处理数据的核心工具,常与算法、IO、数据库结合考查。主要分三大体系:List(有序可重复)、Set(无序不重复)、Map(键值对)。

1. List实现类对比

特性ArrayListLinkedListVector
底层结构动态数组双向链表动态数组(线程安全)
随机访问快(O(1))慢(O(n))快
插入/删除慢(需移动)快(仅改指针)慢
线程安全否否是(方法加synchronized)
推荐场景查询多、尾部插入频繁插入/删除旧版多线程环境(现多用Collections.synchronizedList)

2. Set实现类与去重原理

class Student implements Comparable {
    String name; int score;
    Student(String name, int score) { this.name = name; this.score = score; }
    public int compareTo(Student o) { return Integer.compare(this.score, o.score); }
    public boolean equals(Object o) {  }
    public int hashCode() {  }
}
TreeSet set = new TreeSet<>();
set.add(new Student("张三", 85));
set.add(new Student("李四", 92));
// 遍历结果按score升序排列

3. Map核心操作

Map接口不继承Collection,常用实现类为HashMap、TreeMap、LinkedHashMap。

Map map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
map.put("Java", 3); // 覆盖旧值
// 遍历方式1:entrySet
for(Map.Entry e : map.entrySet()) {
    System.out.println(e.getKey() + " → " + e.getValue());
}
// 遍历方式2:forEach(JDK8+)
map.forEach((k,v) -> System.out.println(k + ": " + v));

【易错点】:HashMap的默认初始容量为16,负载因子0.75。当size > capacity * loadFactor时触发扩容(2倍扩容),频繁扩容影响性能。

〈异常处理〉分类、捕获与自定义异常

Java异常体系以Throwable为根,分Error(严重错误,如OutOfMemoryError)与Exception(可处理异常)。

1. 异常分类图示

2. 异常处理最佳实践

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line = br.readLine();
    System.out.println(line);
} catch (IOException e) {
    System.err.println("读取文件失败:" + e.getMessage());
} // 自动关闭资源,无需finally

3. 自定义异常

业务场景中常需自定义异常,继承Exception(受检)或RuntimeException(非受检):

public class AgeException extends Exception {
    public AgeException(String msg) { super(msg); }
}
public void setAge(int age) throws AgeException {
    if(age < 0 || age > 150) throw new AgeException("年龄超出合理范围!");
    this.age = age;
}

【IO流】字节流、字符流与NIO快速对比

Java IO体系庞大,核心分为:字节流(InputStream/OutputStream)与字符流(Reader/Writer)。字符流自动处理编码(默认UTF-8),适合文本;字节流用于二进制(图片、音频)。

1. 字符流典型应用

try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("期末总结\n");
    bw.write("Java重点整理");
} // 自动flush与关闭

2. 缓冲流提升效率

BufferedInputStream/BufferedOutputStream、BufferedReader/BufferedWriter通过内部缓冲区减少磁盘I/O次数,显著提升性能。

3. NIO(New IO)简介

JDK1.4引入NIO,基于通道(Channel)与缓冲区(Buffer),支持非阻塞模式。核心类:

// NIO读取文件(非阻塞示例)
RandomAccessFile file = new RandomAccessFile("data.txt", "r");
FileChannel channel = file.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
buffer.flip(); // 切换为读模式
while(buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}
channel.close(); file.close();

【考试提示】:掌握FileReader/Writer、BufferedReader/Writer的使用;理解字节流与字符流转换(InputStreamReader/OutputStreamWriter)。

『多线程』创建方式、状态与线程安全

1. 创建线程的三种方式

  1. 继承Thread类:重写run(),调用start()。
  2. 实现Runnable接口:避免单继承局限,推荐。
  3. 实现Callable接口 + FutureTask:支持返回值与异常(JDK5+)。
// 方式2:Runnable
Thread t = new Thread(() -> {
    for(int i=0;i<5;i++) System.out.println("线程执行:" + i);
});
t.start();
// 方式3:Callable
Callable task = () -> {
    Thread.sleep(100);
    return 42;
};
FutureTask future = new FutureTask<>(task);
new Thread(future).start();
System.out.println(future.get()); // 阻塞等待结果

2. 线程状态

NEW → RUNNABLE(含READY与RUNNING)→ BLOCKED → WAITING/TIMED_WAITING → TERMINATED

3. 线程安全与同步

竞争条件(Race Condition)是线程不安全的根源。解决方式:

class Counter {
    private int count = 0;
    public synchronized void increment() { count++; } // 同步方法
    public int getCount() { return count; }
}

【重要概念】:volatile关键字保证可见性(线程间共享最新值),但不保证原子性(如count++非原子操作)。

☆ 网络编程:TCP/UDP与Socket通信

1. TCP与UDP对比

特性TCPUDP
连接面向连接(三次握手)无连接
可靠性可靠(重传、确认)不可靠(尽最大努力)
效率低(开销大)高(开销小)
适用场景文件传输、网页浏览视频直播、DNS查询

2. Socket编程核心步骤

服务端(ServerSocket):

  1. 创建ServerSocket对象(指定端口)
  2. 调用accept()阻塞等待客户端连接
  3. 获取Socket,通过getInputStream/getOutputStream通信

客户端(Socket):

  1. 创建Socket(指定服务器IP与端口)
  2. 获取输入/输出流进行数据收发
// 简单服务端示例
ServerSocket server = new ServerSocket(8080);
Socket client = server.accept(); // 阻塞等待
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();
// 读写数据...
client.close(); server.close();

【高频考点】:端口范围(0-65535),1024以下为系统端口;IP地址格式(IPv4:点分十进制)。

【JDBC】数据库连接五步法与工具类封装

JDBC(Java Database Connectivity)是Java操作数据库的标准API,核心步骤:

  1. 加载驱动(Class.forName("com.mysql.cj.jdbc.Driver"))
  2. 获取连接(DriverManager.getConnection(url, user, pwd))
  3. 创建语句对象(Statement/PreparedStatement)
  4. 执行SQL并处理结果(executeQuery / executeUpdate)
  5. 关闭资源(ResultSet → Statement → Connection)

1. PreparedStatement防SQL注入

String sql = "SELECT * FROM users WHERE name = ? AND pwd = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, username);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();

相比Statement(拼接字符串),PreparedStatement使用参数化查询,自动转义特殊字符,彻底避免SQL注入。

2. 连接池与DBUtils

实际开发中使用连接池(如HikariCP、Druid)管理连接,避免频繁创建/销毁。结合Apache Commons DbUtils可简化ResultSet处理:

QueryRunner runner = new QueryRunner(dataSource);
String sql = "INSERT INTO student(name, score) VALUES(?, ?)";
int rows = runner.update(sql, "王五", 95);

【考试重点】:掌握ResultSet遍历(next())、常用方法(getString/getInt);理解事务(Connection.setAutoCommit(false); commit(); rollback())。

《Java新特性》JDK8~17核心更新(期末重点)

1. Lambda表达式与函数式编程

JDK8引入Lambda,简化匿名内部类,适用于函数式接口(仅一个抽象方法的接口,如Runnable、Comparator):

// 旧写法
Runnable r1 = new Runnable() {
    public void run() { System.out.println("Hello"); }
};
// Lambda写法
Runnable r2 = () -> System.out.println("Hello");
// 方法引用
List names = Arrays.asList("张三", "李四");
names.forEach(System.out::println);

2. Stream API

流式处理集合数据,支持链式操作(filter/map/sorted/collect):

List nums = Arrays.asList(1,2,3,4,5);
List evens = nums.stream()
    .filter(n -> n % 2 == 0)  // 过滤偶数
    .map(n -> n * n)          // 平方
    .sorted()                 // 排序
    .collect(Collectors.toList());
// 结果:[4, 16]

3. 其他重要特性

String html = """
        Hello
    """; // 自动处理换行与缩进

【趋势提示】:近年真题中Lambda与Stream占比超40%,务必重点掌握!

▲ 项目实战:简易图书管理系统(JavaSE版)

结合所学知识,设计一个控制台版图书管理系统,核心功能模块:

  1. 添加图书(添加对象)
  2. 显示所有图书(遍历List)
  3. 按书名查询(遍历+equals)
  4. 删除图书(removeById)
  5. 借阅/归还(修改status字段)
class Book {
    int id; String title; String author; double price; String status;
    Book(int id, String title, String author, double price) {
        this.id = id; this.title = title; this.author = author;
        this.price = price; this.status = "可借";
    }
    // getter/setter...
}
public class LibrarySystem {
    static List books = new ArrayList<>();
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        while(true) {
            System.out.println("1. 添加  2. 显示  3. 查询  4. 删除  5. 借阅  0. 退出");
            int choice = sc.nextInt();
            switch(choice) {
                case 1: addBook(); break;
                case 2: showAll(); break;
                // ... 其他分支
            }
        }
    }
    static void addBook() {
        System.out.print("ID: "); int id = sc.nextInt();
        sc.nextLine(); // 清除换行
        System.out.print("书名: "); String title = sc.nextLine();
        // ... 其他输入
        books.add(new Book(id, title, author, price));
        System.out.println("添加成功!");
    }
}

【扩展建议】:可升级为文件存储(ObjectOutputStream)、GUI界面(JavaFX)或连接MySQL数据库。

☆ 真题解析与高频考点总结

1. 选择题高频陷阱

2. 编程题高频题型

  1. 字符串处理:统计字符出现次数、反转字符串、判断回文。
  2. 集合操作:去除List重复元素(用Set)、按条件过滤。
  3. 多线程:生产者-消费者模型(wait/notify)、线程同步计数器。
  4. 异常处理:自定义异常类,模拟业务校验逻辑。

3. 近三年真题分布统计(本校)

模块202320222021占比
基础语法15%18%16%16.3%
面向对象22%20%24%22.0%
集合框架25%23%20%22.7%
异常与IO12%15%13%13.3%
多线程10%8%11%9.7%
JDBC/网络6%6%6%6.0%
新特性10%10%10%10.0%

〔备考策略〕科学复习时间轴与避坑指南

考前30天

知识梳理阶段

按模块整理思维导图,重点标注易混淆点(如ArrayList vs LinkedList、HashMap vs HashSet)。完成1遍教材阅读+配套习题。

考前20天

代码实战阶段

动手敲写核心代码:集合遍历、多线程同步、JDBC增删改查。每段代码运行并观察输出,理解底层机制。

考前10天

真题演练阶段

限时完成3~5套历年真题,重点分析错题归因(概念不清?粗心?时间不足?)。建立个人错题本。

考前3天

查漏补缺阶段

重读思维导图与错题本,重点记忆公式化知识点(如JDBC五步、线程状态图)。保证充足睡眠,调整心态。

常见误区与应对

考场答题技巧

  1. 选择题:先易后难,排除法优先;不确定选项标记后回头思考。
  2. 填空题:注意大小写(如String不能写成string)、方法名拼写。
  3. 编程题:

【最后叮嘱】:考试时若遇陌生题,回归基础概念。90%的难题可通过拆解为已知知识点解决!祝你期末高分通关!

网友们还关心