一. 在方法中使用 值 接收器 与 在函数中使用 值 参数
（1）定义用一个外部函数（接收器：接收值）方法中使用值接收器方法
package main import "fmt" // 在方法中使用 值 接收器 与 在函数中使用 值 参数 // 在方法中使用 指针 接收器 与函数再使用 指针 参数 // 结构体 type Person5 struct{ name string age int sex int } // (1)定义用一个外部函数（接收器：接收值）方法中使用值接收器方法 func (a Person5)printName(){ fmt.Println(a.name) fmt.Println(a.age) fmt.Println(a.sex) } func main(){ // 定义一个变量 p:=Person5{name:"tt",age:18,sex:1} // 调用值接收器 p.printName()
（2）方法中使用指针接收器
package main import "fmt" // 函数中使用 指针传值 // (1)定义一个结构体 type Person2 struct { name string age int sex int } // (2)定义一个函数 中功能代码 func (a *Person2)printName(){ // 需要执行的功能 哈 fmt.Println(a.name) fmt.Println(a.age) } // (3)入口函数 func main(){ // 定义结构体的变量 // var t *Person2=&Person2{name:"tt",age:18,sex:2} t:=&Person2{name:"tt",age:18,sex:2} // 值的传递可以省略类型 t.printName() }
（3）函数的值传递和指针传递
函数中使用值参数
// (1)定义结构体 type Person2 struct{ name string age string sex int id int } // (2)定义一个外部功能函数 参数和结构体一一对应 其实还有返回值 func printName(a Person2){ fmt.Println(a.name) fmt.Println(a.age) fmt.Println(a.sex) fmt.Println(a.id) } // (3)入口函数 >>>> url 地址的入口 func main() { // (4)定义结构的变量的初始值 //p:=Person2{} //字符串则是 空 数字 则是0 //fmt.Println(p,"---==") p:=Person2{name:"yy",age:"18",sex:2} // 不设置数字就是0 printName(p) // 函数就是传值 接收器（a Person） p点方法 }
（4）函数中的指针传递参数
package main
import "fmt"
// (4)函数中的指针传递值
// (1)go语言定义结构体
type Person2 struct{
name string
age int
sex int
id int
}
// (2)外部执行功能函数
func printName(a *Person2){
fmt.Println(a.name)
fmt.Println(a.age)
fmt.Println(a.sex)
fmt.Println(a.id)
}
// (3)入口函数 func main(){ // (4)定义变量及初始化 p:=&Person2{age:18,name:"yuyu",sex:1,id:13} // 指名道姓 无关顺序 printName(p) // &p和上面的一样获取地址 }
一.接收器如果不能进行识别需要进行重命名
package main import "fmt" // 在非结构体上的方法 》》》重命名 接收器 type MyInt int func (i *MyInt) add(){ (*i)++ fmt.Println(*i) // 11 } func main() { // 定义一个变量 var a MyInt=10 a.add() // 接收器传值 fmt.Println(a) // 引用11 }
三，接口：是一系类方法的集合
（1）实现方式一：接收器 传值 >>> mian 中点方法进行调用
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 pD.speak() // 我是第一只胖鸭子 会speak 可以调 tD.speat() // 我是唐老鸭 会speak
（2）实现接收器中函数的 run() 和speak() 方法 方法二：定义普通函数 在普通函数体内进行 run() 同时在我们的main中 调用 普通函数
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 //pD.speak() // 我是第一只胖鸭子 会speak 可以调 //tD.speat() // 我是唐老鸭 会speak //// speak(tD,"yyyy") //接收器 不是函数 不能传值 // 同时实现speak speak2(tD) 调用普通函数 speak(pD) // XXX(pD) var d Duck d=pD // d=tD fmt.Println(d,"xxxx") // {唐老鸭 false} xxxx } // （4）函数 的传值 func speak(p PDuck){ p.speak() 调用接收器中的方法 } func speak2(p TDuck){ p.speat() } func XXX(p PDuck){ p.run() // 在一个函数调用另一个函数 fmt.Println(p.name) 调用接收器的方法 }
四、断言 switch 判断子类的属性和方法
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 //pD.speak() // 我是第一只胖鸭子 会speak 可以调 //tD.speat() // 我是唐老鸭 会speak //// speak(tD,"yyyy") //接收器 不是函数 不能传值 // 同时实现speak speak2(tD) 调用普通函数 speak(pD) // XXX(pD) var d Duck d=pD // d=tD fmt.Println(d,"xxxx") // {唐老鸭 false} xxxx } // （4）函数 的传值 func speak(p PDuck){ p.speak() 调用接收器中的方法 } func speak2(p TDuck){ p.speat() } func XXX(p PDuck){ p.run() // 在一个函数调用另一个函数 fmt.Println(p.name) 调用接收器的方法 }
截图suoshi:
空接口
package main import "fmt" // 空接口(一个方法都没有) // 匿名空接口 // 所有的数据类型都实现了空接口 // 类似于一个父类 type Empty interface{ } type TDuck2 struct { name string age int wife bool } // 入口函数 func main(){ test3(1) test3("sss") test3(TDuck2{}) test3(10.233432423) //var a Empty=1 //var b Empty="IOOIO" } //func test(a Empty){ // fmt.Println(a) //} func test3(a interface{}) { switch a.(type) { case int: fmt.Println("int类型") case string: fmt.Println("string") case TDuck2: fmt.Println("老鸭子") default: fmt.Println("啥类型") }
五.异常处理
package main import ( "fmt" ) // 异常处理 // defer 延迟调用 即便程序出现严重错误 也会执行 // panic 就是python中的raise(主动跑出异常) // recover 恢复程序， 继续执行 func main() { //先注册，后调用 //defere ???? fmt.Println("xxx") // defere fmt.Println("yyyy") //f1() // 调用 f2() // 调用 //f3() // 调用 } func f1(){ fmt.Println("f1...") } func f2(){ defer func() { if a:=recover();a!=nil{ // a 如果不等于nil, 表示程序出了异常， a就是异常信息 // a 等于nil 表示没有异常 fmt.Println("代码异常出错；了") }//用于会被执行（相当于finally） }() // 这里执行函数 fmt.Println("f2...") // var a = make([]int,3,3) // fmt.Println(a[4]) panic("主动抛异常") } func f3(){ fmt.Println("f3...") }
六。