面向对象的引入

Golang没有类(class),Go语言的结构体(struct)和其他语言的类(class)有同等地位,你可以理解Golang是基于struct来实现面向对象(OOP)的

具体对象

用户: 用户id(int|long),姓名(string),年龄(int),性别(bool|string)

结构体定义

方式一

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Id intName stringAge intSex string}func main(){//创建结构体实例、对象、变量var chen Userfmt.Println(chen)
}

如图说明Id:0,Name:null,Age:0,Sex:null

方式二

var 实例名 对象类型 = 对象类型{}

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Id intName stringAge intSex string}func main(){//创建结构体实例、对象、变量var chen User = User{0,"admin",10,"保密"}fmt.Println(chen)
}

方式三

返回结构体指针

var 实例名 *对象类型 = new(对象类型)
//赋值
(*实例名).属性 = value
//实例名.属性=value  //go底层还是做了处理:  实例名.属性  转化   (*实例名).属性

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Id intName stringAge intSex string}func main(){//创建结构体实例、对象、变量var chen *User = new(User)(*chen).Id = 0(*chen).Name = "admin"(*chen).Age = 10(*chen).Sex = "保密"fmt.Println(chen)
}

方法四

返回结构体指针

var 实例名 *对象类型 = &对象类型{}

结构体之间的转化

方法一

type 对象名1 struct{Name string //同一属性
}
type 对象名2 struct{Name string //同一属性
}
func main(){var 实例名1 对象名1var 实例名2 对象名2实例名1 = 对象名1(实例名2)
}

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Name string
}
type Person struct{Name string
}func main(){//创建结构体实例、对象、变量var u Uservar p Personu = User(p)fmt.Println(u)
}

方法二

结构体type重新定义(相当于取别名); Golang认为是新数据类型，但相互间可以强转

type 对象名1 struct{
}
type 对象名2 对象名1 //重定义对象1为对象2
func main(){var 实例名1 对象名1var 实例名2 对象名2实例名1 = 对象名1(实例名2) //重定义还是得强转
}

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Name string
}
type U Userfunc main(){//创建结构体实例、对象、变量var u Uservar u1 Uu = User(u1)fmt.Println(u)
}

方法的引入

方法是作用在指定的数据类型上，和指定的数据类型绑定；因此自定义类型都可以有方法，不仅仅是struct

声明

type 对象名 struct{...
}
//func 方法名(){/*这个是函数,所以是函数名(这里为了判断)*/}
func (实例名 对象名) 方法名(){//这个是方法
}

(实例名 对象名): 体现出方法和对象有绑定关系

package main
import "fmt"type User struct{//变量名大写可以让其他方法可以访问到这个属性Name string
}func (u User) test() {fmt.Println(u)
}func main(){//创建结构体实例、对象、变量var u *User = &User{"我"}u.test()
}

方法注意事项

• 结构体类型是值类型，在方法调用中，遵守值类型传递机制，是值拷贝传递方式

package mainimport "fmt"type User struct{Name string;
}func (u User) test(){u.Name = "大佬们"fmt.Println(u.Name)//大佬们
}func main(){var u Useru.Name = "陈天羽"u.test()fmt.Println(u.Name)//陈天羽
}

意思是这个值的变化只有在方法中改变(值拷贝)

• 如程序员希望在方法中,改变结构体变量的值，可以通过结构体指针的方式来处理

package mainimport "fmt"type User struct{Name string;
}func (u *User) test(){ //指针类型User(*u).Name = "大佬们好"fmt.Println(u.Name)//大佬们好
}func main(){var u Useru.Name = "陈天羽"(&u).test()//传递的是指针变量地址fmt.Println(u.Name)//大佬们好
}

go语言可以简化

package mainimport "fmt"type User struct{Name string;
}func (u *User) test(){//对于前者来说就是改变了传入的对象值u.Name = "大佬们好"fmt.Println(u.Name)//大佬们好
}func main(){var u User*u.Name = "陈天羽"u.test()fmt.Println(u.Name)//大佬们好
}

• Golang中的方法作用在指定的数据类型上的，和指定的数据类型绑定，因此自定义类型，都可以有方法，而不是仅仅是struct,比如int,float等都可以有方法

package mainimport "fmt"type integer int //给int类型起别名func (i integer) print(){fmt.Println("i = ",i)
}func main(){var i integer = 20i.print()
}

如果方法里修改参数，得这么写

package mainimport "fmt"type integer intfunc (i *integer) print(){*i = 30fmt.Println("i = ",i)
}func main(){var i integer = 20i.print()fmt.Println(i)
}