How do Go interfaces work implicitly, and why is this different from Java/C# explicit interfaces?

Go Interfaces — Implicit Satisfaction

// Define interface
type Storer interface {
    Store(data []byte) error
    Retrieve(id string) ([]byte, error)
}

// Implement interface — NO "implements" keyword needed
type RedisStore struct { client *redis.Client }

func (r *RedisStore) Store(data []byte) error {
    return r.client.Set("key", data, 0).Err()
}

func (r *RedisStore) Retrieve(id string) ([]byte, error) {
    return r.client.Get(id).Bytes()
}

// RedisStore AUTOMATICALLY satisfies Storer
// Compiler checks at usage site, not definition site
var store Storer = &RedisStore{} // ✅ Compiles!

Why Implicit Is Better

AspectExplicit (Java)Implicit (Go)

CouplingInterface defined first, class references itDecoupled — interface user doesn't know about implementer
Third-partyCan't implement external interfacesCan create interfaces for third-party types
RefactoringMust update all implements declarationsJust match the method signatures
TestingNeed interface at definitionDefine interface at consumption site

The "Accept Interfaces, Return Structs" Rule

// ✅ Good: Accept interface for flexibility
func ProcessData(store Storer, data []byte) error {
    return store.Store(data)
}

// In tests:
type MockStore struct{}
func (m *MockStore) Store(data []byte) error { return nil }
func (m *MockStore) Retrieve(id string) ([]byte, error) { return nil, nil }

ProcessData(&MockStore{}, testData) // Easy mocking!

Empty Interface (interface{})

// Accepts ANY type (like Object in Java, any in TS)
func Print(v interface{}) {
    fmt.Println(v)
}

// Prefer typed interfaces or generics over interface{}

Type Assertion & Type Switch

func handle(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Println("String:", val)
    case int:
        fmt.Println("Int:", val)
    default:
        fmt.Println("Unknown:", val)
    }
}