Java 面向对象核心知识点（封装 / 继承 / 重写 / 多态）

一、封装

1. 核心思想

"高内聚、低耦合"：隐藏类的内部细节，仅对外暴露必要的访问接口，保证数据安全。

2. 实现步骤

属性私有化 ：用private修饰属性，禁止外部直接访问；
提供公共方法 ：通过public的getter/setter方法间接访问 / 修改属性；
添加校验逻辑 ：在setter方法中校验数据合法性（如年龄范围、非空判断）。

3. 示例（Girl 类）

csharp 复制代码

public class Girl {
    // 私有属性
    private int age;
    
    // setter方法（带校验）
    public void setAge(int age) {
        if (age > 30) {
            this.age = 18; // 非法值强制修正
        } else {
            this.age = age;
        }
    }
    
    // getter方法
    public int getAge() {
        return age;
    }
}

二、继承

1. 核心思想

子类继承父类的非私有属性和方法，实现代码复用，同时可扩展自身特有功能（"is-a" 关系）。

2. 语法格式

scala 复制代码

public class 子类名 extends 父类名 {
    // 子类特有属性/方法
}

3. 核心特点

单继承：Java 中一个子类只能直接继承一个父类，支持多层继承；
私有成员：子类能继承但不能直接访问父类私有成员，需通过父类公共方法；
构造器规则 ：子类构造器默认调用父类空构造器（super()），无空构造器时需显式调用。

4. 示例（Person/Student）

csharp 复制代码

// 父类：Person
public class Person {
    private String name;
    public void eat() { System.out.println("人吃饭"); }
    // getter/setter省略
}

// 子类：Student
public class Student extends Person {
    private int sno; // 特有属性
    public void study() { System.out.println("学生学习"); } // 特有方法
}

5. 继承的好处

提高代码复用性；
便于功能扩展；
为多态铺垫。

三、方法重写（Override）

1. 核心思想

子类对父类的方法实现不满意时，重新定义方法（方法名、参数列表、返回值需完全一致）。

2. 语法要求

方法名、参数列表必须与父类完全一致；
子类方法权限不能比父类更严格（如父类public，子类不能private）；
推荐添加@Override注解（编译期校验重写规则）。

3. 示例（Animal/Dog）

csharp 复制代码

// 父类
public class Animal {
    public void shout() {
        System.out.println("动物发出声音");
    }
}

// 子类（重写方法）
public class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("狗-汪汪叫"); // 子类特有实现
    }
}

4. 重写 vs 重载

表格

特性	方法重写（Override）	方法重载（Overload）
发生位置	子类与父类之间	同一个类中
参数列表	必须完全一致	必须不同
返回值	需兼容（通常一致）	无要求
修饰符	权限不能更严格	无要求

四、多态

1. 核心思想

"同一种行为，不同对象表现出不同状态"，仅针对方法，与属性无关。

2. 实现前提

存在继承 / 实现关系；
子类重写父类方法；
父类引用指向子类对象（父类变量 = new 子类()）。

3. 核心示例（Animal/Cat/Dog/Girl）

java

运行

typescript 复制代码

// 1. 父类
public class Animal {
    public void shout() { System.out.println("动物喊叫"); }
}

// 2. 子类（重写方法）
public class Cat extends Animal {
    @Override
    public void shout() { System.out.println("猫-喵喵叫"); }
}
public class Dog extends Animal {
    @Override
    public void shout() { System.out.println("狗-汪汪叫"); }
}

// 3. 多态调用（Girl类）
public class Girl {
    public void play(Animal animal) {
        animal.shout(); // 执行子类重写后的方法
    }
}

// 4. 测试类
public class Test {
    public static void main(String[] args) {
        Girl g = new Girl();
        // 父类引用指向子类对象
        Animal cat = new Cat();
        Animal dog = new Dog();
        
        // 同一方法，不同结果（多态核心）
        g.play(cat); // 输出：猫-喵喵叫
        g.play(dog); // 输出：狗-汪汪叫
    }
}

4. 多态的好处

高扩展性：新增子类（如 Bird）无需修改原有代码，直接传入即可；
低耦合：调用方依赖抽象父类，而非具体子类；
代码简洁：避免大量重载方法（如 play (Cat)/play (Dog)）。

五、核心知识点总结

封装：通过 "私有属性 + 公共方法" 保护数据安全，是面向对象的基础；
继承：实现代码复用，是重写和多态的前提；
重写：子类定制父类方法，是多态的核心实现手段；
多态：父类引用指向子类对象，让代码更灵活、易扩展，体现 "开闭原则"。