创建型设计模式

时间：2020-09-28 01:10:54 阅读：41 评论：0 收藏：0 [点我收藏+]

创建型设计模式

创建型设计模式是一类处理对象创建的设计模式，通过某种方式控制对象的创建来避免基本对象创建时可能导致设计上的问题或增加设计上的复杂度。

简单工厂模式（Simple Factory）:

又名静态工厂方法，由一个工厂对象决定创建某一种产品对象类的实例。主要用来创建同一类对象。

通过类实例化对象创建

var LoginAlert = function(text) {
    this.content = text;
};
LoginAlert.prototype.show = function() {
    // 显示警告信息
};

var LoginConfirm = function(text) {
    this.content = text;
};
LoginConfirm.prototype.show = function() {
    // 显示确认信息
};

var LoginPrompt = function(text) {
    this.content = text;
};
LoginPrompt.prototype.show = function() {
    // 显示提示信息
};
var PopFactory = function(name) {
    switch (name) {
        case "alert":
            return new LoginAlert();
        case "confirm":
            return new LoginConfirm();
        case "prompt":
            return new LoginPrompt();
    }
};

通过创建一个新对象然后包装增强其属性和功能来实现的

function CreatePop(type, text) {
    var o = Object.create();
    o.content = text;
    o.show = function() {
        //显示方法
    };
    if (type === "alert") {
        //警告框
    } else if (type === "confirm") {
        //确认框
    } else if (type === "prompt") {
        //提示框
    }
}

第一种是通过类实例化对象创建的，第二种是通过创建一个新对象然后包装增强其属性和功能来实现的，他们之间的差异性也造成前面通过类创建的对象，如果这些类集成同一父类，那么他们的父类原型岛上的方法是可以公用的。2而后面寄生方式创建的对象都是一个新的个体，所以他们的方法就不能共用了。

工厂方法模式（Factory Method）

通过对产品类的抽象使其创建业务主要负责用于创建多类产品的实例。(安全模式类是说可以屏蔽使用这对类的错误使用造成的错误。比如一个类的创建是需要new 关键字的，如果没有关键字此时我们得到的并不是我们预期的对象)

// 安全模式创建的工厂类
var Factory = function(type, content) {
    if (this instanceof Factory) {
        var s = new this[type](content);
    } else {
        return new Factory(type, conteny);
    }
};
//工厂原型中设置创建所有类型数据对象的基类
Factory.prototype = {
    Java: function(content) {
        // ....
    },
    Ui: function(content) {
        // ....
    },
    Php: function(content) {
        // ....
    },
    Javascript: function(content) {
        this.content = content;
        (function(content) {
            var div = document.createElement("div");
            div.innerHTML = content;
            div.style.border = "1px solid red";
            document.getElementById("container").appendChild(div);
        })(content);
    }
};

抽象工厂模式（Abstract Factory）

通过对类对工厂抽象使其业务用于对产品类簇的创建，而不负责创建某一类产品的实例

var VehicleFactory = function(subType, superType) {
    if (typeof VehicleFactory[superType] === "function") {
        function F() {}
        F.prototype = new VehicleFactory[superType]();
        subType.prototype = subType;
        subType.prototype = new F();
    } else {
        throw new Error("未创建该抽象类");
    }
};
// 小汽车抽象类
VehicleFactory.Car = function() {
    this.type = "car";
};
VehicleFactory.Car.prototype = {
    getPrice() {
        return new Error("抽象方法不能被使用");
    },
    getSpeed() {
        return new Error("抽象方法不能被使用");
    }
};
//公交车抽象类
VehicleFactory.Bus = function() {
    this.type = "car";
};
VehicleFactory.Bus.prototype = {
    getPrice() {
        return new Error("抽象方法不能被使用");
    },
    getSpeed() {
        return new Error("抽象方法不能被使用");
    }
};

//=======抽象与实现(让子类继承父类，是对子类对一个拓展)
var BMW = function(price, speed) {
    this.price = price;
    this.speed = speed;
};
VehicleFactory(BMW, "Car");
BMW.getPrice = function() {
    return this.price;
};
BMW.getSpeed = function() {
    return this.speed;
};

工厂模式之间的异同点：抽象工厂模式是设计模式忠最抽象的一种，也是创建模式中唯一一种抽象化创建模式。该模式创建出的结构不是一个真实的对象实例，而是一个类簇，它定制类的结构，这也就是区别与简单工厂模式创建单一对象，工厂方法模式创建多类对象。

建造者模式（Builder）

将一个复杂对象的构建层与其表示层相互分离，同样的构建过程可采用不同的表示

//创建一位人类
var Human = function(param) {
    this.skill = (param && param.skill) || "保密";
    this.hobby = (param && param.hobby) || "保密";
};
// 人类原型方法
Human.prototype = {
    getSkill: function() {
        return this.skill;
    },
    getHobby: function() {
        return this.hobby;
    }
};
//实例化姓名类
var Named = function(name) {
    var that = this;
    //构造器
    (function(name, that) {
        that.wholeName = name;
        if (name.indexOf(" ") > -1) {
            that.firstName = name.slice(0, name.indexOf(" "));
            that.secondName = name.slice(name.indexOf(" "));
        }
    })(name, that);
};
var Work = function(work) {
    var that = this;
    (function(work, that) {
        switch (work) {
            case "code":
                this.work = "工程师";
                this.workDescript = "每天沉醉与编程";
                break;
            case "UI":
            case "UE":
                this.work = "设计师";
                this.workDescript = "设计是一种艺术";
                break;
            default:
                this.work = work;
                this.workDescript = "对不起，我们不清楚您职位相关描述";
        }
    })(work, that);
};
Work.prototype.changeWork = function(work) {
    this.work = work;
};
Work.prototype.changeDescript = function(setence) {
    this, (workDescript = setence);
};

//========创建一位应聘者
var Person = function(name, work) {
    //创建应聘者缓存对象
    var _person = new Human();
    // 创建姓名解析对象
    _person.name = new Named(name);
    // 创建应聘者期望的职位
    _person.work = new Work(work);
    // 返回应聘者对象
    return _person;
};

var person = new Person(‘小明‘,‘code‘)

建造者模式中我们关心的是对象创建过程，因此我们通常将创建对象的类模块化，这样是被创建的类的每一个模块都可以得到灵活的运用与高质量的复用。

原型模式（Prototype）

原型模式就是将原型实例指向创建对象的类，适用于创建新的对象的类共享原型对象的属性以及方法。也是一种继承，

单例模式（Singleton）

又被成为单体模式，是只允许实例化一次的对象类。有时我们也用一个对象来规划一个命名空间，井井有条的管理对象上的属性与方法。

创建型设计模式

原文：https://www.cnblogs.com/yu-zeng/p/13737469.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)