面向对象的JS-设计模式(1)


编程风格

面向对象变成就是将你的需求抽象成一个对象,然后针对这个对象分析其特征(属性)与动作(方法)。这个对象大家称之为类。面向对象编程思想其中一个特点就是封装,就是说把你需要的功能放在一个对象里。

封装

在js中创建一个类很容易,首先声明一个函数保存在一个变量里。按编程习惯,一般将这个代表类的变量名首字母大写。然后在这个函数(类)的内部通过对this(函数内部自带的一个变量,用于指向当前这个对象)变量添加属性或者方法来实现对类添加属性或者方法,例如:

var Book = function (id,bookname,price){
    this.id = id;
    this.bookname = bookname;
    this.price = price;
}

当然也可以通过原型的方式来实现,在JS中类、函数都是一个对象,所以也有原型prototype。在原型上添加属性和方法有两种

一种是一一为原型对象属性赋值,另一种则是将一个对象赋值给类的原型对象

ps:这两种方式不要混用.
  •     Book..prototype.display = function(){
            //
        }
    
  •     Book.prototype = {
            display:function(){}
        }
    

封装好了类,那么大家如何使用?

大家不能直接使用这个Book类、需要用new关键字来实例化(创建)新的对象。使用实例化对象的属性或者方法时,可以通过点语法访问,例如:

var Book = function (id,bookname,price){
    this.id = id;
    this.bookname = bookname;
    this.price = price;
}

var book = new Book(10,"js高级进阶",88.88);

console.log(book.bookname); // js高级进阶

问题:那么通过this添加的属性和方法同在prototype中添加的属性和方法有什么区别呢?

通过this添加的属性、方法是在当前对象上添加的,然而JavaScipt是一种基于原prototype的语言,所以每创建一个对象时,她都有一个prototype用于指向其继承的属性、方法。

这样通过prototype继承的方法并不是对象自身的,所以在使用这些方法时,需要通过prototype一级一级查找来得到。这样你就会发现通过this定义的属性或者方法是该对象自身拥有的,所以大家每次通过类创建一个新对象,this指向的属性和方法都会得到相应的创建,而通过prototype继承的属性或者方法是每个对象通过prototype访问到,所以大家每次通过类创建一个新对象时这些属性和方法不会再次创建。

问题:在java中有public 、 private等关键字来创建 公共,私有变量,那么JS里也有吗?如果没有JS如何实现呢?

首先你需要这么几点...

  1. js的函数(类)是 原型 prototype
  2. js的函数级作用域,在作用域内声明的变量,外部是访问不到的
  3. 但是函数作用域内this创建的属性和方法,在类创建对象时,每个对象自身都拥有一份并且可以在外部访问到。
  4. this创建的方法可以访问函数内私有的属性和私有的方法。

那么接下来,大家来看一下这个demo。

