Go言語のインターフェースの利点・必要性がイマイチよく分かりません

Question

Go言語の勉強を初めて5日ほどです。
現在、インターフェースについて勉強中です。

自分でサンプルプログラムを作ってみました。
まずは、以下を見て頂けますでしょうか。

package main

import "fmt"

type Add struct {}
func (x Add) calculate(a int, b int) int { return a+b }

type Sub struct {}
func (x Sub) calculate(a int, b int) int { return a-b }

type Mul struct {}
func (x Mul) calculate(a int, b int) int { return a*b }

type Div struct {}
func (x Div) calculate(a int, b int) int  { return a/b }

func main() {
    var a Add
    var s Sub
    var m Mul
    var d Div

    fmt.Println("和：", a.calculate(7, 2))
    fmt.Println("差：", s.calculate(7, 2))
    fmt.Println("積：", m.calculate(7, 2))
    fmt.Println("商：", d.calculate(7, 2))
}

これをインターフェースを使って書き直したものが以下です。

package main

import "fmt"

type Calc interface{
    calculate(a int, b int) int
}

type Add struct {}
func (x Add) calculate(a int, b int) int { return a+b }

type Sub struct {}
func (x Sub) calculate(a int, b int) int { return a-b }

type Mul struct {}
func (x Mul) calculate(a int, b int) int { return a*b }

type Div struct {}
func (x Div) calculate(a int, b int) int  { return a/b }

func main() {
    var a Add
    var s Sub
    var m Mul
    var d Div
    var calc Calc

    calc = a
    fmt.Println("和：", calc.calculate(7, 2))
    calc = s
    fmt.Println("差：", calc.calculate(7, 2))
    calc = m
    fmt.Println("積：", calc.calculate(7, 2))
    calc = d
    fmt.Println("商：", calc.calculate(7, 2))
}

どちらも同じ出力結果となります。
この2つのコードを比べても、インターフェースを使う利点・必要性がイマイチよく分かりません。

インターフェースを使ったコードの方が良いのでしょうか？
あるいはサンプルコードが不適ということはあるでしょうか？

当方、オブジェクト指向の知識・経験は少ないです。
一応、継承・ポリモーフィズについて、さらっとネットで調べはしました。
例えば、こちらのWebページなど
https://qiita.com/Akatsuki_py/items/3e35ba326ff254a6790d
https://teratail.com/questions/60856

ご回答頂けると嬉しいです。

Answer 1

Add, Sub, Mul, Divのどれを使うかだけが違う関数を書くとき(例えば計算結果を表示するだけ)
インターフェースがないと引数の型が違うだけの関数を4つ書きますが、
インターフェースがあれば1つで済みます。

余剰計算Modを追加したときに、
インターフェースがないとまた同じような関数が一つ増えますが、
あれば何もせずに済みます。

なのでこのコードだと実感しづらいです。

---

package main

import "fmt"



type Add struct {}
func (x Add) calculate(a int, b int) int { return a+b }

type Sub struct {}
func (x Sub) calculate(a int, b int) int { return a-b }

type Mul struct {}
func (x Mul) calculate(a int, b int) int { return a*b }

type Div struct {}
func (x Div) calculate(a int, b int) int  { return a/b }


// 型によって作り分ける
func somethingNiceFunctionAdd(c Add, left int, right int) {
    fmt.Println(c.calculate(left, right))
}
func somethingNiceFunctionSub(c Sub, left int, right int) {
    fmt.Println(c.calculate(left, right))
}
func somethingNiceFunctionMul(c Mul, left int, right int) {
    fmt.Println(c.calculate(left, right))
}
func somethingNiceFunctionDiv(c Div, left int, right int) {
    fmt.Println(c.calculate(left, right))
}


func main() {
    var a Add
    var s Sub
    var m Mul
    var d Div

    // 呼ぶ側も型によって使い分ける
    somethingNiceFunctionAdd(a, 7, 2)
    somethingNiceFunctionSub(s, 7, 2)
    somethingNiceFunctionMul(m, 7, 2)
    somethingNiceFunctionDiv(d, 7, 2)

}

package main

import "fmt"

type Calc interface{
    calculate(a int, b int) int
}

type Add struct {}
func (x Add) calculate(a int, b int) int { return a+b }

