Go言語の構造体とインターフェースによるクラス風実装について解説

package main
import "fmt"
// Person構造体は名前と年齢を保持する
type Person struct {
	Name string
	Age  int
}
// GreetはPersonの挨拶を返すメソッド
func (p Person) Greet() string {
	return "こんにちは、" + p.Name + "さん！"
}
func main() {
	// Personオブジェクトを生成して挨拶を出力
	person := Person{Name: "太郎", Age: 30}
	fmt.Println(person.Greet())
}

こんにちは、太郎さん！

package main
import "fmt"
// Person構造体定義
type Person struct {
	Name string
	Age  int
}
// NewPersonはPerson型オブジェクトの初期化を行う関数
func NewPerson(name string, age int) *Person {
	return &Person{Name: name, Age: age}
}
func main() {
	// NewPersonでオブジェクト生成
	person := NewPerson("花子", 25)
	fmt.Printf("名前: %s, 年齢: %d\n", person.Name, person.Age)
}

名前: 花子, 年齢: 25

package main
import "fmt"
// Person構造体は名前と年齢を保持する
type Person struct {
	Name string
	Age  int
}
// UpdateAgeはPersonの年齢を更新するメソッド
func (p *Person) UpdateAge(newAge int) {
	p.Age = newAge
}
func main() {
	// ポインタでオブジェクトを生成し、状態管理を実施
	person := &Person{Name: "太郎", Age: 30}
	fmt.Println("更新前の年齢:", person.Age)
	person.UpdateAge(31)
	fmt.Println("更新後の年齢:", person.Age)
}

更新前の年齢: 30
更新後の年齢: 31

package main
import "fmt"
// Greeterインターフェースは挨拶メソッドのシグネチャを定義する
type Greeter interface {
	Greet() string
}
// Person構造体はGreeterインターフェースを実装する
type Person struct {
	Name string
}
func (p Person) Greet() string {
	return "こんにちは、" + p.Name + "さん！"
}
func main() {
	var greeter Greeter = Person{Name: "次郎"}
	fmt.Println(greeter.Greet())
}

こんにちは、次郎さん！

package main
import "fmt"
// Greeterインターフェースは挨拶メソッドのシグネチャを定義する
type Greeter interface {
	Greet() string
}
// Person構造体
type Person struct {
	Name string
}
func (p Person) Greet() string {
	return "こんにちは、" + p.Name + "さん！"
}
// Dog構造体
type Dog struct {
	Name string
}
func (d Dog) Greet() string {
	return "ワンワン！ " + d.Name
}
func main() {
	// Greeterインターフェースを実装する異なる型のオブジェクトをスライスで管理
	greeters := []Greeter{
		Person{Name: "三郎"},
		Dog{Name: "ポチ"},
	}
	for _, g := range greeters {
		fmt.Println(g.Greet())
	}
}

こんにちは、三郎さん！
ワンワン！ ポチ

package main
import "fmt"
// PrinterインターフェースはPrintメソッドのシグネチャを定義する
type Printer interface {
	Print() string
}
// Document構造体は文書情報を保持する
type Document struct {
	Title   string
	Content string
}
func (d Document) Print() string {
	return "文書タイトル: " + d.Title + "\n内容: " + d.Content
}
func main() {
	doc := Document{Title: "サンプル文書", Content: "こちらは文書の内容です。"}
	var printer Printer = doc
	fmt.Println(printer.Print())
}

文書タイトル: サンプル文書
内容: こちらは文書の内容です。

package main
import "fmt"
// Base構造体は共通の機能を提供する
type Base struct {
	ID int
}
func (b Base) Info() string {
	return "IDは: " + fmt.Sprint(b.ID)
}
// Derived構造体はBaseを埋め込み、さらに独自のフィールドを追加する
type Derived struct {
	Base // Base構造体を埋め込み
	Name string
}
func main() {
	d := Derived{
		Base: Base{ID: 1001},
		Name: "派生クラス",
	}
	// 埋め込みによって、BaseのInfoメソッドがそのまま利用可能
	fmt.Println(d.Info())
}

