Go语法的基本使用

Posted 2021-03-23 mofujin

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语法的基本使用相关的知识，希望对你有一定的参考价值。

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

　　（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语法的基本使用的主要内容，如果未能解决你的问题，请参考以下文章