1
// 定义一个 Person 类
2
class Person {
3
    // 类的主体
4
}

1
// 创建 Person 类的实例
2
const person1 = new Person();
3
const person2 = new Person();
4

5
console.log(person1);  // Person {}
6
console.log(person2);  // Person {}
7
console.log(person1 === person2);  // false（不同的实例）

1
// 定义一个简单的类
2
class Person {
3
    constructor(name, age) {
4
        this.name = name;
5
        this.age = age;
6
    }
7

8
    greet() {
9
        console.log(`你好，我是 ${this.name}`);
10
    }
11
}
12

13
// 创建实例
14
const person1 = new Person("张三", 25);
15
const person2 = new Person("李四", 30);
16

17
// 调用方法
18
person1.greet();  // 你好，我是 张三
19
person2.greet();  // 你好，我是 李四
20

21
// 访问属性
22
console.log(person1.name);  // 张三
23
console.log(person2.age);   // 30

1
class Person {
2
    constructor(name, age, city) {
3
        // this 指向当前实例
4
        this.name = name;
5
        this.age = age;
6
        this.city = city;
7
    }
8
}
9

10
const person = new Person("张三", 25, "北京");
11
console.log(person.name);  // 张三

1
class Person {
2
    constructor(name, age) {
3
        // 实例属性
4
        this.name = name;
5
        this.age = age;
6
    }
7
}
8

9
const person1 = new Person("张三", 25);
10
const person2 = new Person("李四", 30);
11

12
console.log(person1.name);  // 张三
13
console.log(person2.name);  // 李四

1
class Person {
2
    // 类属性（静态属性）
3
    static species = "人类";
4
    static count = 0;
5

6
    constructor(name) {
7
        this.name = name;
8
        // 访问类属性
9
        Person.count++;
10
    }
11
}
12

13
const person1 = new Person("张三");
14
const person2 = new Person("李四");
15

16
console.log(Person.species);  // 人类
17
console.log(Person.count);    // 2
18
console.log(person1.species); // undefined（实例不能直接访问类属性）

1
class Calculator {
2
    constructor(result = 0) {
3
        this.result = result;
4
    }
5

6
    // 实例方法
7
    add(num) {
8
        this.result += num;
9
        return this;
10
    }
11

12
    subtract(num) {
13
        this.result -= num;
14
        return this;
15
    }
16

17
    getResult() {
18
        return this.result;
19
    }
20
}
21

22
const calc = new Calculator();
23
calc.add(10).subtract(3);
24
console.log(calc.getResult());  // 7

1
class MathUtils {
2
    // 静态方法
3
    static add(a, b) {
4
        return a + b;
5
    }
6

7
    static multiply(a, b) {
8
        return a * b;
9
    }
10

11
    static factorial(n) {
12
        if (n <= 1) return 1;
13
        return n * this.factorial(n - 1);
14
    }
15
}
16

17
// 通过类调用静态方法
18
console.log(MathUtils.add(5, 3));           // 8
19
console.log(MathUtils.multiply(4, 3));      // 12
20
console.log(MathUtils.factorial(5));        // 120
21

22
// 不能通过实例调用
23
// const utils = new MathUtils();
24
// utils.add(5, 3);  // TypeError

1
class Person {
2
    constructor(name, age) {
3
        this.name = name;
4
        this.age = age;
5
    }
6

7
    // 实例方法
8
    introduce() {
9
        return `我是 ${this.name}，今年 ${this.age} 岁`;
10
    }
11

12
    // 实例方法
13
    celebrateBirthday() {
14
        this.age++;
15
        return `${this.name} 今年 ${this.age} 岁了！`;
16
    }
17

18
    // 静态方法
19
    static compareAge(person1, person2) {
20
        if (person1.age > person2.age) {
21
            return `${person1.name} 比 ${person2.name} 大`;
22
        } else if (person1.age < person2.age) {
23
            return `${person1.name} 比 ${person2.name} 小`;
24
        } else {
25
            return `${person1.name} 和 ${person2.name} 同岁`;
26
        }
27
    }
28
}
29

