接口与结构体方法对比及Go语言接口实现代码解析咨询

Hey there! Let's start by fixing up your incomplete code (since the for loop was cut off) and then break down both the code itself and the key differences between interfaces and struct methods in Go.

First, Let's Complete & Explain Your Code #

Here's the full, runnable version of your code with comments explaining each part:

package main
import (
    "math"
    "fmt"
)

// Circle is a struct that encapsulates the properties of a circle: center coordinates (x,y) and radius r
type Circle struct {
    x, y, r float64
}

// Rectangle is a struct that holds the coordinates of two opposite corners of a rectangle
type Rectangle struct {
    x1, y1, x2, y2 float64
}

// Figure is an interface that defines a single behavior: calculating area
// Any type that implements an Area() method with this signature automatically satisfies this interface
type Figure interface {
    Area() float64
}

// This is a struct method bound to the *Circle pointer type
// It implements the Area() method required by the Figure interface
func (c *Circle) Area() float64 {
    return math.Pi * c.r * c.r
}

// This is a struct method bound to the *Rectangle pointer type
// It also implements the Figure interface's Area() method
func (r *Rectangle) Area() float64 {
    width := math.Abs(r.x2 - r.x1)
    height := math.Abs(r.y2 - r.y1)
    return width * height
}

func main() {
    // Create a slice that holds any type satisfying the Figure interface
    figures := make([]Figure, 0)
    // Add instances of *Circle and *Rectangle to the slice (since their pointer types implement Figure)
    figures = append(figures, &Circle{0, 0, 10})
    figures = append(figures, &Rectangle{0, 0, 10, 20})
    
    // Iterate over the slice and call Area() on each Figure
    // Thanks to interfaces, we don't need to check the concrete type of each element
    for _, fig := range figures {
        fmt.Printf("Calculated Area: %.2f\n", fig.Area())
    }
}

Key Code Takeaways: #

• Structs are Go's way of defining custom data types that bundle related properties (like a circle's radius or a rectangle's corner coordinates).
• Struct methods are functions tied to a specific struct type (or its pointer) that add behavior to that type. Here, Area() gives each shape the ability to calculate its own area.
• Interfaces act as a behavioral contract: they define what methods a type must have, but not how those methods are implemented. Go uses "duck typing" here—if a type has all the methods an interface defines, it automatically implements that interface (no explicit implements keyword needed).
• The []Figure slice demonstrates polymorphism: we can store different concrete types (Circle, Rectangle) in the same collection and treat them uniformly by calling the interface's method.

Core Differences Between Interfaces & Struct Methods #

Let's break down the fundamental distinctions:

1. Definition & Purpose #

• Struct Methods: These are concrete implementations of behavior tied directly to a specific type. They exist to add functionality to a struct (or any custom type) — think of them as "actions" a specific data structure can perform.
• Interfaces: These are abstract contracts that define a set of method signatures. They don't implement any logic themselves; their job is to group types that share the same behavior, enabling flexible, reusable code.

2. Binding & Resolution #

• Struct Methods: Method calls are statically bound at compile time. When you call c.Area() where c is a *Circle, the compiler knows exactly which method to run before the program executes.
• Interfaces: Method calls are dynamically bound at runtime. When you call fig.Area() where fig is a Figure interface, the program looks up the concrete type of fig at runtime and runs the corresponding Area() implementation.

3. Use Cases #

• Struct Methods: Use these when you need to add type-specific functionality. For example, adding a Circumference() method only to Circle, or a Diagonal() method only to Rectangle.
• Interfaces: Use these when you need to handle multiple types uniformly. For example, if you wanted to add a Perimeter() method to Figure, any type implementing Figure could add its own Perimeter() logic, and your existing code that processes []Figure slices would work without modification.

4. Relationship to Each Other #

• Struct methods are the building blocks of interface implementation: a type can only satisfy an interface if it implements all the methods defined by that interface.
• Interfaces are the abstraction layer over struct methods: they let you write code that depends on behavior rather than concrete types, making your code easier to extend and test.

内容的提问来源于stack exchange，提问作者rtut