1. 封装（Encapsulation）

1.1 基本概念

封装是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

1.2 实现方式

• 使用private修饰符隐藏属性
• 提供public的getter和setter方法
• 对方法参数进行有效性检查

1.3 代码示例

public class Student {
    // 私有属性，外部无法直接访问
    private String name;
    private int age;
    private double score;
    
    // 构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        setAge(age);  // 使用setter方法进行参数校验
        setScore(score);
    }
    
    // getter方法
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public double getScore() {
        return score;
    }
    
    // setter方法，包含参数校验
    public void setName(String name) {
        if (name != null && !name.trim().isEmpty()) {
            this.name = name;
        } else {
            throw new IllegalArgumentException("姓名不能为空");
        }
    }
    
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("年龄必须在0-150之间");
        }
    }
    
    public void setScore(double score) {
        if (score >= 0 && score <= 100) {
            this.score = score;
        } else {
            throw new IllegalArgumentException("成绩必须在0-100之间");
        }
    }
}

1.4 面试常见问题

Q: 为什么要使用封装？A:

1. 数据安全性：防止外部代码随意修改对象内部状态
2. 代码维护性：内部实现变化不影响外部调用
3. 数据完整性：通过setter方法进行数据校验
4. 访问控制：可以控制哪些属性和方法对外可见

2. 继承（Inheritance）

2.1 基本概念

继承是面向对象编程中的一种机制，允许一个类（子类）获得另一个类（父类）的属性和方法。Java使用extends关键字实现继承。

2.2 继承特点

• Java只支持单继承，一个类只能继承一个父类
• 子类可以访问父类的非私有成员
• 子类可以重写父类的方法
• 使用super关键字调用父类的构造方法和方法

2.3 代码示例

// 父类
public class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    
    public void makeSound() {
        System.out.println(name + "发出声音");
    }
}

// 子类
public class Dog extends Animal {
    private String breed;  // 品种
    
    public Dog(String name, int age, String breed) {
        super(name, age);  // 调用父类构造方法
        this.breed = breed;
    }
    
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    
    // 子类特有方法
    public void wagTail() {
        System.out.println(name + "摇尾巴");
    }
    
    public void fetch() {
        System.out.println(name + "去捡球");
    }
}

// 另一个子类
public class Cat extends Animal {
    private boolean isIndoor;
    
    public Cat(String name, int age, boolean isIndoor) {
        super(name, age);
        this.isIndoor = isIndoor;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "喵喵叫");
    }
    
    public void climb() {
        System.out.println(name + "爬树");
    }
}

2.4 面试常见问题

Q: Java为什么不支持多继承？A:

1. 避免钻石问题：如果一个类继承两个父类，而这两个父类又继承同一个祖先类，会产生歧义
2. 简化语言设计：单继承使语言更简洁，降低复杂性
3. 接口弥补：Java通过接口实现多重继承的效果

Q: 继承和组合的区别？A:

• 继承：is-a关系，强耦合，子类依赖父类
• 组合：has-a关系，弱耦合，更灵活

3. 多态（Polymorphism）

3.1 基本概念

多态是指同一个接口，使用不同的实例而执行不同的操作。在Java中，多态主要通过方法重写和接口实现来体现。

3.2 多态实现条件

1. 继承关系（或接口实现）
2. 方法重写
3. 父类引用指向子类对象

3.3 代码示例

// 使用上面定义的Animal、Dog、Cat类
public class Polymo