js 面向对象设计模式 ---继承

//类式继承

// 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);