js设计模式及面向对象的概念

一、工厂模式

概念：工厂方法说白了就是在工厂里面去写方法，在外部写一个公用的方法去调取工厂的独有方法，来实现客户的需求

可以批量创建相同属性和方法的对象，不用每次都重新定义对象

工厂模式需要3个基本步骤，原料投入（传参），加工过程（new—>return），成品出厂（return）

 //工厂模式
    var a = {};//不能重复的利用  设置公共属性的代码
    // 我们需要创建10个cat属性，每个对象都有 年龄姓名的属性，包括run方法
    function createCat(age, name) {//工厂模式就是标准化的生成默认对象的函数
        var o = new Object();
        // var o={};
        o.age = age;
        o.name = name;
        o.run = function () {
            console.log(this.name + '  running....')
        }
        return o;
    }
    var c = createCat(19, 'hhh')
    var c2 = createCat(20, 'ggg')
    // 优点：
    // 1、可以进行批量的创建 都有公共的默认值和属性对象，解决了重复创建对象的问题
    // 缺点
    // 1、对象的方法不能重用，每个对象的内存都存储一份函数对象的内存
    // 2、不能识别对象的原型机构造函数
    // 3、c instance of  Cat;//false

2、构造函数创建对象及优缺点

优点
所有创建出来的对象，都可以找到他的原型和构造函数
公共的属性和方法也可以在创建的时候统一创建和维护
缺点
对象的函数，每个对象都会拥有一份内存拷贝。浪费内存

 function Cat(name, age) {
        this.age = age
        this.name = name
        this.run = function () {
            console.log(this.name, this.age)
        }
    }
    var c1 = new Cat('black', 3);
    var c2 = new Cat('white', 2);

3、组合构造函数模式与原型模式构建对象

概念：组合使用构造函数模式与原型模式
公共的属性何方法放到原型上，独立的属性使用构造函数模式，放到对象自己身上
优点：
既保证了方法等共享的属性，只在内存中保存一份，节省内存
又可以实现每个对象有自己单独存放的属性。是一种经典的构建对象的方法

function Cat() {
        this.age = 19
        // 如果需要共享的属性和方法我们统一放到原型中定义
        // this.run = function () {
        //     console.log('fun')
        // }
    }
    Cat.prototype.name = 'black cat'
    Cat.prototype.run = function () {
        console.log(this.name, this.age)
    }
    var c1 = new Cat();
    var c2 = new Cat();
    console.log(c1.name)//black cat
    console.log(c2.name)//black cat
    // c1.run();
    console.log(c1.run() === c2.run())//true
    c1.name = 'white cat'
    console.log(c1.name);

image.png

4、稳妥构造函数模式

概念：
所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象

优点
可以共享属性和方法的初始代码
无论用户是否用了new还是没有使用new都会被正确的返回新的对象
缺点
无法追溯对象的原型和构造函数，默认没有公共的属性和方法，内存浪费

 function Cat() {
        var o = {};
        o.age = 10;
        o.name = 'black cat';
        o.run = function () {
            console.log(o.name + '  running....')
        }
        // 如果返回是引用类型就将他返回，如果是基本类型就返回this
        // o = { name: 'liu' };
        // o = 2;//2
        return o;
    }
    // new一个对象和不用new 是一样的
    var c1 = new Cat()//构造函数调用
    var c2 = Cat()//函数调用模式
    console.log(c1)
    console.log(c2)

5、对象的继承

原型链继承方式

// 动物基类
    function Animal(name, age) {
        this.name = name;
        this.age = age;
        this.fruit = ['water', 'apple']
    }
    // 在动物的基类上添加方法run
    Animal.prototype.run = function () {
        console.log(this.name + '  running')
    }

    function Cat(name, age) {
        this.name = name;
        this.age = age;
    }
    // 原型链的继承方式
    // Cat.prototype.constructor === Cat
    // console.log(Cat.prototype.constructor === Cat)//true
    Cat.prototype = new Animal();
    //上面的代码把cat的prototype指向了Animal 现在要还原回来
    Cat.prototype.constructor = Cat;
    console.log(Cat)
    console.log(Cat.prototype.constructor)//Animal
    var c = new Cat('Tom', 17)//希望cat继承animal的属性和方法
    c.run();//从animal原型上继承的方法
    c.fruit.push('banana')
    console.log(c.fruit)//["water", "apple", "banana"]
    // 问题
    // 1、子类的构造函数的参数，没法传给父级的构造函数
    // 2、子类的原型的constructor会被改变，需要自己变回来
    // 3、如果父类里有引用类型的属性，那么所有的子类会共享这个引用类

构造函数继承

 // 父类
    function Animal(name, age) {
        this.name = name;
        this.age = age;
        this.fruit = ['water', 'apple']
    }
    // 在父类的原型上 创建run方法
    Animal.prototype.run = function () {
        console.log(this.name + '  running')
    }

    function Cat(name, age) {
        // Animal(age,name)//this===window; 
        Animal.call(this, name, age)//借用父类的构造函数 给子类创建实例属性
    }
    var c = new Cat('Tom', 12)
    console.dir(Cat.prototype.constructor)

    console.log(c)// Tom
    console.log(c.name)// Tom
    console.log(c.age)// Tom
    console.log(c.fruit)// ['water', 'apple']

组合继承

 // 父类
    function Animal(name, age) {
        this.name = name;
        this.age = age;
        this.fruit = ['water', 'apple']
    }
    // 在父类的原型上 创建run方法
    Animal.prototype.run = function () {
        console.log(this.name + '  running')
    }

    function Cat(name, age) {
        // Animal(age,name)//this===window; 
        Animal.call(this, name, age)
    }
    Cat.prototype = new Animal();//组合原型继承模式
    Cat.prototype.constructor = Cat;
    var c = new Cat('Tom', 12)
    console.dir(Cat.prototype.constructor)

    console.log(c)// Tom
    console.log(c.name)// Tom
    console.log(c.age)// Tom
    console.log(c.fruit)// ['water', 'apple']

原型方法继承

    function object(o) {
        function F() { }
        F.prototype = o//让空函数的原型指向o对象
        return new F();//创建一个f实例，f的内部原型指向o对象
    }
    var o = { name: 'liu', age: 23 }
    var m1 = object(o)
    console.log(m1.name)
// 优点：
// 不需要使用new构造函数就可以直接 构造另外其他对象
// 缺点：
// 所有构造函数出来的实例会共享 原型对象上的引用类型的属性

寄生继承方式
寄生继承模式是在原型式继承模式上增强原型对象的增强模式。只是对象原型式继承的扩张而已
寄生继承类似一个工厂模式，工厂内部把原型对象进行构造出另一个实例，并对构造出来的实例进行增强，最后返回这个实例

function Person(name, age, job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function() {
        alert(this.name);
    }
    return o;
}

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

寄生组合的方式

image.png

image.png

区别地址