类继承

基本继承

1. extends 关键字

class Animal {
    constructor(name) {
        this.name = name;
    }

    speak() {
        console.log(`${this.name} makes a sound`);
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }

    speak() {
        console.log(`${this.name} barks`);
    }
}

const dog = new Dog('Rex', 'German Shepherd');
dog.speak(); // 'Rex barks'

2. super 关键字

class Animal {
    constructor(name) {
        this.name = name;
    }

    speak() {
        console.log(`${this.name} makes a sound`);
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        // 调用父类构造函数
        super(name);
        this.breed = breed;
    }

    speak() {
        // 调用父类方法
        super.speak();
        console.log(`${this.name} barks`);
    }
}

const dog = new Dog('Rex', 'German Shepherd');
dog.speak();
// 'Rex makes a sound'
// 'Rex barks'

继承链

1. 多级继承

class Animal {
    constructor(name) {
        this.name = name;
    }

    eat() {
        console.log(`${this.name} eats`);
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }

    bark() {
        console.log(`${this.name} barks`);
    }
}

class Puppy extends Dog {
    constructor(name, breed, age) {
        super(name, breed);
        this.age = age;
    }

    play() {
        console.log(`${this.name} plays`);
    }
}

const puppy = new Puppy('Rex', 'German Shepherd', 1);
puppy.eat(); // 'Rex eats'
puppy.bark(); // 'Rex barks'
puppy.play(); // 'Rex plays'

2. 继承内置类

class CustomArray extends Array {
    first() {
        return this[0];
    }

    last() {
        return this[this.length - 1];
    }
}

const arr = new CustomArray(1, 2, 3, 4, 5);
console.log(arr.first()); // 1
console.log(arr.last()); // 5
console.log(arr.length); // 5
console.log(arr instanceof Array); // true

继承模式

1. 方法重写

class Animal {
    constructor(name) {
        this.name = name;
    }

    speak() {
        console.log(`${this.name} makes a sound`);
    }
}

class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks`);
    }
}

class Cat extends Animal {
    speak() {
        console.log(`${this.name} meows`);
    }
}

const dog = new Dog('Rex');
const cat = new Cat('Fluffy');
dog.speak(); // 'Rex barks'
cat.speak(); // 'Fluffy meows'

2. 组合继承

class Swimmer {
    swim() {
        console.log(`${this.name} swims`);
    }
}

class Flyer {
    fly() {
        console.log(`${this.name} flies`);
    }
}

class Duck {
    constructor(name) {
        this.name = name;
        // 组合而不是继承
        this.swimmer = new Swimmer();
        this.flyer = new Flyer();
    }

    swim() {
        this.swimmer.swim.call(this);
    }

    fly() {
        this.flyer.fly.call(this);
    }
}

const duck = new Duck('Donald');
duck.swim(); // 'Donald swims'
duck.fly(); // 'Donald flies'

instanceof 运算符

class Animal {}
class Dog extends Animal {}

const dog = new Dog();
console.log(dog instanceof Dog); // true
console.log(dog instanceof Animal); // true
console.log(dog instanceof Object); // true

最佳实践

1. 总是在子类构造函数中调用 super()
2. 避免过深的继承层次
3. 组合优于继承
4. 避免多重继承（JavaScript 不支持）
5. 使用 super 调用父类方法
6. 注意继承内置类的特殊行为
7. 使用 instanceof 检查继承关系
8. 使用 Object.getPrototypeOf() 检查原型链