go类内实现

package main  
  
import "fmt"  
  
// Person类 绑定方法:eat run laugh 成员  
type Person struct {  
   name   string  
   age    int  
   gender string  
   score  float64  
}  
  
// 在外边绑定方法 +()func (this *Person) Eat() {  
   fmt.Println("Person is eating")  
   fmt.Println(this.name + " is eating !")  
   this.name = "yongen"  
   fmt.Println(this.name + " is eating !")  
}  

func (this Person) Eat2() {  
   // 指针才会改编数据 单纯赋值是不会修改的原数据的  
   fmt.Println("Person is eating")  
   fmt.Println(this.name + " is eating !")  
   this.name = "yongen"  
   fmt.Println(this.name + " is eating !")  
}  

func main() {  
   yasuo := Person{"yasuo", 30, "male", 100}  
   fmt.Println(yasuo)  
   yasuo.Eat()  
   fmt.Println(yasuo)  
}

package main  
  
import "fmt"  
  
type Person struct {  
   name   string  
   age    int  
   gender string  
   score  float64  
}  
  
// 嵌套一个 persontype Std struct {  
   per    Person  
   school string  
}  
  
// 继承是直接来写就行 没有字段名字  
type Teacher struct {  
   Person  
   subject string  
}  
  
func (this *Person) Eat() {  
   fmt.Println("I'm ,", this.name)  
}  
  
func main() {  
   s1 := Std{  
      per:    Person{"yasuo", 16, "male", 100},  
      school: "aiouniya",  
   }  
   fmt.Println(s1.per, s1.school)  
  
   // 继承  
   // 可以这样来操作  
   //t1 := Teacher{  
   // Person:  Person{"yongen", 18, "male", 100},   // subject: "Chinese",   //}   t1 := Teacher{}  
   t1.subject = "Math"  
   t1.name = "ikun"  
   t1.Eat()  
  
   // 特殊用法  
   // 继承的时候 我们没有定义字段名字 但是会创建一个同名字段  
   // 为了在自雷中依然可以操作父类 因为子类父类可能出现同名的字段  
   fmt.Println("t1.Person.name", t1.Person.name)  
}

package src  
  
import "fmt"  
  
type Person struct {  
   Name   string  
   Age    int  
   Gender string  
   Score  float64  
}  
  
// 嵌套一个 persontype Std struct {  
   Per    Person  
   School string  
}  
  
// 继承是直接来写就行 没有字段名字  
type Teacher struct {  
   Person  
   Subject string  
}  
  
func (this *Person) Eat() {  
   fmt.Println("I'm ,", this.Name)  
}

package main  
  
import (  
   "fmt"  
   "polymorphic/src")  
  
func main() {  
   s1 := src.Std{  
      Per:    src.Person{"yasuo", 16, "male", 100},  
      School: "aiouniya",  
   }  
   fmt.Println(s1.Per, s1.School)  
  
   // 继承  
   // 可以这样来操作  
   //t1 := Teacher{  
   // Person:  Person{"yongen", 18, "male", 100},   // subject: "Chinese",   //}   t1 := src.Teacher{}  
   t1.Subject = "Math"  
   t1.Name = "ikun"  
   t1.Eat()  
  
   // 特殊用法  
   // 继承的时候 我们没有定义字段名字 但是会创建一个同名字段  
   // 为了在自雷中依然可以操作父类 因为子类父类可能出现同名的字段  
   fmt.Println("t1.Person.name", t1.Person.Name)  
}

package main  
  
import "fmt"  
  
// c++中实现接口 纯虚构函数代替接口  
// go语言有专门的关键字 interface 来代替接口  
// 不仅仅用于处理多态 介意接受任意的数据类型 类似于void  
func main() {  
   fmt.Println("")  
  
   //定义 接口  
   var i, j, k interface{}  
   name := []string{"yasuo", "yongen"}  
   i = name  
   fmt.Println("i behalf of arr:", i)  
  
   i2 := 20  
   age := i2  
   j = age  
   fmt.Println("j behalf of num:", j)  
  
   str := "hello world"  
   k = str  
   fmt.Println("k behalf of string:", k)  
  
   // 我们现在只知道 k是 interface 但不知道他的明确类型  
   // 需要一种判断 -->断言  
   value, ok := k.(int)  
   if !ok {  
      fmt.Println("type is not int")  
   } else {  
      fmt.Println("key value is", value)  
   }  
  
   // 使用场景 把 interface当做一个函数的参数 类似于 print ,使用switch 来判断用户输入的类型  
   // 根据类型 来进行处理  
  
   // 创建一个具有三个接口类型的切片  
   arr := make([]interface{}, 3)  
   arr[0] = 10086  
   arr[1] = "yasuo"  
   arr[2] = true  
   for _, v := range arr {  
      // 可以去除当前接口真正数据类型  
      switch v := v.(type) {  
      case int:  
         fmt.Println("type is int ,value is", v)  
      case bool:  
         fmt.Println("type is bool ,value is", v)  
      case string:  
         fmt.Println("type is string ,value is", v)  
      default:  
         fmt.Println("type is not find")  
      }  
   }  
}

package main  
  
import "fmt"  
  
// 实现go多态 需要实现定义接口  
// 注意类型是 interfacetype IAttack interface {  
   // 接口可以有多个 但只能有一个函数原型  
   Attack()  
}  
  
// 低等级  
type PersonLowLevel struct {  
   name  string  
   level int  
}  
  
// 高等级  
type PersonHighLevel struct {  
   name  string  
   level int  
}  
  
func (a *PersonLowLevel) Attack() {  
   fmt.Println("I'm", a.name, "and level is", a.level, "causing harm", a.level*50)  
}  
func (a *PersonHighLevel) Attack() {  
   fmt.Println("I'm", a.name, "and level is", a.level, "causing harm", a.level*90)  
}  
  
// 定义一个多态的接口 传入不同的对象 调用同样的方法  
func DoAttack(a IAttack) {  
   a.Attack()  
}  
func main() {  
   var player IAttack // 空接口  
  
   lowLevel := PersonLowLevel{  
      name:  "yasuo",  
      level: 1,  
   }  
   lowLevel.Attack()  
  
   // 对于player进行赋值  
   // 任何一个实现了接口的 都可以使用这个方法  
   // 接口需要通过指针进行赋值  
   player = &lowLevel  
   fmt.Println(player)  
   player.Attack()  
  
   highLevel := PersonHighLevel{  
      name:  "yongen",  
      level: 10,  
   }  
   //highLevel.Attack()  
   player = &highLevel  
   highLevel.Attack()  
  
   DoAttack(&lowLevel)  
   DoAttack(&highLevel)  
}