go语言之字符串、指针、数组、切片、结构struct、面向对象

概述：
Go 语言将字符串作为 种原生的基本数据类型，字 符串的初始化可以使用字符串字面量。

(1)字符串是常量，可以通过类 数组 索引访问其字节单元，但是不能修改某个字节的值
(2)宇符串转换为切片［］byte( 要慎用，尤其是当数据量较大时（每转换一次都需复制内容）
a := ” hello, world !”
b : = []byte (a)
(3)字符串尾部不包含 NULL 字符
(4)字符串类型底层实现是一个二元的数据结构，一个是指针指向字节数组的起点，另一个是长度(5)基于字符串创建的切片和原字符串指向相同的底层字符数组 一样不能修改 对字符
串的切片操作返回的子串仍然是由in ，而非 slicea := ” hello, world !
b :=a[: ]
c :=a [:2]
d :=a [:)
( ）字符串和切片的转换字符串可以转换为字节数组，也可以转换为 Unicode 的字数组。
( ）字符串的运算。

package mainimport (
"bytes"
"fmt"
"strconv"
"strings"
"time"
)func main() {
fmt.Println("字符串测试")fmt.Println("字符串转化")
//获取程序运行的操作系统平台下 int 类型所占的位数，如：strconv.IntSize。
//strconv.IntSizefmt.Println("将字符串转换为 int 型。")
var trastr01 string = ""
traint01, err_tra := strconv.Atoi(trastr01)
if err_tra != nil {
fmt.Println(err_tra)
} else {
fmt.Println(traint01)
}
fmt.Println("将字符串转换为 float64 型")
var trastr02 string = "100.55"
trafloat01, err_float := strconv.ParseFloat(trastr02, )
if err_float != nil {
fmt.Println(err_float)
} else {
fmt.Println(trafloat01)
}
trastr03 := strconv.Itoa()
fmt.Println("int 转字符安 " + trastr03)var str01 string = "hello,world"
str02 := "你好,世界"
fmt.Println(str01)
fmt.Println(str02)////字符串比较
com01 := strings.Compare(str01, str02)
if com01 == {
fmt.Println("相等")
} else {
fmt.Println("不相等 " + string(com01))
}
fmt.Println(com01)//查找 包含
var isCon bool = strings.Contains(str01, "hello")
fmt.Println(isCon) //true//查找位置
var theIndex int = strings.Index(str01, ",")
fmt.Println(theIndex) //
fmt.Println(strings.Index(str01, "haha")) //不存在返回-1lastIndex := strings.LastIndex(str01, "o")
fmt.Println("在字符串中最后出现位置的索引 " + strconv.Itoa(lastIndex)) //7
//-1 表示字符串 s 不包含字符串//统计给定子串sep的出现次数, sep为空时, 返回1 + 字符串的长度
fmt.Println(strings.Count("cheeseeee", "ee")) //
fmt.Println(strings.Count("five", "")) // 5// 重复s字符串count次, 最后返回新生成的重复的字符串
fmt.Println("hello " + strings.Repeat("world ", ))fmt.Println("替换")
// 在s字符串中, 把old字符串替换为new字符串，n表示替换的次数，小于0表示全部替换
var str03 string = "/Users//Documents/GOPatch/src/MyGO/config/TestString/"
str04 := strings.Replace(str03, "/", "**", -)
str05 := strings.Replace(str03, "/", "**", )fmt.Println(str04) //**Users****Documents**GOPatch**src**MyGO**config**TestString**
fmt.Println(str05) //**Users****Documents**GOPatch/src/MyGO/config/TestString/fmt.Println("删除字符串的开头和尾部")
fmt.Println("删除两头的/ = " + strings.Trim(str03, "/")) //Users//Documents/GOPatch/src/MyGO/config/TestString
fmt.Println("删除左边的/ = " + strings.TrimLeft(str03, "/")) //Users//Documents/GOPatch/src/MyGO/config/TestString/
//还有 TrimRightstr06 := strings.TrimSpace(" hello hao hao hao ")
fmt.Println("删除开头末尾的空格 =" + str06) //'hello hao hao hao'fmt.Println("大小写")
str07 := "hello hao hao hao"
fmt.Println(strings.Title(str07)) //Hello Hao Hao Hao
fmt.Println(strings.ToLower(" Hello Hao Hao Hao")) // hello hao hao hao
fmt.Println(strings.ToUpper(str07)) //HELLO HAO HAO HAO//前缀 后缀
fmt.Println(strings.HasPrefix("Gopher", "Go")) // true
fmt.Println(strings.HasSuffix("Amigo", "go")) // truefmt.Println("字符串分割")
fieldsStr := " hello it's a nice day today "
//根据空白符分割,不限定中间间隔几个空白符
fieldsSlece := strings.Fields(fieldsStr)
fmt.Println(fieldsSlece) //[hello it's a nice day today]for i, v := range fieldsSlece {
fmt.Printf("下标 %d 对应值 = %s \n", i, v)
}
for i := ; i < len(fieldsSlece); i++ {
fmt.Println(fieldsSlece[i])
}//根据特定字符分割
slice01 := strings.Split("q,w,e,r,t,y,", ",")
fmt.Println(slice01) //[q w e r t y ]
fmt.Println(cap(slice01)) //7 最后多个空""
for i, v := range slice01 {
fmt.Printf("下标 %d 对应值 = %s \n", i, v)
}//拼接
//Join 用于将元素类型为 string 的 slice, 使用分割符号来拼接组成一个字符串：
var str08 string = strings.Join(fieldsSlece, ",")
fmt.Println("Join拼接结果=" + str08) //hello,it's,a,nice,day,todayfmt.Println("------------对比字符串拼接效率----------------")
var buffer bytes.Bufferstart := time.Now()
for i := ; i < ; i++ {
buffer.WriteString("test is here\n")
}
buffer.String() // 拼接结果
end := time.Now()
fmt.Println("Buffer time is ", end.Sub(start).Seconds())start = time.Now()
str := ""
for i := ; i < ; i++ {
str += "test is here\n"
}
end = time.Now()
fmt.Println("+= time is ", end.Sub(start).Seconds())start = time.Now()
var sl []string
for i := ; i < ; i++ {
sl = append(sl, "test is here\n")
}
strings.Join(sl, "")
end = time.Now()
fmt.Println("Join time is", end.Sub(start).Seconds())
/*
Buffer time is 0.00388283
+= time is 11.730007558
Join time is 0.016644653
*/}

* pointerType //指针类型使用＊后面跟其指向的类型名
[n] elementType //／数纽类型使用[]后面跟数纽元素类型来表示， n表示该数组的长度
[] elementType //切片类型使用[] 后面跟切片元素类型来表示
map [keyType] valueType //map类型使用map[键类型]值类型来表示
chan valueType //通道使用chan后面跟通道元素类型表示
interface{ //接口类型 interface{} 将各个方法括起来
method1(inputParams)(returnParams)
method2(inputParams) (returnParams)
)

概述：
指针声明类型为*T，多指针为**T
通过变量名前加&来获取变量的地址

var a=
p := &a //*p和a的值都是11

import "fmt"type User struct {
name string
age int
}
func main(){
andes := User{
name: "andes",
age: ,
}
p := &andes
fmt.Println(p.name) //p.name 通过“.”操作符访问成员变量
}

package mainimport "fmt"func main() {
// 声明变量
var a int =
// 声明指针
var ip *int
// 指针变量的存储
ip = &a
fmt.Printf("a变量地址是：%x\n", &a)
//指针变量存储的地址
fmt.Printf("ip变量存储的指针地址：%x\n", ip)
//使用指针访问值
fmt.Printf("*ip变量的值：%d\n", *ip)
}

a :=
P := &a
p++ // 不允许，报 non-numeric type *int 错误

package mainimport "fmt"func sum (a , b int) *int {
sum := a + b
return &sum //允许， sum会分配在heap上
}
func main(){
fmt.Println(sum(,)) //打印内存地址
}

程序获取一个int变量num的地址并打印
将num的地址赋给指针ptr，并通过ptr去修改num的值

package main
import "fmt"
func main(){
//定义变量
var num int =10
fmt.Println(&num)
//定义指针
var ptr *int
//指针赋值
ptr = &num
//根据指针修改值
*ptr=20
fmt.Println(num)
}

概述：
数组的类型名是 [n]emetType ，其中n是数组长度， elementType 是数组元素类型
数组一般在 创建时通过字面量初始化，单独声明一个数组类型变量而不进行初始化是没有意义的。

a : = []int {，，} //指定长度和初始化字面量
a : = [ . . . ]int{l , , } //不指定长度，但是由后面的初始 列表数量来确定其长度
a : = []int{l : l , : ) // 指定总长度，并通过索引值进行初始化，没有初始化元素时使用类型默认值
a : =[ ...}int{l :, : ) //不指定总长度，通过索引值进行初始化，数组长度由最后一个索引值确定，没有指定索引的元 被初始化为类型的零值

）数组创建完长度就固定了，不可以再追加元素。
）数组是值类型的，数组赋值或作为函数参数都是值拷贝。
）数组长度是数组类型的组成部分，[]int 和[]int 表示不同的类型。
）可以根据数组创建切片

package mainimport "fmt"func main() {
a :=[...]int{,,}
b := a[]
for i,v :=range a{
fmt.Println(i,v)
fmt.Println(b)
}
}

package mainimport "fmt"func main(){
a := [...]int{,,}
alengh :=len(a)
for i :=; i<alengh; i++{
fmt.Println(a) //[1 2 3]
fmt.Println(alengh) //3 数组长度
fmt.Println(i) //2 索引值
}
}

概述：
Go 语言的数组的定长性和值拷贝限制了其使用场景， Go 提供了另一种数据类型 lic （中文为切片），
这是 种变长数组，其数据结构中有指向数组的指针，所以是 种引用类型

package mainimport "unsafe"func main(){
type slice struct {
arry unsafe.Pointer
len int
cap int //cap()函数返回的是数组切片分配的空间大小
}
}

语法：
array[b:c],array表示数组名；b表示开始索引，可以不指定，默认是0；c表示结束索引，可以不指定，默认是len(array)，数组长度，

package main
import (
"fmt"
)
func main(){
//创建有7个int类型元素的数组
var array = [...]int{,,,,,,}
s1 := array[:]
s2 := array[:]
s3 := array[:]
fmt.Println("%v\n",s1) // [0 1 2 3]
fmt.Println("%v\n",s2) // [0 1 2 3]
fmt.Println("%v\n",s3) // [2 3 4 5 6]
}

package mainimport "fmt"func main(){
//len=10,cap=10 创建数组a
a := make([]int,)
//len=10,cap=5 创建数组b
b := make([]int,,)
fmt.Printf("%v\n",a) //[0 0 0 0 0 0 0 0 0 0]
fmt.Printf("%v\n",b) //[0 0 0 0 0 0 0 0 0 0]
}

func main(){
var a []int
fmt.Printf("%v\n",a) //结采为 []
}

内置函数 len()返回切片长度
内置函数 cap()返回切片底层数组容量。
内置函数 ppend()对切片追加元素。
内置函数 copy() 用于 一个切片

package mainimport (
"fmt"
)func main() {
a := [...]int{,,,,,,}
b := make([]int,,)
c := a[:]
fmt.Println(b) //[0 0]
fmt.Println(len(b)) //
fmt.Println(cap(b)) //
b = append(b,) //切片尾部追加元素 1
fmt.Println(b) //[0 0 1]
fmt.Println(len(b)) //
fmt.Println(c) //[0 1 2]
fmt.Println(cap(b)) // b = append(b,c...)
fmt.Println(b) //[0 0 1 0 1 2]
fmt.Println(len(b)) //
fmt.Println(cap(b)) // d := make([]int,,)
copy(d,c) //copy只会复制d和c中长度最小的
fmt.Println(d) //[0 1]
fmt.Println(len(d)) //
fmt.Println(cap(d)) //
}

package mainimport "fmt"func main() {
// 定义数组
arr := [...]int{,,,,,,,}
// 切片取值
fmt.Println("arr[2:6]=",arr[:])
fmt.Println("arr[:6]=",arr[:])
fmt.Println("arr[2:]=",arr[:])
fmt.Println("arr[:]=",arr[:])
}

package mainimport "fmt"func main() {
//空切片
var s1 []int
s1=append(s1,,)
s1=append(s1, ,,)
fmt.Println("s1=" ,s1) //s1= [2 3 4 5 6]
//创建指定大小的切片
s2 := make([]int,) //创建长度为5的并初始化为0的切片
s2 =append(s2,)
fmt.Println(s2) //[0 0 0 0 0 6]
//创建并初始化切片
s3 := []int{,,}
s3 =append(s3,,)
fmt.Println(s3) //[1 2 3 4 5]
}

package mainimport (
"fmt"
)func main() {
//1 go 语言切片是对原数组的映射，并没有创建一个真正的切片
//定义数组
arr :=[...]int{,,,,,,,}
//取切片
s1 :=arr[:]
fmt.Println(s1) //[2 3 4 5] s2 := s1[:]
fmt.Println(s2) //[5 6]
s3 := append(s2,)
fmt.Println(s3) //[5 6 10]
s4 :=append(s3,)
fmt.Println(s4) //[5 6 10 11]
s5 :=append(s4,)
fmt.Println(s5) //[5 6 10 11 12]
}

package mainimport "fmt"func main() {
//go语言切片是对原数组的映射，并灭有创建一个真正的切片
//定义数组
data := [...]int{,,,,,,,,,}
//取切片 8，9
s1 := data[:]
s2 := data[:]
//将后面切片元素，拷贝到前面切面里面
//copy（）是从前往后添加并覆盖
copy(s2,s1)
fmt.Println(s2) //[8 9 2 3 4]
fmt.Println(data) // [8 9 2 3 4 5 6 7 8 9]
}

package mainimport (
"fmt"
)func main() {
//1go语言切片是对原数组的映射，并没有创建一个真正的切片
//定义数组
arr :=[...]int{,,,,,,}
//去切片
s1 :=arr[:]
//修改值
s1[] =
fmt.Println(s1) //[100 4 5 6 7]
fmt.Println(arr) //[1 2 100 4 5 6 7]
fmt.Println()
//go 语言切片美誉取到的位置，可以反向延申，不可向前延申
s3 :=arr[:]
fmt.Println(s3) //[100 4 5 6]
s4 :=s3[:]
fmt.Println(s4) //[6 7]
//容量大小
fmt.Println("s3=%v,len(s3)=%d,cap(s3)=%d\n",s3,len(s3),cap(s3))
// [100 4 5 6] 4 5
}

package main
import "fmt"
func main(){
str := "hello,世界" //通过字符串字面量初始化 个字符串 str
a := []byte(str) //将字符串转换为[]byte 类型切片
b := []rune(str) //将字符串转换为[]rune 类型切片
fmt.Println(a) //[104 101 108 108 111 44 228 184 150 231 149 140]
fmt.Println(b) //[104 101 108 108 111 44 19990 30028]
}

概述：
go语言内置的字典类型叫map。map的类型格式：
map[K]T,其中K可以是任意可以进行比较的类型
T值类型。map也是一种引用类型

package mainimport "fmt"func main() {
//1 创建map
var m1 map[int]string
fmt.Println(m1==nil)
//赋值报错因为是空的
//m1[1]="xxx"
//2 :=
m2 :=map[int]string{}
m3 :=make(map[int]string)
fmt.Println(m2,m3)
fmt.Println(m2[])
//3 指定容量
m4 :=make(map[int]string,)
fmt.Println(m4)
fmt.Println(m4[])
}

package mainimport "fmt"func main(){
ma := map[string]int { "a": , "b": }
fmt.Println(ma ["a"]) //
fmt.Println(ma ["b"]) //
}

package mainimport (
"fmt"
)func main() {
//1 定义并初始化
var m1 map[int]string= map[int]string{:"hello",:"world"}
fmt.Println(m1)
//2 自动推断类型
m2 := map[int]string{:"hello",:"world"}
fmt.Println(m2)
}

package mainimport "fmt"func main(){
//make(map[K]T) //map 容量使用默认位
//make(map[K]T,len) //map 的容量使用给定 len值
mpl := make(map[int]string)
mp2 := make(map[int]string,)
mpl[l] = "tom" mp2[] = "pony"
fmt.Println(mpl[l] ) //tom
fmt.Println(mp2[] ) //pony
}

map 的单个键值访问格式为mapName[key], 更新某个key 值时mapName[key]等号左边，访某个key的值时 mapName[key]放在等号的右边。
可以使用range遍历一个map类型变量,但是不保证每次迭代 元素的顺序。
删除map中的某个键值用如下语法： delete(mapName,key）。 delete是内置函数用来删除 map 中的某个键值对
可以使用内置的len()函数返回map中的键值对数量。

package mainimport (
"fmt"
)func main(){
mp := make(map[int]string)
mp[1] = "tom"
mp[1] = "pony"
mp[2] = "jsky"
mp[3] = "andes"
delete(mp,3)
fmt.Println(mp[1]) //pony
fmt.Println(len(mp)) //2
for k,v := range mp{
fmt.Println("key",k,"value",v)
//key 2 value jsky
//key 1 value pony
}
}

package mainimport (
"fmt"
)func main() {
m1 :=map[int]string{:"湖南小小鲜肉",:"成都小妹妹"}
m1[]="山西肉蒲团"
m1[] ="东莞小姐姐"
fmt.Println(m1) //map[0:山西肉蒲团 1:湖南小小鲜肉 2:成都小妹妹 3:东莞小姐姐]
//make()
m2 :=make(map[int]string,)
m2[]="山西挖煤团"
m2[]="内蒙放羊团"
fmt.Println(m2) //map[0:山西挖煤团 1:内蒙放羊团]
fmt.Println(m2[],m2[]) // 山西挖煤团 内蒙放羊团
}

package mainimport (
"fmt"
)func main() {
m1 := map[int]string{:"肉蒲团",:"黄梅"}
m1[] = "东京卫视"
m1[] = "北京卫视"
fmt.Println(m1) //map[1:东京卫视 2:黄梅 3:北京卫视]
//make()
m2 :=make(map[int]string,)
m2[]="东京热"
m2[]="小泽玛丽呀"
fmt.Println(m2) //map[0:东京热 1:小泽玛丽呀]
fmt.Println(m2[],m2[]) // 东京热 小泽玛丽呀
//map遍历
for k := range m1{
fmt.Println("%d----->%s\n",k,m1[k])
/*
%d----->%s
1 东京卫视
%d----->%s
2 黄梅
%d----->%s
3 北京卫视
*/
//判断map里面有没有此键
value,ok := m1[]
fmt.Println("value1=",value,",ok1=",ok) //value1= ,ok1= false
}
//删除delete
delete(m1,)
fmt.Println(m1) //map[1:东京卫视 3:北京卫视]
}

Go 内置的map不是并发安全的，并发安全的map可以使用标准包sync中的map
不要直接修改map value内某个元素的值，如果想修改 map 的某个键值，则必须整体赋值

package mainimport "fmt"type User struct {
name string
age int
}
func main(){
ma := make(map[int]User)
andes := User{
name:"andes",
age :,
}
ma[] = andes //必须整体赋值
//ma[1].age=19 //error ,不能通过map引用直接修改
andes.age=
fmt.Printf("%v\n",ma) //map[1:{andes 18}]
fmt.Println(andes.age) //
}

概述：由多个不同类型的元素组合而成，有两层含义：
struct 结构中的类型可以是任意类型
struct 的存储空间是连续的其字段按照声明时的顺序存放（字段之间有对齐的要求）
struct有两种形式：
struct字面量 2使用type声明自定义struct类型

struct {
FeildName FeildType //字段名 字段类型
FeildName FeildType
FeildName FeildType
}

type TypeName struct {
FeildName Fe ldType //字段名 字段类型
FeildName FeildType
FeildName FeildType
}

package mainimport "fmt"//定义学生结构体
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main(){
//1顺序初始化
//字符串用双引号，字符用单引
var s1 Student = Student{,"约汉",'f',,"xx"}
fmt.Println(s1) //{1 约汉 102 18 xx}
s2 :=Student{,"Jack",'m',,"yy"}
fmt.Println(s2) //{2 Jack 109 20 yy}
//2 指定初始化
s3 :=Student{id:,age:}
fmt.Println(s3) //{3 0 20 }
//3 结构体作为指针变量初始化
var s4 *Student = &Student{,"撸死",'m',,"jd"}
fmt.Println(s4) //&{4 撸死 109 24 jd}
//指针访问变量
//go底层会先判断传的是值还是指针类型
//若是指针类型，go会将s4 id替换（*s4）.id
fmt.Println((s4).id) //
fmt.Println(s4.id) // s5 :=&Student{,"xx",'f',,"sz"}
fmt.Println(s5) //&{5 xx 102 27 sz}
}

package mainimport "fmt"
func main() {
type Person struct {
name string
age int
}
type student struct {
*Person
Number int
} //按照类型声明顺序，逐个赋值
//不推荐这种初始化方式，一旦struct增加字段，则整个初始化语句会报错
a := Person{"Tom", }
//推荐这种使用Feild名字的初始化方式，没有指定的字段则默认初始化为类型的零值
P := &Person{
name: "tata",
age: ,
}
s := student{
Person: P,
Number:,
}
fmt.Println(a) //{Tom 21}
fmt.Println(P) //&{tata 12}
fmt.Println(s) //{0xc000078420 110}
}

结构体可以作为函数参数传递
结构体作为指针或非指针效果不一样

package mainimport (
"fmt"
)type Student struct {
id int
name string
sex string
age int
addr string
}
func tmpStudent(tmp Student) {
tmp.id=
fmt.Println("tmp=",tmp) //tmp= {250 zhangsan f 20 sz00}
}
func tmpStudent2(p *Student) {
p.id =
fmt.Println("tmp=",p) //tmp= &{249 zhangsan f 20 sz00}
}
func main() {
var s Student = Student{,"zhangsan","f",,"sz00"}
//传递非指针对象
tmpStudent(s)
fmt.Println("main s=",s) //main s= {1 zhangsan f 20 sz00}
//传递指针对象
tmpStudent2(&s)
fmt.Println("main s2=",s) // main s2= {249 zhangsan f 20 sz00}
}

go语言对于面向对象的设计非常简洁而优雅
没有封装、继承、多态这些概念，但同样通过别的方式实现这些特性
1封装：通过方法实现
2继承：通过匿名字段实现
3多态：通过接口

package mainimport "fmt"type Person struct {
name string
sex string
age int
}
//学生
type Student struct {
//匿名字段
Person
id int
addr string
}
func main() {
//1.顺序初始化
s1 :=Student{Person{"杰克","female",},,"sz"}
fmt.Println(s1) //{{杰克 female 18} 1 sz}
// 部分初始化
s2 := Student{Person: Person{name:"接客"}, id: }
fmt.Println(s2) // {接客 0} 2 }
}

package mainimport (
"fmt"
)//人的结构体
type Person struct {
name string
sex string
age int
}
type Student struct {
//匿名字段
Person
id int
addr string
//和Person中的字段同名
name string
}func main() {
var s Student
s.name="约汉"
fmt.Println(s) //{{ 0} 0 约汉}
//默认是就近原则赋值
//若需要赋值上一层，需要显式调用
s.Person.name="杰克"
fmt.Println(s) //{{杰克 0} 0 约汉}
}

package mainimport ( "fmt"
)//人的结构体
type Person struct {
name string
sex string
age int
}
//自定义类型
type mystr string
//学生
type Student struct {
//结构体类型匿名字段
Person
//内置类型匿名字段
int
//自定义类型匿名字段
mystr
}
func main() {
s1 := Student{Person{"lisi","male",},,"bj"}
fmt.Println(s1) //{{lisi male 18} 1 bj}
fmt.Println(s1.name) // lisi
}

package mainimport (
"fmt"
)//人的结构体
type Person struct {
name string
sex string
age int
}
//学生
type Student struct {
//结构体类型的匿名字段
*Person
id int
addr string
}
func main() {
s1 := Student{&Person{"wwangwu","male",},,"sz"}
fmt.Println(s1) //{0xc000088300 1 sz}
fmt.Println(s1.name) // wwangwu
}

在面向对象编程中，一个对象其实也就是一个简单的值或者一个变量，在这个对象中会包含一些函数
这种带有接收者的函数，我们称为方法，本质上，一个方法则是一个和特殊类型关联的函数
方法的语法如下
func (接收参数名 接收类型) 方法名(参数列表)(返回值)
1可以给任意自定义类型（包括内置类型，但不包括指针类型）添加相应的方法
2接收类型可以是指针或非指针类型
3为类型添加方法

package mainimport "fmt"type Myint int//定义方法，实现两个数相加
func Add(a,b Myint) Myint{
return a + b
}
func (a Myint) Add(b Myint) Myint{
return a + b
}
func main() {
var a Myint =
var b Myint=
//面向过程调用
fmt.Println("Add(a,b)",Add(a,b)) //Add(a,b) 2
//面向对象的调用
fmt.Println("a.Add(b)",a.Add(b)) //a.Add(b) 2}

package mainimport "fmt"type Person struct {
name string
sex string
age int
}//给Person添加方法
func (p Person) PrintInfo() {
fmt.Println(p.name, p.sex, p.age)
}func main() {
p := Person{"zhaoliu", "male", }
p.PrintInfo()
}

package mainimport "fmt"type Person struct {
name string
sex string
age int
}//给成员赋值，引用语义
func (p *Person) SetInfoPointer() {
(*p).name = "tianqi"
p.sex = "female"
p.age =
}//值语义
func (p Person) SetInfoValue() {
p.name = "zhouba"
p.sex = "male"
p.age =
}func main() {
//指针作为接收者的效果
p1 := Person{"xxx", "male", }
fmt.Println("函数调用前=", p1)
(&p1).SetInfoPointer()
fmt.Println("函数调用后=", p1) //值作为接收者
p2 := Person{"yyy", "female", }
fmt.Println("函数调用前=", p2)
p2.SetInfoValue()
fmt.Println("函数调用后=", p2)
}

package mainimport "fmt"type Person struct {
name string
sex string
age int
}//为Person定义方法
func (p *Person) PrintInfo() {
fmt.Printf("%s,%s,%d\n", p.name, p.sex, p.age)
}//继承上面的方法
type Student struct {
Person
id int
addr string
}func main() {
p := Person{"xxx", "male", }
p.PrintInfo()
s := Student{Person{"yyy", "male", }, , "bj"}
s.PrintInfo()
}

package mainimport "fmt"type Person struct {
name string
sex string
age int
}//为Person定义方法
func (p *Person) PrintInfo() {
fmt.Printf("%s,%s,%d\n", p.name, p.sex, p.age)
}//继承上面的方法
type Student struct {
Person
id int
addr string
}//相当于实现了方法重写
func (s *Student) PrintInfo() {
fmt.Printf("Student:%s,%s,%d\n", s.name, s.sex, s.age)
}func main() {
p := Person{"xxx", "male", }
p.PrintInfo()
s := Student{Person{"yyy", "male", }, , "bj"}
s.PrintInfo()
//显式调用
s.Person.PrintInfo()
}

package mainimport "fmt"type Person struct {
name string
sex string
age int
}func (p *Person) PrintInfoPointer() {
//%p是地址，%v是值
fmt.Printf("%p,%v\n", p, p)
}func main() {
p := Person{"zhangsan", "male", }
//传统调用方式
p.PrintInfoPointer()
//go语义方法值特性
pFunc1 := p.PrintInfoPointer
pFunc1()
//go方法表达式特性
pFunc2 := (*Person).PrintInfoPointer
pFunc2(&p)
}

package mainimport "fmt"//练习：创建属性的getter和setter方法并进行调用
type Dog struct {
name string
// 1公0母
sex int
}func (d *Dog) SetName(name string) {
d.name = name
}func (d *Dog) GetName() string {
return d.name
}//dog咬人的方法
func (d *Dog) bite() {
fmt.Printf("%s咬人了，起锅烧油", d.name)
}func test01() {
//创建dog对象
d := Dog{"二哈", }
d.bite()
}func main() {
test01()
}

new()和make()
new()用来分配内存，但与其他语言中的同名函数不同，它不会初始化内存，只会将内存置零
make(T)会返回一个指针，该指针指向新分配的，类型为T的零值，适用于创建结构体
make()的目的不同于new()，它只能创建slice、map、channel，并返回类型为T（非指针）的已初始化（非零值）的值