20200326 指针结构体方法与接口

目录

• 昨日回顾
• go语言进阶
  • 一. 指针 &*
    • 1. 指针的定义
    • 2.指针的零值
    • 3. 指针的解引用
    • 4. 向该函数传递指针参数
    • 5. 不要向函数传递数组的指针,而应该使用切片
    • 6. go 不支持指针运算
    • 7. 指向指针的指针
    • 8. 数组指针与指针数组
  • 二. 结构体 type struct
    • 1.结构体定义
    • 2.结构体的使用
    • 3. 结构体的零值
    • 4. 定义并初始化(传入属性)
    • 5. 创建匿名结构体
    • 6. 结构体的指针
    • 7. 匿名字段
    • 8.嵌套结构体(结构体中套结构体)
    • 9.字段提升(只把不重复的字段提升)
    • 10. 导出结构体(大小写)和字段(大小写)
    • 11.结构体相等性
  • 三. 方法 fnuc (t type)
    • 1. 方法的定义
    • 2. 使用方法
    • 3. 指针接收器与值接收器
    • 4. 那么什么时候使用指针接收器，什么时候使用值接收器
    • 5. 匿名字段的方法
    • 6. 在方法中使用值接收器 与 在函数中使用值参数
    • 7. 在方法中使用指针接收器 与 在函数中指针参数
    • 8.在非结构体上的方法
  • 四. 接口 type 名字 interface
    • 1. 定义
    • 2. 简单使用

昨日回顾

// swtich 数组切片 map

// 1 switch （作为if else的另一种尝试）
          /*
          swtich 变量 {
            case 1,5:
              代码
            case 2,6：
              代码
            defult：
              代码
          }

          swtich  {
            case 条件:
              代码
            case 条件：
              代码
              Fallthrough
            defult：
              代码
          }
          */
//2 数组
 -内存中连续的存储空间，数组大小是固定的
	-var a [8]int=[8]int{1,2}
	-var a [8]int=[8]int{1:99}
	-a[2]
	-数组是值类型
	-数组长度 len
	-数组的遍历（两种）
      -for i,v:=range a{
              ---i:索引
              ---v：值
      }
	-多维数组
			-var a [2][3]int=[2][3]int{{1,2,3},{4,5,6}}
			-a[0][1]
//3 切片：本身不存储数据，对底层数组的引用
	-基于底层数组创建
			var a [8]int=[8]int{1,2}
			b:=a[:]
			b:=make([]int,3,5)
			b:=[]int{1,2}
	-长度和容量
	-使用 b[100]  //程序执行，如果越界，就报错
	-引用类型
	-追加 append
	-循环  range
	-多维切片
	-切片的数据结构  a[4]
			{
        指向数组的指针
        长度
        容量、
      }

//4 map:key value存储
	-定义 var a map[key的类型]value的类型
	-var a map[key的类型][]map[int]string
	-var a map[key的类型]对象
	-a[key]
	-可能为空值，不会报错
	-判断key是否存在
    if _,ok:=a[999];!ok{
      fmt.Println("不存在")
    }
	-map的长度 len
	-循环map
      for k,v:=range a{
          k:key
          v:value
      }
	-map是引用类型 （空值为nil，当参数传递会修改原来的值）
	-相等性（只能跟nil比较）




//补充：自动化运维
	-资产收集20台服务器
	-项目日志：echars 
	-批量执行命令，批量安装软件，代码自动发布，自动下线

go语言进阶

一. 指针 &*

指针是一种存储 变量内存地址 的变量

• 取一个变量的地址: & 取地址符号
• 如果在类型前面加*,表示指向这个类型的指针
• 在指针变量前加*,表示解引用(反解),通过地址拿到值

1. 指针的定义

func main(){
    var b=156
    // 把b内存地址赋值给a这个指针
    // 取一个变量的地址: & 取地址符号
    
    // 如果在类型前面加*,表示指向这个类型的指针
    var a *int = &b
    // var c *string =&b  int类型不能赋值给字符串类型的指针
    // a :=&b
    fmt.Println(a)
}

2.指针的零值

var b int 
fmt.Println(b)   // nil

3. 指针的解引用

拿到地址指向的值

var b = 156
a:=&b
fmt.Println(a)
// 指针a指向的值: 解引用(反解)
fmt.Println(*a)

4. 向该函数传递指针参数

func(){
    var b = 126
    fmt.Println(b)	//156
    test(&b)
    fmt.Println(*b)	//166
}

func test(b *int){
    //解引用,然后操作 b是一个指针
    *b++	//指针传过来地址,修改了原来的数据
    fmt.Println(*b)	//166
}

5. 不要向函数传递数组的指针,而应该使用切片

• 切片较数组内存占用小
• 传递类型不会因数组大小而更改

func main() {
    var a[3]int = [3]int{3,4,5}
    //写一个函数,传入数组,改掉原来的数组
    test(&a)    // 传入变量的地址
    
    
    // 向函数传递切片 (推荐使用切片)
    test1(a[:])
}


