设计模式
[TOC]
1、简单工厂模式
通过实例化对象创建
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 = new Object();
o.content = text;
o.show = function(){
//公共的代码
};
if(type =='alert'){
//这里添加弹出框的具体实现方式
}
if (type == 'propt') {
//这里添加输入框的具体实现方式
}
if (type == 'confirm') {
//这里添加确认框的具体实现方式
}
return o;
}
var userNameALert = createPop('alert','用户名只能是26个字母和数字');
2、工厂方法模式
将实际创建的对象工作推迟到子类当中。这样核心类就成了抽象类
安全模式类
安全类模式类屏蔽使用者对类的错误使用照成的错误，比如Demo类，我们必须要new Demo才可以，但是，为了防止人var d = Demo();这种操作带来的错误，我们需要兼容
var Demo = function (){
}
Demo.prototype = {
show:function(){
console.log('成功获取');
},
}
var d = new Demo();
d.show();
var e = Demo();
e.show();//TypeError: undefined is not an object (evaluating 'e.show')
如上，这个时候就会报错，所以我们需要这样写Demo
var Demo = function (){
if(!(this instanceof Demo)){
return new Demo();
}
}
安全的工厂方法
- 使用了安全模式类
- 工厂方法中，主方法通过type content灵活调用，不用switch,或者是if这样就能直接使用而不用在构造方法里也进行添加
var Factory = function(type,content){
if(this instanceof Factory){
var s = new this[type](content);
return s;
}
else{
return new Factory(type,content);
}
}
Factory.prototype = {
java:function(content){},
javascript:function(content){},
//...
}
3、抽象工厂模式
抽象工厂方法：
抽象类方法就是一个实现子类继承父类的方法，
//抽象工厂方法
var VehicleFactory = function(subType,superType){
//判断抽象工厂中是否有这个抽象类
if(typeof vehicleFactory[subType] == 'function'){
// 缓存
function F(){};
F.prototype = new vehicleFactory[subType]();
subType.constructor = subType;
subType.prototype = new F();
}else{
throw new Error("未创建该抽象类");
}
}
//小汽车的抽象方法
VehicleFactory.Car = function(){
this.type = "car";
}
VehicleFactory.Car.prototype = {
getPrice:function(){
throw new Error("抽象方法不能调用");
},
getSpeed:function(){
throw new Error("抽象方法不能调用")
}
}
//公共车的抽象方法
VehicleFactory.Bus = function () {
this.type = "Bus";
}
VehicleFactory.Bus.prototype = {
getPrice: function () {
throw new Error("抽象方法不能调用");
},
getSpeed: function () {
throw new Error("抽象方法不能调用")
}
}
抽象类的实现
//使用的方法：
var BMW = function(price,speed){
this.price = price;
this.speed = speed;
}
VehicleFactory(BMW,"Car");
BMW.prototype.getPrice = function(){
return this.price;
}
BWM.prototype.getSpeed = function(){
return this.getSpeed;
}
//调用的时候
var car = new BMW("1000",10);
console.log(car.getPrice());
console.log(car.getSpeed());
4、建造者模式
工厂模式我们得到的都是对象实例或者是类簇，建造者模式目的也是为了创建对象，但是更多的是关心创建这个对象的过程，甚至创建对象的每一个细节
我的理解：就是将每个属性封装成一个类
//创建一个人的类
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.wolename = 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":
that.work = "工程师";
that.workDescirpt = "编程";
break;
case "teacher":
that.work = "老师";
that.workDescirpt = "分享";
break;
case "UE":
that.work = "设计师";
that.workDescirpt = "设计";
break;
default :
that.work = work;
that.workDescirpt = "不知道你干嘛的";
}
}(work,that))
}
Work.prototype.changeWork = function(work){
this.work = work;
}
Work.prototype.changeWorkDescirpt = function (workDescirpt) {
this.workDescirpt = workDescirpt;
}
//创建应聘者，这个人创建一些属性，包括工作，名字之类的
var Persion = function(name,work){
var _Persion = new Human();
_Persion.work = new Worker(work);
_Persion.name = new Named(name);
return _Persion;
}
