add go for abstract

Author: jarry

abstract-factory/go/src/AbstractFactory.go

@@ -0,0 +1,21 @@
+package src
+
+import (
+  "./shop"
+
+  "./vehicle"
+)
+
+/*
+  意图：提供一个创建一系列相互依赖的接口，而无需指定它们具体的类。
+  主要作用：主要解决接口选择的问题。在一个对象家族系统里面里面，抽象定义多个产品对象。
+  何时使用：产品很多，形成产品系列，而系统只需要处理其中某一类的产品。
+  如何解决：在一个产品系列里面，定义多个产品对象。由抽象类来负责创建产品工厂。
+*/
+
+// 抽象工厂类，用来生成具体的工厂。Go里没有抽象类，用接口代替。
+type AbstractFactory interface {
+  GetVehicle(vehicleType string, name string) vehicle.Vehicle
+
+  GetShop(shopType string, name string) shop.Shop
+}

abstract-factory/go/src/FactoryCreator.go

@@ -0,0 +1,28 @@
+package src
+
+type FactoryCreator struct {
+}
+
+// 工厂生成器，返回同一业务不同种类的产品工厂
+func (f *FactoryCreator) GetFactory(factoryType string) AbstractFactory {
+  switch factoryType {
+  case "vehicle":
+    return &VehicleFactory{}
+  case "shop":
+    return &ShopFactory{}
+  default:
+    return nil
+  }
+}
+
+// 工厂生成器，返回同一业务不同种类的产品工厂，go没有static，可以用一个全局函数
+// func CreateFactory(name string) AbstractFactory {
+//   switch name {
+//   case "vehicle":
+//     return new(VehicleFactory)
+//   case "shop":
+//     return new(ShopFactory)
+//   default:
+//     return nil
+//   }
+// }

abstract-factory/go/src/ShopFactory.go

@@ -0,0 +1,35 @@
+package src
+
+import (
+  "./shop"
+  "./vehicle"
+)
+
+type ShopFactory struct {
+}
+
+func (s *ShopFactory) GetShop(shopType string, name string) shop.Shop {
+  switch shopType {
+  case "AgencyShop":
+    return &shop.AgencyShop{
+      Name: name,
+    }
+  case "DirectSaleShop":
+    return &shop.DirectSaleShop{
+      Name: name,
+    }
+  case "SupermarketShop":
+    return &shop.SupermarketShop{
+      Name: name,
+    }
+  default:
+    return &shop.AgencyShop{
+      Name: name,
+    }
+  }
+}
+
+func (s *ShopFactory) GetVehicle(vehicleType string, name string) vehicle.Vehicle {
+  // ignored, this function for Vehicle
+  return nil
+}

abstract-factory/go/src/VehicleFactory.go

@@ -0,0 +1,45 @@
+package src
+
+import (
+  "./shop"
+
+  "./vehicle"
+)
+
+const (
+  VehicleType_BUS        = "bus"
+  VehicleType_CAR        = "car"
+  VehicleType_MOTORCYCLE = "motorcycle"
+  VehicleType_VAN        = "van"
+)
+
+type VehicleFactory struct {
+}
+
+func (v *VehicleFactory) GetVehicle(vehicleType string, name string) vehicle.Vehicle {
+  switch vehicleType {
+  case VehicleType_BUS:
+    return &vehicle.Bus{
+      Name: name,
+    }
+  case VehicleType_CAR:
+    return &vehicle.Car{
+      Name: name,
+    }
+  case VehicleType_MOTORCYCLE:
+    return &vehicle.Motorcycle{
+      Name: name,
+    }
+  case VehicleType_VAN:
+    return &vehicle.Van{
+      Name: name,
+    }
+  default:
+    return nil
+  }
+}
+
+func (v *VehicleFactory) GetShop(shopType string, name string) shop.Shop {
+  // ignored, this function for Shop
+  return nil
+}

abstract-factory/go/src/go.mod

@@ -0,0 +1,3 @@
+module src
+
+go 1.15

