面向对象的Javascript
1.1动态类型与鸭子类型
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 makeSoud = function(animal){
if(animal instanceof Duck){
console.log('嘎嘎嘎');
}else if (animal instanceof Chicken){
console.log('咯咯咯');
}
}
var Duck = function(){}
var Chicken = function(){}
makeSoud(new Duck());
makeSoud(new Chicken());
加狗又要改makeSoud代码
1.2.2对象的多态性
var makeSoud = function(animal){
animal.sound();
};
var Duck = function(){};
Duck.prototype.sound = function(){
console.log('嘎嘎噶');
};
var Chicken = function(){};
Chicken.prototype.sound = function(){
console.log('咯咯咯');
}
makeSoud(new Duck());
makeSoud(new Chicken());
var Dog = function(){};
Dog.prototype.sound = function(){
console.log('汪汪汪');
}
makeSoud(new Dog());
1.2.3 类型检查与多态
java
1.2.4 使用继承得到多态效果
1.2.5 Javascript的多态
不需要java类似的向上转型
1.2.6 多态在面向对象程序设计中的作用
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 googleMap = {
show:function(){
console.log('开始渲染谷歌地图');
}
};
var baiduMap = {
show:function(){
console.log('开始渲染百度地图');
}
}
var renderMap = function(map){
if(map.show instanceof Function){
map.show();
}
}
renderMap(googleMap);
renderMap(baiduMap);
实际开发中借助适配器模式
1.2.7 设计模式与多态
1.3 封装
1.3.1 封装数据
var myObject = (function(){
var _name = 'sven';
return {
getName:function(){
return _name;
}
}
})();
console.log(myObject.getName()); //sven
console.log(myObject._name); //undefined
1.3.2 封装实现
封装不仅仅是隐藏数据，还包括隐藏细节 设计细节 对象的类型 等
1.3.3 封装类型
封装类型是通过抽象类和接口来进行的 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;
var clonePlane = Object.create(plane);
console.log(clonePlane.attackLevel); //10
/*不支持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中的原型继承
- 所有的数据都是对象
- 要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。
- 对象会记住它的原型。
- 如果对象无法响应某个请求，它会把这个请求委托给它的对象系统的。
1.所以的数据都是对象
undefined number boolean string function object
Javascript设计本意是除了undefined之外，一切应是对象，为了实现这一目标number boolean string这几种基本类型也可以通过“包装类”的方式变成对象类型数据来处理。
Javascript中的根对象是Object.prototype对象->空对象
var obj1 = new Object();
var obj2 = new Object();
console.log(Object.getPrototyprOf(obj1) === Object.prototype);//ture
console.log(Object.getPrototyprOf(obj2) === Object.prototype);//ture
2.要得到一个对象，不是通过实例化类，而是找到一个对象的原型并克隆它
function Person(name){
this.name = name;
}
Person.prototype.getName = function(){
return this.name;
}
var a = new Person('sven');
console.log(a.name); //sven
console.log(a.getName()); //sven
console.log(Object.getPrototypeOf(a) === Person.prototype); //ture
Person并不是类，而是函数构造器，Javascript的函数既可以作为普通函数被调用，也可以做为构造器被调用。当使用new运算符来调用函数时，此时的函数就是一个构造器。用new运算符来创建对象的过程，实际上也只是先克隆Object.prototype对象，再进行一些额外的操作。
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); //ture
Javascript给对象提供一个名为proto的隐藏属性，默认指向它的构造器的原型对象。即｛Constructor}.prototype.在一些浏览器中，proto被公开出来。
proto就是对象跟“对象构造器的原型”联系起来的纽带
var a = new Object();
console.log(a.__proto__ === Object.prototype);
4如果无法响应某个请求，它会把这个请求委托给它的构造器的原型
var obj = {name:'sven'};
var A = function(){};
A.prototype = obj;
var a = new A();
console.log(a.name); //sven
继承
var A = function(){};
A.prototype = {name:'sven'};
var B = function(){};
B.prototype = new A();
var b = new B();
console.log(b.name); //输出sven
1.4.6 原型继承未来
Object.create(null)可以创建出没有原型的对象
es6
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());