30
const person1 = new Person("张三", 25);
31
const person2 = new Person("李四", 30);
32

33
console.log(person1.introduce());  // 我是 张三，今年 25 岁
34
console.log(person1.celebrateBirthday());  // 张三 今年 26 岁了！
35
console.log(Person.compareAge(person1, person2));  // 张三 比 李四 小

1
// 父类
2
class Animal {
3
    constructor(name, age) {
4
        this.name = name;
5
        this.age = age;
6
    }
7

8
    eat() {
9
        console.log(`${this.name} 正在吃东西`);
10
    }
11

12
    sleep() {
13
        console.log(`${this.name} 正在睡觉`);
14
    }
15
}
16

17
// 子类继承父类
18
class Dog extends Animal {
19
    constructor(name, age, breed) {
20
        // 调用父类的构造函数
21
        super(name, age);
22
        this.breed = breed;
23
    }
24

25
    bark() {
26
        console.log(`${this.name} 正在汪汪叫`);
27
    }
28
}
29

30
const dog = new Dog("旺财", 3, "金毛");
31
dog.eat();    // 旺财 正在吃东西
32
dog.sleep();  // 旺财 正在睡觉
33
dog.bark();   // 旺财 正在汪汪叫

1
class Animal {
2
    constructor(name) {
3
        this.name = name;
4
    }
5

6
    makeSound() {
7
        console.log(`${this.name} 发出声音`);
8
    }
9
}
10

11
class Dog extends Animal {
12
    makeSound() {
13
        console.log(`${this.name} 汪汪叫`);
14
    }
15
}
16

17
class Cat extends Animal {
18
    makeSound() {
19
        console.log(`${this.name} 喵喵叫`);
20
    }
21
}
22

23
const dog = new Dog("旺财");
24
const cat = new Cat("咪咪");
25

26
dog.makeSound();  // 旺财 汪汪叫
27
cat.makeSound();  // 咪咪 喵喵叫

1
class Animal {
2
    constructor(name) {
3
        this.name = name;
4
    }
5

6
    makeSound() {
7
        console.log(`${this.name} 发出声音`);
8
    }
9
}
10

11
class Dog extends Animal {
12
    makeSound() {
13
        // 先调用父类的方法
14
        super.makeSound();
15
        // 再添加自己的行为
16
        console.log(`${this.name} 汪汪叫`);
17
    }
18
}
19

20
const dog = new Dog("旺财");
21
dog.makeSound();
22
// 输出：
23
// 旺财 发出声音
24
// 旺财 汪汪叫

1
// 祖父类
2
class Vehicle {
3
    constructor(brand) {
4
        this.brand = brand;
5
    }
6

7
    start() {
8
        console.log(`${this.brand} 车辆启动`);
9
    }
10
}
11

12
// 父类
13
class Car extends Vehicle {
14
    constructor(brand, model) {
15
        super(brand);
16
        this.model = model;
17
    }
18

19
    drive() {
20
        console.log(`${this.brand} ${this.model} 正在行驶`);
21
    }
22
}
23

24
// 子类
25
class ElectricCar extends Car {
26
    constructor(brand, model, batteryCapacity) {
27
        super(brand, model);
28
        this.batteryCapacity = batteryCapacity;
29
    }
30

31
    charge() {
32
        console.log(`${this.brand} ${this.model} 正在充电`);
33
    }
34
}
35

36
const tesla = new ElectricCar("Tesla", "Model 3", "75kWh");
37
tesla.start();   // Tesla 车辆启动
38
tesla.drive();   // Tesla Model 3 正在行驶
39
tesla.charge();  // Tesla Model 3 正在充电

