js两种生成对象模式（公有成员和成员私有）

假设有个需求，创建一个book类，有isbn码，书名，作者 ；可以对isbn进行数据完整性校验；--js设计模式

<script type="text/javascript">

/**
方案一，属性全部属于公有类型,用this创建
该方式可以在构造器中对数据的完整性进行检验的控制，但对其他人员会把什么值赋给该属性而不能进行数据完整性检验的控制；
**/

var Book = function(isbn,name,author){
if(!this.checkIsbn(isbn)) throw new Error("不合法的isbn码");
this.isbn = isbn;
this.name = name || '没有名字';
this.author = author || '没有作者';
}

Book.prototype={
checkIsbn:function(isbn){
/**
专门用来检验isbn的数据完整性，以防在该类中其他方法中出错
**/
if(isbn||typeof isbn !='string'){
return false;
}
// 可以对isbn进行各种校验  ...............
},
display:function(){
/** 展示书本的一些信息 用this.isbn,this.name展示信息**/
}
}

/** 优化后的方案一，以后所有的访问采用接口方式访问，属性用存取器来访问（可以将每个属性设置 为取值器和设置器（get，set）;通过设置器你可以对你的属性（isbn）在存取器中进行数据完整性校验）；
但是这种访问并不是强制性的，得靠开发人员自觉遵守，还是可以直接修改属性的； **/
var BookInter = new Interface('BookInter',['getIsbn','setIsbn','getName','setName','getAuthor','setAuthor','display']);
var Book = function(isbn,name,author){
this.setIsbn(isbn); //采用存取器来设置属性
this.setName(name);
this.setAuthor(author);
}
Book.prototype = {
checkIsbn:function(isbn){
........
},
getIsbn:function(){
return this.isbn;
},
setIsbn:function(isbn){
if(!this.checkIsbn(isbn))throw new Error("不合法的isbn码");
this.isbn = isbn;
},
getName:function(){
return this.name;
},
setName:function(){
this.name = name || '没有名字';
},
getAuthor:function(){
return this.author
},
setAuthor:function(){
this.author = author || '没有作者';
},
display:function(){
//..................
}
};

/**
方案二，采用闭包的方式形成真真的私有属性和方法；javascript中的作用域是词法性的；函数运行在定义他们的作用域中，而不是
运行在调用他们的作用域中。子类不能访问父类的所有私有属性和方法。所以用闭包实现私用成员导致了‘继承破坏封装’；有子类的话尽量用
方案一
**/
var Book = function(newIsbn,newName,newAuthor){
var isbn,name,author;//私有属性
function checkIsbn(isbn){
//私有访法
}
//有特权的方法（那些需要直接访问私有成员的方法才被设置为特权方法，特权方法太多占用内存，每个对象实例都包含了所有特权方法的副本）
this.getIsbn = function(){
return isbn;
};
this.setIsbn = function(){
if(!checkIsbn(newIsbn)) throw new Error('非法的isbn码');
isbn = newIsbn;
};
this.getName = function(){
return name;
}
this.setName = function(newName){
name = newName || '没有名字';
}
this.getAuthor = function(){
return author;
}
this.setAuthor = function(newAuthor){
author = newAuthor || '没有作者';
}

//构造器代码
this.setIsbn(newIsbn);
this.setName(newName);
this.setAuthor(newAuthor);
};
//公有的
Book.prototype = {
display: function(){ //不需要直接访问私有属性，可以通过特权方法来访问
/**展示书刊的一些信息**/
}
}

/**
方案三，可以在方案二的基础上给类和对象添加静态变量和方法（私有的和公有的），大多数方法，属性关联在类的实例（对象）上；静态的变量和方法关联在类对象（js处处是对象）上，静态成员都只有一份；
**/

var Book = (function(){ //在这里，book想当于是一个构造函数，return返回这个函数， 括号括起来的相当于是个闭包；
//静态变量（私）
var countBookNum=0;
//静态方法（私）
function checkIsbn(isbn){
if(!isbn||typeof isbn !='string'){
return false;
}
return true;
}
//返回构造函数（作为一个内嵌函数返回）
return function(newIsbn,newName,newAuthor){
var isbn,name,author;//私有属性
//有特权的方法（那些需要直接访问私有成员的方法才被设置为特权方法，特权方法太多占用内存，每个对象实例都包含了所有特权方法的复本）
this.getIsbn = function(){
return isbn;
};
this.setIsbn = function(){
if(!checkIsbn(newIsbn)) throw new Error('非法的isbn码');
isbn = newIsbn;
};
this.getName = function(){
return name;
}
this.setName = function(newName){
name = newName || '没有名字';
}
this.getAuthor = function(){
return author;
}
this.setAuthor = function(newAuthor){
author = newAuthor || '没有作者';
}
countBookNum++;
if(countBookNum>5) throw new Error("书本只能有"+(countBookNum-1)+"本！");
//构造器代码
this.setIsbn(newIsbn);
this.setName(newName);
this.setAuthor(newAuthor);
}
})();
/**该方法作为构造函数的属性出现的；是公有的，静态函数**/
Book.converteUpperCase = function(inputString){
alert(inputString.toUpperCase());
}

Book.prototype = {
display: function(){
/**展示书刊的一些信息**/
alert("** "+this.getIsbn()+" *** "+this.getName()+" ** "+this.getAuthor());
}
}

/**代码测试：这里要进行异常处理**/
try{
for(var i=0;i<7;i++){
var b = new Book('12qw','极品药师','明明');
b.display();
b = null;
}
}catch(e){
alert(e);
}
Book.conterLitterCase('Hello World!'); //静态公有方法的调用(实际是作为构造函数的属性)

</script>

注：方案三中私有成员和特权成员仍被申明在构造器中，构造器却变成一个内嵌函数，并作为包含它的函数的返回值赋给了Book。创建了一个闭包。位于外层函数申明的一对括号很重要，作用是代码一载入立即执行这个函数。这个函数返回值是另一个函数，被赋给了Book变量，因此Book成了一个构造函数；实例化Book时，调用的是这个内层函数。外层那个函数只是用于创建一个可以用来存放静态私用成员的闭包。

checkIsbn被设计为静态方法，是不让每个对象中都有一个这个函数；静态属性countBookNum统计Book构造器的总调用次数。