每日 Java 面试题分享【第 17 天】

欢迎来到每日 Java 面试题分享栏目！
订阅专栏，不错过每一天的练习

今日分享 3 道面试题目！

评论区复述一遍印象更深刻噢~

问题一：Java 中的访问修饰符有哪些？

在 Java 中，访问修饰符用于控制类、变量、方法和构造方法的可见性范围。以下是 Java 的四种访问修饰符及其作用域，结合代码示例和底层原理进行说明：

访问修饰符分类及作用域

修饰符	类内部	同包其他类	不同包子类	不同包非子类
`public`	✔️	✔️	✔️	✔️
`protected`	✔️	✔️	✔️	❌
默认（无修饰符）	✔️	✔️	❌	❌
`private`	✔️	❌	❌	❌

1. public：全局可见

作用范围：所有类均可访问。
使用场景：开放 API 方法或常量。

代码示例：

public class Logger {
    public static final String LEVEL = "DEBUG"; // 所有类可访问
    public void log(String message) { /* 实现 */ }
}

底层原理：编译时无访问限制检查，JVM 通过符号引用直接访问。

2. protected：继承体系可见

作用范围：同包类 + 不同包的子类（需通过继承访问）。
关键细节：不同包子类中，只能访问从父类继承的 protected 成员，不能直接访问其他父类实例的成员。

代码示例：

// 包 com.example;
public class Base {
    protected void init() { /* 初始化逻辑 */ }
}

// 包 com.other;
public class Sub extends Base {
    void test() {
        init();               // ✔️ 允许（继承访问）
        new Base().init();    // ❌ 编译错误（直接访问其他实例）
    }
}

设计意义：支持模板方法模式，允许子类扩展特定步骤。

3. 默认（包级私有）：同包可见

作用范围：仅限同包内类访问。
使用场景：包内工具类或组件间协作。

代码示例：

class PackagePrivateUtils { // 默认修饰符
    static void helper() { /* 包内共享工具方法 */ }
}

底层原理：编译器在跨包访问时校验类权限，阻止外部包通过全限定名访问。

4. private：类内封闭

作用范围：仅限当前类内部。
使用场景：封装对象状态或内部工具方法。

代码示例：

public class Singleton {
    private static Singleton instance; // 私有静态变量
    private Singleton() {}             // 私有构造方法
    public static Singleton getInstance() { /* 提供全局访问点 */ }
}

反射限制：通过 setAccessible(true) 可突破限制，但违背封装原则。

高级应用与原理

类本身的修饰符：
- 顶级类（非内部类）只能用 public 或默认修饰符。
- 内部类可任意使用四种修饰符（如 private static class Node 用于链表实现）。

构造方法的特殊修饰：

public class HttpClient {
    private HttpClient() {} // 强制通过工厂方法创建实例
    public static HttpClient create() { return new HttpClient(); }
}

模块系统（Java 9+）：
即使成员是 public，若所在模块未导出对应包，其他模块仍无法访问（强化封装性）。

实战技巧

最小权限原则：优先使用最严格的访问级别（如默认 > protected > public）。
代码维护性：private 方法更易重构，public 方法需谨慎设计避免破坏兼容性。
测试考量：通过包结构组织测试类，合法访问默认和 protected 成员。

通过合理使用访问修饰符，可以有效控制代码的可见性，提升模块化设计和系统安全性。

问题二：Java 中静态方法和实例方法的区别是什么？

一、核心区别对比表（快速建立知识框架）

维度	静态方法 (Static Method)	实例方法 (Instance Method)
归属对象	类级别（Class Level）	对象级别（Object Level）
内存分配时机	类加载时	对象实例化时
调用方式	`ClassName.method()`	`object.method()`
隐含引用	无 `this` 引用	有 `this` 引用
多态支持	静态绑定（编译时确定）	动态绑定（运行时确定）
访问权限	只能访问静态成员	可访问静态 + 实例成员
线程安全考量	需关注静态变量竞争	实例变量隔离更易控制

二、底层原理深度解析

