Go言語のInterface（インターフェース）の基本と実践的な使い方について解説

package main
import "fmt"
// Workerというinterfaceを定義
type Worker interface {
	Work() // Workメソッドを抽象的に定義
}
// Person構造体を定義
type Person struct {
	Name string
}
// Person構造体に対してWorkメソッドを実装
func (p Person) Work() {
	fmt.Println("作業中:", p.Name)
}
// main関数でWorker interfaceの実装例を表示
func main() {
	var worker Worker = Person{Name: "太郎"}
	worker.Work() // PersonのWorkメソッドが実行される
}

作業中: 太郎

package main
import "fmt"
func main() {
	// 空のinterface{}は任意の型を保持可能
	var any interface{}
	any = 123 // intを格納
	fmt.Println("整数:", any)
	any = "文字列" // stringを格納
	fmt.Println("文字列:", any)
}

整数: 123
文字列: 文字列

package main
import "fmt"
// Describerインターフェースを定義
type Describer interface {
	Describe() string
}
// Product構造体を定義
type Product struct {
	Name  string
	Price float64
}
// ProductはDescriberインターフェースを暗黙的に実装
func (p Product) Describe() string {
	return fmt.Sprintf("商品名: %s, 価格: %.2f", p.Name, p.Price)
}
func main() {
	var d Describer = Product{"本", 2000}
	fmt.Println(d.Describe())
}

商品名: 本, 価格: 2000.00

package main
import "fmt"
// Calculatorインターフェースを定義
type Calculator interface {
	Add(a int, b int) int
}
// SimpleCalc構造体を定義
type SimpleCalc struct{}
// SimpleCalcはCalculatorインターフェースを実装
func (sc SimpleCalc) Add(a int, b int) int {
	return a + b
}
func main() {
	var calc Calculator = SimpleCalc{}
	result := calc.Add(5, 3)
	fmt.Println("足し算の結果:", result)
}

足し算の結果: 8

package main
import "fmt"
// Readerインターフェースを定義
type Reader interface {
	Read() string
}
// Writerインターフェースを定義
type Writer interface {
	Write(s string)
}
// File構造体を定義
type File struct {
	Content string
}
// FileはReaderインターフェースを実装
func (f File) Read() string {
	return f.Content
}
// FileはWriterインターフェースを実装
func (f *File) Write(s string) {
	f.Content = s
}
func main() {
	// ReaderとしてFileを利用
	var reader Reader = File{"初期コンテンツ"}
	fmt.Println("読み込み:", reader.Read())
	// 型アサーションを利用してWriterに変換して利用
	fileInstance := File{"初期コンテンツ"}
	var writer Writer = &fileInstance
	writer.Write("更新されたコンテンツ")
	fmt.Println("更新後の読み込み:", fileInstance.Read())
}

読み込み: 初期コンテンツ
更新後の読み込み: 更新されたコンテンツ

package main
import "fmt"
// Notifierインターフェースを定義
type Notifier interface {
	Notify(message string)
}
// Email構造体を定義
type Email struct {
	Address string
}
// EmailはNotifierインターフェースを実装
func (e Email) Notify(message string) {
	fmt.Printf("メール送信先 %s に通知: %s\n", e.Address, message)
}
// SendNotification関数はNotifierインターフェースを引数に受け取る
func SendNotification(n Notifier, message string) {
	n.Notify(message)
}
func main() {
	email := Email{Address: "example@example.com"}
	SendNotification(email, "プロジェクト更新のお知らせ")
}

メール送信先 example@example.com に通知: プロジェクト更新のお知らせ

package main
import "fmt"
// Printerインターフェースを定義
type Printer interface {
	Print()
}
// Document構造体を定義
type Document struct {
	Title string
}
// DocumentはPrinterインターフェースを実装
func (d Document) Print() {
	fmt.Println("印刷:", d.Title)
}
// main関数で型アサーションの例
func main() {
	var p Printer = Document{Title: "サンプル文書"}
	// 型アサーションでDocument型に変換
	doc, ok := p.(Document)
	if ok {
		fmt.Println("Documentのタイトル:", doc.Title)
	} else {
		fmt.Println("型アサーションに失敗しました")
	}
}

Documentのタイトル: サンプル文書

package main
import "fmt"
// Animalインターフェースを定義
type Animal interface {
	Speak() string
}
// Dog構造体を定義
type Dog struct{}
// DogはAnimalインターフェースを実装
func (d Dog) Speak() string {
	return "ワンワン"
}
// Cat構造体を定義
type Cat struct{}
// CatはAnimalインターフェースを実装
func (c Cat) Speak() string {
	return "ニャーニャー"
}
func main() {
	animals := []Animal{Dog{}, Cat{}}
	for _, a := range animals {
		// 型スイッチを利用して型ごとの処理を実行
		switch v := a.(type) {
		case Dog:
			fmt.Println("犬:", v.Speak())
		case Cat:
			fmt.Println("猫:", v.Speak())
		default:
			fmt.Println("不明な動物")
		}
	}
}

犬: ワンワン
猫: ニャーニャー

package main
import "fmt"
// Readerインターフェースは1つのメソッドに限定し、シンプルに保つ
type Reader interface {
	Read() string
}
// FileReader構造体を定義
type FileReader struct {
	Data string
}
func (fr FileReader) Read() string {
	return fr.Data
}
func main() {
	var r Reader = FileReader{"簡単なデータ"}
	fmt.Println("読み込み結果:", r.Read())
}

読み込み結果: 簡単なデータ

package main
import "fmt"
// NumberHolderインターフェースを定義
type NumberHolder interface {
	GetNumber() int
}
// Holder構造体を定義(ポインタレシーバを利用)
type Holder struct {
	Number int
}
func (h *Holder) GetNumber() int {
	return h.Number
}
func main() {
	holder := &Holder{Number: 42}
	var nh NumberHolder = holder
	fmt.Println("数値:", nh.GetNumber())
}

数値: 42