の箇所です。

インターフェース(interface)はGo言語における型の一種で、振る舞いの集合を定義するために使用されます。型が実装しなければならないメソッドを記述することで、型の振る舞いに関する契約を定めます。

Go言語にはもう一つのデータ型であるインターフェースがあります。これは共通性のあるすべてのメソッドをまとめて定義するもので、他のどの型でもこれらのメソッドを実装すれば、そのインターフェースを実装したことになります。

Goのインターフェースは設計がシンプルでありながら強力で、多態性(ポリモーフィズム)と疎結合を実現するための重要なツールです。

インターフェースを使うと、異なる型を共通のメソッド群に結び付けることができ、多態性と柔軟な設計を実現できます。

インターフェースの特徴

暗黙的な実装:

  • Goには、ある型が特定のインターフェースを実装していることを明示的に宣言するキーワードはありません。
  • ある型がインターフェースで要求されるすべてのメソッドを実装していれば、その型は自動的にそのインターフェースを実装したと見なされます。

インターフェース型の変数:

  • インターフェース変数は、そのインターフェースを実装する任意の値を格納できます。
  • インターフェース変数は実際には次の2つの部分で構成されています。
    • 動的型:実際の値の型を格納します。
    • 動的な値:具体的な値を格納します。

ゼロ値インターフェース:

  • インターフェースのゼロ値は `nil`。nil。
  • 初期化されていないインターフェース変数の値は `nil`nil、動的型も値も含みません。

空インターフェース:

  • `interface{}` と定義されinterface{}、任意の型を表すことができます。

インターフェースの一般的な使い方

  1. 多態性(ポリモーフィズム):異なる型が同じインターフェースを実装し、多態的な振る舞いを実現します。
  2. 疎結合:インターフェースで依存関係を定義し、モジュール間の結合度を下げます。
  3. 汎用化:空インターフェースを使用してinterface{}任意の型を表します。

インターフェースの定義と実装

インターフェースの定義にはキーワード `type` を使用しinterface、その中にメソッド宣言が含まれます。

例

/* インターフェースの定義 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 構造体の定義 */
type struct_name struct {
   /* variables */
}

/* インターフェースメソッドの実装 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* メソッドの実装 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* メソッドの実装 */
}

簡単なインターフェースを定義します:

type Shape interface {
    Area() float64
    Perimeter() float64
}
  • Shape`Shape` はインターフェースであり、2つのメソッドを定義しています:AreaとPerimeter。
  • 任意の型がこの2つのメソッドを実装していれば、Shape`Shape` インターフェースを実装したと見なされます。

インターフェースの実装:型は、インターフェースが要求するすべてのメソッドを実装することで、インターフェースを実装します。

例

package main

import (
        "fmt"
        "math"
)

// インターフェースの定義
type Shape interface {
        Area() float64
        Perimeter() float64
}

// 構造体を定義する
type Circle struct {
        Radius float64
}

// Circle は Shape インターフェースを実装する
func (c Circle) Area() float64 {
        return math.Pi * c.Radius * c.Radius
}

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

func main() {
        c := Circle{Radius: 5}
        var s Shape = c // インターフェース変数はインターフェースを実装した型を格納できる
        fmt.Println("Area:", s.Area())
        fmt.Println("Perimeter:", s.Perimeter())
}

上記のコードを実行すると、出力結果は次のようになります:

Area: 78.53981633974483
Perimeter: 31.41592653589793

空インターフェース

空インターフェースinterface{}は Go の特別なインターフェースで、すべての型のスーパーセットを表します。

  • 任意の型が空インターフェースを実装しています。
  • 任意の型のデータを格納する必要がある場面、例えばジェネリックなコンテナや汎用パラメータなどでよく使われます。

例

package main

import "fmt"

func printValue(val interface{}) {
        fmt.Printf("Value: %v, Type: %T\n", val, val)
}

func main() {
        printValue(42)         // int
        printValue("hello")    // string
        printValue(3.14)       // float64
        printValue([]int{1, 2}) // slice
}

上記のコードを実行すると、出力結果は次のようになります:

Value: 42, Type: int
Value: hello, Type: string
Value: 3.14, Type: float64
Value: [1 2], Type: []int

型アサーション

型アサーションは、インターフェース型からその基になる値を取り出すために使用されます。

基本構文:

value := iface.(Type)
  • iface`x` はインターフェース変数です。
  • Type`T` はアサートする具体的な型です。
  • 型が一致しない場合は、`panic` が発生します。panic。

例

package main

import "fmt"

func main() {
        var i interface{} = "hello"
        str := i.(string) // 型アサーション
        fmt.Println(str)  // 出力:hello
}

