三个需求,逼出三个特性:工资字段谁都能改,改飞了——要封装;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 一行不用改
Animal a = new Dog()):自动,安全,但丢掉子类特有方法Dog d = (Dog) a):手动,转错类型运行时炸 ClassCastException转之前先问一句 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 修饰类,不能被继承,String 就是这么锁的;修饰方法,不能被重写;修饰变量,只能赋一次值,即常量。三把锁锁的都是「不许改」。工程里最常用的是锁变量:配置值、魔法数字加个 final,谁想中途改值,编译器当场拦截。String 整个类不可变,是封装思想的极端形态:内容不许动,才敢放心到处共享——这正是它线程安全的根源,第 7 章会兑现这句伏笔。
子类构造方法的第一行,默认藏着一句 super():先执行父类构造,再干自己的活,因为「先有爹后有子」。父类没写无参构造时,子类必须显式 super(参数) 传值,否则编译报错。super 还能调父类被重写的方法:在子类版本里写 super.eat(),先干爹的老活、再添自己的新活。继承链层层向上,构造会一路追到 Object 才折返——理解了这条链,踩坑清单里「构造方法别调可重写方法」那条也就通了。
直接打印对象 System.out.println(s),输出的是「类名@一串哈希」这种鬼东西。其实它调的是对象的 toString(),没重写时 Object 给的就是这个默认货。给 Student 重写一个 toString,把属性拼成人话,调试打印立刻舒服——这也是 2.3 篇 Arrays.toString(数组) 的同族逻辑。所有类都默认继承 Object,equals、toString、hashCode 全是它给的,这三个方法怎么正确重写,3.5 节专门说。
多态能成立有个前提:子类必须能无条件顶替父类。所有用到 Animal 的地方,换成 Dog 行为不该错乱——这叫里氏替换原则。反面教材:子类重写 eat 时直接抛「我不吃」的异常,全项目的喂食代码当场崩坏。判断标准记一句:子类是父类的特化,不是背叛。重写可以更精彩,不能翻桌子。
@Override 一标就露馅,所以注解永远要写封装藏字段开安检门,继承共性上提、差异下放,多态让父类引用在运行时按真实对象行事——加子类不改旧代码,是三者合力的红利。