面向对象：封装、继承、多态、重载、重写、构造器

Java 面向对象六大核心：封装、继承、多态、重载、重写、构造器

我用通俗人话 + 极简代码 + 核心考点一次性给你讲透，零基础也能秒懂。

---

一、构造器（构造方法）

作用

创建对象时自动调用，用来给成员变量初始化。

特点

1. 名字和类名完全一样
2. 没有返回值（连 void 都不写）
3. 创建对象 new 类名() 时自动执行
4. 可以重载（多个构造器）
5. 不写构造器，编译器默认给一个无参空构造

代码示例

class Person {
    String name;
    int age;

    // 无参构造器
    public Person() {
        System.out.println("无参构造执行");
    }

    // 有参构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 使用
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("张三", 18);
    }
}

---

二、封装

核心思想

把属性藏起来，对外提供方法访问。

• 成员变量用 private 私有化
• 用 getter/setter 取值、赋值
• 好处：安全、可控、易维护

代码示例

class Student {
    // 私有成员变量，外部不能直接访问
    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;
        }
    }
}

口诀：私有属性，公开方法，隐藏细节，保护数据

---

三、继承

作用

子类复用父类代码，不用重复写。
关键字：extends

特点

1. 子类拥有父类非私有的属性和方法
2. Java 单继承：一个子类只能一个父类
3. 用 super 访问父类成员、构造器

代码示例

// 父类
class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

// 子类继承父类
class Dog extends Animal {
    // 直接拥有父类 eat 方法
}

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat(); // 复用父类方法
    }
}

口诀：子类继承父类，代码复用，纵向扩展

---

四、重写（Override）

概念

子类重新写父类已有的方法，覆盖父类实现。

重写要求

1. 方法名、参数列表必须一模一样
2. 返回值兼容
3. 访问权限 子类 ≥ 父类
4. 加注解 @Override 规范校验

代码示例

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

class Cat extends Animal {
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

---

五、重载（Overload）

概念

同一个类中，方法名相同，参数列表不同
参数不同：个数不同、类型不同、顺序不同

特点

1. 在同一个类里
2. 和返回值、访问修饰符无关
3. 构造器也能重载

代码示例

class Calc {
    // 重载：方法名一样，参数不一样
    public int add(int a) {
        return a;
    }
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
}

重载 vs 重写 一眼区分

特性	重载 Overload	重写 Override
位置	同一个类	子类父类
方法名	相同	相同
参数	必须不同	必须相同
关系	横向	纵向继承

---

六、多态

核心口诀

父类引用指向子类对象
父类 引用名 = new 子类();

多态运行机制

• 编译看左边（父类）
• 运行看右边（子类重写方法）

代码示例

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

public class Test {
    public static void main(String[] args) {
        // 多态
        Animal a1 = new Dog();
        Animal a2 = new Cat();
        a1.eat(); // 狗吃骨头
        a2.eat(); // 猫吃鱼
    }
}

好处：程序扩展性强，一个父类引用接收所有子类

---

终极6句总结

1. 构造器：创建对象、初始化属性
2. 封装：私有化属性，用方法控制访问
3. 继承：子类复用父类代码，extends
4. 重写：子类改写父类方法，参数必须一样
5. 重载：同类同名不同参，方便方法多样
6. 多态：父类引用指向子类对象，运行走子类