JS OOP包机制,类创建的方法定义

JS OOP（面向对象编程）的包机制是指如何将类组织起来并进行封装。在JS中，OOP的核心概念是类（class），而封装、继承、多态则是其辅助概念。在JS中，我们可以通过以下两种方式进行类的创建和定义。

1. 类的创建方式一：使用构造函数

1.1 构造函数的定义

构造函数是创建JS类的一种方式，它定义了一个可重复使用的对象或模板，可以多次调用它来创建新的对象。基本语法如下：

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.sayHello = function() {
        console.log('Hello, my name is ' + this.name + ', I am ' + this.age + ' years old.');
    }
}

上述代码中，我们定义了一个Person类，该类有两个属性name和age，以及一个方法sayHello。这个方法会输出“Hello, my name is [name], I am [age] years old.”，其中[name]和[age]会被替换为具体的属性值。

1.2 构造函数创建对象

创建对象的方法如下:

var person = new Person('Jim', 30);

上述代码中，我们使用构造函数Person来创建一个person对象，name属性被设置为“Jim”，age属性被设置为30。

1.3 构造函数的继承

JS中的类可以通过继承实现代码复用。继承是指一个类（称为子类）从另一个类（称为父类）继承属性和方法。JS中的构造函数可以通过原型链继承来实现继承，基本语法如下：

function Student(name, age, grade) {
    Person.call(this, name, age);
    this.grade = grade;
}
Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;
Student.prototype.sayHello = function() {
    console.log('Hello, my name is ' + this.name + ', I am ' + this.age + ' years old, and I study in grade ' + this.grade);
};

上述代码中，我们定义了一个Student类，该类继承自Person类，并添加了一个新的grade属性。我们使用Person.call(this, name, age)来调用Person的构造函数，并把它的属性复制到Student的实例中。最后，我们通过Object.create(Person.prototype)来创建一个空对象，并将它的原型链指向Person.prototype。这样，我们就实现了从Person类继承的目的。

2. 类的创建方式二：使用类声明语法

2.1 类声明语法

JS中自ECMAScript 6版本开始增加了类声明语法，基本语法如下：

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    sayHello() {
        console.log('Hello, my name is ' + this.name + ', I am ' + this.age + ' years old.');
    }
}

上述代码中，我们使用class关键字来声明一个Person类，并使用constructor来创建构造函数。我们还定义了一个sayHello方法来输出Person的信息。

2.2 创建对象

创建对象的方式和之前的一样，如下：

let person = new Person('Tom', 25);

上述代码中，我们使用new操作符来创建Person的实例，并把它赋值给变量person。

2.3 继承类

类声明语法也支持继承机制，基本语法如下：

class Student extends Person {
    constructor(name, age, grade) {
        super(name, age);
        this.grade = grade;
    }
    sayHello() {
        console.log('Hello, my name is ' + this.name + ', I am ' + this.age + ' years old, and I study in grade ' + this.grade);
    }
}

上述代码中，我们使用extends来实现继承，即从Person类继承。在Student的构造函数中，我们使用super(name, age)来调用Person的构造函数，并把它的属性复制到Student的实例中。最后，我们通过它的sayHello方法来输出Student的信息。

示例说明

以下是两个简单示例，用于说明类的创建和继承：

示例1：

class Animal {
    constructor(type, name) {
        this.type = type;
        this.name = name;
    }
    getFullName() {
        console.log(this.type + ' ' + this.name);
    }
}

class Dog extends Animal {
    constructor(name) {
        super('Dog', name);
        this.color = 'white';
    }
    bark() {
        console.log('汪汪！');
    }
}

let dog = new Dog('旺财');
dog.getFullName(); // 输出 "Dog 旺财"
dog.bark(); // 输出 "汪汪！"

上述代码中，我们使用类声明语法创建了Animal和Dog两个类，并实现了继承关系。我们定义了一些属性和方法，比如Animal的构造函数和getFullName方法以及Dog的构造函数和bark方法。

示例2：

function Fruit(name, price) {
    this.name = name;
    this.price = price;

    this.showInfo = function() {
        console.log('This ' + this.name + ' is priced at $' + this.price);
    }
}

function Apple(name, price, color) {
    Fruit.call(this, name, price);
    this.color = color;
    this.showInfo = function() {
        console.log('This ' + this.color + ' ' + this.name + ' is priced at $' + this.price);
    }
}

Apple.prototype = Object.create(Fruit.prototype);
Apple.prototype.constructor = Apple;

let apple = new Apple('Apple', 2, 'red');
apple.showInfo(); // 输出 "This red Apple is priced at $2"

上述代码中，我们使用构造函数方式创建了Fruit和Apple两个类，实现了继承关系。我们定义了一些属性和方法，比如Fruit的构造函数和showInfo方法以及Apple的构造函数和继承自Fruit的showInfo方法。

总之，JS OOP的包机制可以通过构造函数和类声明语法来实现，其中继承关系可以通过原型链来实现。这种机制可以方便地模块化编程，提高了代码的复用性和可读性。