1. 封装：隐藏字段，暴露受控方法#

1
class User {
2
    private int age;
3

4
    public void setAge(int age) {
5
        if (age < 0) {
6
            throw new IllegalArgumentException("age must be >= 0");
7
        }
8
        this.age = age;
9
    }
10

11
    public int getAge() {
12
        return age;
13
    }
14
}

字段设为 private 后，外部不能随意修改，只能通过公开方法进入对象内部规则。

2. 继承：使用 extends 扩展父类#

1
class Animal {
2
    String name;
3

4
    Animal(String name) {
5
        this.name = name;
6
    }
7

8
    void eat() {
9
        System.out.println(name + " is eating");
10
    }
11
}
12

13
class Dog extends Animal {
14
    Dog(String name) {
15
        super(name);
16
    }
17

18
    void bark() {
19
        System.out.println(name + " is barking");
20
    }
21
}

Dog 继承 Animal 后，可以直接复用父类已经定义好的字段和方法，同时再补充自己独有的行为。

可以把继承先理解成两件事：

• 代码层面：子类拿到父类可继承的成员，减少重复定义。
• 建模层面：子类和父类之间通常要满足明确的“是一个”关系，比如 Dog 是一种 Animal。

继承最常见的价值，不只是“少写几行代码”，而是把公共状态和公共行为收拢到父类里，让一组相似对象共享同一套抽象。

1
class Animal {
2
    Animal(String name) {
3
        System.out.println("Animal constructor: " + name);
4
    }
5
}
6

7
class Dog extends Animal {
8
    Dog(String name) {
9
        super(name);
10
        System.out.println("Dog constructor: " + name);
11
    }
12
}

1
Animal constructor: Buddy
2
Dog constructor: Buddy

1
class Animal {
2
    Animal(String name) {
3
        System.out.println("Animal constructor: " + name);
4
    }
5
    void eat() {
6
        System.out.println("animal eat");
7
    }
8
}
9

10
class Dog extends Animal {
11
    Dog(String name) {
12
        super(name);
13
        System.out.println("Dog constructor: " + name);
14
    }
15
    @Override
16
    void eat() {
17
        super.eat();
18
        System.out.println("dog eat more bones");
19
    }
20
}

1
public class Main {
2
    public static void main(String[] args) {
3
        Dog time = new Dog("Buddy");
4
        time.eat();
5

6
    }
7
}

1
Animal constructor: Buddy
2
Dog constructor: Buddy
3
animal eat
4
dog eat more bones

1
final class Config {
2
    final String env;
3

4
    Config(String env) {
5
        this.env = env;
6
    }
7
}

3. 方法重写：子类改变父类行为#

1
class Dog extends Animal {
2
    @Override
3
    void eat() {
4
        System.out.println("dog eat");
5
    }
6
}

@Override 能让编译器检查是否真的重写了父类方法，建议保留。

重写的关键点是：方法名相同、参数列表相同，真正变化的是实现逻辑。

子类重写父类方法，通常是因为“父类给出了通用定义，但具体子类需要自己的执行方式”。比如：

• Animal.eat() 只是一个通用动作
• Dog.eat()、Cat.eat() 则可以表现出各自差异

重写时还要注意几个基本规则：

• 子类方法访问权限不能比父类更严格。
• 返回值类型要兼容父类方法声明。
• static 方法谈不上典型的运行时重写，它更接近方法隐藏。

初学阶段最需要记住的一条是：看到父类和子类里出现“同签名方法”，优先想到“这里可能是为了多态而设计的重写点”。

4. 多态：父类引用指向子类对象#

1
Animal animal = new Dog("Buddy");
2
animal.eat();

变量类型是 Animal，实际对象是 Dog。调用被重写的方法时，会执行子类版本，这就是动态绑定。

多态的重点不是“语法写法变了”，而是“调用方只依赖抽象类型，但运行结果由真实对象决定”。

这样做的好处是，调用方可以统一处理一组父类对象，而不用为每个具体子类各写一套逻辑。

1
Animal a1 = new Dog("Buddy");
2
Animal a2 = new Cat("Mimi");

