javascript是解释型的语言，在编译时和运行时之间没有明显区别，因此需要更动态的方法。javascript没有正式的类的概念，我们可以使用在运行时创建新的对象类型来替代，并且可以随时更改已有对象的属性。
javascript是一种基于原型的面向对象的语言，即每个对象有个原型，对象从原型中继承属性和方法。当访问对象的属性或调用对象的方法时，解释器首先检查对象是否有个同名的实例属性或方法。如果有，就使用实例属性或方法；如果没有，解释器就检查对象的原型中是否有适当的属性或方法。在这样一个特殊的环境下，该类型（类）的所有对象公共方法和属性可以被封装在原型中，每个对象可以有代表该对象特定数据的实例属性。
在javascript中，原型关系是递归的。即，对象的原型也是一个对象，而原型的本身可能还有一个原型。这就意味着如果被访问的属性发现不是对象的实例属性，也不是对象的原型的属性，解释器将沿着原型链搜索到原型的原型。如果还没有找到，就继续沿原型链向上搜索。javascript中object是所有对象的超类，所以object是它搜索的终点。如果object中还没有找到，那么返回的值就是undefined。如果是在调用方法，则抛出error。
一、javascript面向对象基础
1、对象的创建
javascript中的对象使用一个new运算符和一个构造函数创建。构造函数是一个特殊类型的函数，它通过初始化对象要占据的内存，来准备一个新对象的使用。我们可以使用一个不带参数的构造函数，也可以使用一个带参数的构造函数，来创建对象。如：
var city = new String(); var city = new String(‘上海‘);
2、对象销毁和垃圾回收
对象和其他变量都需要使用内存，而一个计算机中内存资源是有限的。为了防止潜在的内存不足，某些编程语言强制要求程序员仔细的管理他们程序中内存的使用。幸运的是，javascript并不要求程序员管理内存。当javascript创建对象时，解释器自动给对象分配内存。当对象使用完毕后，解释器自动清理对象所用内存，即垃圾回收。
但是，如果我们的对象代码中包含了大量的数据操作，最好将不需要的数据用null来替换，以尽快释放资源。
var book = new Book(); ....
大量数据操作后...
.... book = null;
如果对相同数据有多个引用，必须确保所有的引用设为null。否则，解释器将保留这些数据，以备再次需要。
3、动态添加对象属性
var obj = new Object(‘hello world‘); alert(obj.name);//undefined obj.name=‘jiajia‘; alert(obj.name);//jiajia
动态添加的属性，我们称之为实例属性，之所以叫实例属性，是因为它们仅出现在它们添加到的特定对象或实例中。与此相反还有一个公共属性，比如说string的length属性，所有string对象都具有这一公共属性。实例属性有利于为了某些特殊用途对已存在的对象进行补充或扩展。
4、动态删除对象属性
var mystring = new String(‘hello world‘); mystring.isTrue = true; delete mystring.isTrue; alert(mystring.isTrue);//undefined;
java程序员注意，javascript中delete与Java中不同，它仅仅用在对象中删除属性或者从数组中删除元素，但是我们不能删除对象本身。
5、动态添加对象的方法
像添加属性方式一样，方法也可以动态添加：
var mystring = new String(‘hello world‘);
function alertSay(){alert(‘不行‘);};
mystring.sayno=alertSay;
mystring.sayno();//不行
以上是添加了一个实名函数，我们还可以添加一个匿名函数：
var mystring = new String(‘hello world‘);
mystring.sayno=function(){alert(‘不行‘);};
mystring.sayno();//不行
6、对象语句
如果程序中要使用某个对象的多个属性和方法，则可以考虑使用with语句，将需要使用其属性和方法的对象用with语句包含起来，语法：
with(对象){
.....语句.....
}
例如：
with(document.myform){
if(username.value==‘‘)
if(password.value==‘‘)
}
for语句是一种特殊的循环语句，用于遍历一个对象的所有属性。注意是所有属性！
例如，以下示例用for...in语句遍历了document对象的所有属性，并将其显示出来：
document.write(‘<h3>document对象的所有属性如下:</h3>‘);
for(var i in document){
document.write(i+‘<br/>‘);
}
二、创建自定义的javascript类和对象
1、工厂方式
所谓工厂方式，就是先创建对象，然后往对象中添加属性和方法。
带参批量生产：
function createPerson(name){
var personobj = new Object();
personobj.name=name;
personobj.say=function(){
alert(‘who is‘+this.name);
}
return personobj;
}
var persion1 = createPerson(‘fanfan‘);
var persion2 = createPerson(‘xiaoxiao‘);
person1.say();//fanfan
person2.say();//xiaoxiao
随着javascript正规起来，这种创建对象的方式并不提倡了。原因有二：
（1）语义上的，即这种方式不适用new运算符创建对象；
（2）功能上的，每次调用createPerson（）函数，都建一个新的函数say（）。这意味着每个对象都有自己版本的say（）方法。然后在现实中，每个对象都是共享相同的方法。
2、构造函数的方式
与工厂方式类似，类名的第一个字母是大写。
function Person(name){
this.name = name;
this.say = function(){
alert(‘who is‘+name);
}
}
var person1 = new Person(‘fanfan‘);
var person2 = new Person(‘xiaoxiao‘);
我们可以看到，在构造函数内部没有创建对象，而是使用了this关键字。当用new运算符调用构造函数时，在构造函数第一行被执行之前就创建了一个对象，此时这个对象可以通过this运算符访问。然后，我们可以直接给this分配属性，而这个this是默认是作为函数值返回的。
然后，与工厂模式一样，构造函数方式也是没创建一个对象，就生成一个新函数。
3、原型方式
原型方式利用了对象的prototype属性。在object类中，每个对象都有一个prototype属性，该属性代表对象的父类。
function Person(){
}
Person.prototype.name=‘fanfan‘;
Person.prototype.say=function(){
alert(‘who is‘+this.name);
}
var person1 = new Person();
var person2 = new Person();
当new Person（）被调用时，所有的prototype的属性和方法立即被分配给创建的对象，这样所有的Person实例就都包含了指向相同say（）函数的指针。从语义上讲，属性和方法都属于一个对象，这就解决了前面重复生成函数的问题。此外，在这种方式中，我们还可以使用instanceof运算符检测给定变量所指向的对象类型。
alert(person1 instanceof Person);//true
但是，原型方式不能通过构造函数传递参数初始化属性值。
4、混合构造函数和原型方式
使用构造函数方式定义对象的属性，使用原型方式定义对象的方法。这样，函数只创建一次，同时每个对象都有自己的对象属性实例。
function Person(name){
this.name=name;
}
Person.prototype.say=function(){
alert(‘who is‘+this.name);
}
var person1 = new Person(‘fanfan‘);
var persion2 = new Person(‘xiaoxiao‘);
alert(person1.say());//fanfan
alert(person1.say());//xiaoxiao
5、动态原型方式
function Person(name){
this.name=name;
if(typeof Person.initial == ‘undefined‘){
Person.prototype.say=function(){
alert(‘who is‘+this.name);
}
Person.initial = true;
}
}
var person1 = new Person(‘fanfan‘);
var persion2 = new Person(‘xiaoxiao‘);
alert(person1.say());//fanfan
alert(person1.say());//xiaoxiao
6、使用JSON格式创建对象
var personobj={
firstname:‘fanfan‘,
lastname:‘xiaoxiao‘,
age:50,
tellyourage:function{
alert(‘yourage:‘+this.age)
}
}
与工厂方式没有本质区别，只是更加快捷。
三、对象继承实现
创建子类将继承超类的所有属性和方法，包括构造函数及方法的实现。记住，所有属性和方法都是公用的，因此子类可直接访问这些方法。子类还可添加超类中没有的新属性和方法，也可以覆盖超类中的属性和方法。
1、对象冒充
所谓对象冒充，就是新的类冒充旧的类（旧的类必须采用构造函数的方式），从而达到继承的目的，其原理如下：构造函数使用this关键字给所有属性和方法赋值（即采用类声明的构造函数方式）。因为构造函数只是一个函数，所以 可使ClassA的构造函数成为ClassB的方法，然后调用它。ClassB就会收到ClassA的构造函数中定义的属性和方法。
function Person(name){
this.name=name;
this.say=function(){
alert(‘who is‘+this.name);
}
}
我们知道，关键字this引用的事构造函数当前创建的对象。而在方法中，this指向的是所属的对象。这个原理是把People作为常规函数来建立继承机制，而不是作为构造函数。
function WhitePeople(name){
this.inherit=People;//冒充
this.inherit(name);//继承
delete this.inherit;//删除继承
this.area = function(){
alert(‘我在欧洲‘);
}
}
var tom=new WhitePeople(‘tom‘);
tom.say();
tom.area();
所以新属性和新方法必须在删除了继承后再定义，这样是为了避免覆盖父类的相关属性和方法。
对象冒充可以支持多继承，也就是说，一个类可以继承多个超类。
function Person(name){
this.name=name;
this.say=function(){
alert(‘who is‘+this.name);
}
}
function Worker(pay,work){
this.pay=pay;
this.work=work;
}
function City_worker(name,pay,work){
this.inherit = People;
this.inherit(name);
delete this.inherit;
this.inherit = Work;
this.inherit(pay,work);
delete this.inherit;
}
var jerry=new City_worker(‘jerry‘,‘10000‘,‘coder‘);
jerry.say();
alert(jerry.work);
2、call方式
基类.call（对象，参数列表）
function WhitePeople(name){
//this.inherit=People;//冒充
//this.inherit(name);//继承
//delete this.inherit;//删除继承
People.call(this.name);
this.area = function(){
alert(‘我在欧洲‘);
}
}
var tom=new WhitePeople(‘tom‘);
tom.say();
tom.area();
3、apply
apply（）也是对象冒充一个封装函数。apply（）方法有两个参数，用做this的对象和要传递给函数的参数的数组。其格式为：
基类.apply（对象，参数数组）;
function City_worker(name,pay,work){
People.apply(this,new Array(name));
Worker.apply(this,[pay,work]);
}
var jerry=new City_worker(‘jerry‘,‘10000‘,‘coder‘);
jerry.say();
alert(jerry.work);
4、原型链
上面三种方式都是采用构造函数的方式继承，对应的，也具有原型函数方式的继承，原型链。
function Blue_collor(){
}
Blue_collor.prototype.name=‘jean‘;
Blue_collor.prototype.say=function(){
alert(‘who is ‘+this.name);
}
function City_blue_collor(){
}
City_blue_collor.prototype = new Blue_collor();
var j1 = new City_blue_collor();
j1.say();
注意在使用原型链继承时，基类构造函数内不能有任何参数。