1
class BankAccount {
2
    #balance;  // 私有属性
3
    #pin;      // 私有属性
4

5
    constructor(owner, initialBalance, pin) {
6
        this.owner = owner;
7
        this.#balance = initialBalance;
8
        this.#pin = pin;
9
    }
10

11
    // 公共方法
12
    deposit(amount) {
13
        if (amount > 0) {
14
            this.#balance += amount;
15
            console.log(`存款成功，余额：${this.#balance}`);
16
        }
17
    }
18

19
    withdraw(amount, pin) {
20
        if (pin === this.#pin) {
21
            if (amount <= this.#balance) {
22
                this.#balance -= amount;
23
                console.log(`取款成功，余额：${this.#balance}`);
24
            } else {
25
                console.log("余额不足");
26
            }
27
        } else {
28
            console.log("密码错误");
29
        }
30
    }
31

32
    // 公共方法（只读）
33
    getBalance() {
34
        return this.#balance;
35
    }
36
}
37

38
const account = new BankAccount("张三", 1000, "1234");
39
account.deposit(500);           // 存款成功，余额：1500
40
account.withdraw(200, "1234");  // 取款成功，余额：1300
41
account.withdraw(200, "0000");  // 密码错误
42
console.log(account.getBalance());  // 1300
43

44
// 不能直接访问私有属性
45
// console.log(account.#balance);  // SyntaxError
46
// console.log(account.#pin);      // SyntaxError

1
class Calculator {
2
    #secret = 42;
3

4
    // 私有方法
5
    #validateInput(num) {
6
        if (typeof num !== 'number' || isNaN(num)) {
7
            throw new Error('输入必须是数字');
8
        }
9
    }
10

11
    add(a, b) {
12
        this.#validateInput(a);
13
        this.#validateInput(b);
14
        return a + b;
15
    }
16

17
    multiply(a, b) {
18
        this.#validateInput(a);
19
        this.#validateInput(b);
20
        return a * b;
21
    }
22

23
    getSecret() {
24
        return this.#secret;
25
    }
26
}
27

28
const calc = new Calculator();
29
console.log(calc.add(5, 3));      // 8
30
console.log(calc.getSecret());    // 42
31
// calc.#validateInput(5);        // SyntaxError

1
class Person {
2
    constructor(name, age) {
3
        this.name = name;
4
        this._age = age;  // 约定：以下划线开头的属性为"私有"
5
    }
6

7
    getAge() {
8
        return this._age;
9
    }
10

11
    setAge(newAge) {
12
        if (newAge >= 0 && newAge <= 150) {
13
            this._age = newAge;
14
        } else {
15
            console.log("年龄不合法");
16
        }
17
    }
18
}
19

20
const person = new Person("张三", 25);
21
console.log(person.getAge());  // 25
22
person.setAge(26);
23
console.log(person.getAge());  // 26
24
person.setAge(200);  // 年龄不合法

1
class Shape {
2
    constructor(color) {
3
        this.color = color;
4
    }
5

6
    draw() {
7
        console.log("绘制形状");
8
    }
9

10
    getArea() {
11
        return 0;
12
    }
13
}
14

15
class Circle extends Shape {
16
    constructor(color, radius) {
17
        super(color);
18
        this.radius = radius;
19
    }
20

21
    draw() {
22
        console.log(`绘制一个 ${this.color} 的圆形`);
23
    }
24

25
    getArea() {
26
        return Math.PI * this.radius * this.radius;
27
    }
28
}
29

30
class Rectangle extends Shape {
31
    constructor(color, width, height) {
32
        super(color);
33
        this.width = width;
34
        this.height = height;
35
    }
36

37
    draw() {
38
        console.log(`绘制一个 ${this.color} 的矩形`);
39
    }
40

41
    getArea() {
42
        return this.width * this.height;
43
    }
44
}
45

46
const shapes = [
47
    new Circle("红色", 5),
48
    new Rectangle("蓝色", 4, 6)
49
];
50

51
// 多态：同一接口，不同实现
52
shapes.forEach(shape => {
53
    shape.draw();
54
    console.log(`面积：${shape.getArea().toFixed(2)}`);
55
});
56

57
// 输出：
58
// 绘制一个 红色 的圆形
59
// 面积：78.54
60
// 绘制一个 蓝色 的矩形
61
// 面积：24.00

