[Go 再学習] Go の interface を理解する

package main

import (
	"fmt"
	"math"
)

// Shape インターフェースを定義する
// メソッドセットを持つ型はこのインターフェースを満たす
type Shape interface {
	Area() float64
	Perimeter() float64
}

type Circle struct {
	Radius float64
}

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

func (c Circle) Perimeter() float64 {
	return 2 * math.Pi * c.Radius
}

type Rectangle struct {
	Width, Height float64
}

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

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

// インターフェース型を引数に取ることで、どの Shape 実装でも受け付ける
func printShapeInfo(s Shape) {
	fmt.Printf("面積: %.2f, 周長: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
	c := Circle{Radius: 5}
	r := Rectangle{Width: 4, Height: 6}

	fmt.Print("Circle: ")
	printShapeInfo(c)

	fmt.Print("Rectangle: ")
	printShapeInfo(r)
}

package main

import "fmt"

// 通知の送信手段を抽象化するインターフェース
type Notifier interface {
	Send(message string) error
}

type EmailNotifier struct {
	Address string
}

func (e EmailNotifier) Send(message string) error {
	fmt.Printf("[Email -> %s] %s\n", e.Address, message)
	return nil
}

type SlackNotifier struct {
	Channel string
}

func (s SlackNotifier) Send(message string) error {
	fmt.Printf("[Slack #%s] %s\n", s.Channel, message)
	return nil
}

type SMSNotifier struct {
	PhoneNumber string
}

func (s SMSNotifier) Send(message string) error {
	fmt.Printf("[SMS -> %s] %s\n", s.PhoneNumber, message)
	return nil
}

// 複数の Notifier に一括送信する
// 新しい通知手段を追加しても、この関数は変更不要
func broadcast(notifiers []Notifier, message string) {
	for _, n := range notifiers {
		if err := n.Send(message); err != nil {
			fmt.Printf("送信エラー: %v\n", err)
		}
	}
}

func main() {
	notifiers := []Notifier{
		EmailNotifier{Address: "user@example.com"},
		SlackNotifier{Channel: "alerts"},
		SMSNotifier{PhoneNumber: "090-1234-5678"},
	}

	broadcast(notifiers, "システムメンテナンスのお知らせ")
}

package main

import (
	"fmt"
	"strings"
)

type Reader interface {
	Read() string
}

type Writer interface {
	Write(data string)
}

type Closer interface {
	Close()
}

// 埋め込みで合成する
type ReadWriter interface {
	Reader
	Writer
}

type ReadWriteCloser interface {
	Reader
	Writer
	Closer
}

type Buffer struct {
	data   strings.Builder
	closed bool
}

func (b *Buffer) Write(data string) {
	if b.closed {
		fmt.Println("書き込みエラー: バッファは閉じられています")
		return
	}
	b.data.WriteString(data)
}

func (b *Buffer) Read() string {
	if b.closed {
		return ""
	}
	return b.data.String()
}

func (b *Buffer) Close() {
	b.closed = true
	fmt.Println("バッファをクローズしました")
}

// 書き込みのみ行う関数 - Writer だけを要求する（最小権限の原則）
func writeAll(w Writer, items []string) {
	for _, item := range items {
		w.Write(item)
	}
}

// 読み取りのみ行う関数 - Reader だけを要求する
func readAndPrint(r Reader) {
	fmt.Printf("内容: %s\n", r.Read())
}

func main() {
	buf := &Buffer{}

	writeAll(buf, []string{"Hello, ", "Go ", "Interface!"})
	readAndPrint(buf)

	buf2 := &Buffer{}
	buf2.Write("処理済みデータ")
	fmt.Printf("読み取り: %s\n", buf2.Read())
	buf2.Close()

	// クローズ後の操作
	buf2.Write("追記しようとしています")
}

package main

import "fmt"

type Animal interface {
	Sound() string
}

type Dog struct{ Name string }
type Cat struct{ Name string }
type Bird struct {
	Name   string
	CanFly bool
}

func (d Dog) Sound() string  { return "ワン" }
func (c Cat) Sound() string  { return "ニャン" }
func (b Bird) Sound() string { return "チュン" }

func describeAnimal(a Animal) {
	fmt.Printf("鳴き声: %s", a.Sound())

	switch v := a.(type) {
	case Dog:
		fmt.Printf(" -> 犬の名前は %s\n", v.Name)
	case Cat:
		fmt.Printf(" -> 猫の名前は %s\n", v.Name)
	case Bird:
		canFly := "飛べない"
		if v.CanFly {
			canFly = "飛べる"
		}
		fmt.Printf(" -> 鳥の名前は %s (%s)\n", v.Name, canFly)
	default:
		fmt.Printf(" -> 未知の動物\n")
	}
}

// ok パターンによる単一の型アサーション
func tryGetDog(a Animal) {
	if dog, ok := a.(Dog); ok {
		fmt.Printf("犬を発見: %s\n", dog.Name)
	} else {
		fmt.Println("犬ではありませんでした")
	}
}

func main() {
	animals := []Animal{
		Dog{Name: "ポチ"},
		Cat{Name: "タマ"},
		Bird{Name: "ピーちゃん", CanFly: true},
		Bird{Name: "ペンギン", CanFly: false},
	}

	fmt.Println("=== type switch ===")
	for _, a := range animals {
		describeAnimal(a)
	}

	fmt.Println("\n=== ok パターン ===")
	tryGetDog(Dog{Name: "ハチ"})
	tryGetDog(Cat{Name: "ミケ"})
}

package main

import (
	"fmt"
	"strings"
)

type UserRepository interface {
	FindByID(id int) (string, error)
	Save(id int, name string) error
}

// インメモリ実装（テスト・開発用）
type InMemoryUserRepository struct {
	store map[int]string
}

func NewInMemoryUserRepository() *InMemoryUserRepository {
	return &InMemoryUserRepository{store: make(map[int]string)}
}

func (r *InMemoryUserRepository) FindByID(id int) (string, error) {
	name, ok := r.store[id]
	if !ok {
		return "", fmt.Errorf("ユーザー %d が見つかりません", id)
	}
	return name, nil
}

func (r *InMemoryUserRepository) Save(id int, name string) error {
	r.store[id] = name
	return nil
}

// UserService はビジネスロジックを担う
// リポジトリの具体的な実装に依存しない
type UserService struct {
	repo UserRepository
}

func NewUserService(repo UserRepository) *UserService {
	return &UserService{repo: repo}
}

func (s *UserService) Register(id int, name string) error {
	name = strings.TrimSpace(name)
	if name == "" {
		return fmt.Errorf("名前は空にできません")
	}
	return s.repo.Save(id, name)
}

func (s *UserService) Greet(id int) (string, error) {
	name, err := s.repo.FindByID(id)
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("こんにちは、%s さん！", name), nil
}

func main() {
	repo := NewInMemoryUserRepository()
	svc := NewUserService(repo)

	_ = svc.Register(1, "Alice")
	_ = svc.Register(2, "Bob")

	for _, id := range []int{1, 2, 3} {
		msg, err := svc.Greet(id)
		if err != nil {
			fmt.Printf("エラー: %v\n", err)
			continue
		}
		fmt.Println(msg)
	}
}