javaScript面向对象编程-封装

1.封装
1）在js中创建一个类
//在内部通过this变量添加属性和方法来实现对类添加属性或者方法
            var Book = function(name,price,num){
                this.name = name;
                this.price = price;
                this.num = num;
            }

            //也可以通过在类的原型上添加属性或者方法
            Book.prototype.dishow = '什么书';
            Book.prototype.display = function(){
                //展示
            }
            //或者
            Book.prototype = {
                disshow : '什么书',
                display : function(){
                    //展示
                }
            }

            //使用的时候通过new实例化新的对象
            //使用实例化对象的属性或者方法的时候，通过点语法访问
            var book = new Book('javaScript设计模式',10,20);
            console.log(book.name)

//通过this添加的属性/方法，是在当前对象上添加的

//js是一种基于原型prototype的语言，每创建一个对象的时候，都有一个原型prototype用于指向其继承的属性和方法
//通过prototype继承的方法并不是自身的，在使用时候需要通过prototype来一层一层查找

//在创建新对象的时候/实例化一个对象的时候
//通过this创建的属性或者方法都是该对象自身拥有的，this指向的属性和方法都会得到相应的创建
//通过prototype继承的属性或者方法是通过prototype访问到的，每次通过类来创建一个新对象的时候这些属性和方法并不会被再次创建

//constructor构造器 是在prototype对象中自己创建的用于指向拥有整个原型对象的函数或者是对象

2）.属性和方法的封装
//由于js的函数级作用域，声明在函数内部的变量或者方法在函数外部是访问不到的，
//通过这个特性来创建类的私有变量和方法

//在内部通过this创建的变量或者方法，在类创建的时候，每个对象都拥有一份并且在外部能方法到
//通过这个方法来创建类的共有属性和对象的共有方法

//通过this创建的方法，不仅能够访问到这些对象的共有属性和方法，还能访问到类（创建时）或对象自身的私有属性和私有方法
//这些方法可以称为特权方法。
//通过它来初始化实例对象的一些属性，所以在创建对象时调用的特权方法还可以看做是类的构造器

var Book = function(id, name, price){
                //私有属性
                var num = 1;                
                //私有方法
                function checkId (){};
                //特权方法
                this.getName = function(){};
                this.getPrice = function(){};
                this.setName = function(){};
                this.setPrice = function(){};
                //对象共有属性
                this.id = id;
                this.name = name;
                this.price = price;
                //对象共有方法
                this.copy = function(){}

                //构造器
                this.setName(name);
                this.setPrice(price);
            }

//通过new关键字创建对象的时候，由于类外面通过点方法添加的属性和方法没有被执行到，所以新创建的对象没有获取到他们
//但是可以通过类来使用
//这些被称为类的静态共有属性和类的静态共有方法

//类通过prototype创建的属性或者方法在类实例的对象中可以通过this访问到
//将prototype对象中的属性和方法称为共有属性和共有方法

Book.isChinese = true;              //类的静态共有属性 （实例化对象不能访问）
    Book.resetTime = function(){        //类静态共有方法（对象不能访问）
        console.log('is ok!!!')
    }       

    Book.prototype = {
        isJsBook : true,                //共有属性

        display : function(){}          //共有方法
    }

//new创建对象的实质就是 对新对象的this不断的赋值，并将prototype指向类的prototype所指向的对象
//而类的构造函数外面通过点语法定义的属性和方法不会被添加到新创建的对象上去
//而类的原型prototype上定义的属性就能在新对象中直接使用。因为新对象的prototype和类的prototype指向同一个对象

var b = new Book(11,'JavaScript设计模式',50);
console.log(b.num);　　　　// undefined 
console.log(b.isJSBook);　　// false
console.log(b.id);　　　　　　// 11
console.log(b.isChinese);　　// undefined
console.log(Book.isChinese);　　// true
Book.resetTime();　　　　　　　 　　// new Tiem

3）.闭包实现类的静态变量

var Book = (function(){
                //私有变量
                var bookNum = 1;
                //私有方法
                function checkBook(name){

                };

                //返回构造函数
                function _book(newId,newName,newPrice){
                    //私有变量
                    var name,price;
                    //私有方法
                    function checkId(id){};
                    //特权方法
                    this.getName = function(){};
                    this.getPrice = function(){};
                    this.setName = function(){};
                    this.setPrice = function(){};

                    //共有属性
                    this.id = id;
                    //共有方法
                    this.copy = function(){};
                    bookNum ++ ;

                    if(bookNum > 10){
                        throw new Error('只卖10本');
                    }
                    //构造器
                    this.setName(name);
                    this.setPrice(price);
                }
                _book.prototype{
                    //静态共有属性
                isJsBook : true,
                //静态共有方法
                display : function(){}
                }
                return _book;
            })();

4）创建对象的安全模式

    var Book = function(title, time, type){
        　　// 判断执行过程中this是否是当前这个对象（如果是说明是用new创建的）
        　　if(this instanceof Book){
        　　　　this.title = title;
        　　　　this.time = time;
        　　　　this.type = type;
        　　// 否则重新创建这个对象
        　　}else{
        　　　　return new Book(title, time, type);
        　　}
        }
        var book = Book('JavaScript', '2014', 'js');

参考资料 JavaScript设计模式 张容铭