1.结构体

go语言中结构体是开启面向对象编程的基础，go语言与python，js，java等语言的oop特性有很大的区别，在go语言中oop编程可以理解为面向结构体编程

1.1 例1 定义结构体

package main

import "fmt"

// Student 大写表示是公有的属性/方法，可以导出在其他文件中使用，小写名称就是私有的
type Student struct {
	Name string
	Age int
	hobby string
}

func main() {
	// 定义结构体的方式1
	var student Student
	student.Age = 20
	student.Name = "小明"
	fmt.Println(student) // {小明 20 }

	// 方式2
	student2 := Student{Name: "小王", Age: 30, hobby: "读书"}
	fmt.Println(student2) // {小王 30 读书}

	// 方式3 指针形式
	// 取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
	// 指针变量是 *，放在一个变量前使用就代表地址值。
	student3 := &Student{Name: "小妮", Age: 25, hobby: "跑步"}
	fmt.Println(*student3)
}

1.2 方法

package main

import "fmt"

// Student 大写表示是公有的属性/方法，可以导出在其他文件中使用，小写名称就是私有的
type Student struct {
	Name string
	Age int
	hobby string
}
func (s *Student) name() string {
	// s 是指针时会修改原来结构体的值
	s.Name = "小芳"
	return s.Name
}

func main() {
	// 方式2
	student2 := Student{Name: "小王", Age: 30, hobby: "读书"}
	fmt.Println(student2) // {小王 30 读书}

	name := student2.getName()
	fmt.Println(student2, name) // {小王 30 读书} 小贝

	name2 := student2.name()
	fmt.Println(name2, student2) // 小芳 {小芳 30 读书}
}

继承

package main

import "fmt"

type AA struct {
	Name string
	Age int
}

type BB struct {
	AA // 如此写就是继承
	hobby string
	address string
}

func main() {
	b := BB{hobby: "篮球", address: "上海", AA: AA{ Name: "小方", Age: 20 }}
	fmt.Println(b) // {{小方 20} 篮球 上海}
	// 如果不是多继承，就可以直接访问继承的结构体的属性
	// 当然方法也一样的
	fmt.Println(b.Age) // 20
	fmt.Println(b.AA.Age) // 20
}

2 接口

go中接口我开始也不是很理解，但是想到python的抽象类就理解了，千万不要将他与结构体混淆，它的本质是模板，标准。但实现确实借助了结构体(但不是必须的)，go语言中接口内部是方法

package main

import "fmt"

// Usb 声明一个接口
type Usb interface {
	// Start 声明了2个没有实现的方法
	Start()
	Stop()
}

type Phone struct {
}

// Start 让Phone实现usb接口的方法
func (p Phone) Start() {
	fmt.Println("手机开始工作")
}

func (p Phone) Stop() {
	fmt.Println("手机停止工作")
}

type Camera struct {
}

func (c Camera) Start() {
	fmt.Println("相机开始工作")
}

func (c Camera) Stop() {
	fmt.Println("相机停止工作")
}

// Computer 计算机
type Computer struct {
}

// Working 接收Usb接口类型变量
func (c Computer) Working(usb Usb) {
	usb.Start()
}

func main() {
	// 先创建结构体变量
	c := Computer{}
	phone := Phone{}
	camera := Camera{}

	c.Working(phone)
	c.Working(camera)
}

例子2

package main

import "fmt"

type AInterface interface {
	Say()
}

type Stu struct {
	Name string
}

func (s Stu) Say() {
	fmt.Println("stu Say()")
}

func main() {
	var s Stu // 结构体变量 实现了Say（）
	var s0 AInterface = s
	s0.Say()
}

接口继承

package main

import "fmt"

type A interface {
	Say()
}

type B interface {
	Hello()
}

// C 继承接口
type C interface {
	A
	B
}

type P struct {
	Name string
}

func (p P) Say() {
	fmt.Println("p say()")
}

func (p P) Hello() {
	fmt.Println("p Hello()")
}

func main() {
	var p P
	var p0 C = p
	p0.Say()
	p0.Hello()
}