1
class PaymentMethod {
2
    processPayment(amount) {
3
        throw new Error("必须实现 processPayment 方法");
4
    }
5
}
6

7
class CreditCard extends PaymentMethod {
8
    constructor(cardNumber, expiry) {
9
        super();
10
        this.cardNumber = cardNumber;
11
        this.expiry = expiry;
12
    }
13

14
    processPayment(amount) {
15
        console.log(`使用信用卡 ${this.cardNumber} 支付 ¥${amount}`);
16
    }
17
}
18

19
class Alipay extends PaymentMethod {
20
    constructor(account) {
21
        super();
22
        this.account = account;
23
    }
24

25
    processPayment(amount) {
26
        console.log(`使用支付宝 ${this.account} 支付 ¥${amount}`);
27
    }
28
}
29

30
class WeChatPay extends PaymentMethod {
31
    constructor(account) {
32
        super();
33
        this.account = account;
34
    }
35

36
    processPayment(amount) {
37
        console.log(`使用微信支付 ${this.account} 支付 ¥${amount}`);
38
    }
39
}
40

41
// 使用多态
42
function checkout(paymentMethod, amount) {
43
    console.log("开始结账...");
44
    paymentMethod.processPayment(amount);
45
    console.log("支付完成！");
46
}
47

48
const creditCard = new CreditCard("1234-5678-9012-3456", "12/25");
49
const alipay = new Alipay("user@example.com");
50
const wechat = new WeChatPay("user123");
51

52
checkout(creditCard, 100);  // 使用信用卡支付
53
checkout(alipay, 200);      // 使用支付宝支付
54
checkout(wechat, 150);      // 使用微信支付

1
class Person {
2
    constructor(name, age) {
3
        this._name = name;
4
        this._age = age;
5
    }
6

7
    // Getter
8
    get name() {
9
        return this._name;
10
    }
11

12
    // Setter
13
    set name(newName) {
14
        if (newName.length >= 2) {
15
            this._name = newName;
16
        } else {
17
            console.log("名字至少需要 2 个字符");
18
        }
19
    }
20

21
    // Getter
22
    get age() {
23
        return this._age;
24
    }
25

26
    // Setter
27
    set age(newAge) {
28
        if (newAge >= 0 && newAge <= 150) {
29
            this._age = newAge;
30
        } else {
31
            console.log("年龄必须在 0-150 之间");
32
        }
33
    }
34
}
35

36
const person = new Person("张三", 25);
37

38
// 使用 getter
39
console.log(person.name);  // 张三
40
console.log(person.age);   // 25
41

42
// 使用 setter
43
person.name = "李四";
44
console.log(person.name);  // 李四
45

46
person.name = "A";  // 名字至少需要 2 个字符
47

48
person.age = 30;
49
console.log(person.age);  // 30
50

51
person.age = 200;  // 年龄必须在 0-150 之间

1
class Rectangle {
2
    constructor(width, height) {
3
        this.width = width;
4
        this.height = height;
5
    }
6

7
    // 计算属性
8
    get area() {
9
        return this.width * this.height;
10
    }
11

12
    get perimeter() {
13
        return 2 * (this.width + this.height);
14
    }
15
}
16

17
const rect = new Rectangle(5, 3);
18
console.log(rect.area);       // 15
19
console.log(rect.perimeter);  // 16

1
class Circle {
2
    constructor(radius) {
3
        this._radius = radius;
4
    }
5

6
    get radius() {
7
        return this._radius;
8
    }
9

10
    set radius(newRadius) {
11
        if (newRadius > 0) {
12
            this._radius = newRadius;
13
        } else {
14
            console.log("半径必须大于 0");
15
        }
16
    }
17

18
    // 只读属性（没有 setter）
19
    get diameter() {
20
        return 2 * this._radius;
21
    }
22

23
    get circumference() {
24
        return 2 * Math.PI * this._radius;
25
    }
26

27
    get area() {
28
        return Math.PI * this._radius * this._radius;
29
    }
30
}
31

