Go语言学习（七）-- 方法和接口

目录

1 方法的定义和使用

 2 方法的继承和重写

 3. 接口的定义与实现

 4. 接口类型断言

go语言中不仅有函数还有方法。其实他们之间的区别并不是很大，函数只要声明定义了以后只要在它的作用域类就可以使用函数，而方法就是多了一个接收者，我们只有通过接收者来调用这个方法，感觉能够更加体现出封装的感觉。这个接收者可以是值对象接收者也可以是指针对象接收者，但是接收者不能够是内置数据类型。

语法格式如下：

func (variable_name variable_data_type) function_name( 参数列表) [return_type] {
 
/* 函数体*/
 
}

1 方法的定义和使用

func (p People) GetName() string {
    return p.Name
} 

func (p *People) GetAge() uint { 
    return p.Age 
}

• 修改实例状态
• 大对象
• 调用时会按照实际值来执行调用

代码实例：

package main
 
import "fmt"
 
type Student struct {
	id   int
	name string
}
 
// 无参数列表与返回值
func (stu Student) method1() {
 
}
 
// 有参数列表无返回值
func (stu Student) method2(id int, name string) {
 
}
 
// 有参数列表有返回值
func (stu Student) method3(id int, name string) int {
	return 0
}
 
// 有参数列表并且多个返回值
func (stu Student) method4(id int, name string) (a, b int) {
	return 0, 0
}
 
// 只要是值对象接受者 就不能够对其内容进行修改 因为操作的是一个备份
func (stu Student) method5(id int, name string) *Student {
	stu.id = id
	stu.name = name
	return &stu
}
 
// 指针对象接受者 我们可以对内容进行修改了
func (stu *Student) method6(id int, name string) *Student {
	stu.id = id
	stu.name = name
	return stu
}
 
//虽然接收者是一个值对象 但是传入值和指针对象都能够成功的调用这个方法
func (stu Student) showMessage() {
	fmt.Println(stu.id, " ", stu.name)
}
 
func main() {
	stu1 := Student{1, "tom"}
	// 值类型调用方法
	stu1.showMessage()
	//调用方法修改名字（）值接收者
	stu1.method5(2, "修改了名字")
	stu1.showMessage() //发现无法修改
 
	// 指针类型调用方法
	stu2 := &stu1
	stu2.method6(2, "修改")
	stu2.showMessage()
}

 2 方法的继承和重写

继承主要是通过匿名结构体来实现的，实际上并不是真正意义上的继承，只是再使用起来的时候看起来像那么回事。

可以看看我前面的博客来学习关于“继承”的知识： 匿名结构体中继承

package main
 
import "fmt"
 
type Person struct {
	Name string
	Age  int
}
 
func (P Person) Speak() {
	fmt.Printf("我是%s，今年%d岁了\n", P.Name, P.Age)
}
 
type Stu struct {
	Person
	Score float32
}
 
func (S Stu) Speak() {
	fmt.Printf("我是%s，今年%d岁了,得了%f分\n", S.Name, S.Age, S.Score)
}
 
func main() {
	person1 := Person{"zhangsan", 19}
	person1.Speak()
 
	stu1 := Stu{Person{"tom", 11}, 90.2}
	stu1.Speak()
}

type Animal interface { 
    GetName() string 
}
 
//只要是实现了方法体GetName的结构体都是实现了Animal这个接口

package main
 
import "fmt"
 
/*
type 接口名 interface{
	方法声明
	方法名（参数）返回值
}
*/
 
//定义一个接口
type Humaner interface {
	SayHi()
}
 
type Person2 struct {
	Name string
	Age  int
}
 
type Teacher struct {
	Person2
	Subject string
}
type Student2 struct {
	Person2
	Score int
}
 
//Teacher 实现了Humaner接口
func (t *Teacher) SayHi() {
	fmt.Printf("大家好，我是%s，我今年%d岁，我教%s\n", t.Name, t.Age, t.Subject)
}
 
//stu也实现了humaner接口
func (s *Student2) SayHi() {
	fmt.Printf("大家好，我是%s，我今年%d岁，我的成绩%d\n", s.Name, s.Age, s.Score)
}
 
func main0401() {
	//tea := Teacher{Person2{"张三", 33}, "go语言开发"}
	stu := Student2{Person2{"木子", 18}, 100}
	//创建接口类型变量
	var h Humaner
	//将对象的地址赋值给接口类型
	h = &stu
	//通过接口调用
	h.SayHi()
}
 
//多态 将接口类型作为函数参数
func SayHi(h Humaner) {
	h.SayHi()
}
func main() {
	//初始化对象
	tea := Teacher{Person2{"李四", 33}, "go语言开发"}
	stu := Student2{Person2{"木子", 18}, 100}
	//test:= struct {}{}
	SayHi(&stu)
	SayHi(&tea)
}

 4. 接口类型断言

package main
 
import "fmt"
 
type people struct {
	Name string
}
 
func main0501() {
	var i interface{} = &people{"jack"}
	//类型断言
	if v, ok := i.(*people); ok {
		fmt.Println(v.Name)
	} else {
		fmt.Println("类型匹配失败")
	}
}
func main() {
	var i interface{} = people{"李四"}
	switch i.(type) {
	case people:
		fmt.Println("people")
	case *people:
		fmt.Println("*people")
	default:
		fmt.Println("类型匹配失败")
 
	}
}