← 课程目录 🚀 从零到一
📐 学习维度 阶段1 · 第3章 面向对象 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

3.2 封装、继承、多态:一件事的三种聪明做法

审校 2026-09-26 · 素材来源:乐字节基础讲义(底稿改写)
📑 本篇章节导航 (共13节,点击直达)
封装:值机柜台,不许直接上跑道继承:不用每个小区重新发明电梯多态:同一句话,各自反应转型:上下之间的规矩三特性的分工四个访问修饰符:藏多深,给谁看重写的规矩final:三把锁super:子类怎么喊爹toString:对象的自报家门里氏替换:继承的隐性契约踩坑清单一句话总结

三个需求,逼出三个特性:工资字段谁都能改,改飞了——要封装;Dog、Cat 两个类一半代码雷同——要继承;喂食方法对每种动物写一遍——要多态。面向对象三大特性不是课本名词,是三次「懒得重复、怕被改坏」的工程决策。

封装:值机柜台,不许直接上跑道

封装(Encapsulation)= 把属性藏起来,只开带安检的门。飞机不让你直接走上跑道,但值机柜台帮你办。


class Account {
    private double balance;          // private:外人碰不到

    public void deposit(double amt) {
        if (amt <= 0) throw new IllegalArgumentException("金额非法");  // 安检
        balance += amt;
    }

    public double getBalance() {     // 只读口
        return balance;
    }
}

好处一句话:非法数据进不来,合法修改有据可查。字段全 private、要暴露就配 getter/setter,是 JavaBean 的起点,也是所有框架能反射操作对象的前提。

继承:不用每个小区重新发明电梯

继承(Inheritance)用 extends 让子类白拿父类的属性和方法,只写差异部分:


class Animal {
    protected String name;
    void eat() { System.out.println(name + "在吃饭"); }
}

class Dog extends Animal {          // eat 自动到手
    void bark() { System.out.println(name + "在汪汪"); }
}

class Cat extends Animal {
    void bark() { }                  // 猫不叫?重写父类方法
}

两个高频词分开记:重写(Override)是子类改写父类同名同参方法,@Override 注解让编译器帮你核对签名;重载(Overload)是同一个类里同名不同参的多个方法,纯属巧合的同名。

注意 Java 是单继承:一个爹只能有一个,要更多能力靠 3.3 节的接口。

多态:同一句话,各自反应

多态(Polymorphism)= 父类引用指向子类对象,调方法时执行的是子类的版本:


Animal a = new Dog();       // 父类引用,子类对象
a.eat();                    // Animal 的 eat(没重写)
// a.bark();                // 编译报错:引用类型是 Animal,看不见 bark

class Cat extends Animal {
    @Override
    void eat() { System.out.println("猫优雅地吃"); }
}

Animal b = new Cat();
b.eat();                    // 猫优雅地吃——变量类型 Animal,行为看 Cat

编译看左边(能调什么由引用类型决定),运行看右边(实际执行谁的方法由对象决定)。这叫动态绑定:JVM 运行时按对象的真实类型找到重写后的方法。

多态真正的威力是「加子类不改旧代码」:


void feed(Animal a) {       // 一个方法,喂遍天下动物
    a.eat();                // 传 Dog 走 Dog 的逻辑,传 Cat 走 Cat 的
}

feed(new Dog());
feed(new Cat());            // 新增 Panda?feed 一行不用改

转型:上下之间的规矩

转之前先问一句 if (a instanceof Dog),确认了再转。这个判断在 JDK 16 后还能顺手领个新写法:if (a instanceof Dog d) d.bark();——判断即转型,5.4 节还会遇到它。

三特性的分工

特性解决什么一句口诀
封装怕被改坏藏字段、开安检门
继承怕重复共性上提,差异下放
多态怕改老代码父类收参数,子类给行为

四个访问修饰符:藏多深,给谁看

private 只给本类;默认(什么都不写)给同一个包;protected 给同包外加子类;public 给所有人。这是一道从私密到公开的权限阶梯。工程习惯也简单:字段一律 private;只给自己用的工具方法标 private;对外的门口挂 public。protected 用得少,主要出现在「专为继承而设计」的框架基类里。包的概念顺带立住:同包大致就是同一个文件夹下的类,默认权限即「同包可见」——所以包结构乱了,权限就会意外漏风。

重写的规矩

子类重写父类方法:方法名、参数必须一模一样;返回值可以更具体(父类返回 Animal,子类可以返回 Dog);访问权限不能比父类严;抛的异常不能比父类多。条文记不全没关系,@Override 一标,编译器逐条替你核对,违规当场红线。这就是注解的价值:让机器守规矩,人只管写意图。

final:三把锁

final 修饰类,不能被继承,String 就是这么锁的;修饰方法,不能被重写;修饰变量,只能赋一次值,即常量。三把锁锁的都是「不许改」。工程里最常用的是锁变量:配置值、魔法数字加个 final,谁想中途改值,编译器当场拦截。String 整个类不可变,是封装思想的极端形态:内容不许动,才敢放心到处共享——这正是它线程安全的根源,第 7 章会兑现这句伏笔。

super:子类怎么喊爹

子类构造方法的第一行,默认藏着一句 super():先执行父类构造,再干自己的活,因为「先有爹后有子」。父类没写无参构造时,子类必须显式 super(参数) 传值,否则编译报错。super 还能调父类被重写的方法:在子类版本里写 super.eat(),先干爹的老活、再添自己的新活。继承链层层向上,构造会一路追到 Object 才折返——理解了这条链,踩坑清单里「构造方法别调可重写方法」那条也就通了。

toString:对象的自报家门

直接打印对象 System.out.println(s),输出的是「类名@一串哈希」这种鬼东西。其实它调的是对象的 toString(),没重写时 Object 给的就是这个默认货。给 Student 重写一个 toString,把属性拼成人话,调试打印立刻舒服——这也是 2.3 篇 Arrays.toString(数组) 的同族逻辑。所有类都默认继承 Object,equals、toString、hashCode 全是它给的,这三个方法怎么正确重写,3.5 节专门说。

里氏替换:继承的隐性契约

多态能成立有个前提:子类必须能无条件顶替父类。所有用到 Animal 的地方,换成 Dog 行为不该错乱——这叫里氏替换原则。反面教材:子类重写 eat 时直接抛「我不吃」的异常,全项目的喂食代码当场崩坏。判断标准记一句:子类是父类的特化,不是背叛。重写可以更精彩,不能翻桌子。

踩坑清单

一句话总结

封装藏字段开安检门,继承共性上提、差异下放,多态让父类引用在运行时按真实对象行事——加子类不改旧代码,是三者合力的红利。