/* 定义接口 */ 
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] { 
   /* 方法实现*/ 
} 

package main 
 
import "fmt" 
 
//面向对象的多态是通过接口interface来实现的,不同的对象，调用相同的接口，实现不同的效果 
 
 
 
//go语言中，接口interface是一个自定义类型，描述了一系列方法的集合，关键字interface 
//接口不能被实例化 
 
//定义接口的方法 
//type 接口名字 interface { 
// 
//} 
 
//接口的名字一般以er结尾 
 
//定义一个Personer的接口 
type Personer interface { 
	Say() 
} 
 
 
//定义一个学生的结构体 
 
type Studentxxx struct { 
	name string 
	score int 
} 
 
 
type Teacherxxx struct { 
	name string 
	class string 
} 
 
func (s *Studentxxx) Say ()  { 
	fmt.Println(s.name,s.score) 
} 
 
 
func (s *Teacherxxx) Say ()  { 
	fmt.Println(s.name,s.class) 
} 
 
 
type Mystring string 
 
func (m Mystring) Say ()  { 
	fmt.Println("自定义标准类型") 
} 
 
//go语言的多态来实现 
func Whosay(i Personer) { 
	i.Say() 
} 
 
func main() { 
	sxxxx := &Studentxxx{name:"张三",score:12} 
	txxxx := &Teacherxxx{name:"李四",class:"一年级"} 
 
	var my Mystring = "ABC" 
 
	sxxxx.Say() 
	txxxx.Say() 
	my.Say() 
	//张三 12 
	//李四 一年级 
	//自定义标准类型 
 
 
	//go语言实现多态 
	Whosay(sxxxx) 
	Whosay(txxxx) 
	Whosay(my) 
 
	//张三 12 
	//李四 一年级 
	//自定义标准类型 
 
	//练习一下make，创建一个数组 
	x := make([]Personer,3) 
 
	x[0],x[1],x[2] = sxxxx,txxxx,my 
	for _,value := range x { 
		value.Say() 
	} 
	//张三 12 
	//李四 一年级 
	//自定义标准类型 
} 

//定义一个Personer的接口 
type Personer interface { 
	Say() 
} 
 
//接口也可以继承，我们这里写了一个Personer1的接口，这个接口继承Personer这个接口,也就是说Personer1 
//这个接口也有Say这个方法了，我们同样也为Personer1这个接口定义了自己的方法，Run() 
type Personer1 interface { 
	Personer 
	Run() 
} 

type Personxxxx struct { 
	name string 
	class string 
	age int 
} 

//go语言的多态来实现 
func Whosay(i Personer) { 
	i.Say() 
} 

func (s2 *Personxxxx) Say()  { 
	fmt.Println("接口的继承测试1") 
} 
 
func (s2 *Personxxxx) Run()  { 
	fmt.Println("接口的继承测试2") 
} 

	p2 := &Personxxxx{name:"p2222",class:"二年级",age:12} 
 
	p2.Say() 
	p2.Run() 
	//接口的继承测试1 
	//接口的继承测试2 
 
	Whosay(p2) 
	//接口的继承测试1 

package main 
 
import ( 
	"fmt" 
) 
 
//接口类型判断 
 
//定义一个空接口 
type Niler interface { 
} 
 
type PersonTest struct { 
	name string 
	age int 
 
} 
 
func main() { 
	//定义一个接口类型的切片 
	list := make([] Niler,3) 
	list[0] = 1 
	list[1] = "hello" 
	list[2] = PersonTest{name:"erBi",age:12} 
 
	for k,v := range list { 
		//类型断言，返回的两个参数，一个是value，一个是ok，value是变量的值，ok是返回的布尔值 
		//comma-ok断言 
		//这里的例子就是通过上面的返回值v来判断v的类型，如果v的类型为int。则ok为true 
		_,ok := v.(int) 
		if ok { 
			fmt.Println(k,v,"数字") 
		} else if _,ok := v.(string);ok{ 
			fmt.Println(k,v,"字符串") 
		} else if value,ok := v.(PersonTest);ok { 
			fmt.Println(value.name,"结构体") 
		} else { 
			fmt.Println("错误的数据类型") 
		} 
	} 
	//0 1 数字 
	//1 hello 字符串 
	//erBi 结构体 
}