1
// 父类
2
public class Animal {
3
    protected String name;
4
    protected int age;
5

6
    public Animal(String name, int age) {
7
        this.name = name;
8
        this.age = age;
9
    }
10

11
    public void eat() {
12
        System.out.println(name + " 正在吃东西");
13
    }
14

15
    public void sleep() {
16
        System.out.println(name + " 正在睡觉");
17
    }
18
}
19

20
// 子类
21
public class Dog extends Animal {
22
    private String breed;   // 子类特有字段
23

24
    public Dog(String name, int age, String breed) {
25
        super(name, age);           // 必须先调用父类构造器
26
        this.breed = breed;
27
    }
28

29
    public void bark() {            // 子类特有方法
30
        System.out.println(name + " 汪汪叫");
31
    }
32
}
33

34
// 使用
35
Dog dog = new Dog("旺财", 3, "柴犬");
36
dog.eat();     // 继承自 Animal
37
dog.sleep();   // 继承自 Animal
38
dog.bark();    // Dog 自己的

1
// JavaScript
2
class Animal {
3
    constructor(name) { this.name = name; }
4
    eat() { console.log(`${this.name} 吃东西`); }
5
}
6
class Dog extends Animal {
7
    constructor(name, breed) {
8
        super(name);
9
        this.breed = breed;
10
    }
11
}

1
Animal a = new Dog("旺财", 3, "柴犬");   // ✅ 父类引用指向子类对象
2
a.eat();                                  // ✅
3
// a.bark();                              // ❌ 编译报错，Animal 类型看不到 bark

1
public class Animal {
2
    public void makeSound() {
3
        System.out.println("某种动物叫声");
4
    }
5
}
6

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

14
public class Cat extends Animal {
15
    @Override
16
    public void makeSound() {
17
        System.out.println("喵喵");
18
    }
19
}

1
public class User { ... }
2
// 等价于
3
public class User extends Object { ... }

1
public class AnimalShelter {
2
    public static void main(String[] args) {
3
        // 声明类型是 Animal，实际类型是 Dog/Cat/Bird
4
        List<Animal> animals = List.of(
5
            new Dog("旺财", 3, "柴犬"),
6
            new Cat("咪咪", 2),
7
            new Dog("小黑", 5, "拉布拉多")
8
        );
9

10
        for (Animal a : animals) {
11
            a.makeSound();      // 运行时根据实际类型调用不同的方法
12
            // 输出：汪汪 / 喵喵 / 汪汪
13
        }
14
    }
15
}

1
public class Parent {
2
    public String name = "Parent";
3
}
4
public class Child extends Parent {
5
    public String name = "Child";    // 隐藏（hide）父类字段，不是重写
6
}
7

8
Parent p = new Child();
9
System.out.println(p.name);          // "Parent" ← 编译时决定
10
System.out.println(((Child) p).name); // "Child"

1
public abstract class Shape {
2
    protected String color;
3

4
    public Shape(String color) {
5
        this.color = color;
6
    }
7

8
    // 抽象方法：只有声明没有实现，子类必须重写
9
    public abstract double area();
10

11
    // 普通方法：子类直接继承
12
    public void describe() {
13
        System.out.println("一个 " + color + " 的图形，面积 " + area());
14
    }
15
}
16

17
public class Circle extends Shape {
18
    private double radius;
19

20
    public Circle(String color, double radius) {
21
        super(color);
22
        this.radius = radius;
23
    }
24

25
    @Override
26
    public double area() {
27
        return Math.PI * radius * radius;
28
    }
29
}
30

31
// Shape s = new Shape("red");   // ❌ 抽象类不能实例化
32
Shape s = new Circle("red", 2.0);   // ✅ 通过子类
33
s.describe();

1
// 1. 继承
2
public class Dog extends Animal {
3
    public Dog(String name) {
4
        super(name);          // 必须调用父类构造器
5
    }
6
}
7

8
// 2. 重写
9
@Override
10
public void makeSound() {
11
    super.makeSound();        // 可选调用父类逻辑
12
    // 自己的实现
13
}
14

15
// 3. Object 三兄弟
16
@Override
17
public String toString() { return "User{name=" + name + "}"; }
18

19
@Override
20
public boolean equals(Object o) {
21
    if (this == o) return true;
22
    if (!(o instanceof User other)) return false;
23
    return age == other.age && Objects.equals(name, other.name);
24
}
25

26
@Override
27
public int hashCode() { return Objects.hash(name, age); }
28

29
// 4. 向上/向下转型
30
Animal a = new Dog("旺财");       // 向上，自动
31
if (a instanceof Dog d) d.bark(); // 向下，模式匹配
32

33
// 5. 多态
34
List<Animal> list = List.of(new Dog(), new Cat());
35
for (Animal a : list) a.makeSound();   // 运行时决定调用哪个
36

37
// 6. final
38
final double PI = 3.14;               // 变量不能改
39
public final void method() {}         // 方法不能重写
40
public final class Immutable {}       // 类不能继承