Java基础篇面试题1

以下是面向对象编程（OOP） 的面试核心知识点解析，结合代码示例与设计思想，助你透彻理解：

一、四大核心特性

1. 封装（Encapsulation）

• 目标：隐藏内部实现，暴露安全接口

• 实现：

  • private 限制字段访问

  • public 方法提供可控操作

public class BankAccount {
    private double balance;  // 私有字段
​
    public void deposit(double amount) {  // 公开方法
        if (amount > 0) balance += amount;
    }
    // Getter 避免直接修改
    public double getBalance() { return balance; } 
}

2. 继承（Inheritance）

• 目标：代码复用 + 扩展功能

• 实现：extends 关键字

class Animal {
    void eat() { System.out.println("Eating..."); }
}
class Dog extends Animal {  // 继承
    void bark() { System.out.println("Barking..."); }
}

3. 多态（Polymorphism）

• 编译时多态（重载）：

  void print(int i) { ... }  
  void print(String s) { ... }  // 方法名相同，参数不同

• 运行时多态（重写）：

  class Animal {
      void sound() { System.out.println("Animal sound"); }
  }
  class Cat extends Animal {
      @Override  // 重写父类方法
      void sound() { System.out.println("Meow"); }
  }
  // 调用
  Animal myCat = new Cat();  
  myCat.sound();  // 输出 "Meow"（动态绑定）

4. 抽象（Abstraction）

• 目标：定义规范，隐藏细节

• 实现：

  • 抽象类（abstract class）：含抽象方法/具体方法

  • 接口（interface）：纯抽象（Java 8 前）

  abstract class Shape {  
      abstract void draw();  // 抽象方法
  }
  interface Drawable {       // 接口
      void draw();           // 默认 public abstract
  }

二、五大设计原则（SOLID）

三、关键面试题深度解析

1. 抽象类 vs 接口

使用场景：

• 抽象类：共享代码 + 定义公共状态（如模板方法模式）

• 接口：定义行为契约（如策略模式）

2. 多态底层原理

• JVM 动态绑定：

  1. 编译时检查父类方法是否存在

  2. 运行时根据实际对象类型调用方法

  Animal a = new Dog(); 
  a.sound();  // JVM 通过对象头找到 Dog 类方法表 -> 执行 Dog.sound()

3. 组合 vs 继承

• 继承问题：

  • 破坏封装（子类依赖父类实现）

  • 脆弱的基类问题（父类改动影响子类）

• 优先组合：

  class Car {
      private Engine engine;  // 组合代替继承
      void start() { engine.ignite(); }
  }

四、设计模式实战

1. 工厂模式（解决对象创建耦合）

interface PaymentGateway { void pay(); }
class Alipay implements PaymentGateway { ... }
class WechatPay implements PaymentGateway { ... }
​
class PaymentFactory {
    PaymentGateway create(String type) {
        if ("alipay".equals(type)) return new Alipay();
        if ("wechat".equals(type)) return new WechatPay();
        throw new IllegalArgumentException();
    }
}

2. 策略模式（封装可互换算法）

interface SortingStrategy { void sort(int[] data); }
class QuickSort implements SortingStrategy { ... }
class BubbleSort implements SortingStrategy { ... }
​
class Sorter {
    private SortingStrategy strategy;
    void setStrategy(SortingStrategy s) { this.strategy = s; }
    void execute(int[] data) { strategy.sort(data); }
}

五、高频面试题

1. 重载（Overload）和重写（Override）的区别？

   • 重载：同一类中，方法名相同、参数列表不同（编译时绑定）

   • 重写：子类重新定义父类方法（运行时绑定）

2. super 关键字的作用？

   • 调用父类构造方法（super(...)）

   • 访问父类被覆盖的方法（super.method()）

3. 能否重写静态方法？

   • 不能！静态方法属于类，调用时无多态（Animal.staticMethod() 永远调用父类版本）

4. 接口能否有构造方法？

   • 不能！接口无实例化需求，仅定义行为契约

💡 总结： 面向对象核心 = 四大特性 + SOLID原则 + 设计模式应用 面试中需结合代码解释理论，并强调设计选择（如为什么用组合而非继承）。