JavaScript 面向对象

对象其实就是一种引用类型。而对象的值就是引用类型的实例。

在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一起。它也常被称做为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具备传统面向对象语言所支持的类和接口等基本结构。

一、对象的创建以及常用的操作

　　1、使用new运算符　　　　

    　 var user = new Object();        //使用new运算符创建一个对象
　　　　user.name = '编程达人';        //给对象添加属性
　　　　user.age = 22;
　　　　user.address = '四川成都红瓦寺';

　　2、对象字面量(JSON方式)

　　　　var user = {
    　　　　name:'编程达人',
    　　　　age:22,
    　　　　address:'四川成都红瓦寺'    
　　　　};

　　3、简单方式(传统赋值方式)

　　　　var user = {};
　　　　user.name = '编程达人';        //给对象添加属性
　　　　user.age = 22;
　　　　user.address = '四川成都红瓦寺';

　　4、属性的调用

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

　　　　　　① 方法一

　　　　　　alert(user.name + " " +user.age);   //返回值为 '编程达人 四川成都红瓦寺'

　　　　　　② 方法二

　　　　　　 alert(user['name'] + " " +user['age']);//返回 '编程达人 四川成都红瓦寺'

　　5、添加方法

　　　　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();

二、简单直观创建对象的弊端　　

　　1、简单创建对象的代码

　　　　var user = new Object();  
　　　　user.name = '编程达人';
　　　　user.age = 22;
　　　　user.address = '四川成都红瓦寺';

　　2、弊端

　　　　用这样的方法创建对象比较简单直观，也是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('红红', 22);    //第一个实例
　　var obj2= create('灰灰', 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('红红', 22);    //第一个实例
　　var user2 = new User('灰灰', 20);    //第二个实例

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

　　　　① 创建一个新对象；

　　　　② 将构造函数的作用域给新对象(因此this指向的这个新对象)。

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

　　　　④ 返回新对象。

　　构造函数也是函数

　　　　构造函数与函数的唯一区别，就是调用方式的不同，不过，构造函数毕竟也是函数，不存在什么特殊的定义构造函数的语法。任何函数，只要通过new操作符来调用，就可以把它看作是构造函数；而任何函数，如果不通过new操作符调用，它就和普通函数没有什么区别，例如前面定义的User:

　　　　//当作构造函数调用
　　　　var user1 = new User('红红', 22);  
　　　　user1.show(); //红红 22;

　　　　//当作普通函数调用
　　　　User('红红', 22);
　　　　window.show(); //红红22;

　　　　结果上没有什么区别，只是大家可以看到，当作普通函数调用的话，函数里this对象的指向，其实是指向的window全局对象。而通过new关键字调用，this指向的则是新对象而已，所以，其实还可以这么来写:

　　　　var obj = new Object();
　　　　User.call(obj,'红红', 22)；
　　　　obj.show();

　　　　通过函数方法call来重新定义对象的作用域，其实就是改变 this 的指向

　　构造函数的问题

　　　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 面向对象

一、 对象的创建以及常用的操作

一、对象的创建以及常用的操作