go的结构体、方法、接口
结构体：
结构体：不同类型数据集合
结构体成员是由一系列的成员变量构成，这些成员变量也被称为“字段”
先声明一下我们的结构体：
type Person struct {
name string
age int
sex string
}定义结构体法1：
var p1 Person
fmt.Println(p1)
p1.name = "XUPT"
p1.sex = "无性别"
p1.age = 74定义结构体法2：
p2 := Person{}
p2.age = 244
p2.name = "艾美莉卡"
p2.sex = "沃尔玛购物袋"
fmt.Println(p2) //{艾美莉卡 244 沃尔玛购物袋}定义结构体法3：
p3 := Person{name: "荷叶饭",
sex: "女",
age: 18, //加逗号
}
fmt.Println(p3) //{荷叶饭 18 女}定义结构体法4：
p4 := Person{
"米库",
16,
"女",
}
fmt.Println(p4) //{米库 16 女}结构体为值类型，默认深拷贝（连同对象引用的所有嵌套对象（或指针指向的对象）都进行独立的复制）,往往用指针操纵：
fmt.Printf("%T\n", &p4) //*main.Person
fmt.Printf("%T\n", p1) //main.Person当你对一个结构体变量取地址时，返回的是这个结构体在内存中的存储位置，这个“储存位置”就是用指针类型来储存的
定义结构体指针：
var pp1 *Person
pp1 = &p1//p1是一个结构体，对p1取地址就是一个指针，所以可以画等号
fmt.Println(pp1)
fmt.Printf("%p,%T\n", pp1, pp1) //0xc0001040c0,*main.Person
fmt.Println(*pp1) //{XUPT 74 无性别}使用内置函数new(),go中专门用来创建某种类型的指针的函数
pp2 := new(Person)
fmt.Printf("%p,%T\n", pp2, pp2) //0xc0000202d0,*main.Person,指针类型
(*pp2).name = "zyzy"//也可以省略前面的*号,pp2.name="tzz"
(*pp2).age = 22
(*pp2).sex = "男"
fmt.Println(pp2) //&{zyzy 22 男}创建匿名结构体，一个没有名称的结构体：
s2 := struct {
name string
age int
}{
name: "无敌高考大王",
age: 18,
}
fmt.Println(s2.name, s2.age)好处：
简洁性
- 代码简洁：匿名结构体允许我们在定义变量的同时声明其类型，这减少了代码量并提高了可读性。
- 减少命名负担：对于只使用一次的小型结构体，无需费心命名。
- 即时定义：在函数或方法中快速定义新的数据结构，非常适合处理一次性的、结构简单的数据。
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
type Worker struct {
/*name string
age int*/
string
int //匿名字段
}定义一个含匿名字段的结构体：
w2 := Worker{
"无敌崩坏星穹铁道大王",
18,
}
fmt.Println(w2.string, w2.int) //打印匿名字段结构体
嵌套结构体：
结构体里套着结构体：
type Book struct {
bookName string
price float64
}
type Studentbook struct {
name string
age int
book Book
}定义法1：
ss2 := Studentbook{
name: "code",
age: 18,
book: Book{
"西西弗神话",
24.9,
},
}
fmt.Println(ss2)
定义法2：
bb1 := Book{}
bb1.bookName = "1984"
bb1.price = 45.8
ss1 := Studentbook{}
ss1.name = "奥威尔"
ss1.age = 24
ss1.book = bb1
fmt.Println(bb1)
fmt.Println(ss1)定义法3：
bb3 := Book{
bookName: "三体",
price: 14.9,
}
ss3 := Studentbook2{
name: "刘慈欣",
age: 18,
book: &bb3,
}
fmt.Println(bb3) //{三体 14.9}
fmt.Println(ss3) 
type关键字
1.类型定义：type 类型名 Type
2.类型别名：type 类型名=Type
var i1 myint //int
var i2 = 100 //int
var str1 mystr
str1 = "嘻嘻"
//main函数外
type myint int
type mystr string看上去好像myint和int没什么区别?
打印一下他们的数据类型：
fmt.Printf("i1类型==%T\ni2类型==%T\n", i1, i2)
//i2!=i1,i1,i2是两种语法类型
fmt.Printf("str1类型==%T\n", str1) //main.mystr
所以他们不是同一种数据类型，不能直接相等哦
我们也可以用type来重命名我们的函数类型：
type myfun func(int, int) string//定义一个新的函数类型，myfun就等价于 func(int,int)string
//照这个类型定义一个函数，等价于 func fun11() func(int, int) string
func fun11() myfun {
fun := func(a, b int) string {
s := strconv.Itoa(a) + strconv.Itoa(b)
return s
}
return fun
}
/*
上述函数等价于
func fun11() func(int, int) string {
fun := func(a, b int) string {
s := strconv.Itoa(a) + strconv.Itoa(b)
return s
}
return fun
}
*/调用我们的函数：
res1 := fun11()
fmt.Println(res1(10, 20)) //拼接10和20
type myint2 = int //给int起了别名，就像define
放弃了大量面向对象的特性，首字母大写可共用，小写为私用
这个类的私用和共用和保护在c++中是这么体现的：
class BaseClass {
public:
// 公有成员
int publicData;
protected:
// 保护成员
int protectedData;
};
class DerivedClass : public BaseClass {
public:
// 在派生类中可以访问基类的保护成员
void accessProtected() {
protectedData = 42; // 正常访问
}
private:
// 派生类有自己的私有成员
int derivedPrivate;
};
int main() {
DerivedClass d;
d.publicData = 10; // 可见，因为是公有的
d.accessProtected(); // 可见，因为DerivedClass继承了BaseClass
// BaseClass的对象尝试访问protectedData是不允许的
// BaseClass base;
// base.protectedData = 50; // 错误，protectedData仅对DerivedClass可见
return 0;
}如果我们写成go应该是这样的：
package main
import "fmt"
type BaseClass struct {
PublicData int //共有字段
protectData int //protected，只能在包内私用，未导出的字段
}
// 模拟c++的继承，嵌套结构体
type DerivedClass struct {
BaseClass
derivedPrivate int
}
func (d *DerivedClass) AccessProtected() {
d.protectData = 42 //访问我们未导出的protected字段
fmt.Println("protectData==", d.protectData)
}
func main() {
d := DerivedClass{}
d.PublicData = 10
fmt.Println("d.PublicData==", d.PublicData)
d.AccessProtected()
base := BaseClass{}
base.protectData = 50 // 如果在c++里编译错误：无法访问，因为我们的protected是对于派生类可以被访问
//但是在go里，我们不能把protected限定在类里，只能控制它在包内和包外是否可调用
fmt.Println(base.protectData) //50
fmt.Println("program finished")
}
很显然我们的go在面向对象这方面并不能像c++一样（比如我们的protected类）
oop(面向对象)
面向对象和面向过程的区别：
其实不止操作系统，很多系统的管理模式都是用面向对象的模式管理的
管理者并不在乎你每个人的个体特征。
在公司里，老板让你买咖啡，并且他很急。买咖啡有多种方式，例如点外卖、自己到楼下购买、托正在外面的同事捎来或者给老板花超绝三块钱冲雀巢等等。然后你就问老板说：老板，那我是去点外卖还是自己买还是给你冲速溶咖啡还是......老板根本不在乎你说的什么，他只会告诉你：不管怎样，我只要我的桌子上放有咖啡。
员工只要搞到咖啡就好了，而老板考虑的就多了（勾潮的鸣式还在追我
老板这个命令就叫面向对象（oop)他不在乎事情处理的过程；底层员工要做的就是处理好这些事情的过程。
面向对象就是把拥有复杂过程的事情抽象为一个类，比如在这里我们把自己买咖啡、点外卖、冲咖啡这种事情全部抽象为搞到咖啡（其实很像那些不近人情的上级会说：我不问过程只要结果呃呃）
本质上获得咖啡的途径，就是面向过程（opp)。也就是说，面向对象的最底层的实现方法还是面向过程。只不过在这里，面向过程被我们抽象为一个类。
按C++的STL来举例子:首先我们需要一个工具箱，里面装着我们需要的东西。于是我们先创造了工具箱这个东西；然后我们就要想在我们的工具箱里塞什么东西，比如说我需要一个排序的函数，需要一个求大值、最小值的函数；然后我们再去编写函数里面的内容，这个函数最里面的内容是面向过程，然后外边整体用的是面向对象的思想。
也就是说对特定对象先描述，再组织
————————————————之前写的部分
原文链接：https://blog.csdn.net/Au_ust/article/details/141108377
对象是最基本的单位，例如switch就是一个对象，描述他的有属性（是个程序员）和方法（打炉石传说）
这种类型的人可以被抽象、概括出来，就是一个类，例如上述的像switch一样的人可以被抽象为爱打炉石传说的程序员，像她一样爱打炉石传说的程序员都在这个类里面
面向对象编程具有三大特性：封装、继承、多态。
封装：将对象的属性和方法打包
继承：子类可以继承父类已有的功能
多态：不同的类执行不同的方法有不同的结果
在go语言中其实并不具有一种完备的面向对象的机制，没有什么内联函数，不如c++
但是我们可以使用偷感很重的方式：用接口和方法模拟oop的特性：
1.模拟继承性：is-a（是）,一个类继承一个类
子类可以直接访问父类的属性和方法
子类可以新增自己的属性和方法
子类可以重写父类的方法（override，就是将父类已有的方法，重新实现）
type A struct{
field
}
type B struct{
A//匿名字段
//可以在B的里面，在A的基础上修改A的方法属性
}2.模拟聚合关系 has-a（有），一个类拥有一个类
//这个很好理解
type C struct{
field
}
type D struct{
c C//聚合关系
}3.模拟多态
一个对象受到类型的限制，可以定义为父类类型，也可以定义为子类，类似于界门纲目科属种的关系
类型不同，能够访问的字段（功能）不同
go语言通过接口模拟多态，就是一个接口的实现
1.看成实现本身的类型，能够访问实现类中的属性和方法
2.看成是对应接口的类型，只能访问接口中定义的方法
一个很弱智很普通的模拟面向对象的实现：
package main
import "fmt"
func main() {
//1.创建父类对象
p1 := Personoop{"张三", 18}
fmt.Println(p1)
fmt.Println(p1.name, p1.age)
//2.创建子类对象
s1 := Studentoop{Personoop{"李四", 18}, "XUPT"}
fmt.Println(s1)
s2 := Studentoop{Personoop: Personoop{"王五", 18}, school: "XUPT"}
fmt.Println(s2)
var s3 Studentoop
s3.Personoop.name = "老公"
s3.Personoop.age = 18
s3.school = "CCUT"
fmt.Println(s3) //{{老公 18} CCUT}
//Personoop在Studentoopz中为匿名结构体字段，被称为提升字段
//因此可以如下命名
s3.name = "荷叶饭"
s3.age = 16
s3.school = "我不要上学"
fmt.Println(s3) //{{荷叶饭，16} 我不要上学}
}
// 1.定义父类
type Personoop struct {
name string
age int
}
// 2.定义子类//is-a的关系
type Studentoop struct {
Personoop //结构体嵌套模拟继承结构,提升字段,可以直接进行访问
school string //子类的新增属性
}
差不多就是这个意思，等下讲接口
方法（method)
方法的本质是一种函数，但是是定义了接受者的函数，这个接受者可以是很多种数据类型，还要结构体类型中的值或指针
所有给定统一类型的方法称为该类型的方法集。比如虾头太刀侠，可以登！龙！，还可以进行气刃大回旋，登龙和气刃大回旋就是虾头太刀侠的方法集
方法的名字可以重复，但是method区别调用者
语法：
func(接受者)方法名(参数列表)(返回值列表){
}来写一个样例看看：
type Worker1 struct {
name string
age int
sex string
}//结构体定义部分
func (w Worker1) work() {
fmt.Println(w.name, "在工作")
}//工作方法
func (p *Worker1) rest() {
fmt.Println(p.name, "在休息")
}//休息方法
func main(){
w1 := Worker1{name: "张三", age: 18, sex: "男"}
w1.work() //张三 在工作
w2 := &Worker1{name: "李四", age: 18, sex: "女"}
w2.rest() //李四 在休息
}
方法可以重名，我们创建一个新的类和刚刚的类对比：
type Worker1 struct {
name string
age int
sex string
}
type Cat struct {
name string
color string
sex string
}
func (p *Worker1) printfInfo() {
fmt.Println("name:", p.name, "age:", p.age, "sex", p.sex)
}
func (p *Cat) printfInfo() {
fmt.Println("name:", p.name, "color:", p.color, "sex:", p.sex)
}
func main(){
w1 := Worker1{name: "张三", age: 18, sex: "男"}
c1 := Cat{name: "艾露猫", color: "浅棕色", sex: "男"}
c1.printfInfo() //name: 艾露猫 color: 浅棕色 sex: 男
c1.name = "呆猫"
c1.printfInfo() //name: 呆猫 color: 浅棕色 sex: 男
w1.printfInfo() //name: 张三 age: 18 sex 男
//方法可以重名，因为接受者不同
}新增方法和重写方法的区别：
func main(){
//创建Personmethod类型
p1 := Personmethod{"王二狗", 18}
fmt.Println(p1) //{王二狗 18}
p1.eat() //父类的方法，吃盖浇面
s1 := Studentmethod{Personmethod{"ruby", 18}, "XUPT"}
fmt.Println(s1) //{{ruby 18} XUPT}
s1.study() //子类的新增方法，学生学习
s1.eat() //子类重写的方法，吃炸鸡
}
// 继承中的方法
// 定义一个“父类”
type Personmethod struct {
name string
age int
}
// 定义一个子类
type Studentmethod struct {
Personmethod
school string
}
// 定义一个父类方法
func (p Personmethod) eat() {
fmt.Println("父类的方法，吃盖浇面")
}
// 定义一个子类方法
func (p Studentmethod) study() {
fmt.Println("子类的新增方法，学生学习")//和子类的类型一样，方法名不一样
}
func (p Studentmethod) eat() {
fmt.Println("子类重写的方法，吃炸鸡")//重写是名字一样，类型不一样
}接口（interface)
接口是对方法的抽象，例如：你会吃东西，说明你肯定是个生物，但是如果你又会吃东西，还会玩元神，那你就是个私宅；所以吃东西可以单独做一个接口，吃东西和玩元神也可以做另一个接口
这样叫通过方法来确定你的类型（鸭子类型）
go语言中，接口类型的实现关系，是非侵入式：只实现，不用在乎是谁实现的
java中要显示定义
eg:
class Mouse implements USB{}
package main
import (
"fmt"
)
func main(){
//1.创建mouse类型
m1 := Mouse{"罗技小红"}
fmt.Println(m1)
//2.创建FlashDisk
f1 := FlashDisk{"闪速64G"}
fmt.Println(f1)
testIterface(m1)//鼠标就会从testIterface中的USB中找到鼠标对应的start方法
testIterface(f1)//同上
}
func testIterface(usb USB) { //usb=m1 usb=f1
usb.start()
usb.end()
}//测试我们接口的函数
type USB interface {
start()
end()
}//USB接口
func (m Mouse) start() {
fmt.Println("Mouse.start")
}
func (m Mouse) end() {
fmt.Println("Mouse.end")
}//对应的鼠标方法
func (f FlashDisk) start() {
fmt.Println("FlashDisk.start")
}
func (f FlashDisk) end() {
fmt.Println("FlashDisk.end")
}//对应的FlashDisk方法
也可以把main函数里面写成这样：
var usb USB
usb = m1
usb.start()
usb.end()
usb = f1
usb.start()
usb.end()可以更明显的看出接口对同类的不同对象方法的抽象
空接口
没有任何方法签名的接口叫空接口
写一个空接口：
package main
import (
"fmt"
)
func main() {
var a1 A = Dog{"黑犬"}
var a2 A = People{"纸包鱼", 30}
fmt.Println(a1, a2) //{黑犬} {纸包鱼 30}
test1(a1) //{黑犬}
test1(a2) //{纸包鱼 30}
test2(a1) //空接口 {黑犬}
test2(a2) //空接口 {纸包鱼 30}
//空接口代表任意类型的使用
slice1 := make([]interface{}, 0, 10)
slice1 = append(slice1, a1, a2, 100, "abc") //[{黑犬} {纸包鱼 30} 100 abc]
fmt.Println(slice1)
}
func test1(a A) {
fmt.Println(a)
}
func test2(a interface{}) {
fmt.Println("空接口", a)
}
// 空接口
type A interface {
}空接口中不限制数据类型
接口嵌套，可以模拟oop的继承特性，也可以通过不同接口看是什么接口类型，可以把实现类型看成接口类型：
package main
import (
"fmt"
)
func main() {
var dog Dog = Dog{"青色"}
dog.test11()
dog.test22()
dog.test33()
fmt.Println("------分隔符------")
var aa1 AA = dog //AA接口类型
aa1.test11()
fmt.Println("------分隔符------")
var bb1 BB = dog //BB接口类型
bb1.test22()
fmt.Println("------分隔符------")
var cc1 CC = dog //CC接口类型
cc1.test11()
cc1.test22()
cc1.test33()
}
type AA interface {
test11()
}
type BB interface {
test22()
}
type CC interface {
AA
BB
test33()
}
func (d Dog) test11() {
fmt.Println("test11...")
}
func (d Dog) test22() {
fmt.Println("test22...")
} //如果test11和test22都能实现，则Dog同时是AA和BB的实现
func (d Dog) test33() {
fmt.Println("test33...")
}接口断言
我们可以通过接口来判断实现类型。那么如果是空接口呢？或者两个类都可以实现同一个接口下的方法呢？比如你会翻滚，烤肠机上的烤肠也会翻滚，那么如何区分你和烤肠呢？
package main
import (
"fmt"
"math"
)
func main() {
var t1 Triangle = Triangle{3, 4, 5}
fmt.Println(t1.perimeter()) //12
fmt.Println(t1.area()) //6
var c1 Circle = Circle{5}
fmt.Println(c1.perimeter()) //31.41592653589793
fmt.Println(c1.area()) //78.53981633974483
var s1 Shape //Shape类型，但是没有确定为Triangle类型还是Circle类型
s1 = t1 //定义为Triangle类型
fmt.Println(s1.perimeter())
fmt.Println(s1.area())
//fmt.Println(s1.a,s1.b,s1.c),打印不了，因为s1是Shape接口类型
testShape(t1) //周长 12 面积 6
testShape(c1) //周长 31.41592653589793 面积 78.53981633974483
getType(t1) //是三角形,三边为 3 4 5
getType(c1) //是圆形半径为 5
getType(s1) //是三角形,三边为 3 4 5
var t2 *Triangle = &Triangle{3, 4, 5}
getType(t2) //ins:*main.Triangle 0xc000058030
//s:*main.Triangle 0xc0000260a0,地址不一样，值传递
getType1(t2) //三角形结构体指针 3 4 5
}
func getType(s Shape) {
//断言，判断接口对象是不是对应的实际类型
//1.if分支
if ins, ok := s.(Triangle); ok {
fmt.Println("是三角形,三边为", ins.a, ins.b, ins.c)
} else if ins, ok := s.(Circle); ok {
fmt.Println("是圆形半径为", ins.radius)
} else if ins, ok := s.(*Triangle); ok {
fmt.Printf("ins:%T %p\n", ins, &ins)
fmt.Printf("s:%T %p\n", s, &s)
} else {
fmt.Println("我也不知道")
}
}
func getType1(s Shape) {
//2.switch分支
switch ins := s.(type) {
case Triangle:
fmt.Println("是三角形,三边为", ins.a, ins.b, ins.c)
case Circle:
fmt.Println("是圆形半径为", ins.radius)
case *Triangle:
fmt.Println("三角形结构体指针", ins.a, ins.b, ins.c)
}
}
func testShape(s Shape) {
fmt.Println("周长", s.perimeter(), "面积", s.area())
}
// 1.定义一个接口
type Shape interface {
perimeter() float64
area() float64
}
// 2.定义实现类
type Triangle struct {
a, b, c float64
}
func (t Triangle) perimeter() float64 {
return t.a + t.b + t.c
}
func (t Triangle) area() float64 {
p := t.perimeter() / 2
s := math.Sqrt(p * (p - t.a) * (p - t.b) * (p - t.c))
return s
}
type Circle struct {
radius float64
}
func (c Circle) perimeter() float64 {
return math.Pi * c.radius * 2
}
func (c Circle) area() float64 {
return math.Pi * c.radius * c.radius
}