チェック付き型アサーション

panic を避けるために、チェック付き型アサーションを使用できます:

value, ok := iface.(Type)
  • ok`ok` はブール値で、アサーションが成功したかどうかを示します。
  • `value` はゼロ値になり、value例okためにfalse。

例

package main

import "fmt"

func main() {
        var i interface{} = 42
        if str, ok := i.(string); ok {
                fmt.Println("String:", str)
        } else {
                fmt.Println("Not a string")
        }
}

上記のコードを実行すると、出力結果は次のようになります:

Not a string

型スイッチ(type switch)

type switch は Go の構文構造で、インターフェース変数の具体的な型に応じて異なるロジックを実行するために使用されます。

例

package main

import "fmt"

func printType(val interface{}) {
        switch v := val.(type) {
        case int:
                fmt.Println("Integer:", v)
        case string:
                fmt.Println("String:", v)
        case float64:
                fmt.Println("Float:", v)
        default:
                fmt.Println("Unknown type")
        }
}

func main() {
        printType(42)
        printType("hello")
        printType(3.14)
        printType([]int{1, 2, 3})
}

上記のコードを実行すると、出力結果は次のようになります:

Integer: 42
String: hello
Float: 3.14
Unknown type

インターフェースの組み合わせ

インターフェースはネストして組み合わせることで、より複雑な振る舞いを記述できます。

例

package main

import "fmt"

type Reader interface {
        Read() string
}

type Writer interface {
        Write(data string)
}

type ReadWriter interface {
        Reader
        Writer
}

type File struct{}

func (f File) Read() string {
        return "Reading data"
}

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

func main() {
        var rw ReadWriter = File{}
        fmt.Println(rw.Read())
        rw.Write("Hello, Go!")
}

動的な値と動的な型

インターフェース変数は実際には2つの部分で構成されています:

  1. 動的型:インターフェース変数が格納する具体的な型。
  2. 動的な値:具体的な型の値。

動的な値と動的な型の例:

例

package main

import "fmt"

func main() {
        var i interface{} = 42
        fmt.Printf("Dynamic type: %T, Dynamic value: %v\n", i, i)
}

上記のコードを実行すると、出力結果は次のようになります:

Dynamic type: int, Dynamic value: 42

インターフェースのゼロ値

インターフェースのゼロ値は nil です。

インターフェース変数の動的型と動的な値がどちらも nil の場合、インターフェース変数は nil になります。

インターフェースのゼロ値の例:

例

package main

import "fmt"

func main() {
        var i interface{}
        fmt.Println(i == nil) // 出力:true
}

練習問題

次の2つの例は、インターフェースの使用法を示しています:

例 1

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

上記の例では、インターフェース `Phone` を定義しましたPhone、インターフェースにはメソッド `call()` がありますcall()。次に、main`main` 関数内で `Phone` 型変数を定義し、Phoneそれぞれに `NokiaPhone` と `IPhone` を代入しましたNokiaPhoneとIPhone。その後、`call()`call()メソッドを呼び出すと、出力結果は次のようになります:

I am Nokia, I can call you!
I am iPhone, I can call you!

2つ目のインターフェースの例:

例

package main

import "fmt"

type Shape interface {
    area() float64
}

type Rectangle struct {
    width  float64
    height float64
}

func (r Rectangle) area() float64 {
    return r.width * r.height
}

type Circle struct {
    radius float64
}

func (c Circle) area() float64 {
    return 3.14 * c.radius * c.radius
}

func main() {
    var s Shape

    s = Rectangle{width: 10, height: 5}
    fmt.Printf(長方形の面積: %f\n", s.area())

    s = Circle{radius: 3}
    fmt.Printf(円の面積: %f\n", s.area())
}

上記の例では、Shape インターフェースを定義しました。このインターフェースは area() メソッドを1つ定義しており、そのメソッドは float64 型の面積値を返します。次に、Rectangle と Circle という2つの構造体を定義し、それぞれが Shape インターフェースの area() メソッドを実装しています。main() 関数では、まず Shape 型の変数 s を定義し、Rectangle 型と Circle 型のインスタンスをそれぞれ代入し、area() メソッドで面積を計算して出力しています。出力結果は次のようになります:

矩形面积: 50.000000
圆形面积: 28.260000

注意すべき点は、インターフェース型の変数はそのインターフェースを実装した任意の型の値を格納できるということです。この例では、Rectangle 型と Circle 型のインスタンスをどちらも Shape 型の変数 s に代入し、area() メソッドを使ってそれぞれの面積計算メソッドを呼び出しています。

その他の拡張