Go语言接口中的构造器模式：理解与实现策略

package shape

type Shape interface {
    Area() float64 // 接口只定义行为
    // New() Shape // 错误：接口不能包含构造方法
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

package shape

// ... (Shape interface, Rectangle, Circle structs and Area methods as above) ...

// NewRectangle 是 Rectangle 类型的构造函数
func NewRectangle(width, height float64) *Rectangle {
    return &Rectangle{Width: width, Height: height}
}

// NewCircle 是 Circle 类型的构造函数
func NewCircle(radius float64) *Circle {
    return &Circle{Radius: radius}
}

// 使用示例
func main() {
    rect := NewRectangle(10, 5)
    fmt.Printf("Rectangle Area: %.2f\n", rect.Area()) // 输出: Rectangle Area: 50.00

    circle := NewCircle(7)
    fmt.Printf("Circle Area: %.2f\n", circle.Area()) // 输出: Circle Area: 153.94
}

package shape

import "fmt"

// ... (Shape interface, Rectangle, Circle structs and Area methods as above) ...

// NewShape 是一个工厂函数，根据类型字符串创建并返回 Shape 接口实例
func NewShape(shapeType string, params ...float64) (Shape, error) {
    switch shapeType {
    case "rectangle":
        if len(params) < 2 {
            return nil, fmt.Errorf("rectangle requires width and height")
        }
        return &Rectangle{Width: params[0], Height: params[1]}, nil
    case "circle":
        if len(params) < 1 {
            return nil, fmt.Errorf("circle requires radius")
        }
        return &Circle{Radius: params[0]}, nil
    default:
        return nil, fmt.Errorf("unknown shape type: %s", shapeType)
    }
}

// 使用示例
func main() {
    rectShape, err := NewShape("rectangle", 10, 5)
    if err != nil {
        fmt.Println("Error creating rectangle:", err)
    } else {
        fmt.Printf("Shape (Rectangle) Area: %.2f\n", rectShape.Area())
    }

    circleShape, err := NewShape("circle", 7)
    if err != nil {
        fmt.Println("Error creating circle:", err)
    } else {
        fmt.Printf("Shape (Circle) Area: %.2f\n", circleShape.Area())
    }

    _, err = NewShape("triangle", 3, 4, 5)
    if err != nil {
        fmt.Println(err) // 输出: unknown shape type: triangle
    }
}

package shape

import (
    "fmt"
    "reflect"
)

// ... (Shape interface, Rectangle, Circle structs and Area methods as above) ...

// NewShapeInstance 是一个泛型工厂函数，它接收一个 Shape 接口实例作为原型，
// 并返回一个该原型底层具体类型的零值新实例。
func NewShapeInstance(s Shape) (Shape, error) {
    if s == nil {
        return nil, fmt.Errorf("prototype shape cannot be nil")
    }

    // 获取原型实例的反射值
    val := reflect.ValueOf(s)
    // 如果是指针类型，则获取其指向的元素
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    // 使用 reflect.New 创建一个该类型的新指针实例
    // 然后通过 .Elem() 获取其指向的零值结构体
    newVal := reflect.New(val.Type()).Elem()

    // 将新的零值实例转换为接口类型
    // 需要断言回 Shape 接口，如果类型不匹配会panic
    if newInstance, ok := newVal.Addr().Interface().(Shape); ok { // Addr() 获取指针，然后转换为接口
        return newInstance, nil
    }
    return nil, fmt.Errorf("failed to assert new instance to Shape interface")
}

// 使用示例
func main() {
    // 创建一个 Rectangle 原型
    rectPrototype := Rectangle{Width: 10, Height: 5}
    // 使用泛型工厂创建新的零值 Rectangle 实例
    newRect, err := NewShapeInstance(rectPrototype)
    if err != nil {
        fmt.Println("Error creating new rectangle instance:", err)
    } else {
        fmt.Printf("New zero-valued Rectangle: %+v, Area: %.2f\n", newRect, newRect.Area()) // Area会是0.00
    }

    // 创建一个 Circle 原型
    circlePrototype := Circle{Radius: 7}
    // 使用泛型工厂创建新的零值 Circle 实例
    newCircle, err := NewShapeInstance(circlePrototype)
    if err != nil {
        fmt.Println("Error creating new circle instance:", err)
    } else {
        fmt.Printf("New zero-valued Circle: %+v, Area: %.2f\n", newCircle, newCircle.Area()) // Area会是0.00
    }
}