var Book = function (id, name,price){

   //私有属性
    var num = 1;
    //私有方法
    function checkId(){

    }
    this.id = id;
    //特权方法
    this.getName = function(){
        this.id = id;
        return this.id;
    }

    this.getPrice = function(){
        this.price = price;
        return this.price;
    }

    this.setName = function(){

    }

    this.setPrice = function(){

    }
   //对象公有属性
    this.name = name;
    //对象公有方法
    this.copy = function(){

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

}

这样大家就可以理解了,通过JS函数级作用域的特征来实现在函数内部创建外部访问不到的私有化变量和私有方法。

通过new关键字实例化对象时,由于对类实行一次,所以类的内部this上定义的属性和方法自然就可以复制到新创建的对象上,成为对象公有化的属性与方法,而其中一些方法能访问到类的私有属性和方法

var b = new Book(11,'jsvascript设计模式',50);

console.log(b.num); //undefined

console.log(b.isChinses); //undefined

console.log(b.id); //11
console.log(b.isJSBook);//false

闭包的实现

var Book = (function(){

    //静态私有变量
    var bookNum = 0 ;
    //静态私有方法
    function checkBook(name){

    }
    //返回构造函数
    return function(newId,newName,newPrice){
        //私有变量
        var name,price;
        //私有方法
        function checkID(id){}
        //特权方法
        this.getName = function(){
            console.log("1111")
        };
        this.getPrice = function(){};
        this.setName = function(){};
        this.setPrice = function(){};
        //公有属性
        this.id = newId;
        //公有方法
        this.copy = function(){};

        bookNum++;

        if(bookNum > 2){
            throw new Error('heiheihei')
        }
        //构造器
        this.setName(name);
        this.setPrice(price);
    }

    // //构造原型
    // _book.prototype = {
    //  //静态公有属性
    //  isJSBook : false,
    //  display :function(){};
    // };

    // //返回类

    // return _book;
})();

Book.prototype={
    isJSBook : false,
    display : function(){}
};

"闭包是有权访问另外一个函数作用域中变量的函数,即-在一个函数内部创建另一个函数,大家将这个闭包作为创建对象的构造函数,这样它既是闭包又是可实例对象的函数,即可访问到类函数作用域中的变量,如bookNum这个变量。此时这个变量叫静态私有变量。"

"但是,在闭包外部添加原型属性和方法看上去像似脱离了闭包这个类..."

"所以有时候在闭包内部实现一个完整的类然后将其返回"

var Book = (function(){

    //静态私有变量
    var bookNum = 0 ;
    //静态私有方法
    function checkBook(name){

    }
    //返回构造函数
    return function(newId,newName,newPrice){
        //私有变量
        var name,price;
        //私有方法
        function checkID(id){}
        //特权方法
        this.getName = function(){
            console.log("1111")
        };
        this.getPrice = function(){};
        this.setName = function(){};
        this.setPrice = function(){};
        //公有属性
        this.id = newId;
        //公有方法
        this.copy = function(){};

        bookNum++;

        if(bookNum > 2){
            throw new Error('heiheihei')
        }
        //构造器
        this.setName(name);
        this.setPrice(price);
    }

    //构造原型
    _book.prototype = {
        //静态公有属性
        isJSBook : false,
        display :function(){};
    };

    //返回类

    return _book;
})();

instanceof

var Book = function (title,time,type){
    if(this instanceof Book){
        this.title = title;
        this.time = time;
        this.type = type;
    }else{
        return new Book(title,time,type);
    }
}

var book = Book('JAVASCRIPT','2004','JS');

这样即便没new出来关键字也同样可以出结果

继承

JS作为面向对象的弱类型语言,继承也是其非常强大的特性之一。那么如何在JS中实现继承呢?
首先先创建一个父类

function Animal(name){
    //属性
    this.name = name || 'Animal';
    this.pro = ['1','2','3'];
    //实例方法
    this.sleep = function (){
        console.log(this.name + '正在睡觉');
    }
}

//原型方法

Animal.prototype.eat = function(food){
    console.log(this.name + '正在吃' + food);
}
原型链继承

核心: 将父类的实例作为子类的原型

function Cat(){

}

Cat.prototype = new Animal();
Cat.prototype.name = 'cat';


//Test Code 

var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
cat.sleep();
console.log(cat instanceof Animal);
console.log(cat instanceof Cat);

打印结果....

cat
cat正在吃fish
undefined
cat正在睡觉
true
true
[ '1', '2', '3', '5' ]

优点

  1. 非常纯粹的继承关系,实例是子类的实例,也是父类的实例
  2. 父类新增原型方法/原型属性,子类都能访问到
  3. 简单,易于实现

缺点

  1. 要想为子类新增属性和方法,必须要在new Animal()这样的语句之后实行,不能放到构造器中
  2. 无法实现多继承
  3. 来自原型对象的所有属性被所有实例共享
  4. 创建子类实例时,无法向父类构造函数传参

构造继承

核心:使用父类的构造函数来增强子类实例,等于是复制父类的实例属性给子类(没用到原型)

function Cat(name){
    Animal.call(this);
    this.name = name || 'Tome'
}


// Test code 
var cat = new Cat();
console.log(cat.name);
cat.sleep();
console.log(cat instanceof Animal);
console.log(cat instanceof Cat);

输出

Tome
Tome正在睡觉
false
true

优点

  1. 解决了1中,子类实例共享父类引用属性的问题
  2. 创建子类实例时,可以向父类传递参数
  3. 可以实现多继承(call多个父类对象)

缺点

  1. 实例并不是父类的实例,只是子类的实例
  2. 只能继承父类的实例属性和方法,不能继承原型属性/方法
  3. 无法实现函数复用,每个子类都有父类实例函数的副本,影响性能

实例继承

核心:为父类实例添加新特性,作为子类实例返回

function Cat(name){
    var instance = new Animal();
    instance.name = name || 'Tome';
    return instance ;
}


// Test code 
 var cat = new Cat();
 console.log(cat.name);
 cat.sleep();
 console.log(cat instanceof Animal);  // true
 console.log(cat instanceof Cat); // false

优点

  1. 不限制调用方式,不管是new 子类()还是子类(),返回的对象具有相同的效果

缺点

  • 实例是父类的实例,不是子类的实例
  • 不支撑多继承

拷贝继承

function Cat(name){
    var animal = new Animal();
    for (let p in animal){
        Cat.prototype[p] = animal[p];
    }

    Cat.prototype.name = name || 'tom'
}

// test code 

var cat = new Cat();

console.log(cat.name);
cat.sleep();
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

优点

  1. 支撑多继承

缺点

  1. 效率较低,内存占用高(因为要拷贝父类的属性)
  2. 无法获取父类不可枚举的方法(不可枚举方法,不能使用for in 访问到)

组合继承

核心:通过调用父类构造,继承父类的属性并保留传参的优点,然后通过将父类实例作为子类原型,实现函数复用


function Cat(name){
    Animal.call (this);
    this.name = name || 'TOM';
}

Cat.prototype = new Animal();


Cat.prototype.constructor = Cat;

//test-code 


var cat = new Cat();

console.log(cat.name);
cat.sleep();


console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true

优点

  1. 弥补了方式2的缺陷,可以继承实例属性/方法,也可以继承原型属性/方法
  2. 既是子类的实例,也是父类的实例
  3. 不存在引用属性共享问题
  4. 可传参
  5. 函数可复用

缺点

  1. 调用了两次父类构造函数,生成了两份实例(子类实例将子类原型上的那份屏蔽了)

寄生组合继承

核心:通过寄生方式,砍掉父类的实例属性,这样,在调用两次父类的构造的时候,就不会初始化两次实例方法/属性,避免的组合继承的缺点

function Cat(name){
    Animal.call(this);
    this.name = name || 'kris';

}

(function (){
    //创建一个没有实例方法的类
    var Super = function(){}
    Super.prototype = Animal.prototype;
    //将实例作为子类的原型
    Cat.prototype = new Super();

    Cat.prototype.constructor = Cat;
})();

var cat = new Cat();
console.log(cat.name);
cat.sleep();
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true

多态

在面向对象编程中,还有一种特性叫做多态。所谓多态其实就是同一个方法多种调用方式。
只不过在JS中要对传入的参数做判断以实现多种调用方式,如大家定义一个add方法...如果不传则返回10,传了1个参数则+10,传了两个参数,就把结果相加。

// function add(){
//  var arg = arguments

//  len = arg.length;

//  switch(len){
//      case 0:
//      return 10;
//      case 1 :
//      return 10 + arg[0];
//      case 2 :
//      return arg[0]+arg[1];
//  }
// }

// console.log(add())
// console.log(add(5));
// console.log(add(6,7));

当然,大家也可以转化为大家认为简而有效的类的形式...

function Add(){
    function zero(){
        return 10;
    }

    function one(num){
        return 10 + num;
    }

    function two(num1,num2){
        return num1 + num2;
    }

    this.add = function(){
        var arg = arguments;
        len = arg.length;

        switch(len){
            case 0:
             return zero();
             case 1 :
             return one(arg[0] + 10);
             case 2 :
             // console.log("222")
             return two(arg[0],arg[1])
        }
    }
}


var A = new Add();

console.log(A.add());
console.log(A.add(5));
console.log(A.add(6,7));

推荐阅读更多精彩内容