JVM 内存模型差异
- 静态方法：存储在方法区（JDK8+ 的元空间）的类元数据中
- 实例方法：存储在堆内存的对象实例的方法表中
```
// 示例：通过javap观察方法调用指令
// 静态方法调用指令：invokestatic
// 实例方法调用指令：invokevirtual/invokeinterface
```

方法分派机制

class Parent {
    static void staticMethod() { System.out.println("Parent static"); }
    void instanceMethod() { System.out.println("Parent instance"); }
}

class Child extends Parent {
    static void staticMethod() { System.out.println("Child static"); }
    @Override void instanceMethod() { System.out.println("Child instance"); }
}

public static void main(String[] args) {
    Parent p = new Child();
    p.staticMethod();   // 输出"Parent static"（静态方法隐藏）
    p.instanceMethod(); // 输出"Child instance"（实例方法覆盖）
}

三、实战应用场景分析

静态方法典型使用场景

工具类方法（无状态操作）

public final class StringUtils {
    private StringUtils() {} // 防止实例化
    public static boolean isEmpty(String str) { 
        return str == null || str.trim().isEmpty();
    }
}

工厂模式

public class ConnectionFactory {
    public static Connection create() { 
        return DriverManager.getConnection(url); 
    }
}

实例方法核心价值

状态封装（对象特有行为）

public class Order {
    private double amount;
    public void applyDiscount(double rate) { // 操作实例状态
        this.amount *= (1 - rate);
    }
}

模板方法模式

public abstract class PaymentProcessor {
    public final void process() { // 实例方法控制流程
        validate();
        executePayment();
        sendNotification();
    }
    protected abstract void executePayment();
}

四、高频面试深挖点

为什么静态方法不能是抽象的？
- 静态方法属于类级别，而抽象方法需要子类实现，存在根本性冲突
- 替代方案：使用工厂模式或策略模式实现类似效果

静态方法是否可以被重写？

严格说不存在重写（Override），只有隐藏（Hide）

示例说明：

class Animal { static void eat() { System.out.println("Animal eating"); } }
class Dog extends Animal { static void eat() { System.out.println("Dog eating"); } }

Animal myDog = new Dog();
myDog.eat(); // 输出Animal eating（静态方法没有多态性）

如何选择方法类型？决策树

是否需要访问实例变量？
├── 是 → 必须使用实例方法
└── 否 → 是否与对象状态相关？
    ├── 是 → 仍建议实例方法
    └── 否 → 考虑静态方法

五、性能优化注意事项

内存占用对比
- 静态方法：单份代码存储，无对象关联开销
- 实例方法：每个对象持有方法表指针（HotSpot JVM 优化后实际共享代码）
JIT 编译影响
- 高频调用的静态方法更易被内联优化（无虚方法表查找）

并发安全黄金法则

public class Counter {
    private static int count = 0;
    
    // 错误示范：静态方法操作静态变量未同步
    public static void unsafeIncrement() { count++; }
    
    // 正确方案：静态同步方法
    public static synchronized void safeIncrement() { count++; }
}

六、设计模式中的典型应用

单例模式（静态工厂方法）

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() { return INSTANCE; }
}

策略模式（实例方法多态）

public interface PaymentStrategy {
    void pay(double amount); // 实例方法实现多态
}

public class AlipayStrategy implements PaymentStrategy {
    @Override public void pay(double amount) { /* 具体实现 */ }
}

总结回答模板：
" 静态方法与实例方法的本质区别在于方法归属与状态绑定。静态方法属于类层级，在类加载时初始化，适用于工具类和工厂模式；实例方法绑定对象实例，支持多态和状态操作。在阿里中间件开发中，我们严格遵循：操作对象状态必须用实例方法，全局工具方法用静态方法，并通过 Sonar 代码检测确保规范执行。"

问题三：Java 中 for 循环与 foreach 循环的区别是什么？

一、核心区别对比表（快速建立知识框架）

