javascript对象创建

一.前言：

初学js的我们都会这么写来实现我们需要的功能。

<pre name="code" class="javascript"><span style="font-size:18px;">

function method(){
}
function method1(){
}

<pre name="code" class="javascript"></span>

然而这么写会出现很大的弊端。实际告诉我们应该用OOP的思想来编写js。

但是javascript是一种非常灵活的面向对象设计语言，他与传统的强类型的面向对象程序语言（java,c++，c#）有很大的不同。并没有定义类的关键字class,也没有支持继承extend或冒号（java），也没有支持虚函数的virtual（c++），那么下面我们来讨论js是如何来实现js的对象。

二.创建对象方式:（这章我们不讲继承只说组合新对象）

对象直接量方式|构造函数方式|工厂方式|原型方式|构造函数和原型混合方式|动态原型模式

 ***我个人将这些方式中的语法归为两种，一个是直接量，一个是构造函数（构造函数方式|工厂方式|原型    方式|构造函数和原型混合方式），当然语法说完，我还是会一一举例这几种方式的写法。

1.直接量定义语法:

这里定义的对象是直接使用方法的，并不需要new来实例化。所以就有重复构造的问题。

<span style="font-size:18px;">

var Student={
		name:"Mike",
		getName:function(){
			alert(this.name);
		}
}
Student.getName();

</span>

一些高级编程的书里面提到能使用直接量创建对象就使用，那么为什么呢？

答.数组直接量语法简单直接、高雅美观。毕竟数组只是从位置0开始索引的值的集合，完全没必要包含构造器和new运算符的内容（代码会更多），保持简单即可。

（在这里我是有前提条件的，能使用的时候再用，因为对象直接量需要我们重复构造，没有重用性）

2.其他方式语法（个人见解分类了一下）

除直接量方式外都是需要new来实例化。举个例子：

<span style="font-size:18px;">

function Student(){
	var age=18;
	var name="张三";
	var sex="男";
}
var student1=new Student();//new a obj
console.log(student1);//print a obj

</pre><pre name="code" class="javascript"></span>

你会发现student1就是一个对象的实例。

语法讲解:

定义公有属性和私有属性（公有即类外可以访问，私有即只有类中可以访问）.

     私有属性:通过局部变量来定义，而对于定于私有方法的时候，可以通过局部变量，也可以直接定义方法。下面是个例子，一目了然。

<span style="font-size:18px;">

function Student(){
var age=18;//私有成员
function method(){
/*私有方法*/
}
var method=function(){
/*私有方法*/
}
}

</span>

公有属性分为静态与非静态。静态即共用方法 非静态即一个实例单独拥有一个方法，不共用，不过这样占用内存

     公有属性：①静态：

             Student为一个类。

          类属性的定义 Student.age=18;（类中类外都可）

          类方法的定义 Student.alertAge=function(){}（类中类外都可）

          原型方法的定义 Student.prototype.alertAge=function(){}（在类中写和在类中是有区别的，类外不用管，如果在类中写需要用typeof判断是否已经定义过，不能让程序重复去创建，因为是静态方法)

                                                                 ***原型方法定义在类中在下面的动态原型方式中有体现。

          ②非静态

              实例化方法通过this来定义，this.alertAge=function(){}（只能在类中）

***在这里需要强调的是js中的静态中的原型方法和实例化方法都需要用new来进行实例化才可以进行调用。

***类方法无法调用公有属性、公有方法、私有方法、私有属性、特权方法和原型属性。所以实际情况下我们一般不用这个。

***还有就是this指针的问题，当你调用类中的方法返回this指针指向谁的时候，会出现问题，举个例子：

<span style="font-size:18px;">

function Teacher(){
var age="18";
this.alertAge=function(){
alert(this.age);//这里返回的作用域已经不是Teacher，而是指alertAge
}
}
var teacher1=new Teacher();
teacher1.alertAge();//undefined

</span>

解决方法：定义一个局部变量来储存我们的this指向

下面我把上面定义的语法写个例子。大家可以实例化试一下  

<span style="font-size:18px;">

function Student(){
this.age="";//公有成员
this.sex="";//公有成员
Student.Name="";//公有静态成员
function method(){
/*私有方法*/
}
var method=function(){
/*私有方法*/
}
this.alertSex=function(){
/*公有实例化方法*/
alert(this.sex);
}
}
Student.alertName=function(){
/*无法调用公有属性、公有方法、私有方法、私有属性、特权方法和原型属性*/
alert("a");
}
Student.prototype.alertAge=function(){
alert(this.age);//共用方法，但必须实例化
}

</span>

根据上面所说的语法下面我举例介绍一下剩下的定义对象方式

【工厂方式】

<span style="font-size:18px;">

function showName(){
	alert(this.name);
}
function createObj(name) {
    var Student = new Object;
    Student.name = name;
    Student.showName =showName;
    return tempObj;
}
var student1= createObj('Mike');
var student2 = createObj('David');
student1.showName();

</span>

优点：减少了代码量。
缺点：未能解决对象识别的问题。

【构造函数方式】

<span style="font-size:18px;">

function Student(name) {
    this.name = name;
    this.showName = function () {
        alert(this.name);
    }
}
var student1 = new Student('Mike');
var student2 = new Student('David');

</span>

必须通过new来创建一个Student对象，实际上要经历下面四个步骤：

1. 创建一个新对象；
2. 将构造函数的作用域赋给新对象（因此this就指向了这个新对象）；
3. 执行构造函数中的代码（为这个新对象添加属性）；
4. 返回新对象。

优点：在工厂模式的基础上解决了对象识别问题

缺点：可是有的时候我们创建方法不需要每次实例都要去创建一下，这样会占用很大的内存，所以弊端在此。

【原型方式】

<span style="font-size:18px;">

var Student = function () {}
Student.prototype.name = 'Mike';
Student.prototype.showName = function () {
    alert(this.name);
}
var student1  = new Student();
var student2 = new Student();

</span>

原型构造的方法相当于强类型语言中的静态方法，不过也有一些不同，因为需要new实例化来调用，虽然每个实例都共用这个方法。

优点：减少了代码的冗余

缺点：如果只用原型方式来创建对象也会出现问题，因为我们有的方法并不是共用方法。

所以我们用的更多的是【构造函数和原型混合方式】

<span style="font-size:14px;"><span style="font-size:18px;"></span>

<span style="font-size:14px;">var Student  = function (name) {
    this.name = name;
    this.flag = new Array('A', 'B');
}
Student .prototype = {
    showName : function () {
        alert(this.name);
    }
}
var student1   = Student Obj();
var student2 = Student Obj();</span>

<span style="font-size:14px;"></span></span>

优点：结合了构造函数模式和原型模式的优点，并解决了其缺点。
缺点：代码没有很好的封装起来。

【构造函数和原型混合方式】

<span style="font-size:14px;">var Student  = function (name) {
    this.name = name;
    this.flag = new Array('A', 'B');
    if(typeof this.showName!="function"){
    	Student .prototype.showName=function(){
    		 alert(this.name);
    	}
    }
}</span>

这种封装方式已经很完美了。 这里我们只讲组合，继承在这章就不说了。

                                                                                                                       虚怀若谷，求贤若渴。