IDは: 1001

package main
import "fmt"
// Alpha構造体
type Alpha struct{}
func (a Alpha) Message() string {
	return "Alphaのメッセージ"
}
// Beta構造体
type Beta struct{}
func (b Beta) Message() string {
	return "Betaのメッセージ"
}
// Composite構造体はAlphaとBetaを両方埋め込む
type Composite struct {
	Alpha
	Beta
}
func main() {
	comp := Composite{}
	// 名前衝突を回避するため、明示的に埋め込み元を指定する
	fmt.Println(comp.Alpha.Message())
	fmt.Println(comp.Beta.Message())
}

Alphaのメッセージ
Betaのメッセージ

package main
import "fmt"
// Person構造体定義
type Person struct {
	Name string
	Age  int
}
// Greetメソッドは挨拶の文字列を返す
func (p Person) Greet() string {
	return "こんにちは、" + p.Name + "さん！"
}
// NewPersonはPersonオブジェクトの初期化を行う関数
func NewPerson(name string, age int) *Person {
	return &Person{Name: name, Age: age}
}
func main() {
	// Personオブジェクトを初期化
	person := NewPerson("和也", 28)
	fmt.Println("挨拶:", person.Greet())
	// オブジェクトの状態更新
	person.Age = 29
	fmt.Printf("更新後の年齢: %d\n", person.Age)
}

挨拶: こんにちは、和也さん！
更新後の年齢: 29

package main
import "fmt"
// ProcessorインターフェースはProcessメソッドのシグネチャを定義する
type Processor interface {
	Process() string
}
// Worker構造体はProcessorインターフェースを実装する
type Worker struct {
	ID int
}
func (w Worker) Process() string {
	return "Worker " + fmt.Sprint(w.ID) + "が処理を実行しました。"
}
// Manager構造体は複数のProcessorを管理し、処理を一括実行する
type Manager struct {
	Processors []Processor
}
func (m Manager) Run() {
	for _, processor := range m.Processors {
		fmt.Println(processor.Process())
	}
}
func main() {
	// 複数のWorkerオブジェクトを生成
	workers := []Processor{
		Worker{ID: 1},
		Worker{ID: 2},
		Worker{ID: 3},
	}
	// ManagerにProcessorを登録して連携処理を実行
	manager := Manager{Processors: workers}
	manager.Run()
}

Worker 1が処理を実行しました。
Worker 2が処理を実行しました。
Worker 3が処理を実行しました。

package main
import "fmt"
// Strategyインターフェースはアルゴリズムのシグネチャを定義する
type Strategy interface {
	Execute(data int) string
}
// ConcreteStrategyAはStrategyの具体的な実装で、データを2倍して返す
type ConcreteStrategyA struct{}
func (s ConcreteStrategyA) Execute(data int) string {
	return "StrategyA: 処理結果は " + fmt.Sprint(data*2)
}
// ConcreteStrategyBはStrategyの別の実装で、データに100を加算して返す
type ConcreteStrategyB struct{}
func (s ConcreteStrategyB) Execute(data int) string {
	return "StrategyB: 処理結果は " + fmt.Sprint(data+100)
}
// Contextは実行時に戦略を切り替えて利用する
type Context struct {
	strategy Strategy
}
func (c *Context) SetStrategy(s Strategy) {
	c.strategy = s
}
func (c Context) DoWork(data int) string {
	return c.strategy.Execute(data)
}
func main() {
	context := Context{}
	// StrategyAを設定して実行
	context.SetStrategy(ConcreteStrategyA{})
	fmt.Println(context.DoWork(5))
	// StrategyBを設定して実行
	context.SetStrategy(ConcreteStrategyB{})
	fmt.Println(context.DoWork(5))
}

StrategyA: 処理結果は 10
StrategyB: 処理結果は 105

package main
import "fmt"
func main() {
	// 事前に容量100を確保してスライスを生成
	data := make([]int, 0, 100)
	for i := 0; i < 100; i++ {
		data = append(data, i)
	}
	fmt.Println("スライスの長さ:", len(data))
}

スライスの長さ: 100