维度	传统 for 循环 (`for(int i=0;…)`)	增强 for 循环 (`for(E e: collection)`)
语法复杂度	显式控制索引/迭代器	隐式迭代（语法糖）
底层实现	数组：直接索引访问集合：可能低效遍历	数组：编译为传统 for 集合：迭代器模式
代码安全性	需手动控制边界	自动处理越界
集合修改能力	可通过索引或迭代器安全删除	直接删除会抛 `ConcurrentModificationException`
性能差异	数组遍历快（CPU 缓存优化） LinkedList 慢	数组同传统 for 集合迭代器效率更优
调试可见性	可直接观察索引值	无法直接获取当前索引
多维度遍历	灵活控制嵌套层级	需多层嵌套

二、底层原理深度解析

字节码层面对比（使用 javap 反编译验证）

// 示例代码
List<String> list = Arrays.asList("a", "b");

// 传统for循环（集合遍历）
for(int i=0; i<list.size(); i++){
    String s = list.get(i);
}

// 增强for循环（集合遍历）
for(String s : list){}

反编译关键指令：

传统 for 循环：iload(加载索引) + aload(加载集合) + invokeinterface(调用 get)
增强 for 循环：invokeinterface(获取迭代器) + hasNext()/next() 循环

数组遍历优化机制
增强 for 循环在遍历数组时，编译器会优化为传统 for 循环：

// 源代码
int[] arr = {1,2,3};
for(int num : arr){}

// 编译器优化后等价于
for(int i=0; i<arr.length; i++){
    int num = arr[i];
}

三、实战场景选择指南

优先使用增强 for 循环的场景

只读遍历集合/数组
代码简洁性要求高
需要避免 IndexOutOfBoundsException

// 电商订单状态检查（无需修改集合）
for(Order order : orderList){
    if(order.getStatus() == Status.PAID){
        sendShippingNotification(order);
    }
}

必须使用传统 for 循环的场景

需要删除/修改集合元素
需要反向遍历
需要访问相邻元素

// 安全删除元素（使用迭代器模式）
for(Iterator<Item> it = cartItems.iterator(); it.hasNext();){
    Item item = it.next();
    if(item.isExpired()){
        it.remove(); // 安全删除
    }
}

四、性能关键指标对比

数据结构	传统 for 循环时间复杂度	增强 for 循环时间复杂度
ArrayList	O(1) per access	O(1) via iterator
LinkedList	O(n) per access	O(1) via iterator
HashSet	不可用	O(1) via iterator

性能测试数据（百万次遍历）：

ArrayList:
- 传统for循环：12ms
- 增强for循环：15ms
- 迭代器遍历：18ms

LinkedList:
- 传统for循环：4200ms（灾难性性能）
- 增强for循环：28ms
- 迭代器遍历：25ms

五、高频面试深挖点

为什么增强 for 循环删除元素会抛异常？
- 迭代器的 modCount 与集合的 expectedModCount 不一致触发快速失败机制
- 解决方案：使用迭代器的 remove() 方法

如何实现自定义集合的增强 for 循环支持？

实现 Iterable 接口并返回自定义 Iterator

public class CustomCollection<T> implements Iterable<T> {
    // …其他代码
    @Override
    public Iterator<T> iterator() {
        return new CustomIterator();
    }
}

JDK9 对增强 for 循环的优化
- 引入 ImmutableCollections 的优化迭代器
- 对 List.of() 创建的不可变集合进行遍历优化

六、设计模式与最佳实践

迭代器模式的应用
增强 for 循环是迭代器模式的语法糖实现：

// 等价代码解析
for(Iterator<String> it = list.iterator(); it.hasNext();){
    String s = it.next();
    // 循环体
}

防御性编程技巧

// 遍历时检测集合是否被外部修改
List<String> safeList = Collections.unmodifiableList(rawList);
for(String s : safeList){ // 确保遍历过程不被修改
    process(s);
}

总结回答模板：
" 传统 for 循环与增强 for 循环的核心区别在于控制粒度和实现机制。在阿里高并发场景下，我们遵循：对 ArrayList 等随机访问集合优先使用传统 for 循环提升性能；对 LinkedList 等顺序访问集合必须使用增强 for 循环避免性能灾难。同时，在涉及集合修改时，统一使用迭代器删除模式保证线程安全。"