Go言語インタフェースの説明

// Duck defines a duck interface
type Duck interface {
   speak()
   run()
}

// WhiteDuck defines a white duck structure
type WhiteDuck struct {
   name string
   age int
   sex string
sex string }

// BlackDuck defines a black duck structure
type BlackDuck struct {
   name string
   age int
   sex string
}

// Let the white duck and the black duck bind all the methods in the interface, and call it an implementation of the interface
// Let the white duck implement the Duck interface
func (w WhiteDuck) speak() {
   fmt.Println("The white duck quacks, its name is ", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("The white duck walks slowly, its name is ", w.name)
}

// Make the black duck implement the Duck interface
func (b BlackDuck) speak() {
   fmt.Println("The black duck quacks, its name is ", b.name)
}

func (b BlackDuck) run() {
   fmt.Println("Black Duck quacks, its name is ", b.name)
}


func main() {
   var duck Duck
   duck = WhiteDuck{"white", 15, "male"} // Assign my object to an interface type, and you can achieve the effect of polymorphism
   fmt.Println(duck)
    
   // duck is now an interface, it can only take methods, not properties.
   duck.speak()
   duck.run()
}

func main() {
	var duck Duck = WhiteDuck{"小白", 15, "男"}
	// assert that it is of type WhiteDuck
	value, ok := duck.(WhiteDuck)
	// Assertion succeeds, ok = true, value is the WhiteDuck structure object
	fmt.Println(value) // Output: {white 15 male}
	fmt.Println(value.name) // output: White
	fmt.Println(ok) // output: true

	// Assertion failed, ok1 = false, value1 is null of type BlackDuck because no value was assigned
	value1, ok1 := duck.(BlackDuck)
	fmt.Println(value1) // Output: { 0 }
	fmt.Println(ok1) // output: false
}

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(duck)
}

func test(duck Duck) {
   switch value := duck.(type) {
   case WhiteDuck:
      fmt.Println(value.name)
      fmt.Println("I'm a white duck")
   case BlackDuck:
      fmt.Println(value.name)
      fmt.Println("I'm a black duck")
   default:
      fmt.Println(value)
      fmt.Println("I am the class of ducks")
   }
}

type Empty interface {} // Empty interface

func main() {
   var a int = 10
   var b string = "XiaoYang"
   var c [3]int
   var e Empty // e is the empty interface type, which can accept any data type
   e = a
   e = b
   e = c
    
   // In this case you need to select it back
   // Normally I can only accept Empty types, but a b c are not Empty types
   test(a) // output: I am int 10
   test(b) // output: I am the string XiaoYang
   test(c) // output: I am the array [0 0 0]
}

// If this is not an empty interface, like Duck, then all data types that implement the Duck interface can be passed
func test(b Empty) {		
   switch v:=b.(type) {
   case string:
      fmt.Println("I am string", v)
   case int:
      fmt.Println("I am int", v)
   case [3]int:
      fmt.Println("I am array", v)
   }
}

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(10)
   test("XiaoYang")
   test(duck)
}

// This is called the anonymous null interface, all data types can be passed into it, if you want to use the original structure also need to type selection back to use
func test(b interface{}) {
   fmt.Println(b)
}

// Duck Define a duck interface
type Duck interface {
   speak()
   run()
}

type Animal interface {
   eat()
   sleep()
}

// WhiteDuck defines a white duck structure
type WhiteDuck struct {
   name string
   age int
   sex string
sex string }


// Make the white duck implement the Duck interface as well as the Animal interface
func (w WhiteDuck) speak() {
   fmt.Println("White Duck quacks, its name is ", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("The white duck walks slowly, its name is ", w.name) 
}

func (w WhiteDuck) eat() {
   fmt.Println("White Duck eats, its name is ", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("WhiteDuck sleeps, its name is ", w.name)
}


func main() {
	var w WhiteDuck = WhiteDuck{}
	var a Animal
	var d Duck

	// This way my w can be given to either a or d
	// but once you go to an interface, you can only use the methods of that interface, your own properties and your own methods need to be type asserted before you can use them
	
	a = w // If w is given to a, then a can only call the methods of the Animal interface
	a.sleep()
	a.eat()
	
	d = w // w gives d, then a can only call the methods of the Duck interface
	d.run()
	d.speak()
}

type Duck interface {
   Animal // Duck nests the Animal interface
   speak()
   run()
run() }

type Animal interface {
   eat()
   sleep()
sleep()

type WhiteDuck struct {
   name string
   age int
   sex string
}


// This way the white duck implements the Duck interface as well as the Animal interface
func (w WhiteDuck) speak() {
   fmt.Println("The white duck quacks, its name is ", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("The white duck walks slowly, its name is ", w.name)
}
func (w WhiteDuck) eat() {
   fmt.Println("The white duck quacks, its name is ", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("The white duck goes slow, its name is ", w.name)
}



func main() {
   var a Animal
   var d Duck
   var w WhiteDuck = WhiteDuck{}

   // w can be given either to a or to d
   a = w // but a can only call two methods in Animal
   a.sleep()
   a.eat()

   d = w // but d can call all four methods in Duck and Animal
   d.sleep()
   d.eat()
   d.speak()
   d.run()
}

func main() {

   var a Animal // nil means it's a reference type
   // Its internal representation tells us that it holds two values, one of its type and one of a pointer to a specific value

   fmt.Println(a) // Output: <nil>
}

type WhiteDuck struct {
   name string
   sex string
   age int
age int }

func main() {
   var per1 *WhiteDuck = new(WhiteDuck) // new is returning a pointer to this type
   // or I take the address of WhiteDuck and assign it to per2
   var per2 = &WhiteDuck{}

   fmt.Println(per1) // output: &{ 0}
   fmt.Println(per2) // output: &{ 0}

   var per3 = make([]int, 3, 4) // make is a concrete creation reference type
                           // new is to create a pointer to this type
   var per4 = new([]int) // is a pointer to a slice type

   fmt.Println(per3) // output: [0 0 0]
   fmt.Println(per4) // output: &[]
}