Java 进阶基础：这 3 个知识点，新手到高手的必经之路！

很多 Java 开发者卡在 "入门到进阶" 的鸿沟里，其实不是缺高深技巧，而是一些基础知识点没吃透 ------ 比如值传递 vs 引用传递、异常处理规范、集合遍历陷阱。今天用通俗的解释 + 实战代码，帮你打通进阶路上的 "基础关"！

1. 值传递 vs 引用传递：别再被 "传对象" 误导了

坑点：以为传递对象就是 "引用传递"，结果修改对象属性生效，重新赋值却无效？真相：Java 只有值传递！传递对象时，实际传递的是 "对象引用的副本"------ 副本指向原对象，所以能修改属性；但副本本身是新变量，重新赋值不会影响原引用。

java 复制代码

public class PassTest {
    // 自定义对象
    static class Person {
        String name;
        public Person(String name) {
            this.name = name;
        }
    }

    // 修改对象属性
    public static void changeName(Person p) {
        p.name = "李四"; // 生效：副本指向原对象，修改属性
    }

    // 重新赋值对象引用
    public static void reassign(Person p) {
        p = new Person("王五"); // 无效：仅修改副本引用，原对象不受影响
    }

    public static void main(String[] args) {
        Person person = new Person("张三");
        
        changeName(person);
        System.out.println(person.name); // 输出：李四（属性被修改）
        
        reassign(person);
        System.out.println(person.name); // 输出：李四（原对象未变）
    }
}

2. 异常处理：try-catch-finally 的正确打开方式

坑点：忽略 finally 的执行逻辑，或者滥用 catch "吞掉" 异常？规范：finally 一定会执行（除非 JVM 退出），适合释放资源；catch 要精准捕获异常，别用 Exception 一刀切，更不要不处理异常。

java 复制代码

import java.io.FileInputStream;
import java.io.IOException;

public class ExceptionTest {
    public static void readFile(String path) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(path); // 可能抛出FileNotFoundException
            // 读取文件操作
        } catch (IOException e) {
            // 精准捕获IO相关异常，打印日志（别只写e.printStackTrace()）
            System.err.println("文件读取失败：" + e.getMessage());
        } finally {
            // 必须释放资源，finally是最佳位置
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    System.err.println("流关闭失败：" + e.getMessage());
                }
            }
        }
    }

    public static void main(String[] args) {
        readFile("test.txt");
    }
}

3. 集合遍历：foreach 循环不能修改元素？

坑点：用 foreach 遍历 List 时，直接修改元素值无效，删除元素还会报错？原理：foreach 本质是迭代器遍历，普通类型（int、String）遍历的是 "元素副本"；删除元素会触发迭代器的 ConcurrentModificationException，需用迭代器的 remove() 方法。

java 复制代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CollectionTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        // 错误1：foreach修改普通元素（无效）
        for (int num : list) {
            num = num * 2; // 仅修改副本，原集合不变
        }
        System.out.println(list); // 输出：[1,2,3]

        // 正确1：修改对象类型元素（生效，因为遍历的是引用副本）
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三"));
        for (Person p : personList) {
            p.name = "李四"; // 生效
        }
        System.out.println(personList.get(0).name); // 输出：李四

        // 错误2：foreach删除元素（报错ConcurrentModificationException）
        // for (int num : list) {
        //     if (num == 2) list.remove(num);
        // }

        // 正确2：用迭代器删除
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            int num = iterator.next();
            if (num == 2) {
                iterator.remove(); // 安全删除
            }
        }
        System.out.println(list); // 输出：[1,3]
    }

    static class Person {
        String name;
        public Person(String name) {
            this.name = name;
        }
    }
}

总结：进阶的本质是把基础玩透

这 3 个知识点看似简单，但实际开发中出错率极高！记住核心要点：

Java 只有值传递，对象传递是 "引用副本传递"；
异常处理要精准捕获、及时释放资源；
集合遍历修改 / 删除，优先用迭代器或增强 for（对象类型）。