设计模式-工厂模式

工厂方法模式

多了工厂类的概念

要想创建产品，需要先创建该产品的工厂的实例，通过工厂来创建产品

抽象工厂模式

抽象工厂中，一个工厂可以创建多种产品，例如 我们创建一个 Java，他是跨平台的，我们需要创建他的图标需要创建他的按钮等等等等....,我们就要创建抽象工厂方法，方法中声明了 Java 中的一切所需要实现的方法，当我们在 苹果电脑上是，我们创建苹果电脑的java工厂，继承我们的抽象工厂类，并实现其中所有的虚函数，在windwos电脑上时也同样这么操作

简单工厂

class Plant {

constructor(name) {

this.name = name;

}

grow() {

console.log("正在生长~~~");

}

}

class Apple extends Plant {

constructor(name, flavour) {

super(name);

this.flavour = flavour;

}

}


class Orange extends Plant {

constructor(name, flavour) {

super(name);

this.flavour = flavour;

}

}

// 可以直接创建实例

// 这种方式的缺点:

// 高耦合度,也就是必须知道我要new的类在哪里

// 依赖具体的实现,必须知道是什么类也不能对类进行修改删除

// new Apple()

// new Orange()

/***

* @p 简单工厂模式

* @f1 不关心实例创建的具体实现，我们只需要一个直面自己的工厂，我们要什么按照他们的要求给他们说什么

* @f2 不在出现高度耦合性，例如我们把类的实现更改后，或者删除了，如果直接new 的情况下，可能就直接报错编译失败了，但是简单工厂后，

* 我们只需要增减简单工厂的对应实现判断即可，如果不存在则会抛出信息，不会导致编译失败

*/

class Factory {

static create(type) {

switch (type) {

case "apple":

return new Apple("苹果", "甜甜的");

case "orange":

return new Orange("橘子", "酸酸的");

default:

throw new Error("你要的东西不存在");

}

}

}


let apple = Factory.create("apple");

console.log(apple.flavour);

let orange = Factory.create("orange");

console.log(orange.flavour);


/**

* @p 应用场景

* @f JQuery

*/


class JQuery {

constructor(selector) {

this.selector = selector;

this.element = document.querySelectorAll(this.selector);

this.length = this.element.length;

for (let i = 0; i < this.length; i++) {

this[i] = this.element[i];

}

}

html(content) {

if (!content) {

return this[0].innerHTML;

}

this[0].html = content;

}

css(styleObj) {

if (!styleObj) {

return;

}

let style = "";

for (let key in styleObj) {

style += `${key}: ${styleObj[key]};`;

}

let ele = document.createElement("style");

let head = document.querySelector("head");

ele.innerText = `{${style}}`;

head.appendChild(ele);

}

}

let $ = function (selector) {

return new JQuery(selector);

};



console.log($("li")[0]);

$("li").css({

color: "red",

});

工厂方法

/***

* @p 工厂方法模式

* @f1 又称多态性工厂模式

* @f2 在该模式中，核心的工厂类不在负责所有的产品创建，而是将具体的创建工作交给子类去做

*/

// 水果类

class Plant {

  constructor(name) {

    this.name = name;

  }

  grow() {

    console.log("正在生长");

  }

}

class Apple extends Plant {

constructor(name, flaver) {

super(name);

this.flaver = flaver;

}

}


// 创建水果的工厂,父类相当于接口，子类继承父类必须实现父类中的所有方法

class Factory {

create(){}

}


class AppleFactory extends Factory {

static create() {

return new Apple("苹果", "甜甜的");

}

}


// 这样如果我们需要新的水果了，我们不需要修改老代码了，我们只需要添加新的水果类实现，和创建水果的工厂类即可

let apple = AppleFactory.create()

console.log(apple)

抽象工厂方法

/**

* @p 抽象工厂模式是指当有多个角色(产品)时，使用的一种工厂模式

* @f 抽象工厂模式可以向客户端提供一个接口，是客户端不必指定产品的具体情况下，创建多个产品族中的产品对象

* @f 也就是说，在一个工厂可以创建一个包含了多个类的实例对象

*/ 


// 例如创建一个绘制图标和按钮的工厂

class Factory {

createIcon() {}

createButton() {}

} 

// 创建一个图表类

class Icon {} 


// 创建苹果和window 的子类

class AppIcon {

render() {

console.log("绘制苹果图标");

}

}

class WinIcon {

render() {

console.log("绘制windows的图标");

}

} 


// 创建一个 按钮类

class Button {} 


class AppleButton {

render() {

console.log("绘制苹果按钮");

}

}

class WinButton {

render() {

console.log("绘制windows按钮");

}

} 


// 创建苹果和window工厂类的子类

class AppleFactory extends Factory {

createButton() {

return new AppleButton();

}

createIcon() {

return new AppIcon();

}

}
 


class WinFactory extends Factory {

createButton() {

return new WinButton();

}

createIcon() {

return new WinIcon();

}

} 


// 实例化

/**

* Java是跨平台的

* 1. 绘制一个图标

* 2. 绘制一个按钮

*/ 


let windowsFactory = new WinFactory();

windowsFactory.createButton().render();

windowsFactory.createIcon().render(); 


let appleFactory = new AppleFactory();

appleFactory.createButton().render();

appleFactory.createIcon().render();