// GoStudy0219 project main.go
/*
go语言学习——面向对象编程（1）
go中类型的值语义和引用语义
结构体（类）的定义和初始化
*/
package main

import (
	"fmt"
)

func main() {
	//几种“类”的初始化
	v1 := &character{"Tom", 100, 10, 100} //这样定义出来的v1实际上时“类”的地址

	v2 := new(character) //	等价于v4:=&character{}
	v2.name = "Judy"
	v2.hp = 50
	v2.magic = 150
	v2.attack = 30

	v3 := &character{name: "Jim", hp: 150} //注意是花括号
	v3.magic = 30
	v3.attack = 20

	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println("*********************")

	//使用类的函数
	v1.addHp(600)
	fmt.Println(v1)
	fmt.Println(v1.hpIsLessThan(*v2))
	fmt.Println(v2)
	fmt.Println("*********************")

	//其他类型
	var v5 Age = 100
	fmt.Println(v5)

	v5.add(10)
	fmt.Println(v5)

	v5.errorAdd(10)
	fmt.Println(v5)
	fmt.Println("*********************")

	//值语义和引用语义
	//基本数据类型int，float之类的时值语义
	//数组和切片是值语义
	//map，channel和interface是引用语义

}

type Age int

func (this *Age) add(target Age) {
	*this += target
}

func (this Age) errorAdd(target Age) {
	this += target
}

//结构体（与其他语言中的类地位相同）
type character struct {
	name   string
	hp     float32
	attack float32
	magic  float32
}

func (this character) hpIsLessThan(target character) bool { //this character 不会改变this
	target.attack = 66
	return this.hp < target.hp
}

func (this *character) addHp(value float32) { //this *character 会改变this
	this.hp += value
}

// GoStudy0223 project main.go
/*
go语言学习——面向对象编程（2）
匿名组合
可访问性
*/

package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello World!")

	var stu *student = &student{1001, *&person{"Tom", 10, true}}
	fmt.Println(stu)
	stu.greet()           //匿名组合，能直接调用匿名的函数的方法
	fmt.Println(stu.name) //匿名组合能够直接调用匿名函数的属性
	stu.walk()            //多态重载的实现

	var tea *teacher = &teacher{55, "Judy", *&person{"Tom", 10, false}}
	fmt.Println(tea.name)
}

type person struct {
	name  string
	age   int
	isMan bool
}

func (this *person) greet() {
	fmt.Println("hello")
}

func (this *person) walk() {
	fmt.Println("walk slow")
}

type student struct {
	studentId int
	person    //匿名组合
}

func (this *student) walk() { //相当于多态重载，外部调用walk时不再执行匿名函数中的walk函数
	this.person.walk() //根据需求，实现了“基类”的函数，
	fmt.Println("walk quick")
}

type teacher struct {
	teacherId int
	name      string //person 里面的name相当于被隐藏了,外部调用teacher.name的时候，person里面的name并不会起作用
	person
}

/*
匿名组合相当于用类型名称（去掉包名部分）作为成员变量的名字，
因此，一个类型中如果同时有类似于person和xxx.person的时候可能会报错，因此要避免这种情况
*/

/*
首字母大写表示包外可访问，首字母小写，表示包外不能访问。
同一包内，不论首字母是大写还是小写都是能访问的
*/

// GoStudy0224 project main.go
/*
go语言学习——面向对象编程（3）
接口
*/
package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello World!")

	var per = &Person{"Tom", 50}
	fmt.Println(per)

	//接口的赋值
	//用对象赋值
	var v1 IAdd = per //这里传入的实际上是类型的地址
	v1.Add(10)
	fmt.Println(per)
	//用接口赋值
	var v2 IPerson = per
	var v3 IWalk = v2 //函数“全”的接口可以像函数“少”的接口赋值；如果几个接口中函数相同，则这几个接口可以相互转换
	v3.Walk()

	if v4, ok := v2.(IRead); ok { //检测，接口v2能不能转换成IRead接口
		v4.Read()
	}

	if v5, ok := v2.(*Person); ok { //检测，接口v2指向的对象类型是不是Person
		fmt.Println(v5)
	}

	var v6 interface{} = per //interface{}是any类型，空接口
	switch v7 := v6.(type) { //检测接口指向对象的类型
	case int:
		fmt.Println(v7, "int")
	default:
		fmt.Println(v7, "other")
	}

	var v8 IPerson2 = per
	v8.Read()

}

type Person struct {
	name string
	age  int
}

func (this *Person) Add(value int) {
	this.age += value
}

func (this *Person) Walk() {
	fmt.Println("walk")
}

func (this *Person) Speak() {
	fmt.Println("speak")
}

func (this *Person) Read() {
	fmt.Println("read")
}

//定义接口
type IWalk interface {
	Walk() //定义接口函数，省略func关键字
}

type IRead interface {
	Read()
}

type ISpeak interface {
	Speak()
}

type IAdd interface {
	Add(value int)
}

type IPerson interface {
	Walk()
	Read()
	Speak()
}

type IPerson2 interface { //接口的组合，等同于上一个接口的写法
	ISpeak
	IRead
	IWalk
}

/*传统语言的接口是一种契约，使用接口的类必须实现接口的所有方法，不同命名空间下的同名接口也被视为两个不同的接口
eg. C# java等需要考虑定义什么接口，在哪个类里面实现接口
go语言中，并不需要考虑上面的问题
*/