面向对象程序 封装,继承,多态,有时候我们设计程序的时候希望子类重写一个方法 影响父类的其他方法

一个python的多态简单例子

#!/usr/bin/env python

class Base(object):
    def Hello(self):
        self.Hi() #由子类实现
        print("Hello")
    def Hi(self):
        # 由子类实现
        pass

class Child(Base):
    def Hi(self):
        print("Child Hi")


o = Child()
o.Hello()
#子类引用调用父类方法  这个方法调用的方法子类实现 多态 重写是多态的一种实现
# Child Hi
# Hello

go语言中没有继承但是有组合,组合如何实现这种逻辑呢

package main

import (
	"fmt"
)

type Base struct {
	name string
}

func (b Base) Hello() {
	fmt.Println("hello base")
	b.Hi()
}
func (b Base) Hi() {

}

//Child组合了Base
//override重写了Hi
type Child struct {
	Base
}

func (c Child) Hi() {
	fmt.Println("override child")
}
type Welcome interface {
	Hello()
	Hi()
}

func Hello(welcome Welcome)  {
	welcome.Hello()
}

func main() {
	var x Welcome
	x = Child{}
	x.Hello()
	x = Base{}
	x.Hello()
	//hello base
	//hello base
	//	没有输出我想要的结果
	//func (b Base) Hello() {
	//  因为这里的b 就是Base类型 总是调用Base的Hi
    //	fmt.Println("hello base")
    //	b.Hi()
    //}
    
	//我想要输出
	//hello base
	//override child
	//hello base
}

使用函数类型来实现

结构体的函数类型应该就是这样使用的,需要组合的结构体自己重写结构体的函数类型来实现多态,重写结构体方法达不到自己想要的效果

package main

import (
	"fmt"
)

type Base struct {
	name string
	Hi func()
}

func (b Base) Hello() {
	fmt.Println("hello base")
	if b.Hi != nil{
		b.Hi()
    }
}

//Child组合了Base
//override重写了Hi
type Child struct {
	Base
}

type Welcome interface {
	Hello()
}

func Hello(welcome Welcome)  {
	welcome.Hello()
}

func main() {
	x := Child{}
	//x.Hi是匿名组合的语法糖
	x.Hi = func() {
		fmt.Println("override child")
	}
	x.Hello()
	x.Base.Hi = func() {
		fmt.Println("override override child")

	}
	x.Hello()
	//hello base
	//override child
	//hello base
	//override override child
	//	输出我想要的结果
}

回顾一下反射

反射我认为的用途:就是有可能你调用的方法或属性是通过外部传进来的字符串

//然后你就不用这样写.
if input == "foo"{
    foo()
}
if input == "bar"{
    bar()
}
if input == "attr"{
    y = x.attr
}

python的场景

def get():
    print("get")
def post():
    print("post")

method = input("method:")
x = "ss"
exec("%s()" % method)
eval("%s()" % method)
#两个都可以使用
#exec 是执行语句 比如下面的语句 eval是执行表达式
exec("x= %s()" % method)
print(x)

go的场景

package main

import (
	"fmt"
	"reflect"
	"os"
	"log"
	"bufio"
)

type Controller struct {
	Name string
}

func (Controller) Get() string {
	fmt.Println("get")
	return "call get"
}
func (Controller) Post() string {
	fmt.Println("post")
	return "call post"
}
func main() {
	fmt.Print("输入Get执行Get函数,输入Post执行Post函数:")
	rd := bufio.NewReader(os.Stdin)
	line, _, err := rd.ReadLine()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(line))

	v := reflect.ValueOf(Controller{Name: "ww"})
	fmt.Println(v)
	fmt.Println(v.FieldByName("Name"))

	x := v.MethodByName(string(line)).Call([]reflect.Value{})
	fmt.Println(x[0].Kind())
	//输入Get执行Get函数,输入Post执行Post函数:Post
	//Post  fmt.Println(string(line))
	//{ww}  fmt.Println(v)
	//ww     fmt.Println(v.FieldByName("Name"))
	//post   调用post方法
	//string fmt.Println(x[0].Kind())
}