第一部分-基础知识（1）-面向对象的JavaScript

JavaScript 没有提供传统面向对象语言中的类式继承，而是通过原型委托的方式来实现对象与对象之间的继承。

• 1.1 动态类型语言和鸭子类型
• 1.2 多态
• 1.3 封装
• 1.4 原型模式和基于原型继承的JavaScript对象系统

1.1 动态类型语言和鸭子类型

编程语言按照数据类型大体可以分为两类：一类是静态类型语言，另一类是动态类型语言。

• 静态类型语言在编译时便已确定变量的类型。
• 动态类型怨言的变量类型要到程序运行的时候，待变量被赋予某个值之后，才会具有某种类型。

静态类型语言的优点：1、在编译时就能发现类型不匹配的错误。2、如果在程序中明确的规定了数据类型，编译器还可以针对这些信息对程序进行一些优化工作，提高程序执行速度。

静态类型语言的缺点：1、迫使程序员依照强契约来编写程序，为每个变量规定数据类型。2、类型的声明会增加更多的代码，在程序的编写过程中，这些细节会让程序员的 精力从思考业务逻辑上分散开来。

动态类型语言的优点：编写的代码数量更少，看起来也更加简洁，程序员可以把精力更多的放在业务逻辑上面。

动态类型语言的缺点：无法保证变量的类型，从而在程序的运行期有可能发生跟类型相关的错误。

var duck = {
    duckSinging : function() {
        console.log('嘎嘎嘎');
    }
};

var chicken = {
    duckSinging : function() {
        console.log('嘎嘎嘎');
    }
};

var choir = []; //合唱团

var joinChoir = function(animal) {
    if (animal && typeof animal.duckSinging === 'function') {
        choir.push(animal);
        console.log('恭喜加入合唱团');
        console.log('合唱团已有成员数量：' + choir.length);
    }
};

joinChoir(duck);    //恭喜加入合唱团
joinChoir(chicken); //恭喜加入合唱团

1.2 多态

多态的实际含义是 ： 同一操作作用于不同的对象上面，可以产生不同的解释和不同的执行结果。换句话说，给不同的对象发送同一消息的时候，这些对象会根据这个消息分别给出不同的反馈。

1.2.1 一段“多态”的JavaScript代码

var makeSound = function(animal){
    if (animal instanceof Duck) {
        console.log('嘎嘎嘎');
    }else if(animal instanceof Chicken){
        console.log('咯咯咯');
    }
}

var Duck = function(){};
var Chicken = function(){};

makeSound(new Duck());  //嘎嘎嘎
makeSound(new Chicken());  //咯咯咯

多态背后的思想是将“做什么”和“谁去做以及怎样去做”分离开来，也就是将“不变的事物”与“可能改变的事物”分离开来。

1.2.2 对象的多态性

// 把不变的部分隔离出来
var makeSound = function(animal){
    animal.sound();
}

// 把可变的部分各自封装起来
var Duck = function(){};
Duck.prototype.sound = function(){
    console.log('嘎嘎嘎');
}

var Chicken = function(){};
Chicken.prototype.sound = function(){
    console.log('咯咯咯');
}

var Dog = function(){};
Dog.prototype.sound = function(){
    console.log('汪汪汪');
}

makeSound(new Duck());  //嘎嘎嘎
makeSound(new Chicken());  //咯咯咯
makeSound(new Dog());  //汪汪汪

1.2.3 类型检查和多态

类型检查是在表现出对象多态性之前的一个绕不开的话题,但JavaScript是一门不必进行类型检查的动态类型语言。

1.2.4 使用继承得到多态效果

使用继承来得到多态效果，是让对象表现出多态性的最常用的手段。继承通常包括实现继承和接口继承。

1.2.5 JavaScript的多态

JavaScript作为一门动态类型语言，与生俱来的有多态性。

1.2.6 多态在面向对象程序设计中的作用

多态最根本的作用就是通过把过程化的条件分支语句转化为对象的多态性，从而消除这些条件分支语句。

//假设我们要编写一个地图应用，现在有两家可选的地图API提供商供我们接入自己的应用。
//目前我们选择的是谷歌地图，谷歌地图的API中提供了show方法，负责在页面上展示整个地图。示例代码如下：

var googleMap = {
    show : function() {
        console.log('开始渲染谷歌地图');
    }
};

var renderMap = function() {
    googleMap.show();
}

renderMap();    //输出：开始渲染谷歌地图

// 后来因为某些原因，要把谷歌地图换成百度地图，为了让renderMap函数保持一定的弹性
// ，我们用一些条件分支来让renderMap函数同事支持谷歌地图和百度地图：

var googleMap = {
    show : function() {
        console.log('开始渲染谷歌地图');
    }
};

var baiduMap = {
    show : function() {
        console.log('开始渲染百度地图');
    }
};


