js面向对象，封装、继承、多态、静态方法

//1、json创建对象
//js对象只是一个属性字典，就像php中的关联数组，因此可以直接造对象
var ori = {} //地球上最原始的蛋白质
var c = {ceil:1} //单细胞动物
var chicken = {leg:2,song:function(){console.log('我是一只小小鸟')}}
console.log(ori,c,chicken)
chicken.song()
//通过上面可以看出，js中的对象不依赖类，是可以直接生成的，像{k:v,k:v}这种格式生命的对象，称为json格式对象，js的对象的属性也是可以任意增添和删除的
chicken.wine =2;//增加两条翅膀（添加属性）
//这只小鸡受伤了,不会唱歌了
delete chicken.song;//删除属性(方法)
//结论：js中的对象，就是“一组属性(方法)与值的集合，属性(方法)可以任意增减”，方法属性不必区分


//2、用构造函数创建对象
function Dog(){
    this.leg = 4
    this.bark = function(){
        console.log('wang wang ~~')
    }
}
var huzi = new Dog()
huzi.bark()


//3 封装--->闭包实现
function Girl(name,bf){
    var secret = bf;
    this.name = name;
    //获取值
    this.getSecret = function(){
        return secret;
    }
    //赋值
    this.setSecret = function(sec){
        secret = sec;
    }
}
var g = new Girl('林黛玉','贾宝玉')
//林黛玉喜欢undefined，var secret并非this.secret,是Girl内部变量，外部无法访问，闭包内可以访问，达到封装
console.log(g.name+"喜欢"+g.getSecret()) //林黛玉喜欢贾宝玉
g.setSecret('薛蟠');
console.log(g.name+"喜欢"+g.getSecret())//林黛玉喜欢薛蟠

//4、继承
//4.1 原型链继承
function tiger(){
    this.bark = function(){
        console.log('我是百兽之王')
    }
}
var hu = new tiger()
function cat(){
    this.climb = function(){
        console.log('我会爬树')
    }
}
var bosi = new cat()

hu.bark()
bosi.climb()

//用某个cat的具体对象作为老虎原型，实例化一条老虎出来，使它拥有这只猫的属性(方法)
//hu.climb();//hu.climb is not a function， 老虎暂时还不会爬树

//开始继承
tiger.prototype = new cat()
var hnhu = new tiger()
hnhu.climb();//我会爬树
console.log(hnhu) //__proto__:cat
/*
分析继承：
1、构造空对象hnhu{}
2、hnhu.bark = function(){}
3、hnhu.__proto__ = tiger.prototype  //这是继承关键

就是说--js中，每个对象都有一个__proto__指向其原型对象，原型对象也是对象也有__proto__,原型的原型的原型...最终指向Object(Object原型为null)

triger(方法)的prototype-->cat(对象)
hnhu = new triger()
hnhu的__proto__ -->cat对象

cat(方法)的prototype-->Object(对象)
bosi = new cat(); 同时又隐形创造了一个Object（创造过程在下一步）,Object有一个constructor方法反过来指向cat(方法)，所以constructor显示cat(方法)，谁造的Objectconstructor就指向谁
bosi.__proto__-->Object(对象)
Object的prototype为null

Object(系统方法)的prototype-->null
Object(对象) = new Object(系统方法)
Object.__proto__-->null


老虎如何爬树和valueOf的？
答：老虎先在自身对象上着climb方法与valueOf方法，自身没有了就去原型上找，原型__proto__上有此climb方法，因此得以调用,
但是valueOf没有找到，于是继续沿着原型查找，找到一个cat空对象仍然没有，在接着找Object上有valueOf，因此调用成功

对象->原型->原型的原型->object->null ：这样的一条链称为“原型链”，对象的属性和方法就是沿着原型链来查找、调用的
*/


//让所有对象都会唱歌，给最上层的Object加上的话就可以了
Object.prototype.sing = function(){
    console.log('出卖我的爱')
}

function Pig(){
    this.eat = '吃'
}
var pig = new Pig()
pig.sing() //Pig原型最顶层是Object，所以它也有sing了


//覆盖（重写父类proto中的属性）
function Dog(){
    this.bark = function(){
        console.log('wang~')
    }
}

function ZangAo(){
    this.eat = function(){
        console.log('eat~~')
    }
}
function TaiDi(){
    this.c = function(){
        console.log('xxxx')
    }
}
ZangAo.prototype = new Dog()
ZangAo.prototype.bark = function(){console.log('wu~~')}
TaiDi.prototype = new Dog()

zangao = new ZangAo()
zangao.bark()//wu~ ,重写了
taidi = new TaiDi()
taidi.bark()//wang~，继承了



//4.2、原型冒充(通过apply继承)
function Dog(food){
    this.bark = function(){
        console.log('wang~')
    }
    this.eat = function(){
        console.log('love ' + food)
    }
}
function ZangAo(food,corlor){
    this.corlor = corlor
    Dog.apply(this,arguments)
}
za = new ZangAo('meat','red');
za.eat()


//4.3 复制继承
function Dog(food,leg,tail){
    this.leg = leg
    this.tail = tail
    this.eat = function(){
        console.log('love ' + food)
    }
}
function ZangAo(food,corlor){
    this.corlor = corlor
    this.extend = function(parent){
        //复制父亲属性、方法
        for(var key in parent){
            this[key] = parent[key]
        }
    }
}
var za = new ZangAo();
za.extend(new Dog('meat','red')) //复制父属性、方法
za.eat()


//5、多态，静态(js、php、python)语言不存在真正的多态，因为他们参数类型不被限定

//6、对象的静态方法：
function Hashiqi(){
    this.bark = function(){
        console.log('wuwu')
    }
}
Hashiqi.ajax = function(){
    console.log('ajax')
}

var h = new Hashiqi();
console.log(h)
console.log(Hashiqi)
// h.ajax();//h.ajax is not a function
// Hashiqi.ajax();//ajax
/*
    1、ajax()方法是属于“函数”本身的，和返回的对象没关系，返回的对象无法调用
    2、bark要调用，必须new Hashiqi()得到对象,且有返回对象才能调用
    3、ajax要调用，不需要new对象，直接用Hashiqi来调用，用new也无法调用
*/

/*
    之前接触到的静态方法

    1、Math.random()、$.ajax等
    2、写jquery插件，2中方法
        2.1 通过闭包，吧方法写到jquery上的原型上(稍微复杂)
        2.2 直接通过增加$对象的静态方法
*/