golang 接口interface 09

叁歲伎倆 2022-12-10 07:27 209阅读 0赞

###  1.接口会自动和拥有相同方法的结构体关联 ###

/*
    只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。
    如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。
    */
    type MyInterface interface{
    	GetName() string
    	GetAge() int
    }
    
    type StringInterface interface{
    	SumAgeSa() int
    }
    
    type CommonInterface interface{
    	MyInterface
    	StringInterface
    	GetGender() string
    }
    
    type Employee struct {
    	name   string
    	age    int
    	salary int
    	gender string
    }
    
    func (self *Employee) GetName() string {
    	return self.name
    }
    
    func (self *Employee) GetAge() int {
    	return self.age
    }
    
    func (self *Employee) SumAgeSa() int {
    	return self.age + self.salary
    }
    
    func (self *Employee) GetGender() string {
    	return self.gender
    }
    
    /*自动关联上了*/
    func IntRun()  {
    	// 空接口的使用，空接口类型的变量可以保存任何类型的值
    	// 空格口类型的变量非常类似于弱类型语言中的变量
    	var varEmptyInterface interface{}
    	fmt.Println("varEmptyInterface is of type %T\n", varEmptyInterface)
    	varEmptyInterface = 100
    	y := varEmptyInterface.(int) //这里可以类型转换（类型断言 ）
    	fmt.Println("varEmptyInterface is of type int", varEmptyInterface, y)
    	varEmptyInterface = "Golang"
    	k, err := varEmptyInterface.(string) //待判断的类型转换（类型断言 ）
    	if err {
    		fmt.Println("varEmptyInterface is of type string", varEmptyInterface, k)
    	}
    
    	varEmployee := Employee{
    		name:   "Jack Ma",
    		age:    50,
    		salary: 100000000,
    		gender: "Male",
    	}
    
    	var mm MyInterface = &varEmployee
    	fmt.Println(mm.GetName())
    	fmt.Println(mm.GetAge())
    
    	//这里可以调用组合内的所有接口
    	var ww CommonInterface = &varEmployee
    	fmt.Println(ww.GetAge(), ww.GetGender(), ww.GetName(), ww.SumAgeSa())
    }

### 2.通过类型获取值 ###

func IntRun()  {
    	var varEmptyInterface interface{}
    	varEmptyInterface = 100
    	y := varEmptyInterface.(int) //这里可以类型转换（类型断言 ）
    	fmt.Println("varEmptyInterface is of type int", varEmptyInterface, y)
    	classifier(varEmptyInterface)
    
    }
    
    /*
    通过类型获取值
    */
    func classifier(items ...interface{}) {
    	for i, x := range items {
    		switch x.(type) {
    		case bool:
    			fmt.Println("classifier", "bool", i, x)
    		case float64:
    			fmt.Println("classifier","float64", i, x)
    		case int, int64:
    			fmt.Println("classifier","int", i, x)
    		case nil:
    			fmt.Println("classifier","nil", i, x)
    		case string:
    			fmt.Println("classifier","string", i, x)
    		default:
    			fmt.Println("classifier","other", i, x)
    		}
    	}
    }

### 3.简单工厂 ###

/*
    简单工厂例子
    */
    type Animal interface {
    	Sleep()
    	Age() int
    	Type() string
    }
    
    type Cat struct {
    	MaxAge int
    }
    
    func (this *Cat) Sleep() {
    	fmt.Println("Cat need sleep")
    }
    func (this *Cat) Age() int {
    	return this.MaxAge
    }
    func (this *Cat) Type() string {
    	return "Cat"
    }
    
    type Dog struct {
    	MaxAge int
    }
    
    func (this *Dog) Sleep() {
    	fmt.Println("Dog need sleep")
    }
    func (this *Dog) Age() int {
    	return this.MaxAge
    }
    func (this *Dog) Type() string {
    	return "Dog"
    }
    
    func Factory(name string) Animal {
    	switch name {
    	case "dog":
    		return &Dog{MaxAge: 20}
    	case "cat":
    		return &Cat{MaxAge: 10}
    	default:
    		panic("No such animal")
    	}
    }