码迷，mamicode.com
首页 > 其他好文 > 详细

Go语法的基本使用（三）

时间：2019-12-14 09:23:42      阅读：113      评论：0      收藏：0      [点我收藏+]

标签：nal   变量   Speak   efault   src   run   xxx   finally   print   

　　一. 在方法中使用 值 接收器 与 在函数中使用 值 参数

　　（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...")
}

 

　　六。

Go语法的基本使用（三）

标签：nal   变量   Speak   efault   src   run   xxx   finally   print   

原文地址：https://www.cnblogs.com/mofujin/p/12037313.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！