type Sub struct {}
func (x Sub) calculate(a int, b int) int { return a-b }

type Mul struct {}
func (x Mul) calculate(a int, b int) int { return a*b }

type Div struct {}
func (x Div) calculate(a int, b int) int  { return a/b }

// ひとつでいい
func somethingNiceFunction(c Calc, left int, right int) {
    fmt.Println(c.calculate(left, right))
}

func main() {
    var a Add
    var s Sub
    var m Mul
    var d Div

// 呼ぶ側も区別しなくていい
    somethingNiceFunction(a, 7, 2)
    somethingNiceFunction(s, 7, 2)
    somethingNiceFunction(m, 7, 2)
    somethingNiceFunction(d, 7, 2)

}

Comments

[dam9806]

回答ありがとうございます！

Modを追加する場合、どちらのソースにもMod用の構造体とメソッドの追加は必要ですよね？
また、どちらのソースにもmainにfmt.Println文が必要ですよね？
そうだとしたら、私の今のレベルでは、インターフェースの利点・必要性が理解できません。

また、インターフェースのように異なる型を受け付ける仕組みって、ふつうに開発中に必要となってくるものでしょうか？
必要となる機会が少ないのであれば、これを勉強するのを後回しにしようかと思うのですが・・・。

[dam9806]

ozwkさん
改めてコード付きの回答、ありがとうございます！
somethingNiceFunctionを入れることで、私のサンプルコードのようなmain関数内での明示的なインターフェース型変数への代入文が無くなっていますね！
だいぶ理解が進みました。

Answer 2

以下のWebページを見つけました。
https://qiita.com/oahiroaki/items/ff21d9adfb843161d1d8

こちらを見ると、まだ私のレベルでは読解が難しいですが、なんとなくインターフェースの利点が見えてきました。
このサンプルでは、JSONに合わせた構造体を準備しなくても良さそうなので、だいぶスマートに記述できそうです。
今後JSONデータを扱う予定があるので、有用な記事でした。

ネットにどれだけインターフェースを使ったサンプルが落ちているか分かりませんが、できるだけ触れるようにして勉強したいと思います。

クローズさせて頂こうと思います。
ご回答してくれた方々、ありがとうございました！

Comments

[nobonobo]

それはバリアント型としての利点でインターフェースとダックタイプの利点とは異なります。
そして構造体を用意せずにJSONを扱うのはGo言語では悪手です。（のちに余計に手間がかかります）

[dam9806]

コメントありがとうございます！
難しい用語が出てきて理解できませんが、構造体を用いるべきなのですね。
まだ実際にJSONを使ったコーディングをしていないので、どのような手間がかかるのか実感できませんが、構造体を使った場合と使わない場合の手間の違いが把握できるよう、勉強したいと思います。

Answer 3

サンプルコード的なものを書いてみました
https://play.golang.org/p/TDJTvw-3O_8

インターフェースを実装したストラクトを利用すると便利さがわかるかもしれません

package main

import (
	"fmt"
)

// Human interface
type Human interface {
	SayHello()
}

// Japanese struct
type Japanese struct {
	Name string
	Age  int64
}

// American struct
type American struct {
	Name string
	Age  int64
}

// SayHello void (Japanese)
func (japanese *Japanese) SayHello() {
	fmt.Printf("%s(%d):\tこんにちは\n", japanese.Name, japanese.Age)
}

// SayHello void (American)
func (american *American) SayHello() {
	fmt.Printf("%s(%d):\tHello\n", american.Name, american.Age)
}

func main() {
	humans := []Human{}

	humans = append(humans, &Japanese{Name: "東京太郎", Age: int64(30)})
	humans = append(humans, &American{Name: "Bob", Age: int64(25)})

	for _, human := range humans {
		human.SayHello()
	}
}

Comments

[dam9806]

回答ありがとうございます！
サンプルコードの提示もありがとうございます！

ですが、インターフェースの利点・必要性がよくわかりません。
また、ご提示のコードでは、Calcインターフェースを使用しているようには見えなかったので、試しにその宣言部分をコメント化して実行したところ、普通に動きました。
つまり、Calcインターフェースがなくても良い・・・ということではないでしょうか？

[teikoku-penguin]

サンプルコードを修正させて頂きました