GoLang 基础语法（十）

GoLang 基础语法（十）

1.接口嵌套

func main() {
	var d Dog
	d.test1()
	d.test2()
	d.test3()

	var a AA
	var b BB
	var c CC

	a = d
	a.test1()
	b = d
	b.test2()
	c = d
	c.test1()
	c.test2()
	c.test3()
	//要实现CC接口，需要实现AA，BB接口才能使用
}

type Dog struct {
}

func (d Dog) test1() {
	fmt.Println("test1...")
}

func (d Dog) test2() {
	fmt.Println("test2...")
}

func (d Dog) test3() {
	fmt.Println("test3...")
}

type AA interface {
	test1()
}
type BB interface {
	test2()
}
type CC interface {
	AA
	BB
	test3()
}

2.接口断言

• 将接口转换为其它继承自该接口的结构体

func main() {
	var t1 = Triangle{a: 5, b: 4, c: 3}
	fmt.Println(t1.peri())
	fmt.Println(t1.area())
	fmt.Println(t1.a, t1.b, t1.c)
	var c1 = Circle{radius: 10}
	fmt.Println(c1.peri())
	fmt.Println(c1.area())
	fmt.Println(c1.radius)
	fmt.Println("-----------------------")
	var s1 Shape = t1
	var s2 Shape = c1
	fmt.Println(s1.peri())
	fmt.Println(s1.area())
	fmt.Println(s2.peri())
	fmt.Println(s2.area())
	fmt.Println("-----------------------")
	TestShape(s1)
	TestShape(s2)
	TestShape(t1)
	TestShape(c1)
	fmt.Println("------------------------")
	GetType(s1)
	GetType(s2)
	GetType(t1)
	GetType(c1)
	fmt.Println("------------------------")
	var t2 *Triangle = &Triangle{4, 3, 2}
	fmt.Printf("%p\n", t2)
	GetType(t2)
	fmt.Println("------------------------")
	GetType2(s1)
	GetType2(s2)
	GetType2(t1)
	GetType2(c1)
	GetType2(t2)
}

func GetType2(s Shape) {
	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 GetType(s Shape) {
	if ins, ok := s.(Triangle); ok {
		fmt.Println("三角形")
		fmt.Println(ins.a, ins.b, ins.c)
	} else if ins, ok := s.(Circle); ok {
		fmt.Println("圆形")
		fmt.Println(ins.radius)
	} else if ins, ok := s.(*Triangle); ok {
		fmt.Println("*三角形")
		fmt.Println(ins.c, ins.b, ins.c)
		fmt.Printf("%p\n%p\n", &s, s)
		fmt.Printf("%p\n", ins)
	} else {
		fmt.Println("其它")
	}
}

func TestShape(s Shape) {
	fmt.Println("周长:", s.peri(), "面积:", s.area())
}

type Shape interface {
	peri() float64
	area() float64
}

type Triangle struct {
	a, b, c float64
}

func (t Triangle) peri() float64 {
	return t.a + t.b + t.c
}

func (t Triangle) area() float64 {
	p := t.peri() / 2
	s := math.Sqrt(p * (p - t.a) * (p - t.b) * (p - t.c))
	return s
}

type Circle struct {
	radius float64
}

func (c Circle) peri() float64 {
	return 2 * math.Pi * c.radius
}

func (c Circle) area() float64 {
	return math.Pi * math.Pow(c.radius, 2)
}

3.Type关键字（一）

• 不加等号相当于新的类型，不能相互赋值

func main() {
	var i1 int = 10
	var myInt1 myInt = 20
	fmt.Println(i1, myInt1)
	var s1 string = "zzs"
	var myStr1 myStr = "ywj"
	fmt.Println(s1, myStr1)
	//不加等号相当于新的类型，不能相互赋值
	// myInt1 = i1
	// myStr1 = s1
	fmt.Println("--------------------------------")
	res1 := TypeFunc()
	fmt.Println(res1(20, 30))
}

func TypeFunc() myFunc {
	fun := func(a, b int) string {
		return strconv.Itoa(a) + strconv.Itoa(b)
	}
	return fun
}

type myInt int
type myStr string
type myFunc func(int, int) string

4.Type关键字（二）

• 当使用等号时，相当于取别名，所以值可以相互赋值

func main() {
	var i1 int = 10
	var selfInt1 selfInt = 20
	fmt.Println(i1, selfInt1)
	var s1 string = "zzs"
	var selfString1 selfStr = "ywj"
	fmt.Println(s1, selfString1)
	selfInt1 = 300
	selfString1 = "666"
	fmt.Println(selfInt1)
	fmt.Println(selfString1)
}

type selfInt = int
type selfStr = string

5.Type关键字（三）

• 如果想为某个其它包中的Type新增方法

func main() {
	//如果想为某个其它包中的Type新增方法
	var d MyDuration = 1
	d.myFunc()
}

type MyDuration time.Duration

func (d MyDuration) myFunc() {
	fmt.Println("我的方法")
}

6.Type关键字（四）

• 取别名之后，定义在结构体中时（匿名结构体），会因为不知道代表的含义而出现歧义

func main() {
	var s myStudent = myStudent{}
	s.myPerson.name = "zzs" //需要指明相应的名称，以免产生歧义
	s.myPeople.name = "ywj"
	fmt.Println(s)
}

type myPerson struct {
	name string
}
type myPeople = myPerson

type myStudent struct {
	myPerson
	myPeople
}