//*[3]int 类型的指针
func test(x *[3]int){
    //x传入的是指针
    //x[1]=100      // 支持指针自动操作,不会报错,内部自动处理
    (*x)[1]=100     // 先解引用,再改值
    fmt.Println(x)  //x是一个指向数组的指针,地址 : 打印出 &[3 100 5]
}


func test1(x []int){
    x[0] = 100
    fmt.Println(x)
}

6. go 不支持指针运算

    //var b =156
    //a := &b
    ////不允许指针运算
    //a++

7. 指向指针的指针

    var b int=156
    var a *int=&b

    var c **int
    c = &a
    fmt.Println(c)

    var d ***int
    d = &c
    fmt.Println(d)

8. 数组指针与指针数组

• 数组指针: 指向数组的指针
• 指针数组: 数组里面放指针

    //数组指针
    var a[3]int =[3]int{1,2,3}
    var b *[3]int = &a
    fmt.Println(b)

    //指针数组
    var x,y,z=12,13,14
    var b [3]*int = [3]*int{&x,&y,&z}
    fmt.Println(b)

二. 结构体 type struct

go语言中的结构体,类似于面向对象语言中的类

• go中的面向对象: 继承,封装,多态
• 一系列属性的集合

1.结构体定义

定义一个结构体

type 结构体名字 struct {
    属性1 类型
    属性2 类型
    
    
// 大小写表示公有与私有
type Person struct {
    name string
    age int
    sex int
}

2.结构体的使用

func main(){
    p :=Person{}    //相当于实例化得到有一个对象
    var p Person =Person{}    //结构体的类型就是 Person
    fmt.Println(p)
    fmt.Println(p.name)
} 

type Person struct {
    name string
    age int
    sex int
}

3. 结构体的零值

 	var p Person// 值类型,零值是属性的零值
    p.name="jack"
    fmt.Println(p)

4. 定义并初始化(传入属性)

var p Person=Person{}

   按位置传
var p Person=Person{"jack",15,1}
    按关键字传(位置可以乱,有几个值就要传几个值)
var p Person=Person{name:"jack",age:15,sex:2}

fmt.Println(p)
fmt.Println(p.name)

5. 创建匿名结构体

没有名字,也没有type关键字,定义在函数体内部
只使用一次,把一堆属性放到一个变量中

    a := struct {
       name string
       age int
       sex int
    }{age:18}
    fmt.Println(a.age)

6. 结构体的指针

    var p Person=Person{sex:1,age:12}
    var p1 *Person=&Person{sex:1,age:12}    //指针
    var p1 *Person  // 结构体空值是nil
    fmt.Println(p1)

7. 匿名字段

• 字段没有名字
• 做变量提升,提升字段:面向对象中的继承

	// 按位置
    var p Person2=Person2{"lqz",18}
    //按关键字
    var p Person2=Person2{int:18,string:"jack"}
    fmt.Println(p)



//匿名字段
type Person2 struct {
    string
    int
    sex int     // 匿名与有名可以套用
}

8.嵌套结构体(结构体中套结构体)

    // 按位置
    var p Person3=Person3{"jack",12,Hobby{1,"蓝蓝"}}
    //按关键字
    var p Person3=Person3{name:"abc",hobby:Hobby{}}
    fmt.Println(p)
    //把hobby的id设置2,name设置为篮球
    p.hobby.name="篮球"
    p.hobby.id = 2
    fmt.Println(p)



//结构体嵌套
type Hobby struct {
    id int
    name string
}
type Person3 struct {
    name string
    age int
    hobby Hobby
}

9.字段提升(只把不重复的字段提升)

    // 按位置
    var p Person4=Person4{"jack"}
    //按关键字(面向对象的继承)
    var p Person4=Person4{name:"jack",Hobby2:Hobby2{}}

//Hobby中的字段被提升了(可以直接.)
    p.hobby_id=2
    p.hobby_name="chenglong"
    p.Hobby2.hobby_id=3

    // go中通过匿名字段和结构体嵌套实现面向对象的继承


--------------------------------
// 字段提升
type Hobby2 struct {
    hobby_id int
    hobby_name string
}
type Person4 struct {
    name string
    sex int
    age int
    Hobby2
}

10. 导出结构体(大小写)和字段(大小写)

11.结构体相等性

• 结构体是值类型。
• 如果它的每一个字段都是可比较的，则该结构体也是可比较的。
• 如果两个结构体变量的对应字段相等，则这两个变量也是相等的
• 如果结构体包含不可比较的字段，则结构体变量也不可比较。

三. 方法 fnuc (t type)

python: 什么是方法(绑定给对象,类,自动传值),什么是函数

go: 方法是绑定给结构体的: 结构体只有属性 + 方法 = 类

1. 方法的定义

func 关键字和方法名之间 加入了一个特殊的接收器类型
func (t type) 方法名(){}

2. 使用方法

    p :=Person4{"jack",28,1}
    //自动传值
    p.printName()
    // 有了函数,为什么还要方法
    效果一样,但是调用方式,以及函数必须传值等


//定义一个结构体
type Person4 struct {
    name string
    age int
    sex int
}
//给结构体绑定方法
func (p Person4)printName(){
    fmt.Println(p.name)
}

//普通函数
func printName(p Person4)  {
	fmt.Println(p.name)
}

3. 指针接收器与值接收器

值接收器,不会修改原来的

指针接收器才会修改原来的

    p:=Person4{"jack",18,1}
    p.changeName("engo")    //值接收器
    //(&p).changeName("engo")    //值接收器,也可以
    p.changeAge(1111)       // 指针接收器
    //(&p).changeAge(1111)       // 指针接收器,没有区别
    fmt.Println(p)
    // 不管是值类型接收器,还是指针类型接收器,都可以用值和指针来调用



//3. 指针接收器与值接收器
func (p Person4)changeName(name string) {
    p.name=name
    fmt.Println(p)
}
//指针类型接收器的修改年龄
func (p *Person4)changeAge(age int) {
    //(*p).age=age    //解引用(正统的修改)
    p.age=age   // 可以直接修改
    fmt.Println(p)
}

4. 那么什么时候使用指针接收器，什么时候使用值接收器

指针接收器也可以被使用在如下场景：当拷贝一个结构体的代价过于昂贵时

5. 匿名字段的方法

    p :=Person5{}
    //匿名字段的方法也会提升
    p.hobbyName="篮球"
    p.printName()   // 继承.子类没有printName方法,就会调用父类的
    //指定调用父类的printName方法(面向对象的super())
    p.Hobby1.printName()




//匿名字段的方法
type Hobby1 struct {
    id int
    hobbyName string
}

type Person5 struct {
    name string
    age int
    sex int
    Hobby1
}
//Hobby1 的绑定方法
func (h Hobby1)printName(){
    fmt.Println(h.hobbyName)
}
//Person5 的绑定方法
func (p Person5)printName(){
    fmt.Println(p.name)
}

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

• 方法: 指针和值都可以来调用
• 函数 只能传值

7. 在方法中使用指针接收器 与 在函数中指针参数

• 方法: 指针和值都可以来调用
• 函数 只能传递指针

8.在非结构体上的方法

    //像给int类型绑定个add方法可以吗?
    //var i int =10
    //i.add()  // 不行

// 但是可以给传统数据类型重命名,然后绑定方法
    var i Myint=10
    i.add()
    i.add()
    i.add()
    fmt.Println(i)


type Myint int //把int类型重命名为Myint

func (i *Myint)add(){
    (*i)=(*i)+1     // 指针类型 解引用
}

四. 接口 type 名字 interface

interface(接口)是golang最重要的特性之一，Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。

简单的说：

• interface是方法的集合
• interface是一种类型，并且是指针类型
• interface的更重要的作用在于多态实现

1. 定义

定义一个对象的行为,一系列方法的集合

规范了子类应该有哪些行为,类似abc模块
django中: 父类写了一个发布方法,没有d代码.只有一个raise, 子类继承,但是没有重写该方法,一调用就报错



type  接口名称 interface {
method1 (参数列表) 返回值列表
method2 (参数列表) 返回值列表
...
}

2. 简单使用

• 接口的使用不仅仅针对结构体，自定义类型、变量等等都可以实现接口。
• 如果一个接口没有任何方法，我们称为空接口，由于空接口没有方法，所以任何类型都实现了空接口。
• 要实现一个接口，必须实现该接口里面的所有方法。

package main

import "fmt"

//1.定义了一个鸭子接口(run speak方法)
type DuckInterface interface {
    run()
    //run(a int)int     // 有参数,有返回值
    speak()
}




//写一个唐老鸭结构体，实现该接口
type TDuck struct {
    name string
    age int
    wife string
}
//实现接口(只要结构体绑定了接口中的所有方法,就叫做结构体实现了该接口)
func (t TDuck)run() {   //传参的话,接口也必须定义
    fmt.Println("我是唐老鸭",t.name,"我会走路")
}
func (t TDuck)speak() {
    fmt.Println("我是唐老鸭",t.name,"我会说话")
}



//写一个肉鸭结构体
type RDuck struct {
    name string
    age int
}
func (t RDuck)run() {   //传参的话,接口也必须定义
    fmt.Println("我是肉鸭",t.name,"我会走路")
}
func (t RDuck)speak() {
    fmt.Println("我是肉鸭",t.name,"我会说话")
}

func main() {
    //实例化
    var t TDuck=TDuck{"嘤嘤怪",17,"刘亦菲"}
    var r RDuck=RDuck{"怪五",18}
    //唐老鸭的run
    t.run()
    //肉的run
    r.run()

    //定义一个鸭子接口类型(肉鸭和唐老鸭都实现了鸭子接口,所以都可以把对象赋值给鸭子接口)
    var i1 DuckInterface
    i1 = TDuck{"嘤嘤怪",17,"刘亦菲"}
    var i2 DuckInterface
    i2 = RDuck{"怪五",18}
    //分别实现run方法
    i1.run()
    i2.run()
}