设计模式之工厂模式

工厂模式：对相似的实体的一些类型和方法进行统一的封装。优点：减少多余的冗余代码。

"Hey, man!my name is JunZou,  what's your name?"

"YaDu"

工厂模式大体分为一下三种：

1、简单工厂模式（静态工厂模式）

2、工厂方法模式

3、抽象工厂模式

---

1、简单工厂模式

// 简单的工厂模式
function Person(name, IDCard, sex) {
    this.name = name;
    this.IDCard = IDCard;
    this.sex = sex;
}

Person.prototype = {
    getName: function() {
        return this.name
    },
    getIDCard: function() {
        return this.IDCard
    },
    getSex: function() {
        return this.sex
    }
}

var JunZou = new Person('JunZou', '320XXXX0111', 'man')
var YaDu = new Person('YaDu', '320XXXX0111', 'man')
console.log(JunZou.getName())
console.log(YaDu.getName())

2、工厂方法模式

百度百科的解释：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

数据梳理细节化。

// 工厂方法模式
function Human(sex, name) {
    // 男女类别
    if(this instanceof Human) {
        return new this[sex](name)
    } else {
        return new Human(sex, name)
    }
}

Human.prototype = {
    man: function (name) { 
        return {
            name: name,
            sex: 'man'
        }
     },
     woman: function(name) {
        return {
            name: name,
            sex: 'woman'
        }
     }
}

var JunZou = new Human('man', 'JunZou') "{name: "JunZou", sex: "man"}"
var Meng = new Human('woman', 'Meng')  "{name: "Meng", sex: "woman"}"

3、抽象工厂模式

“毒牙君，我只给你一本书，让你记录你的生活。你如果一点记录的话，一切都是原状。生活，就是这么的不主动。”

百度百科的解释：客户类和工厂类分开。消费者任何时候需要某套产品集合时，只需向抽象工厂请求即可。抽象工厂会再向具体的工厂生产出符合产品集规格的产品。

var User = function(subType, superType) {
    if(typeof User[superType] === "function") {
        let F = function() {}
        F.prototype = new User[superType]()
        subType.prototype = new F()
        subType.constructor = subType
    } else {
        throw new Error("抽象类不存在")
    }
}

User.Coder = function() {
    this.user = 'coder'
}

User.Coder.prototype = {
    getName: function() {
        return new Error("抽象方法需要覆盖")
    }
}

User.User = function() {
    this.user = 'user'
}

User.User.prototype = {
    getName: function() {
        return new Error("抽象方法需要覆盖")
    }
}

// coder
var CoderObj = function(age) {
    this.name = name;
    this.age = age
}

// user
var UserObj = function(name, age) {
    this.name = name;
    this.age = age
}

/**
* -------
* | du |
* | ya |
* -------
*/
// CoderObj 继承 user['Coder']
User(CoderObj, 'Coder')

// 覆盖父类的方法
CoderObj.prototype.getName = function() {
    return this.name
}

// UserObj 继承 user['User']
User(UserObj, 'User')
// 覆盖父类的方法
UserObj.prototype.getName = function() {
    return this.user
}

var user1 = new UserObj('duYa')
var user2 = new UserObj('Ya Du')

console.log(user1.getName()) // "duYa"
console.log(user2.getName()) // "Ya Du"