var renderMap = function(type) {
    if (type === 'google') {
        googleMap.show();
    } else if (type === 'baidu') {
        baiduMap.show();
    }
}

renderMap('google');    //输出：开始渲染谷歌地图
renderMap('baidu');     //输出：开始渲染百度地图



// 将程序中相同的部分抽象出来，那就是显示某个地图：
var renderMap = function(map) {
    if (map.show instanceof Function) {
        map.show();
    }
};

renderMap(googleMap);   //输出：开始渲染谷歌地图
renderMap(baiduMap);    //输出：开始渲染百度地图

1.2.7 设计模式与多态

详见《JavaScript设计模式与开发实践》P11

1.3 封装

封装的目的是将信息隐藏。一般而言，我们讨论的封装是封装数据和封装实现。这里不仅包括封装数据和封装实现，还包括封装类型和封装变化。

1.3.1 封装数据

在JavaScript中，我们只能以来变量的作用域来实现封装特性，而且只能模拟出 public 和 private 这两种封装性。

var myObject = (function() {
    var _name = 'sven'; //私有（private）变量
    return {
        getName: function() { //公开（public）方法
            return _name;
        }
    }
})();

console.log(myObject.getName()); //sven
console.log(myObject._name); //undefined

1.3.2 封装实现

封装的目的是将信息隐藏。
从封装实现细节来讲，封装使得对象内部的变化对其他对象而言是透明的，也就是不可见的。对象对它自己的行为负责。其他对象或用户不关心它的内部实现。封装使得对象之间的耦合变松散，对象之间只通过暴露的API接口来通信。

1.3.3 封装类型

封装类型是静态类型语言中一种重要的封装方式。一般而言，封装类型是通过抽象类和接口来进行的。把对象的真正类型隐藏在抽象类或者接口之后，相比对象的类型，客户更关心对象的行为。在许多静态语言的设计模式中，想方设法地去隐藏对象的类型，也是促使这些模式诞生的原因之一。在JavaScrip中，并没有对抽象类的接口的支持。在封装类型方面，JavaScript没有能力，也没有必要做的更多。

1.3.4 封装变化

从设计模式的角度出发，封装在更重的层面体现为封装变化。

1.4 原型模式和基于原型继承的JavaScript对象系统

1.4.1 使用克隆的原型模式

var Plane = function() {
    this.blood = 100;
    this.attackLevel = 1;
    this.defenseLevel = 1;
}

var plane = new Plane();
plane.blood = 500;
plane.attackLevel = 10;
plane.defenseLevel = 7;

var clonePlane = Object.create(plane);
console.log(clonePlane); //输出： Object{blood:500,attackLevel:10,defenseLevel:7}

// 在不支持Object.create方法的浏览器中，则可以使用以下代码：
Object.create = Object.create || function(obj) {
    var F = function() {};
    F.prototype = obj;
    return new F();
}

1.4.2 克隆是创建对象的手段

1.4.3 体验lo语言

1.4.4 原型编程范型的一些规则

• 所有的数据都是对象。
• 要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。
• 对象会记住它的原型。
• 如果对象无法响应某个请求，它会把这个请求委托给它自己的原型。

1.4.5 JavaScript中的原型继承

function Person(name) {
    this.name = name;
};

Person.prototype.getName = function() {
    return this.name;
};

var objectFactory = function() {
    var obj = new Object(), //从Object.prototype上克隆一个空的对象
        Constructor = [].shift.call(arguments); //取得外部传入的构造器，这里是Person

    obj.__proto__ = Constructor.prototype;  //指向正确的原型
    var ret = Constructor.apply(obj, arguments);    //借用外部传入的构造器给obj设置属性

    return typeof ret === 'object' ? ret : obj; //确保构造器总是会返回一个对象
};


var a = objectFactory(Person, 'sven');

console.log(a.name);    //sven
console.log(a.getName());   //sven
console.log(Object.getPrototypeOf(a) === Person.prototype); //true

// 分别调用下面两句代码产生一样的结果：
var a = objectFactory(A, 'sven');
var a = new A('sven');

1.4.6 原型继承的未来

ECMAScritp6带来了新的Class语法。

class Animal{
    constructor(name) {
        this.name = name;
    }

    getName() {
        return this.name;
    }
}

class Dog extends Animal {
    constructor(name) {
        super(name);
    }

    speak() {
        return 'woof';
    }
}

var dog = new Dog('Scamp');
console.log(dog.getName() + ' says ' + dog.speak());    //Scamp says woof

1.4.2 - 1.4.6

更多请参照《JavaScript设计模式与开发实践》P15 - P23

1.4.7 小结

本节讲述了第一个设计模式——原型模式。原型模式是一种设计模式，也是一种编程泛型，它构成了JavaScript这门语言的根本。原型模式十分重要，和JavaScript开发者的关系十分密切。通过原型来实现的面向对象系统虽然简单，但能力同样强大。