go-面相对象使用

package baseDemo

import (
	"demo/baseDemo/utils"
	"fmt"
	"testing"
)

// 函数/方法的入参可以是一个接口(用来实现多态)
func funDemo(pointInterface1 utils.PointInterface) {
	pointInterface1.AddX()
}

func TestStruct(t *testing.T) {
	var point1 utils.Point //对象创建方式1
	point1.X = 1
	point1.Y = 1

	point2 := utils.Point{}           //对象创建方式2
	point6 := utils.Point{X: 1, Y: 2} // 对象创建方式4
	point5 := &utils.Point{1, 2}      //对象创建方式3-1 可以简化为 3-2(由编译器进行转换)
	point3 := utils.Point{1, 2}       //对象创建方式3-2 顺序赋值
	point4 := new(utils.Point)        //指向结构体的指针（类型：*Point）//对象创建方式4
	(*point4).X = 1                   //*:根据地址取出结构体，并进行赋值
	point4.Y = 1                      //编译器进行了转换，转成了(*point4).y = 1

	pointVO1 := utils.PointVO(point1) //不同结构体直接的转换
	fmt.Println(point1, point2, point3, point4, point5, point6, pointVO1)
}

// 方法表达式
func Test1(t *testing.T) {

	fun1 := utils.Point.InitPoint1
	point1, point2, point3 := utils.Point{}, utils.Point{}, utils.Point{}
	point1 = fun1(point1)

	fun2 := (*utils.Point).InitPoint1
	point2 = fun2(&point2)

	(&point3).InitPoint2() //引用传递
	point3.InitPoint2()    //可以简化，由编译器转换(只有类的方法才可以， 函数不会简化)
	fmt.Println(point1, point2, point3)
}

func TestInterface(t *testing.T) {

	//通过接口调用方法(用来实现多态，接口接收不同的类，执行类中多态的方法)
	point1 := utils.NewPoint(1, 1)
	var point2 utils.PointInterface = point1
	point2.AddY()
	fmt.Println(point2)

	//接口数组，可以存放不同的类，但是实现了接口
	pointInterfaceArr := []utils.PointInterface{}
	pointInterfaceArr[0] = point2

	//用空接口接收任意类型的参数
	var empty utils.EmptyInterface = &point1
	fmt.Println(empty)
}

func main() {
	p := utils.NewPoint(1, 1)
	p.SetX(10)
	p.GetX()
	fmt.Println(p)

	point3D := utils.Point3D{}
	point3D.Z = 1
	point3D.Point.X = 1
	point3D.X = 1 // 就近原则，但前类找不到属性/方法 会往父类上找 等于 point3D.Point.x = 1
	point3D.Point.InitPoint2()
	point3D.InitPoint2()

	point3D1 := utils.Point3D{utils.Point{1, 1}, 1}
	fmt.Println(point3D1)
}