javascript面向对象编程(一) 实例代码

下面是针对 "javascript面向对象编程(一) 实例代码" 的详细攻略。

1. 阅读并理解代码

首先，我们需要仔细阅读提供的代码，深入理解它的结构、逻辑和运行机制。代码中定义了一个自定义对象 "Person"，其中包含变量和方法定义。在代码中，我们创建了一个 "Person" 实例，使用了对象的属性和方法。

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;

  this.sayName = function() {
    console.log("My name is " + this.name);
  };
  this.sayAge = function() {
    console.log("I am " + this.age + " years old");
  };
  this.saySex = function() {
    console.log("I am " + this.sex);
  };
}

var person1 = new Person("Tom", 29, "male");
person1.sayName(); // 输出 "My name is Tom"
person1.sayAge(); // 输出 "I am 29 years old"
person1.saySex(); // 输出 "I am male"

2. 理解面向对象编程思想

面向对象编程（Object-Oriented Programming，OOP）是一种编程思想，它将程序中的“对象（Object）”作为程序的基础单元，通过对对象的定义、创建和封装来实现程序的设计和编程。

在面向对象编程中，每个对象都有自己的属性和方法，对象之间通过消息传递实现相互交互和协作。通过封装、继承和多态等面向对象编程的特性，可以实现更加灵活、可扩展和可靠的程序设计。

3. 实现基本的『封装』

在上面的代码中，我们可以看到 "Person" 对象通过 "this" 关键字定义了三个属性 name、age、sex，以及三个方法 sayName()、sayAge()、saySex()。

这里的“this”关键字用于指向该对象本身，定义属性和方法时，都会将其关联到“this”所指向的对象上。

在常规开发中，我们需要将对象的属性和方法封装到私有空间中，同时提供一些公共接口来对外暴露对象的功能。实现『封装』的过程中，我们通常使用闭包来实现。

下面是一个使用闭包实现封装的示例：

function Person(name, age, sex) {
  var _name = name;
  var _age = age;
  var _sex = sex;

  function sayName() {
    console.log("My name is " + _name);
  }

  function sayAge() {
    console.log("I am " + _age + " years old");
  }

  function saySex() {
    console.log("I am " + _sex);
  }

  return {
    sayName: sayName,
    sayAge: sayAge,
    saySex: saySex
  };
}

var person1 = Person("Tom", 29, "male");
person1.sayName(); // 输出 "My name is Tom"
person1.sayAge(); // 输出 "I am 29 years old"
person1.saySex(); // 输出 "I am male"

在这个示例中，我们将变量 _name、_age、_sex 定义在了构造函数内部，通过闭包的方式实现了变量的私有化。同时我们返回了一个匿名对象，该匿名对象包含了 sayName、sayAge、saySex 三个公共方法，并且这三个方法都能够访问到被私有化的变量。

这样一来，就实现了对 "Person" 对象属性和方法的基本封装。

4. 使用原型模式实现共享属性和方法

在面向对象编程中，我们经常会使用原型模式（Prototype）来实现共享属性和方法。在 JavaScript 中，对象的原型（Prototype）是一个对象，它包含了对象的共享属性和方法，并且是由系统自动创建的。

下面是一个使用原型模式实现共享属性和方法的示例：

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

Person.prototype.sayName = function() {
  console.log("My name is " + this.name);
};

Person.prototype.sayAge = function() {
  console.log("I am " + this.age + " years old");
};

Person.prototype.saySex = function() {
  console.log("I am " + this.sex);
};

var person1 = new Person("Tom", 29, "male");
person1.sayName(); // 输出 "My name is Tom"
person1.sayAge(); // 输出 "I am 29 years old"
person1.saySex(); // 输出 "I am male"

在这个示例中，我们使用了 "Person.prototype" 来定义了三个方法 sayName、sayAge、saySex，并且这三个方法被定义在了该对象的原型上，这就意味着无论创建多少个 "Person" 对象，它们都共享一个原型，从而实现了共享属性和方法。

示例说明

1. 实现带有私有属性和方法的 Person 对象

下面看一个实现泛用的带有私有属性和方法的 Person 对象的示例代码：

function Person(name, age, sex) {
  var _name = name,
      _age = age,
      _sex = sex;

  function _checkAge(age) {
    if (typeof age === 'number' && age >= 0 && age < 120) {
      return true;
    } else {
      return false;
    }
  }

  function _checkSex(sex) {
    if (sex === 'male' || sex === 'female') {
      return true;
    } else {
      return false;
    }
  }

  if (_checkAge(age) && _checkSex(sex)) {
    this.name = _name;
    this.age = _age;
    this.sex = _sex;
  }
}

Person.prototype.sayName = function() {
  console.log("My name is " + this.name);
};

Person.prototype.sayAge = function() {
  console.log("I am " + this.age + " years old");
};

Person.prototype.saySex = function() {
  console.log("I am " + this.sex);
};

var person1 = new Person("Tom", 29, "male");
person1.sayName(); // 输出 "My name is Tom"
person1.sayAge(); // 输出 "I am 29 years old"
person1.saySex(); // 输出 "I am male"

在这个示例中，我们通过闭包实现了变量的私有化，同时定义了两个私有函数来检查传入的参数是否合法。这样一来，我们得到了一个基本安全且拥有私有属性和方法的对象。

1. 实现继承

下面看一个实现类的继承的代码示例：

// 声明 Person 类，并基于该类创建对象
function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

Person.prototype.sayName = function() {
  console.log("My name is " + this.name);
};

Person.prototype.sayAge = function() {
  console.log("I am " + this.age + " years old");
};

Person.prototype.saySex = function() {
  console.log("I am " + this.sex);
};

// 声明 Student 类，基于 Person 类创建
function Student(name, age, sex, school) {
  Person.call(this, name, age, sex);
  this.school = school;
}

// 继承 Person
Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;

// 新增 Student 类的方法和属性
Student.prototype.saySchool = function() {
  console.log("I am studying in " + this.school);
};

var tom = new Student("Tom", 20, "male", "Xi'an Jiaotong University");
tom.sayName(); // 输出 "My name is Tom"
tom.sayAge(); // 输出 "I am 20 years old"
tom.saySex(); // 输出 "I am male"
tom.saySchool(); // 输出 "I am studying in Xi'an Jiaotong University"

在这个示例中，我们首先声明了 Person 类，并基于该类创建对象。然后，我们定义了一个 Student 类，基于 Person 类创建，并继承了 Person 类中的属性和方法。同时，我们还为 Student 类定义了一个新方法 saySchool。

通过这个示例，我们可以看到，在 JavaScript 中实现类的继承相对比较复杂。但是只要掌握了这些细节，我们就可以写出优雅、高效的面向对象程序了。