面向对象的三大基本特性
封装(把相关的信息（无论数据或方法）存储在对象中的能力)
继承(由另一个类（或多个类）得来类的属性和方法的能力)
多态(一个对象在不同情况下的多种形态)
定义类或对象
第一种：基于Object对象
|
var person = new Object();
person.name = "Rose";
person.age = 18;
person.getName = function () {
return this.name;
};
console.log(person.name);//Rose
console.log(person.getName);//function () {return
this.name;}
console.log(person.getName());//Rose
|
缺点：不能创建多个对象。
第二种：基于字面量方式
|
var person = {
name : "Rose",
age : 18 ,
getName : function () {
return this.name;
}
};
console.log(person.name);//Rose
console.log(person.getName);//function () {return
this.name;}
console.log(person.getName());//Rose
|
优点：比较清楚的查找对象包含的属性和方法；
缺点：不能创建多个对象。
第三种：工厂模式
方式一：
|
function createPerson(name,age) {
var object = new Object();
object.name = name;
object.age = age;
object.getName = function ()
{
return this.name;
};
return object;
}
var person1 = createPerson("Rose",18);
var person2 = createPerson("Jack",20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName);//false//重复生成函数，为每个对象都创建独立的函数版本
|
优点：可以创建多个对象；
缺点：重复生成函数getName()，为每个对象都创建独立的函数版本。
方式二：
|
function createPerson(name,age) {
var object = new Object();
object.name = name;
object.age = age;
object.getName = getName;
return object;
}
function getName() {
return this.name;
}
var person1 = createPerson("Rose",18);
var person2 = createPerson("Jack",20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName);//true//共享同一个函数
|
优点：可以创建多个对象；
缺点：从语义上讲，函数getName()不太像是Person对象的方法，辨识度不高。
第四种：构造函数方式
方式一：
|
function Person(name,age) {
this.name = name;
this.age = age;
this.getName = function ()
{
return this.name;
}
}
var person1 = new Person("Rose",18);
var person2 = new Person("Jack",20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName); //false//重复生成函数，为每个对象都创建独立的函数版本
|
优点：可以创建多个对象；
缺点：重复生成函数getName()，为每个对象都创建独立的函数版本。
方式二：
|
function Person(name,age) {
this.name = name;
this.age = age;
this.getName = getName
;
}
function getName() {
return this.name;
}
var person1 = new Person("Rose",18);
var person2 = new Person("Jack",20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName); //true//共享同一个函数
|
优点：可以创建多个对象；
缺点：从语义上讲，函数getName()不太像是Person对象的方法，辨识度不高。
第五种：原型方式
|
function Person() {
}
Person.prototype.name = 'Rose';
Person.prototype.age = 18;
Person.prototype.getName = function () {
return this.name;
};
var person1 = new Person();
var person2 = new Person();
console.log(person1.name);//Rose
console.log(person2.name);//Rose//共享同一个属性
console.log(person1.getName
=== person2.getName);//true//共享同一个函数
|
缺点：它省略了为构造函数传递初始化参数，这在一定程序带来不便；另外，最主要是当对象的属性是引用类型时，它的值是不变的，总是引用同一个外部对象，所有实例对该对象的操作都会影响其它实例：
|
function Person() {
}
Person.prototype.name = 'Rose';
Person.prototype.age = 18;
Person.prototype.lessons = ["语文","数学"];
Person.prototype.getName = function () {
return this.name;
};
var person1 = new Person();
person1.lessons.push("英语");
var person2 = new Person();
console.log(person1.lessons);//["语文", "数学", "英语"]
console.log(person2.lessons);//["语文", "数学", "英语"]//person1修改影响了person2
|
第六种：构造函数+原型方式（推荐）
|
function Person(name,age) {
this.name = name;
this.age = age;
}
Person.prototype.getName = function () {
return this.name;
};
var person1 = new Person('Rose', 18);
var person2 = new Person('Jack', 20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName);//true//共享原型中定义的方法
|
缺点：属性定义在构造函数内，方法定义在构造函数外，与面向对象的封装思想不符。
第七种：构造函数+动态原型方式（推荐）
方式一：
|
function Person(name,age) {
this.name = name;
this.age = age;
if (typeof
Person._getName === "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName = true;
}
}
var person1 = new Person('Rose', 18);
var person2 = new Person('Jack', 20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName);//true//共享原型中定义的方法
|
方式二：
|
function Person(name,age) {
this.name = name;
this.age = age;
if (typeof
this.getName !== "function"){
Person.prototype.getName
= function () {
return this.name;
};
}
}
var person1 = new Person('Rose', 18);
var person2 = new Person('Jack', 20);
console.log(person1.name);//Rose
console.log(person2.name);//Jack
console.log(person1.getName === person2.getName);//true//共享原型中定义的方法
|
对象属性的扩展及删除
Javascript的对象可以使用 ’.’ 操作符动态的扩展其属性，可以使用 ’delete’ 关键字或将属性的值设置为
’undefined’ 来删除属性。
|
function Person(name,age) {
this.name = name;
this.age = age;
if (typeof Person._getName
=== "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName =
true;
}
}
var person = new Person("Rose",18);
person.job
= 'Engineer';//添加属性
console.log(person.job);//Engineer
delete person.job;//删除属性
console.log(person.job);//undefined//删除属性后值为undefined
person.age = undefined;//删除属性
console.log(person.age);//undefined//删除属性后值为undefined
|
对象属性类型
数据属性
特性：
[configurable]:表示能否使用delete操作符删除从而重新定义，或能否修改为访问器属性。默认为true;
[enumberable]:表示是否可通过for-in循环返回属性。默认true;
[writable]:表示是否可修改属性的值。默认true;
[value]:包含该属性的数据值。读取/写入都是该值。默认为undefined;如上面实例对象person中定义了name属性，其值为’My
name’,对该值的修改都反正在这个位置
|
function Person(name,age) {
this.name = name;
this.age = age;
if (typeof Person._getName
=== "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName =
true;
}
}
var person = new Person("Rose",18);
Object.defineProperty(person,"name",{configurable:false,writable:false});
person.name
= "Jack";
console.log(person.name);//Rose//重新赋值无效
delete person.name;
console.log(person.name);//Rose//删除无效
|
注意：
一旦将configurable设置为false，则无法再使用defineProperty将其修改为true（执行会报错：cannot redefine property : propertyName）
|
function Person(name,age) {
this.name = name;
this.age = age;
if (typeof Person._getName
=== "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName =
true;
}
}
var person = new Person("Rose",18);
Object.defineProperty(person,"name",{configurable:false,writable:false});
person.name = "Jack";
console.log(person.name);//Rose//重新赋值无效
delete person.name;
console.log(person.name);//Rose//删除无效
Object.defineProperty(person,"name",{configurable:true,writable:true});//Cannot
redefine property: name
|
访问器属性
特性：
[configurable]:是否可通过delete操作符删除重新定义属性；
[numberable]:是否可通过for-in循环查找该属性；
[get]:读取属性时调用，默认：undefined;
[set]:写入属性时调用，默认：undefined;
访问器属性不能直接定义，必须使用defineProperty()或defineProperties来定义：如下
|
function Person(name,age) {
this.name = name;
this._age = age;
if (typeof Person._getName
=== "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName =
true;
}
}
var person = new Person("Rose",18);
Object.defineProperty(person,"age",{
get:function () {
return this._age;
},
set:function (age) {
this._age = age;
}});
person.age = 20;
console.log(person.age);//20//person.age=20是使用set方法将20赋值给_age，person.age是使用get方法将_age的读取出来
console.log(person._age);//20
|
获取所有的属性和属性的特性
使用Object.getOwnPropertyNames(object)方法可以获取所有的属性；
使用Object.getOwnPropertyDescriptor(object,property)方法可以取得给定属性的特性；
|
function Person(name,age) {
this.name = name;
this._age = age;
if (typeof Person._getName
=== "undefined"){
Person.prototype.getName
= function () {
return this.name;
};
Person._getName =
true;
}
}
var person = new Person("Rose",18);
Object.defineProperty(person,"age",{
get:function () {
return this._age;
},
set:function (age) {
this._age = age;
}});
console.log(Object.getOwnPropertyNames(person));//["name",
"_age", "age"]
console.log(Object.getOwnPropertyDescriptor(person,"age"));//{enumerable:
false, configurable: false, get: function, set: function}
|
对于数据属性，可以取得：configurable,enumberable,writable和value；
对于访问器属性，可以取得：configurable,enumberable,get和set；
继承机制实现
对象冒充
|
function Father(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function Son(name,age) {
this._newMethod = Father;
this._newMethod(name);
delete this._newMethod;
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var father = new Father("Tom");
var son = new Son("Jack",18);
console.log(father.getName());//Tom
console.log(son.getName());//Jack//继承父类getName()方法
console.log(son.getAge());//18
|
多继承（利用对象冒充可以实现多继承）
|
function FatherA(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function FatherB(job) {
this.job = job;
this.getJob = function ()
{
return this.job;
}
}
function Son(name,job,age) {
this._newMethod = FatherA;
this._newMethod(name);
delete this._newMethod;
this._newMethod = FatherB;
this._newMethod(job);
delete this._newMethod;
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var fatherA = new FatherA("Tom");
var fatherB = new FatherB("Engineer");
var son = new Son("Jack","Programmer",18);
console.log(fatherA.getName());//Tom
console.log(fatherB.getJob());//Engineer
console.log(son.getName());//Jack//继承父类FatherA的getName()方法
console.log(son.getJob());//Programmer//继承父类FatherB的getJob()方法
console.log(son.getAge());//18
|
call()方法
|
function Father(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function Son(name,job,age) {
Father.call(this,name);
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var father = new Father("Tom");
var son = new Son("Jack","Programmer",18);
console.log(father.getName());//Tom
console.log(son.getName());//Jack//继承父类getName()方法
console.log(son.getAge());//18
|
多继承（利用call()方法实现多继承）
|
function FatherA(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function FatherB(job) {
this.job = job;
this.getJob = function ()
{
return this.job;
}
}
function Son(name,job,age) {
FatherA.call(this,name);
FatherB.call(this,job);
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var fatherA = new FatherA("Tom");
var fatherB = new FatherB("Engineer");
var son = new Son("Jack","Programmer",18);
console.log(fatherA.getName());//Tom
console.log(fatherB.getJob());//Engineer
console.log(son.getName());//Jack//继承父类FatherA的getName()方法
console.log(son.getJob());//Programmer//继承父类FatherB的getJob()方法
console.log(son.getAge());//18
|
apply()方法
|
function Father(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function Son(name,job,age) {
Father.apply(this,new Array(name));
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var father = new Father("Tom");
var son = new Son("Jack","Programmer",18);
console.log(father.getName());//Tom
console.log(son.getName());//Jack//继承父类getName()方法
console.log(son.getAge());//18
|
多继承（利用apply()方法实现多继承）
|
function FatherA(name) {
this.name = name ;
this.getName = function ()
{
return this.name;
}
}
function FatherB(job) {
this.job = job;
this.getJob = function ()
{
return this.job;
}
}
function Son(name,job,age) {
FatherA.apply(this,new Array(name));
FatherB.apply(this,new
Array(job));
this.age = age;
this.getAge = function ()
{
return this.age;
}
}
var fatherA = new FatherA("Tom");
var fatherB = new FatherB("Engineer");
var son = new Son("Jack","Programmer",18);
console.log(fatherA.getName());//Tom
console.log(fatherB.getJob());//Engineer
console.log(son.getName());//Jack//继承父类FatherA的getName()方法
console.log(son.getJob());//Programmer//继承父类FatherB的getJob()方法
console.log(son.getAge());//18
|
原型链方法
|
function Father() {
}
Father.prototype.name = "Tom";
Father.prototype.getName = function () {
return this.name;
};
function Son() {
}
Son.prototype
= new Father();
Son.prototype.age = 18;
Son.prototype.getAge = function () {
return this.age;
};
var father = new Father();
var son = new Son();
console.log(father.getName());//Tom
console.log(son.getName());//Tom//继承父类FatherA的getName()方法
console.log(son.getAge());//18
|
混合方式（call()+原型链）
|
function Father(name) {
this.name = name;
}
Father.prototype.getName = function () {
return this.name;
};
function Son(name,age) {
Father.call(this,name);
this.age = age;
}
Son.prototype
= new Father();
Son.prototype.getAge = function () {
return this.age;
};
var father = new Father("Tom");
var son = new Son("Jack",18);
console.log(father.getName());//Tom
console.log(son.getName());//Jack//继承父类Father的getName()方法
console.log(son.getAge());//18
|
多态机制实现
|
function Person(name) {
this.name = name;
if (typeof this.getName
!== "function"){
Person.prototype.getName
= function () {
return this.name;
}
}
if (typeof this.toEat
!== "function"){
Person.prototype.toEat
= function (animal) {
console.log( this.getName()
+ "说去吃饭：");
animal.eat();
}
}
}
function Animal(name) {
this.name = name;
if (typeof this.getName
!== "function"){
Animal.prototype.getName
= function () {
return this.name;
}
}
}
function Cat(name) {
Animal.call(this,name);
if (typeof this.eat
!== "function"){
Cat.prototype.eat
= function () {
console.log(this.getName()
+ "吃鱼");
}
}
}
Cat.prototype = new Animal();
function Dog(name) {
Animal.call(this,name);
if (typeof this.eat
!== "function"){
Dog.prototype.eat
= function () {
console.log(this.getName()
+ "啃骨头");
}
}
}
Dog.prototype = new Animal();
var person = new Person("Tom");
person.toEat(new Cat("cat"));//Tom说去吃饭：cat吃鱼
person.toEat(new Dog("dog"));//Tom说去吃饭：dog啃骨头
|
- 浅谈JavaScript的面向对象和它的封装、继承、多态
写在前面 既然是浅谈,就不会从原理上深度分析,只是帮助我们更好地理解... 面向对象与面向过程 面向对象和面向过程是两种不同的编程思想,刚开始接触编程的时候,我们大都是从面向过程起步的,毕竟像我一样, ...
- 浅谈JavaScript的面向对象程序设计（四）
本文继续讲解JavaScript的面向对象程序设计.继承是面向对象语言中的一个基本概念,面向对象语言支持两种继承实现方式:接口继承和实现继承.接口继承只继承方法签名,而实现继承则继承实际的方法.但是在 ...
- 浅谈JavaScript的面向对象程序设计（三）
前面已经对JavaScript的面向对象程序设计作了简单的介绍,包括了对象的属性.对象的工厂模式.构造函数和原型等.通过介绍,这些创建对象的方法依然有不少优化和改进的地方. 组合使用构造函数模式和原型 ...
- 浅谈JavaScript的面向对象程序设计（一）
面向对象的语言有一个标志,他们都有类的概念,通过类可以创建多个具有相同属性和方法的对象.但是JavaScript中没有类的概念,因此JavaScript与其他的面向对象语言还是有一定区别的.JavaS ...
- 浅谈JavaScript的面向对象程序设计（二）
前面介绍通过Object构造函数或者字面量创建单个对象,但是通过这个的方法创建对象有明显的缺点:调用同一个接口创建多个实例,会产生大量的重复代码.怎么样解决? 工厂模式 工厂模式是软件工程领域经常使用 ...
- 浅谈javascript函数节流
浅谈javascript函数节流 什么是函数节流? 函数节流简单的来说就是不想让该函数在很短的时间内连续被调用,比如我们最常见的是窗口缩放的时候,经常会执行一些其他的操作函数,比如发一个ajax请求等 ...
- 浅谈JavaScript浮点数及其运算
原文:浅谈JavaScript浮点数及其运算 JavaScript 只有一种数字类型 Number,而且在Javascript中所有的数字都是以IEEE-754标准格式表示的.浮点数的精度问题 ...
- 浅谈JavaScript中的闭包
浅谈JavaScript中的闭包 在JavaScript中,闭包是指这样一个函数:它有权访问另一个函数作用域中的变量. 创建一个闭包的常用的方式:在一个函数内部创建另一个函数. 比如: functio ...
- 浅谈 JavaScript 编程语言的编码规范
对于熟悉 C/C++ 或 Java 语言的工程师来说,JavaScript 显得灵活,简单易懂,对代码的格式的要求也相对松散.很容易学习,并运用到自己的代码中.也正因为这样,JavaScript 的编 ...
随机推荐
- python第三方库 pip 豆瓣源
pip install xxx -i http://pypi.douban.com/simple/ xxx 为包名
- C#中跨线程访问控件
net 原则上禁止跨线程访问控件,因为这样可能造成错误的发生,推荐的解决方法是采用代理,用代理方法来间接操作不是同一线程创建的控件. 第二种方法是禁止编译器对跨线程访问作检查,可以实现访问,但是出不出 ...
- CUDA5.5入门文章：VS10设置
原文链接:http://blog.csdn.net/augusdi/article/details/12205435 作者专栏:http://blog.csdn.net/augusdi/article ...
- vue项目布局
1.底部有分类布局 类似这种底部有分类的,点击四个tap分别道不同的页面这样的,每个页面都是一个路由,把底部作为一个组件在每一个页面中引入就行.组件就是公用的,能公用的就写成组件.如下 { path: ...
- 路飞学城Python-Day79
27-url控制器之path方法 由于基于re_path的路径编写方式是重复性高的编写url,如果规则改变了,则对应的要去修改很多url,这样是很不方便的 所以采用Django2.0的path去编写u ...
- Ubuntu18.04 安装 oh-my-zsh
目录 Ubuntu18.04 安装 oh-my-zsh 目录 安装zsh 安装curl 安装oh-my-zsh 使用zsh替换bash 修改终端主题和配色 修改终端配置 隐藏用户和主机名 效果图 Ub ...
- NOIP2018提高组省一冲奖班模测训练（六）
NOIP2018提高组省一冲奖班模测训练(六) https://www.51nod.com/Contest/ContestDescription.html#!#contestId=80 20分钟AC掉 ...
- uni-app 之验证码
手机APP---验证码 最近公司在开发手机APP,app避不可免的就是登录了,emmmm 登录验证码那必须的是有的,我们公司发给我们的图片是酱紫的~~ 这个要求大家应该都能看懂,做这个手机号啊,验证码 ...
- CCPC2018秦皇岛游记
Day1 27号晚上8点多的火车. 然后..第二天(28号)6点40左右的样子到了天津(中转站) 然后一顿乱拍. 看到宝葫芦了没:) 然后.看到了狗不理包子铺...不过当时没开门,就溜了. 然后去秦皇 ...
- Git学习总结（11）——Git撤销操作详解
本文主要讨论和撤销有关的 git 操作.目的是让读者在遇到关于撤销问题时能够方便迅速对照执行解决问题,而不用去翻阅参数繁多的 git 使用说明. 一开始你只需了解大致功能即可,不必记住所有命令和具体参 ...
