面试专题：面向对象

清峰大约 7 分钟

面试专题：面向对象

概述

面向对象编程（OOP）是Java的核心特性，也是面试中必问的知识点。本章节将系统讲解面向对象的核心概念、设计原则以及常见面试题，帮助你全面掌握面向对象编程的精髓。

知识要点

1. 核心概念

1.1 封装

封装是将数据和方法组合在一个单元中的机制，它隐藏了对象的内部实现细节，只暴露必要的接口。

public class User {
    // 私有属性，外部无法直接访问
    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("年龄必须在0-150之间");
        }
    }
}

1.2 继承

继承允许一个类获取另一个类的属性和方法。被继承的类称为父类，继承的类称为子类。

// 父类
public class Animal {
    public void eat() {
        System.out.println("动物会进食");
    }
}

// 子类
public class Dog extends Animal {
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    // 子类特有方法
    public void bark() {
        System.out.println("狗会汪汪叫");
    }
}

1.3 多态

多态是指同一个方法可以有不同的实现方式。在Java中，多态通过方法重载和方法重写实现。

// 方法重载 - 同一个类中，方法名相同，参数不同
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

// 方法重写 - 子类重写父类的方法
public class Animal {
    public void move() {
        System.out.println("动物会移动");
    }
}

public class Bird extends Animal {
    @Override
    public void move() {
        System.out.println("鸟会飞");
    }
}

1.4 抽象

抽象是指忽略细节，关注本质。在Java中，抽象通过抽象类和接口实现。

// 抽象类
public abstract class Shape {
    // 抽象方法，没有实现
    public abstract double getArea();

    // 具体方法
    public void display() {
        System.out.println("这是一个形状");
    }
}

// 接口
public interface Flyable {
    void fly();
}

2. 设计原则

2.1 单一职责原则

一个类应该只有一个引起它变化的原因。

// 违反单一职责原则
public class User {
    private String name;
    private int age;

    public void save() {
        // 保存用户到数据库
    }

    public void validate() {
        // 验证用户信息
    }
}

// 遵循单一职责原则
public class User {
    private String name;
    private int age;
    // 只包含用户相关的属性和方法
}

public class UserRepository {
    public void save(User user) {
        // 保存用户到数据库
    }
}

public class UserValidator {
    public boolean validate(User user) {
        // 验证用户信息
        return true;
    }
}

2.2 开闭原则

对扩展开放，对修改关闭。

// 违反开闭原则
public class ShapeCalculator {
    public double calculateArea(Shape shape) {
        if (shape instanceof Circle) {
            return Math.PI * ((Circle) shape).getRadius() * ((Circle) shape).getRadius();
        } else if (shape instanceof Rectangle) {
            return ((Rectangle) shape).getWidth() * ((Rectangle) shape).getHeight();
        }
        // 每添加一个新形状，都需要修改这个方法
        return 0;
    }
}

// 遵循开闭原则
public abstract class Shape {
    public abstract double getArea();
}

public class Circle extends Shape {
    private double radius;

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    @Override
    public double getArea() {
        return width * height;
    }
}

public class ShapeCalculator {
    public double calculateArea(Shape shape) {
        return shape.getArea();
        // 不需要修改这个方法，只需要扩展新的形状类
    }
}

2.3 里氏替换原则

子类可以替换父类，而不会改变程序的正确性。

// 违反里氏替换原则
public class Bird {
    public void fly() {
        System.out.println("鸟会飞");
    }
}

public class Ostrich extends Bird {
    @Override
    public void fly() {
        // 鸵鸟不会飞，违反了里氏替换原则
        throw new UnsupportedOperationException("鸵鸟不会飞");
    }
}

// 遵循里氏替换原则
public class Bird {
    public void move() {
        System.out.println("鸟会移动");
    }
}

public class Ostrich extends Bird {
    @Override
    public void move() {
        System.out.println("鸵鸟会跑");
    }
}

2.4 接口隔离原则

客户端不应该被迫实现它不需要的接口。

// 违反接口隔离原则
public interface Animal {
    void eat();
    void fly();
    void swim();
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void fly() {
        // 狗不会飞，但是被迫实现这个方法
        throw new UnsupportedOperationException();
    }

    @Override
    public void swim() {
        System.out.println("狗会游泳");
    }
}

// 遵循接口隔离原则
public interface Eat {
    void eat();
}

public interface Fly {
    void fly();
}

public interface Swim {
    void swim();
}

public class Dog implements Eat, Swim {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗会游泳");
    }
}

2.5 依赖倒置原则

高层模块不应该依赖低层模块，它们都应该依赖抽象。

// 违反依赖倒置原则
public class Light {
    public void turnOn() {
        System.out.println("灯打开了");
    }

    public void turnOff() {
        System.out.println("灯关闭了");
    }
}

public class Switch {
    private Light light;

    public Switch(Light light) {
        this.light = light;
    }

    public void operate() {
        light.turnOn();
    }
}

// 遵循依赖倒置原则
public interface Switchable {
    void turnOn();
    void turnOff();
}

public class Light implements Switchable {
    @Override
    public void turnOn() {
        System.out.println("灯打开了");
    }

    @Override
    public void turnOff() {
        System.out.println("灯关闭了");
    }
}

public class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        device.turnOn();
    }
}