javascript面向对象编程
1.封装
// 面向对象编程-类的封装 // 类中的属性和方法: // 私有属性 // 私有方法 // 公有属性 // 特权方法 // 原型属性(位于原型中) // 公有方法(位于原型中) // 寄生组合式继承 // 父类 function Person(name, age) { // 公有属性 this.name = name; this.age = age; // 特权方法 // 特权方法可以访问私有属性、私有方法、特权属性、特权方法 // 特权方法不能放在prototype内,因此无法复用 // 访问私有属性sexOrientation的特权方法 this.getSexOrientation = function () { return sexOrientation; }; // 访问私有方法setSexOrientation的特权方法 this.admittedByBUPT = function () { console.log("I'm admitted by BUPT!"); setSexOrientation('同性恋'); }; // 私有属性 var sexOrientation = '异性恋'; // 私有方法 // 私有方法可以访问私有属性(闭包)、私有方法(闭包) // 因为在私有方法中this指向的是全局对象window(不信可以打印this看一下),所以无法通过this访问到公有属性和特权方法 var setSexOrientation = function (sex) { sexOrientation = sex; // console.log(this); }; } // 原型属性 Person.prototype.className = 'Person'; // 原型方法 // 原型方法可以访问原型属性、原型方法、公有属性、特权方法,但不可以访问私有属性和私有方法 Person.prototype.getName = function () { return this.name; }; Person.prototype.getAge = function () { return this.age; }; // 静态属性 Person.country = 'Chinese'; // 静态方法 Person.setCountry = function (country) { this.country = country; }; Person.getCountry = function () { return this.country; }; // 寄生组合式继承 // 继承公有属性、特权方法、原型属性、公有方法 // 本写法是纯净的组合式继承 // 组合式继承指的是“原型链继承”+“构造函数式继承” function Teacher(name, age, school) { // 构造函数式继承 Person.call(this, name, age); // 子类新增公有属性 this.school = school; } // 子类新增公有方法 Teacher.prototype.getSchool = function () { return this.school }; // 实现继承 // 可以将这段实现继承的代码封装成一个inherit函数 var F = function () {}; F.prototype = Person.prototype; var o = new F(); o.constructor = Teacher; Teacher.prototype = o;
2.原型链继承
// 原型链继承 // 父类 function Person(name,age) { this.name = name; this.age = age; } Person.prototype.getName = function () { return this.name; } Person.prototype.getAge = function () { return this.age; } // 子类 function Teacher(school) { this.school = school; } // 注意 // 创建继承关系时无法向父类传递参数(因为传什么参数都会被所有子类实例共享,因此最好不传递任何参数),因此无法对父类中的属性进行实例化 // 这是原型链继承的第一个缺点 Teacher.prototype = new Person(); Teacher.prototype.getSchool = function () { return this.school; } var t1 = new Teacher('BUPT'); var t2 = new Teacher('BUPT'); console.log(t1 instanceof Teacher); console.log(t1 instanceof Person); console.log(t2 instanceof Teacher); console.log(t2 instanceof Person); console.log(Teacher.prototype.isPrototypeOf(t1)); console.log(Person.prototype.isPrototypeOf(t1)); console.log(Teacher.prototype.isPrototypeOf(t2)); console.log(Person.prototype.isPrototypeOf(t2)); console.log(t1.getSchool()); console.log(t1.getName()); console.log(t1.getAge()); console.log(t2.getSchool()); console.log(t2.getName()); console.log(t2.getAge()); t1.school = 'BNU'; // 注意 // 如果采用第一种设置属性的方式,那么在对象t1和其__proto__里面有相同的两份属性,只不过属性值不一样 // 如果采用第二种设置属性的方式,那么很显然,对象t2也将获得与对象t1相同的属性值 // 这是原型链继承的第2个缺点 // 第一种 // t1.name = 'Tom'; // t1.age = 20; // 第二种 t1.__proto__.name = 'Tom'; t1.__proto__.age = 20; console.log(t1.getSchool()); console.log(t1.getName()); console.log(t1.getAge()); console.log(t2.getSchool()); console.log(t2.getName()); console.log(t2.getAge());
3.构造函数式继承
// 构造函数式继承 // 父类 function Person(name,age) { this.name = name; this.age = age; } Person.prototype.getName = function () { return this.name; } Person.prototype.getAge = function () { return this.age; } // 子类 function Teacher(name, age, school) { Person.apply(this, arguments); this.school = school; } Teacher.prototype.getSchool = function () { return this.school; } var t1 = new Teacher('Tom', 20, 'BUPT'); var t2 = new Teacher('Joy', 18, 'BNU'); console.log(t1 instanceof Teacher); console.log(t1 instanceof Person);// false console.log(t2 instanceof Teacher); console.log(t2 instanceof Person);// false console.log(Teacher.prototype.isPrototypeOf(t1)); console.log(Person.prototype.isPrototypeOf(t1)); console.log(Teacher.prototype.isPrototypeOf(t2)); console.log(Person.prototype.isPrototypeOf(t2)); // 注意 // 由于这种构造函数式继承没有涉及到父类的原型,因此子类实例无法访问父类prototype中定义的属性和方法 // 这是构造函数式继承的明显缺点 // console.log(t1.getName()); console.log(t1.name); console.log(t1.getSchool()); // console.log(t2.getName()) console.log(t2.name); console.log(t2.getSchool());
4.组合式继承:原型链继承+构造函数式继承
// 原型链继承+构造函数式继承=组合式继承 // 父类 function Person(name, age) { this.name = name; this.age = age; } Person.prototype.getName = function () { return this.name; } Person.prototype.getAge = function () { return this.age; } // 子类 function Teacher(name, age, school) { // 构造函数式继承 Person.apply(this, arguments); this.school = school; } // 原型链继承 Teacher.prototype = new Person(); Teacher.prototype.getSchool = function () { return this.school; } var t1 = new Teacher('Tom', 20, 'BUPT'); var t2 = new Teacher('Joy', 18, 'BNU'); console.log(t1 instanceof Teacher); console.log(t1 instanceof Person); console.log(t2 instanceof Teacher); console.log(t2 instanceof Person); console.log(Teacher.prototype.isPrototypeOf(t1)); console.log(Person.prototype.isPrototypeOf(t1)); console.log(Teacher.prototype.isPrototypeOf(t2)); console.log(Person.prototype.isPrototypeOf(t2)); console.log(t1.getName()); console.log(t1.name); console.log(t1.getSchool()); console.log(t2.getName()) console.log(t2.name); console.log(t2.getSchool()); // 注意 // 这种组合式继承将父类构造函数执行了(n+1)遍,n为实例化的对象个数。 // 如果n远大于1的话倒是没什么问题,但是如果n比较小(一般情况应该也不会很大吧),比如n=1,即只实例化一次,那么这一次额外的父类构造函数调用(添加原型时的那次调用)将不能忽略。 // 并且,这次构造函数的调用将在子类的原型添加父类的属性,可以通过下面查看__proto__来看到。 // 因此这种继承方式存在两个缺点:多调用一次父类构造函数造成额外开销,继承冗余不纯净。 console.log(t1.__proto__); console.log(t2.__proto__);
5.寄生组合式继承
请移步1封装。