abstract-factory/go/src/shop/AgencyShop.go

@@ -0,0 +1,17 @@
+package shop
+
+import (
+  "fmt"
+)
+
+type AgencyShop struct {
+  Name string
+}
+
+func (a *AgencyShop) GetName() string {
+  return a.Name
+}
+
+func (a *AgencyShop) Greetings() {
+  fmt.Println("AgencyShop::Greetings [Name=" + a.GetName() + "]")
+}

abstract-factory/go/src/shop/DirectSaleShop.go

@@ -0,0 +1,21 @@
+package shop
+
+import (
+  "fmt"
+)
+
+type DirectSaleShop struct {
+  Name string
+}
+
+func (d *DirectSaleShop) GetName() string {
+  return d.Name
+}
+
+func (d *DirectSaleShop) Greetings() {
+  fmt.Println("DirectSaleShop::Greetings [Name=" + d.GetName() + "]")
+}
+
+func (d *DirectSaleShop) Welcome() {
+  fmt.Println("DirectSaleShop::Welcome [Name=" + d.GetName() + "]")
+}

abstract-factory/go/src/shop/Shop.go

@@ -0,0 +1,7 @@
+package shop
+
+// 具体产品接口类，规范某类产品的行为
+type Shop interface {
+  GetName() string
+  Greetings()
+}

abstract-factory/go/src/shop/SupermarketShop.go

@@ -0,0 +1,17 @@
+package shop
+
+import (
+  "fmt"
+)
+
+type SupermarketShop struct {
+  Name string
+}
+
+func (s *SupermarketShop) GetName() string {
+  return s.Name
+}
+
+func (s *SupermarketShop) Greetings() {
+  fmt.Println("SupermarketShop::Greetings [Name=" + s.GetName() + "]")
+}

abstract-factory/go/src/vehicle/Bus.go

@@ -0,0 +1,18 @@
+package vehicle
+
+import (
+  "fmt"
+)
+
+// 具体产品实现类
+type Bus struct {
+  Name string
+}
+
+func (b Bus) GetName() string {
+  return b.Name
+}
+
+func (b *Bus) Run() {
+  fmt.Println("Bus::Run() [Name=" + b.Name + "]")
+}

abstract-factory/go/src/vehicle/Car.go

@@ -0,0 +1,18 @@
+package vehicle
+
+import (
+	"fmt"
+)
+
+// 具体产品实现类
+type Car struct {
+	Name string
+}
+
+func (c Car) GetName() string {
+	return c.Name
+}
+
+func (c *Car) Run() {
+	fmt.Println("Car::Run() [Name=" + c.Name + "]")
+}

abstract-factory/go/src/vehicle/Motorcycle.go

@@ -0,0 +1,18 @@
+package vehicle
+
+import (
+  "fmt"
+)
+
+// 具体产品实现类
+type Motorcycle struct {
+  Name string
+}
+
+func (m Motorcycle) GetName() string {
+  return m.Name
+}
+
+func (m *Motorcycle) Run() {
+  fmt.Println("Motorcycle::Run() [Name=" + m.Name + "]")
+}

abstract-factory/go/src/vehicle/Van.go

@@ -0,0 +1,18 @@
+package vehicle
+
+import (
+  "fmt"
+)
+
+// 具体产品实现类
+type Van struct {
+  Name string
+}
+
+func (v Van) GetName() string {
+  return v.Name
+}
+
+func (v *Van) Run() {
+  fmt.Println("Van::Run() [Name=" + v.Name + "]")
+}

abstract-factory/go/src/vehicle/Vehicle.go

@@ -0,0 +1,7 @@
+package vehicle
+
+// 具体产品接口类，规范某类产品的行为
+type Vehicle interface {
+	GetName() string
+	Run()
+}