1
class Animal {
2
    void eat() {
3
        System.out.println("animal eat");
4
    }
5
}
6

7
class Dog extends Animal {
8
    @Override
9
    void eat() {
10
        System.out.println("dog eat bones");
11
    }
12
}
13

14
class Cat extends Animal {
15
    @Override
16
    void eat() {
17
        System.out.println("cat eat fish");
18
    }
19
}
20

21
public class Demo {
22
    static void feed(Animal animal) {
23
        animal.eat();
24
    }
25
}

4.3 字段不参与典型的运行时多态#

方法调用会发生动态绑定，但字段访问看的是引用类型，不是对象真实类型。比如：

1
class Animal {
2
    String type = "animal";
3
}
4

5
class Dog extends Animal {
6
    String type = "dog";
7
}
8

9
Animal animal = new Dog();
10
System.out.println(animal.type);

输出是 animal，不是 dog。

这说明 Java 里最典型的多态，主要体现在实例方法重写上，而不是字段访问上。

4.4 向下转型要谨慎#

1
Animal animal = new Dog("Buddy");
2

3
if (animal instanceof Dog) {
4
    Dog dog = (Dog) animal;
5
    dog.bark();
6
}

父类引用想调用子类特有方法时，需要向下转型。但向下转型有前提：真实对象本来就得是那个子类，否则会抛出 ClassCastException。

所以能不向下转型时就尽量少转，必须转时先做类型判断。

常见陷阱与错误示例#

1. 把继承当成代码复用的默认方案#

继承会形成强耦合，父类变化可能影响所有子类。只有存在清晰的“是一个”关系时，才优先考虑继承。

2. 误以为子类能直接访问父类 private 字段#

1
class Animal {
2
    private int age = 3;
3
}
4

5
class Dog extends Animal {
6
    void printAge() {
7
        // System.out.println(age); // 编译失败
8
    }
9
}

private 是“对当前类私有”，不是“对子类开放”。如果子类确实需要读取，通常应该通过父类公开方法暴露。

3. 忘记 @Override#

如果方法名或参数写错，没有 @Override 时可能变成新方法而不是重写。加上 @Override 可以让编译器及时报错。

4. 父类引用不能直接调用子类特有方法#

1
Animal animal = new Dog("Buddy");
2
animal.bark();

如果 bark 只定义在 Dog 中，这段代码无法通过编译。变量的编译期类型决定能调用哪些方法。

5. 把字段访问误认为多态#

很多初学者看到“父类引用指向子类对象”，就会以为字段和方法都按子类版本执行。实际不是这样：

• 实例方法重写，走运行时多态。
• 字段访问，走编译期类型。

这一点如果没分清，后面读框架代码时会很容易误判。

6. 不判断类型就向下转型#

1
Animal animal = new Cat("Mimi");
2
Dog dog = (Dog) animal;

这段代码可以编译，但运行时会抛出 ClassCastException。强制类型转换能不能成功，不看“你想转成什么”，而看对象真实类型是不是那个子类。

1. 什么是封装#

封装是把对象内部状态隐藏起来，通过公开方法提供受控访问，从而保护对象不被随意改坏。

2. 重载和重写有什么区别#

重载发生在同一个类中，方法名相同、参数列表不同；重写发生在父子类之间，子类重新实现父类方法。

3. 多态的前提是什么#

通常需要继承或接口、方法重写、父类或接口引用指向子类对象。

4. 为什么说多态提高了扩展性#

因为调用方依赖的是父类或接口，不需要写死具体实现。新增一个子类时，只要遵守同一套抽象契约，原有调用代码通常不用改。

5. super 和 this 有什么区别#

this 代表当前对象，super 代表父类那部分实现。this(...) 用于调用本类其他构造方法，super(...) 用于调用父类构造方法。

6. 为什么构造方法不能被继承#

构造方法的职责是创建并初始化“当前类对象”。父类构造方法只能被子类通过 super(...) 调用，用来完成父类部分初始化，但它本身不属于可被重写和复用的普通成员方法。

7. 字段有没有多态#

通常说的 Java 多态，主要是实例方法的运行时分派。字段访问不参与这种动态绑定，它看的是引用的编译期类型。