Go接口嵌套

Go接口支持嵌入其他接口，组合形成更大接口。

接口嵌入语法

基本嵌入

// 定义基础接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// 组合接口：嵌入其他接口
type ReadWriter interface {
    Reader  // 嵌入Reader
    Writer  // 嵌入Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

嵌入接口后，组合接口包含所有嵌入接口的方法。

组合接口方法

方法集合

// ReadWriter包含Reader和Writer的方法
type ReadWriter interface {
    Reader  // Read方法
    Writer  // Write方法
}

// ReadWriter方法集：{Read, Write}

// 实现ReadWriter需实现Read和Write
type MyRW struct{}

func (m MyRW) Read(p []byte) (int, error) {
    return len(p), nil
}

func (m MyRW) Write(p []byte) (int, error) {
    return len(p), nil
}

var rw ReadWriter = MyRW{}

多层嵌套

type Reader interface {
    Read(p []byte) (int, error)
}

type Writer interface {
    Write(p []byte) (int, error)
}

type Closer interface {
    Close() error
}

type Seeker interface {
    Seek(offset int64, whence int) (int64, error)
}

// 多接口组合
type ReadWriteSeekCloser interface {
    Reader
    Writer
    Seeker
    Closer
}

// 方法集：{Read, Write, Seek, Close}

标准库组合示例

io包组合接口

// 标准库io包的接口组合
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// io.ReadWriter
type ReadWriter interface {
    Reader
    Writer
}

// io.ReadCloser
type ReadCloser interface {
    Reader
    Closer
}

// io.WriteCloser
type WriteCloser interface {
    Writer
    Closer
}

// io.ReadWriteCloser
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

实际类型满足组合接口

// os.File满足多个组合接口
file, _ := os.Open("data.txt")

// File满足：Reader, Writer, Closer, ReadWriter, ReadCloser...
var r io.Reader = file        // ✓
var w io.Writer = file        // ✓
var c io.Closer = file        // ✓
var rw io.ReadWriter = file   // ✓
var rc io.ReadCloser = file   // ✓

嵌套与添加方法

组合+新方法

type Reader interface {
    Read(p []byte) (int, error)
}

// 组合Reader并添加新方法
type ExtendedReader interface {
    Reader           // 嵌入
    ReadAll() []byte // 新增方法
}

// 实现ExtendedReader需实现Read和ReadAll
type MyExtendedReader struct{}

func (m MyExtendedReader) Read(p []byte) (int, error) {
    return len(p), nil
}

func (m MyExtendedReader) ReadAll() []byte {
    return []byte{}
}

接口嵌套规则

嵌入接口名

type ReadWriter interface {
    Reader  // 嵌入接口名
    Writer  // 嵌入接口名
}

// 不写方法签名，只写接口名

嵌入顺序无关

// 嵌入顺序不影响方法集
type A interface {
    Reader
    Writer
}

type B interface {
    Writer
    Reader
}

// A和B方法集相同

方法不能重复

// 错误：方法名重复
type Bad interface {
    Reader
    BadReader  // 如果BadReader也有Read方法，冲突
}

接口组合优势

分层设计

// 小接口组合成大接口
// 用户按需使用

func processReader(r Reader) {
    // 只需Read
}

func processReadWriter(rw ReadWriter) {
    // 需Read和Write
}

func processReadWriteCloser(rwc ReadWriteCloser) {
    // 需全部功能
}

满足规则

// 类型满足小接口也满足组合接口

type MyType struct{}

func (m MyType) Read() {}
func (m MyType) Write() {}
func (m MyType) Close() {}

// MyType满足：Reader, Writer, Closer
// MyType满足：ReadWriter, ReadCloser, WriteCloser
// MyType满足：ReadWriteCloser

接口组合表

要点总结

• 接口嵌入其他接口形成组合接口
• 嵌入语法：接口名写在interface{}内
• 组合接口包含所有嵌入接口的方法
• 实现组合接口需实现所有嵌入方法
• 标准库io包大量使用接口组合
• 嵌入顺序无关，方法集相同
• 满足小接口也满足组合接口
• 组合接口用于分层设计，按需使用
• 小接口组合设计更灵活