js继承

 

js 是弱类型语言;

 

面向对象有三个特征:

 

封装 继承 多态

 

找寻机制 -> 原型链;

 

    链：作用域链 -> 原型链;

 

继承的限制 => 只有在使用构造函数和原型编程时可以使用继承;

 

1.克隆是继承;

2.权限式继承;

 

构造函数的继承:function Father(name, age, money) {this.name = name;this.age = age;this.money = money;}var father = new Father("王健林", "60", "100亿");console.log(father);function Son(name, age, money) {Father.call(this, name, age, money);}function Son() {Father.apply(this, arguments);}var son = new Son("王思聪", "31", "50亿");console.log(son);Math.min(1, 2, 3, 4, 5, 6, 7)Math.min.apply(false, [1, 2, 3, 4, 5])


call&apply (改变this指向的方法)

this指向的两种情况:
1.指向函数的调用者;
2.在构造函数中，指向实例化对象;
3.bind => 在函数创建初期固定this指向;


function foo(a, b, c) {
console.log(this, a, b, c);
}

// foo(); // this => window

// call 第一个参数就是制定当前函数this指向的;
// foo.call({ name: "一个任意对象" }) // 调用

// call 制定函数的调用者;
   foo.apply({ name: "一个任意对象" })

// call 和 apply 都是制定函数调用者的方法(在调用时改变函数的this指向的方法);

// call 和 apply 的不同;

// call(arg1, arg2, arg3, ..., arg10)

// call 的第二个及以后的参数和形参一一对应;

// foo.call({ name: "一个任意对象" }, 1, 2, 3)
// foo.call({ name: "二个任意对象" }, 1, 2, 3)
// foo.call({ name: "三个任意对象" }, 1, 2, 3)

// foo.call(改变tihis指向，实参1，实参2，...，实参n)

// apply 只接受两个参数;
   apply(arg_this, arg_arguments_array);
   foo.apply({ name: "一个任意对象" }, [1, 2, 3]);

// call,apply 都是在调用函数的时候改变this指向的方法;

// call,接受n个参数 第一个参数改变this，其余的参数和形参一一对应
// apply,接收两个参数 第一个参数改变this，第二个参数改变arguments对象;


原型对象的继承:

// 方法有必要复制么 ?

// function foo(){
// console.log("我执行了");
// }

// var myFoo = foo;

// var myNewFoo = eval("("+foo.toString()+")");

// myFoo();
// myNewFoo();

// 函数体内的代码是不变更的;

// 在继承方法的时候，只要拿到函数的地址就可以了;

// console.log(foo === myFoo , foo === myNewFoo);


function Father() {
this.name = "马云";
};
Father.prototype.show = function () {
console.log("马云 : 我不喜欢钱，我对钱没有兴趣");
console.log("撒贝宁 : 噗呲... ");
}

// father => 由构造函数直接负责;

var father = new Father();
console.log(father);
father.show();


// 原型的动态性;

function Son() {

this.hello = function () {
console.log("say hello");
}
};

// var son = new Son();
// console.log(son);

// Son.prototype = Father.prototype;

// var son2 = new Son();
// console.log(son2);

//tip : 在实例化之前一定要完成原型的变更;

// var son = new Son();
// console.log(son);

// 新的方法就必须写在构造函数里了;

// Son.prototype.hello = function(){
// console.log("say hello");
// }

// console.log(son);

// 原型的赋值;

// 循环赋值 => 保留了子集的原型，不用把新的覆盖的方法写在构造函数中;


// 遍历父级所有方法;
for (var attr in Father.prototype) {
Son.prototype[attr] = Father.prototype[attr];
}

Son.prototype.hello = function () {
console.log("say hello");
}

var son = new Son();

console.log(son);


原型链的继承:

// 原型链
// 链 ? 找寻方式;

var obj = {};
var obj = new Object();

console.log(obj);
console.log(obj.toString());

// 实例化对象找寻某个属性是否存在的过程,在这个过程之中会按照当前对象之中存在的原型指针依次进行查找;

// 访问某个属性是解析器做了些啥 ?

// 1. 有没有某个属性 ?
// 1.1 有 => 返回;
// 1.2 没有 => 有没有原型指针;
// 1.2.1 有 => 返回;
// 1.2.2 没有 => 返回undefined;

// function Father() {

// }
// Father.prototype.hello = function () {

// }
// function Son() {

// }
// Son.prototype = new Father();

// var son = new Son();

// console.log(son);

function Father() {

}
Father.prototype.hello = function () {

}
function Son() {

}

// Son.prototype = new Father();

// 语义化更清晰了; ES5 的;

// Son.prototype = Object.create(Father.prototype);
// Son.prototype = Object.create({ name: "hello" });

// Object.create();
// Object.create 创建一个对象; 这个对象之中有一个指针指向参数对象;


// var son = new Son();
// console.log(son);

// 不要这样;

Son.prototype = Object.create(Son.prototype);
var son = new Son();
console.log(son);

// 原型链继承 => 给当前原型对象上添加一个原型指针，让当前原型对象和父级(希望继承的原型上有一个联通方式);