Go语言中面向对象

OOP思想

Go不是纯面向对象的语言

Go没有面向对象的三大特征(封装，继承，多态)

Go通过结构体嵌套模拟继承

继承，提升字段

type Person struct {
	name string
	age  int
}
type Student struct {
	Person        //匿名变量
	school string //子类自己的属性字段

}

func main() {
	p1 := Person{"周南", 18}
	fmt.Println(p1)
	s1 := Student{Person{name: "周南", age: 20}, "清华"}
	fmt.Println(s1.name)

	var s3 Student
	s3.name = "打阿伟"
	fmt.Println(s3)
}

方法讲解

type Dog struct {
	name string
	age  int
}

func (Dog) sleep() {
	fmt.Println("睡觉")

}

func (dog Dog) eat() {
	fmt.Println("Dog shutting")
}

type Cat struct {
	name string
	age  int
}

func (cat *Cat) eat() {
	fmt.Println("Cat shutting")
	cat.name = "黑黑"

}

func main() {
	d1 := Dog{"小白", 2}
	d1.eat()
	d1.sleep()
	fmt.Println(d1)
	c1 := Cat{}
	c1.eat()
	fmt.Println(c1)

}

方法重写

type Animal struct {
	name string
	age  int
}

type Dog2 struct {
	Animal
}
type Cat2 struct {
	Animal
}

func (animal Animal) eat() {
	fmt.Println("吃东西")
}
func (dog Dog2) eat() {
	fmt.Println("狗吃")
}

func main() {
	dog := Dog2{Animal{"名字", 2}}
	fmt.Println(dog)
	dog.eat()
	cat := Cat2{Animal{name: "小黑", age: 2}}
	fmt.Println(cat)
	cat.eat()

}

接口实现

type Usb interface {
	oInput()
	oOutput()
}
type Mouse struct {
	name string
}

func (mouse Mouse) oInput() {
	fmt.Println(mouse.name + "点击了")
}
func (mouse Mouse) oOutput() {
	fmt.Println(mouse.name + "离开了")
}
func (mouse Mouse) oOutput1() {
	fmt.Println(mouse.name + "罗森离开了")
}
func main() {
	mouse := Mouse{name: "雷蛇"}
	mouse.oOutput()
	mouse.oInput()
	mouse.oOutput1()
	fmt.Println(mouse)

}

接口实现多态

type Animal1 interface {
	eat()
	sleep()
}
type Pig struct {
	name string
}

func (pig Pig) eat() {
	fmt.Println(pig.name, "吃饭")

}
func (pig Pig) sleep() {
	fmt.Println(pig.name, "睡觉")

}
func text1(a Animal1) {
	fmt.Println("text1")
	a.eat()
	a.sleep()

}
func main() {
	p := Pig{name: "骚逼"}
	fmt.Println(p)
	p.eat()
	p.sleep()
	//实现类实现了这个接口，所有定义这个接口的地方都可以传入这个实现类
	text1(p)
	//定义一个类型为接口的变量
	//实际上可以赋值任何实现其接口实现类的对象
	var animal Animal1
	animal = p
	fmt.Println(animal)

}

空接口

type Dog1 struct {
	name string
}
type Cat1 struct {
	name string
	age  int
}

func (d Dog1) eat() {
	fmt.Println(d.name, "吃了")
}

type A interface {
}

func testa(a A) {
	fmt.Println(a)
}

// fmt 下面的输出接收参数都是这样的
func textab(a interface{}) {
	fmt.Println(a)
}
func main() {
	var a1 A = Dog1{name: "皱起远"}
	var a2 A = Cat1{name: "朱加祎", age: 12}
	var a3 A = 100
	fmt.Println(a1)
	fmt.Println(a2)
	fmt.Println(a3)

	d := Dog1{"小黑"}
	testa(d)
	fmt.Println(d)
	//map  k string v obj
	map1 := make(map[string]interface{})
	map1["name"] = "周南"
	map1["age"] = 20
	map1["addr"] = "怀德"
	fmt.Println(map1)

	//切片
	s1 := make([]interface{}, 0, 10)
	s1 = append(s1, a1, a2, a3, 1, 1, 1, 1)
	fmt.Println(s1)
	//总结 interface{}接口是一个万能对象相当于java中的object

}

接口继承

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

type DD struct {
	name string
}

func (dd DD) test1() {
	fmt.Println("test1")
}
func (dd DD) test2() {
	fmt.Println("test2")
}
func (dd DD) test3() {
	fmt.Println("test3")
}

func main() {
	var d DD = DD{"周南"}
	d.test1()
	d.test2()
	d.test3()
	var ia AA = d
	ia.test1()
	fmt.Println(ia)
	var ic CC = d
	ic.test3()
	fmt.Println(ic)

}

接口断言

func main() {
	asserString("aaa")
	asserInt(1)

}
func asserInt(i interface{}) {
	s, ok := i.(int)
	if ok {
		fmt.Println("接口变量i是int类型")
		fmt.Println(s)
	} else {
		fmt.Println("接口变量i不是int类型")
	}
}

func asserString(i interface{}) {
	s := i.(string)
	fmt.Println(s)
}