32
const circle = new Circle(5);
33
console.log(circle.diameter);       // 10
34
console.log(circle.circumference);  // 31.4159...
35
console.log(circle.area);           // 78.5398...
36

37
// 不能修改只读属性
38
// circle.diameter = 20;  // 无效（没有 setter）

1
class Person {
2
    constructor(name) {
3
        this.name = name;
4
    }
5

6
    greet() {
7
        console.log(`你好，我是 ${this.name}`);
8
    }
9
}
10

11
const person = new Person("张三");
12

13
console.log(person.__proto__ === Person.prototype);  // true
14
console.log(Person.prototype.__proto__ === Object.prototype);  // true
15
console.log(Object.prototype.__proto__ === null);  // true

1
class Person {
2
    constructor(name) {
3
        this.name = name;
4
    }
5
}
6

7
// 在原型上添加方法
8
Person.prototype.greet = function() {
9
    console.log(`你好，我是 ${this.name}`);
10
};
11

12
Person.prototype.introduce = function() {
13
    console.log(`我叫 ${this.name}`);
14
};
15

16
const person = new Person("张三");
17
person.greet();      // 你好，我是 张三
18
person.introduce();  // 我叫 张三

1
function Animal(name) {
2
    this.name = name;
3
}
4

5
Animal.prototype.eat = function() {
6
    console.log(`${this.name} 正在吃东西`);
7
};
8

9
function Dog(name, breed) {
10
    Animal.call(this, name);  // 调用父类构造函数
11
    this.breed = breed;
12
}
13

14
// 设置原型链
15
Dog.prototype = Object.create(Animal.prototype);
16
Dog.prototype.constructor = Dog;
17

18
Dog.prototype.bark = function() {
19
    console.log(`${this.name} 汪汪叫`);
20
};
21

22
const dog = new Dog("旺财", "金毛");
23
dog.eat();   // 旺财 正在吃东西
24
dog.bark();  // 旺财 汪汪叫

1
class Person {
2
    constructor(name) {
3
        this.name = name;  // 实例属性
4
    }
5

6
    greet() {  // 原型方法
7
        console.log(`你好，我是 ${this.name}`);
8
    }
9
}
10

11
const person = new Person("张三");
12

13
// hasOwnProperty：检查是否是实例自身的属性
14
console.log(person.hasOwnProperty("name"));   // true
15
console.log(person.hasOwnProperty("greet"));  // false
16

17
// in 操作符：检查属性是否存在（包括原型链）
18
console.log("name" in person);   // true
19
console.log("greet" in person);  // true

1
// ES6 类语法
2
class Person {
3
    constructor(name, age) {
4
        this.name = name;
5
        this.age = age;
6
    }
7

8
    greet() {
9
        console.log(`你好，我是 ${this.name}`);
10
    }
11

12
    static createAnonymous() {
13
        return new Person("匿名", 0);
14
    }
15
}
16

17
// 继承
18
class Student extends Person {
19
    constructor(name, age, grade) {
20
        super(name, age);
21
        this.grade = grade;
22
    }
23

24
    study() {
25
        console.log(`${this.name} 正在学习`);
26
    }
27
}

1
// 传统构造函数
2
function Person(name, age) {
3
    this.name = name;
4
    this.age = age;
5
}
6

7
// 在原型上添加方法
8
Person.prototype.greet = function() {
9
    console.log(`你好，我是 ${this.name}`);
10
};
11

12
// 静态方法
13
Person.createAnonymous = function() {
14
    return new Person("匿名", 0);
15
};
16

17
// 继承
18
function Student(name, age, grade) {
19
    Person.call(this, name, age);  // 调用父类构造函数
20
    this.grade = grade;
21
}
22

23
// 设置原型链
24
Student.prototype = Object.create(Person.prototype);
25
Student.prototype.constructor = Student;
26

27
// 添加方法
28
Student.prototype.study = function() {
29
    console.log(`${this.name} 正在学习`);
30
};