abstract-factory/go/test/test.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+  "fmt"
+
+  "../src"
+  "../src/shop"
+)
+
+// main包下的main入口方法
+func main() {
+  fmt.Println("test start:")
+  /**
+   * 抽象工厂就是把生产产品的工厂也根据统一的抽象工厂来创建，
+   * 这样不同类型的工厂可以在统一的约束下，整体上看更新加清晰。
+   * 当声明工厂时可以通过抽象类型或具体工厂来声明，然后依据工厂来生产不同的产品。
+   */
+
+  // 通过工厂建造类获得指定工厂
+  var FactoryCreator = &src.FactoryCreator{}
+  var vehicleFactory = FactoryCreator.GetFactory("vehicle")
+
+  // 获取Bus对象，并调用它的 run 方法
+  var bus = vehicleFactory.GetVehicle(src.VehicleType_BUS, "bus")
+  bus.Run()
+
+  // 获取Car对象，并调用它的 run 方法
+  var car = vehicleFactory.GetVehicle(src.VehicleType_CAR, "car")
+  car.Run()
+
+  // 获取Motorcycle对象，并调用它的 run 方法
+  var motorcycle = vehicleFactory.GetVehicle(src.VehicleType_MOTORCYCLE, "motorcycle")
+  motorcycle.Run()
+
+  // 获取Motorcycle对象，并调用它的 run 方法
+  var van = vehicleFactory.GetVehicle(src.VehicleType_VAN, "van")
+  van.Run()
+
+  // /*********************** 分割线 ******************************************/
+
+  // 再次声明商店工厂
+  var shopFactory = FactoryCreator.GetFactory("shop")
+  // 从商店工厂获取商店对象
+  var supermarketShop = shopFactory.GetShop("SupermarketShop", "shop")
+  // 调用商店的方法
+  supermarketShop.Greetings()
+
+  // /*********************** 分割线 ******************************************/
+
+  // 再声明一个商店工厂
+  var shopFactory2 = FactoryCreator.GetFactory("shop")
+  var directSaleShop = shopFactory2.GetShop("DirectSaleShop", "directSaleShop")
+  directSaleShop.Greetings()
+  // 直接类型转换失败
+  // var directSaleShop1 = shop.DirectSaleShop(directSaleShop)
+  // directSaleShop1.Welcome()
+  // 通过类型断言实现类型转换
+  var directSaleShop1 = directSaleShop.(*shop.DirectSaleShop)
+  directSaleShop1.Welcome()
+}
+
+/*
+jarry@jarrys-MacBook-Pro go % go build src/*.go
+jarry@jarrys-MacBook-Pro go % go run test/test.go
+test start:
+Bus::Run() [Name=bus]
+Car::Run() [Name=car]
+Motorcycle::Run() [Name=motorcycle]
+Van::Run() [Name=van]
+SupermarketShop::Greetings [Name=shop]
+DirectSaleShop::Greetings [Name=directSaleShop]
+DirectSaleShop::Welcome [Name=directSaleShop]
+*/

abstract-factory/java/src/shop/AgencyShop.java

@@ -1,5 +1,6 @@
 package src.shop;
 
+// 具体产品类，实现抽象产品接口
 public class AgencyShop implements Shop {
   @Override
   public void greetings() {

abstract-factory/java/src/shop/DirectSaleShop.java

@@ -1,7 +1,13 @@
 package src.shop;
+
+// 具体产品类，实现抽象产品接口
 public class DirectSaleShop implements Shop {
   @Override
   public void greetings() {
      System.out.println("DirectSaleShop::greetings().");
   }
+
+  public void welcome() {
+     System.out.println("DirectSaleShop::welcome().");
+  }
 }

abstract-factory/java/src/shop/Shop.java

@@ -1,4 +1,5 @@
 package src.shop;
+// 具体产品的接口，约束具体产品的行为
 public interface Shop {
   void greetings();
 }

abstract-factory/java/src/shop/SupermarketShop.java

@@ -1,4 +1,6 @@
 package src.shop;
+
+// 具体产品类，实现抽象产品接口
 public class SupermarketShop implements Shop {
   @Override
   public void greetings() {