美文网首页
面向对象的JS-设计模式（1）

面向对象的JS-设计模式（1）

作者: Kris_lee | 来源:发表于2019-01-02 17:24 被阅读11次

编程风格

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

封装

在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));

相关文章

  • 面向对象的JS-设计模式（1）

    面向对象编程风格 封装 继承 多态 编程风格 面向对象变成就是将你的需求抽象成一个对象，然后针对这个对象分析其特征...

  • GeekBand极客班C++设计模式(一)

    1、设计模式简介 设计模式-不断解决，不必重复推荐书籍-设计模式：可复用面向对象软件的基础面向对象-底层思维：语言...

  • 面向对象设计原则

    面向对象设计原则 面向对象设计原则是设计模式的基础，每个设计模式都符合一一种或多种面向对象的设计原则。 常用的面向...

  • 要点1 Java相关

    1. 熟练掌握Java技术，熟悉面向对象思想，熟悉常用设计模式； 面向对象思想: 继承, 封装, 多态 设计模式:...

  • 单例模式

    面向对象设计的设计模式（四）：单例模式

  • 面向对象：6大原则、24种设计模式

    接上一篇：面向对象介绍 为什么要学设计原则、设计模式？ 若不学好经典设计模式，和通过设计模式理解面向对象的原则，你...

  • 设计模式的原则

    面向对象的原则是面向对象的目标，而设计模式是为了实现这些原则的手段和方法。这也就是为什么要有设计模式。 面向对象的...

  • 设计模式(1)——面向对象

    一、面向对象 1.1面向对象三大特性：封装、继承、多态 继承 People是父类，公共的，不仅仅服务于studen...

  • 面向对象、设计原则、设计模式、编程规范、重构

    面向对象、设计原则、设计模式、编程规范、重构 面向对象 主流的三个编程风格有：面向对象，面向过程，函数式编程。 面...

  • GeekBand C++设计模式 第一周

    1.设计模式简介 课程目标 松耦合设计思想 面向对象设计原则 重构技法改善设计 GOF核心设计模式 设计模式 不断...

网友评论

      本文标题：面向对象的JS-设计模式（1）

      本文链接：https://www.haomeiwen.com/subject/azttrqtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|面向对象的JS-设计模式（1）|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！