javascript面向对象（一）

对象其实就是一种引用类型。而对象的值就是引用类型的实例。在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一块儿。javascript

它也常被称作为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具有传统面向对象语言所支持的类和接口等基本结构。html

对象的建立以及经常使用操做

使用new运算符java

var user = new Object(); //使用new运算符建立一个对象 user.name = '李铭'; //给对象添加属性 user.age = 21; user.address = '四川成都';

对象字面量(JSON方式)编程

var user = { name:'王五', age:22, address:'四川成都' };

简单方式(传统赋值方式)数据结构

var user = {}; user.name = '王五'; //给对象添加属性 user.age = 22; user.address = '四川成都';

属性的调用函数

对于对象属性的调用有两种方式：post

调用方法以下：测试

alert(user.name + " " +user.age);this
//返回 '王五四川成都'spa

另外一种方法：

alert(user['name'] + " " +user['age']);
//返回 '王五四川成都'

添加方法

var user = { name:'王五子', //给对象添加属性 age:22, address:'四川成都', showInfo:function(){//添加一个方法 alert(this.name+" "+this.age+" "+this.address); }, showHello:showHello//将对象外部的方法添加到对象 }; function showHello(){ alert("Hello!"); } user.showInfo();//调用方法 user.showHello();

javascript面向对象（二）

建立对象

咱们知道，要建立一个对象咱们能够用以下代码：

var user = new Object(); user.name = '赵六'; user.age = 22; user.address = '四川成都';

用这样的方法建立对象比较简单直观，也是JavaScript种建立对象最基本的方法。可是这样就有一个问题，若是咱们须要建立多个对象，

那么我就得写不少重复的代码。好比咱们想建立另外一个对象user1，咱们就得从新将上面的代码从新写一遍，这在实际开发过程当中是不合适的，

这样若是对象过多，代码量将大大增长。

为了解决这样的问题，咱们可使用一种叫作工厂模式的方法，这种方法就是为了解决实例化对象产生大量重复代码的问题。

工厂模式

function create(name, age) { 　　var obj = new Object(); 　　obj.name = name; 　　obj.age = age; 　　obj.show = function () { 　　　　return this.name +' '+ this.age; 　　}; 　　return obj; } var obj1= create('bclz', 30); //第一个实例 var obj2= create('bcxb', 20); //第二个实例 alert(obj1.show()); alert(obj2.show());

从上面的代码咱们能够看出，工厂模式解决了实例化时代码大量重复的问题，但又出现了一个问题，那就是识别问题，咱们根本没法弄清楚他们究竟是哪一个对象的实例。好比

alert(typeof obj1); //Object alert(obj1 instanceof Object); //true

以上代码标明obj1是Object对象，可是咱们没法知道具体是哪个对象建立的。

构造函数(构造方法)

function User(name, age) { //构造函数模式 　　this.name = name; 　　this.age = age; 　　this.show = function () { 　　　　return this.name + ' '+this.age; 　　}; }

建立对象的时候用new运算符就能够了：

var user1 = new User('bclz', 30); //第一个实例 var user2 = new User('bcxb', 20); //第二个实例

如今咱们就能够检测user1或者user2是否是属于User。

alert(user1 instanceof User);//true

可见，使用构造函数的方法，即解决了重复实例化的问题，又解决了对象识别的问题。

要建立User对象的新实例，就要使用new操做符，使用这个方式构建实例对象，会通过下面4个步骤：

1.建立一个新对象；

2.将构造函数的做用域给新对象(所以this指向的这个新对象)。

3.执行构造函数内的代码在(为新对象添加属性)；

4.返回新对象。

不过须要注意下面两个问题:

构造函数也是函数
构造函数与函数的惟一区别，就是调用方式的不一样，不过，构造函数毕竟也是函数，不存在什么特殊的定义构造函数的语法。

任何函数，只要经过new操做符来调用，就能够把它看做是构造函数；而任何函数，若是不经过new操做符调用，它就和普通函数没有什么区别，例如前面定义的User:

//看成构造函数调用
var user1 = new User('bclz', 30); user1.show(); //bclz 30; //看成普通函数调用 User('bclz', 30); window.show(); //bclz 30;

结果上没有什么区别，只是你们能够看到，看成普通函数调用的话，函数里this对象的指向，实际上是指向的window全局对象。而经过new关键字调用，this指向的则是新对象而已，因此，其实还能够这么来写:

var o = new Object(); User.call(o,'bclz', 30)； o.show();

经过函数方法call来从新定义对象的做用域，这里很少作解释，讲到函数细节时再仔细介绍这种方法，这里只是说明能够改变对象的做用域的，其实就是改变this的指向

构造函数的问题

构造函数的模式虽然好，可是并不是没有缺点。构造函数最大的问题就是，每一个方法都要在实例上从新建立一次。在前面的例子中,user1和user2中都有一个show方法，若是咱们执行如下语句：

alert(user1.show==user2.show);//结果返回的是false

结果返回的是false，这就说明方法其实也是一种引用地址。若是咱们一样重复建立了多个对象，那么每一个对象中的方法都会在内存中开辟新的空间，

这样浪费的空间就比较多。要解决这个问题，咱们就须要用到实例属性或者方法的共享。咱们可使用一种变通的方式，来达到咱们想要的效果，也就是让show方法再也不重复建立

function User(name, age) { 　　this.name = name; 　　this.age = age; 　　this.show = show; } function show(){ alert(this.name + ' ' + this.age); }

将show方法移到外部，至关于show方法成了一个全局函数,而后再到User构造函数内部去引用show方法，这样User内部的this.show都指向了同一个全局函数show，

所以，咱们实例化的user1和user2就实现了共享，能够再次调用:

alert(user1.show==user2.show);//结果返回的是true

可是这只是一个测试，若是你要让更多的属性或者方法实现共享，那不是要定义更多的全局函数或者变量，这种方式是不科学也不可行的。所以，咱们须要引入另一个javascript面向对象的重要概念原型

Javascript 面向对象编程（一）：封装

把两个属性封装在一个对象里面。可是，这样的写法有两个缺点，一是若是多生成几个实例，写起来就很是麻烦；二是实例与原型之间，没有任何办法，能够看出有什么联系。

例子：

var cat1 = {}; // 建立一个空对象

　　　　cat1.name = "李密昂"; // 按照原型对象的属性赋值

　　　　cat1.age= "20

　　var cat2 = {};

　　　　cat2.name = "三毛";

　　　　cat2.age= "19";

那么问题来了，咱们能够写一个函数，解决代码重复的问题吗？固然能够。

function Cat(name,color){

　　　　return {

　　　　　　name:name,

age:age

　　　　}

而后调用函数：

　　var cat1 = Cat("李密昂","20");

　　var cat2 = Cat("三毛","19");

构造函数模式

所谓"构造函数"，其实就是一个普通函数，可是内部使用了this变量。对构造函数使用new运算符，就能生成实例，而且this变量会绑定在实例对象上。

原型对象如今能够这样写：

function Cat(name,color){

　　　　this.name=name;

　　　　this.age=age;

　　}

生成实例对象：

var cat1 = new Cat("李铭","20");

　　var cat2 = new Cat("三毛","19");

　　alert(cat1.name); // 李铭

　　alert(cat1.age); // 20

这时cat1和cat2会自动含有一个constructor属性，指向它们的构造函数。

alert(cat1.constructor == Cat); //true

　　alert(cat2.constructor == Cat); //true

Prototype模式

Javascript规定，每个构造函数都有一个prototype属性，指向另外一个对象。这个对象的全部属性和方法，都会被构造函数的实例继承。

这意味着，咱们能够把那些不变的属性和方法，直接定义在prototype对象上。

function Cat(name,age){

　　　　this.name = name;

　　　　this.age= age;

　　}

　　Cat.prototype.type = "猫科动物";

　　Cat.prototype.eat = function(){alert("吃老鼠")};

生成实例：

var cat1 = new Cat("李铭","20");

　　var cat2 = new Cat("三毛","19");

　　alert(cat1.type); // 猫科动物

　　cat1.eat(); // 吃老鼠

指向prototype对象“

alert(cat1.eat == cat2.eat); //true