Композиция интерфейсов

Часть раздела Объектно-ориентированное программирование путешествия по GO на Coddy — урок 31 из 107.

Go позволяет создавать более крупные интерфейсы путем композиции более мелких. Вместо того чтобы определять один большой интерфейс со множеством методов, вы встраиваете существующие интерфейсы внутрь определения нового интерфейса.

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter объединяет оба интерфейса
type ReadWriter interface {
    Reader
    Writer
}

Интерфейс ReadWriter теперь требует наличия обоих методов: Read() и Write(). Любой тип, реализующий оба метода, удовлетворяет интерфейсу ReadWriter, а также интерфейсам Reader и Writer по отдельности.

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File удовлетворяет ReadWriter
}

Этот подход на основе композиции позволяет сохранять интерфейсы небольшими и узкоспециализированными. Вы можете комбинировать их по мере необходимости, создавая точные контракты для ваших функций. Стандартная библиотека Go широко использует этот паттерн, например, io.ReadWriter, который объединяет io.Reader и io.Writer.

Задание

Легко

Давайте создадим систему медиаплеера, которая демонстрирует композицию интерфейсов. Вы создадите небольшие специализированные интерфейсы, а затем объедините их в более мощный составной интерфейс, которому может соответствовать один тип.

Вы организуете свой код в двух файлах:

media.go: Определите три интерфейса и структуру, которая реализует их все:
- Интерфейс Player с методом Play() string
- Интерфейс Recorder с методом Record(content string) string
- Интерфейс MediaDevice, который объединяет в себе Player и Recorder
- Структуру SmartDevice с полем Name, которая реализует все необходимые методы
main.go: Создайте функции, демонстрирующие, как одно и то же устройство SmartDevice может использоваться через различные типы интерфейсов. Напишите три функции:
- UsePlayer, которая принимает Player и вызывает его метод Play
- UseRecorder, которая принимает Recorder и строку контента, затем вызывает Record
- UseMediaDevice, которая принимает MediaDevice и строку контента, затем вызывает и Record, и Play
Считайте имя устройства и контент из входных данных, создайте SmartDevice и продемонстрируйте его использование через все три типа интерфейсов.

Будут предоставлены следующие входные данные:

Строка 1: Имя устройства
Строка 2: Контент для записи

Ваши методы должны возвращать строки в следующих форматах:

Play(): [Name] is playing
Record(content): [Name] recorded: [content]

Например, для MyPhone и voice memo ваш вывод должен быть следующим:

MyPhone is playing
MyPhone recorded: voice memo
MyPhone recorded: voice memo
MyPhone is playing

Первые две строки показывают устройство, используемое через отдельные интерфейсы (Player и Recorder). Последние две строки показывают его использование через составной интерфейс MediaDevice, который требует наличия обеих возможностей. Обратите внимание, как ваш единственный SmartDevice удовлетворяет всем трем интерфейсам, так как он обладает обоими необходимыми методами.

Шпаргалка

Go позволяет создавать более крупные интерфейсы путем композиции более мелких, встраивая существующие интерфейсы в определение нового интерфейса:

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter объединяет оба интерфейса
type ReadWriter interface {
    Reader
    Writer
}

Любой тип, реализующий все методы встроенных интерфейсов, удовлетворяет составному интерфейсу:

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File удовлетворяет ReadWriter
}

Тип, реализующий составной интерфейс, также удовлетворяет каждому из отдельных встроенных интерфейсов. Такой подход к композиции позволяет сохранять интерфейсы небольшими и узкоспециализированными, в то же время позволяя создавать точные контракты для ваших функций.

Попробуйте сами

package main

import (
	"bufio"
	"fmt"
	"os"
)

// TODO: Реализовать UsePlayer, которая принимает Player и вызывает его метод Play
// Она должна выводить результат Play()

// TODO: Реализовать UseRecorder, которая принимает Recorder и строку content
// Она должна выводить результат Record(content)

// TODO: Реализовать UseMediaDevice, которая принимает MediaDevice и строку content
// Она должна выводить результат Record(content), а затем Play()

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	deviceName := scanner.Text()
	
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Создать SmartDevice с заданным именем
	
	// TODO: Использовать устройство через интерфейс Player
	
	// TODO: Использовать устройство через интерфейс Recorder
	
	// TODO: Использовать устройство через интерфейс MediaDevice
	
	_ = deviceName
	_ = content
	fmt.Println("Implement the solution")
}