Go结构体方法

package main

import "fmt"

func main() {
	/*
	方法：method
		一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。
		所有给定类型的方法属于该类型的方法集


	语法：
		func （接受者） 方法名(参数列表)(返回值列表){

		}

	总结：method，同函数类似，区别需要有接受者。(也就是调用者)

	对比函数：
		A：意义
			方法：某个类别的行为功能，需要指定的接受者调用
			函数：一段独立功能的代码，可以直接调用

		B：语法
			方法：方法名可以相同，只要接受者不同
			函数：命名不能冲突

	 */
	w1 := Worker{name: "王二狗", age: 30, sex: "男"}
	w1.work()

	w2 := &Worker{name: "Ruby", age: 34, sex: "女"}
	fmt.Printf("%T\n", w2)
	w2.work()

	w2.rest()
	w1.rest()

	w2.printInfo()
	c1 := Cat{color: "白色的", age: 1}
	c1.printInfo()

}

//1.定义一个工人结构体
type Worker struct {
	//字段
	name string
	age  int
	sex  string
}

type Cat struct {
	color string
	age   int
}

//2.定义行为方法

func (w Worker) work() { //w = w1
	fmt.Println(w.name, "在工作。。。")
}

func (p *Worker) rest() { //p = w2 ,p = w1的地址
	fmt.Println(p.name, "在休息。。")
}

func (p *Worker) printInfo() {
	fmt.Printf("工人姓名：%s，工人年龄：%d，工人性别：%s\n", p.name, p.age, p.sex)
}

func (p *Cat) printInfo() {
	fmt.Printf("猫咪的颜色：%s，年龄：%d\n", p.color, p.age)
}

package main

import "fmt"

func main() {
	/*
	OOP中的继承性：
		如果两个类(class)存在继承关系，其中一个是子类，另一个作为父类，那么：

		1.子类可以直接访问父类的属性和方法
		2.子类可以新增自己的属性和方法
		3.子类可以重写父类的方法(orverride，就是将父类已有的方法，重新实现)


	Go语言的结构体嵌套：
		1.模拟继承性：is - a
			type A struct{
				field
			}
			type B struct{
				A //匿名字段
			}

		2.模拟聚合关系：has - a
			type C struct{
				field
			}
			type D struct{
				c C //聚合关系
			}

	 */
	 //1.创建Person类型
	 p1 := Person{name:"王二狗",age:30}
	 fmt.Println(p1.name,p1.age) //父类对象，访问父类的字段属性
	 p1.eat() //父类对象，访问父类的方法

	 //2.创建Student类型
	 s1 := Student{Person{"Ruby",18},"千锋教育"}
	 fmt.Println(s1.name) //s1.Person.name
	 fmt.Println(s1.age) //子类对象，可以直接访问父类的字段，(其实就是提升字段)
	 fmt.Println(s1.school) //子类对象，访问自己新增的字段属性

	 s1.eat() //子类对象，访问父类的方法
	 s1.study() //子类对象，访问自己新增的方法
	 s1.eat() //如果存在方法的重写，子类对象访问重写的方法
}

//1.定义一个"父类"
type Person struct {
	name string
	age int
}

//2.定义一个"子类"
type Student struct {
	Person //结构体嵌套，模拟继承性
	school string
}

//3.方法
func (p Person) eat(){
	fmt.Println("父类的方法，吃窝窝头。。")
}

func (s Student) study(){
	fmt.Println("子类新增的方法，学生学习啦。。。")
}

func (s Student) eat(){
	fmt.Println("子类重写的方法：吃炸鸡喝啤酒。。")
}