//类式继承
// function Father(){
// this.fartherValue = true;
// }
// Father.prototype.getFartherValue = function () {
// return this.fartherValue;
// }
// function Child(){
// this.childValue = false;
// }
// Child.prototype = new Father();
// Child.prototype.getChildValue = function(){
// return this.childValue;
// }
// let a = new Child();
// console.log(a.getChildValue());
// console.log(a.getFartherValue());
//类式继承的缺点 //1,子类通过原型对父类进行实例化,继承了父类,父类共有属性要是
//引用类型就会在子类中被实例化共用,更该实例化的子类其他子类 //也会送到影响
// function Farther() {
// this.books = ["javascript","html","css"];
// this.name ="-";
// }
// function Child(){
//
// }
// Child.prototype = new Farther();
// let c1 = new Child();
// let c2 = new Child();
// console.log(c1.books);
// console.log(c1.name);
// c1.books.push("设计模式");
// // c1.name.replace(/-/g,"hello");类式继承为啥只有引用类型搜影响
// console.log(c2.books);
// console.log(c2.name);
**
//构造函数继承
**
// //call方法把Child 指针指向Farther 所以new Child 的对象可以使用 // // Farther 里的共有属性和方法,所以对象无法获取Farther 中的Prototype // // 的属性和方法,so 应该使用组合继承
// function Farther(id) {
// //引用类型共有属性
// this.books = ['javascript','html',"css"];
// //基本数据类型共有属性
// this.id= id;
// }
// //父类原型方法
// Farther.prototype = {
// showBooks:function () {
// console.log(this.books);
// }
// }
// function Child(id){
// Farther.call(this,id);
// this.name = "hello";
// }
// let c1 = new Child(10);
// let c2 = new Child(11);
// console.log("c1 "+c1.books);
// console.log(c1.name);
// console.log("c2 "+c2.books);
// c1.books.push(“设计模式”);
// console.log("c1 "+c1.books);
// console.log("c2 "+c2.books);
// // console.log(c1.showBooks());
//组合继承
// function F(name){
// this.books = ['html','css','javascript'];
// this.name = name;
// }
// F.prototype.display = function(){
// console.log(this.name);
// }
// function C(time,name){
// F.call(this,name);
// this.time = time;
// }
// C.prototype = new F();
// C.prototype.gettme = function(){
// console.log(this.time);
// }
// let c1 = new C(2019,"yqf");
// let c2 = new C(2018,"yqf");
// console.log(c1.books);
// c1.books.push("zeji");
// console.log(c2.books);
// c1.display();
// c2.gettme();
//以上方法使用构造函数继承时又执行了遍父类的构造函数,而在实现子类 //原型的继承时,有调用父类,父类的构造函数执行了两边.
//所以原型继承孕育而生
//原型继承
// function inhertObject(o) {
// //申明一个过度函数对象
// function F() {}
// F.prototype =o;
// return new F();
// }
// let book ={
// name:"js book",
// books:["css","html","javasript"]
// };
// let newbook1 = inhertObject(book);
// let newbook2 = inhertObject(book);
// console.log(newbook1.books);
// newbook1.books.push("hello");
// console.log(newbook2.books);
//寄生模式
// function inhertObject(o) {
// //申明一个过度函数对象
// function F() {}
// F.prototype =o;
// return new F();
// }
// let book ={
// name:"js book",
// books:["css","html","javasript"]
// };
// function createBook(obj) {
// let o = new inhertObject(obj);//寄生对象
// o.getName = function () {//拓展对象
//
// }
// return o;
// }
// let newbook1 = createBook(book);
// let newbook2 = createBook(book);
// console.log(newbook1.books);
// newbook1.books.push("hello");
// console.log(newbook2.books);
//总计继承者-寄生组合类 //相对于组合继承 ,寄生组合继承不用new 整个father构造器中的
//共有属性,他只要定义空函数作为一个缓冲
function inhertObject(o) {
//申明一个过度函数对象
function F() {}
F.prototype =o;
return new F();
}
function inhertiPrototype(Child,Father) {
// 复制一份父类的原型副本保存在变量中
let p = inhertObject(Father.prototype);
p.constructor = Child;
// 复制过来的constructor是存放指向farther对象的指针地址
// 所以要把复制的p 的原型对象指针指向Child
Child.prototype =p;
}
function Father(name) {
this.name = name;
this.books =['html',"css","javascript"];
}
function Child(name) {
this.time = "2019";
Father.call(this,name);
}
//寄生继承父类原型
inhertiPrototype(Child,Father);
let c1 = new Child("yqf");
let c2 = new Child("fqy");
console.log(c1.books);
c1.books.push("java");
console.log(c1.books);
console.log(c2.books);