海面模拟（一）

简单工厂

  简单工厂的实现思想，即创建一个工厂，将产品的实现逻辑集中在这个工厂中。

/***
 *	Simple Factory
 */
type FoodFactory struct {
}

func (ff FoodFactory) CreateFood(name string) Food {
	var s Food;
	switch name {
	case "Meat":
		s = new(Meat);
	case "Hamberger":
		s = new(Hamberger)
	}
	return s;
}

type Food interface {
	Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
	fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
	fmt.Println("Eat Hamberger.")
}

func main(){

	// Simple Factory
	f := FoodFactory{}
	f.CreateFood("Meat").Eat()
	f.CreateFood("Hamberger").Eat()
}

工厂方法

  工厂方法用于弥补简单工厂的不足之处:

• 当新增一种产品的时候，需要修改工厂逻辑
  
• 简单工厂没有继承的结构
  
• 一旦工厂瘫痪，整个系统都瘫痪
  

  工厂方法将产品的创建逻辑写在子类之中,代码如下

/***
 *	Factory Method
 */
type Factory interface {
	Create() Food
}

type MeatFactory struct {
}

func (mf MeatFactory) Create() Food {
	m := Meat{}
	return m
}

type HambergerFactory struct{

}

func (hf HambergerFactory) Create() Food {
	h := Hamberger{}
	return h
}

type Food interface {
	Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
	fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
	fmt.Println("Eat Hamberger.")
}

func main(){
	// Factory Method
	mf := MeatFactory{}
	mf.Create().Eat()
	hf := HambergerFactory{}
	hf.Create().Eat()
}

抽象工厂

  抽象工厂是针对一个产品族而言的.

  产品族就好像套餐.一个套餐包含了好几种食品，而每一种食品都是一种类型的食物。举个例子.

  一个套餐定义为食品和饮料.而有一家餐馆的食品包括肉和汉堡，饮料包括CoCo和茶.这家餐馆不想单独出售某种食品和饮料，只卖套餐.

  于是老板定义:

• 套餐A:肉和CoCo
  
• 套餐B:汉堡和茶
  

  定好了之后,把套餐A外包给工厂A负责生产，套餐B外包给工厂B负责生产。两个工厂根据这家店的需求，实习那了生产食品和生产饮料的方法。A工厂就负责A套餐，那么他就需要实现生产肉的逻辑和生产CoCo的逻辑即可.而B工厂只需要实现生产汉堡和生产茶的逻辑即可.

  这样以来，来到店里的客人，只需要订购套餐，服务员通知工厂生产并送达即可。假设一个客人要套餐A，服务员通知工厂A，先生产一个肉，再来一杯CoCo，服务员负责把这些产品递给客人食用即可。

/***
 *	Abstract Factory
 */

type HJXFactory interface{
	CreateFood()Food
	CreateDrink()Drink
}

type FactoryA struct {

}

func (af FactoryA)CreateFood()Food{
	f := Meat{}
	return f
}

func (af FactoryA)CreateDrink()Drink{
	d := CoCo{}
	return d
}

type FactoryB struct {

}

func (bf FactoryB)CreateFood()Food{
	f := Hamberger{}
	return f
}

func (bf FactoryB)CreateDrink()Drink{
	d := Tea{}
	return d
}
type Food interface {
	Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
	fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
	fmt.Println("Eat Hamberger.")
}

type Drink interface{
	Drink()
}

type CoCo struct{

}

func (cc CoCo)Drink(){
	fmt.Println("Drink CoCo")
}

type Tea struct{

}

func (t Tea)Drink(){
	fmt.Println("Drink Tea")
}
func main(){
	// Abstract Factory
	fa := FactoryA{}
	fa.CreateFood().Eat()
	fa.CreateDrink().Drink()

	fb := FactoryB{}
	fb.CreateFood().Eat()
	fb.CreateDrink().Drink()
}

Author: 寒江雪
Date:2018-03-08

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以邮件