非零基础速成 Go_面向对象之结构体、接口与断言

╰半夏微凉° 2023-01-13 09:54 107阅读 0赞

# 非零基础速成 Go\_面向对象之结构体、接口与断言 #

## 结构体/类 ##

在 Java 面向对象中，class 来表示一个类，在 Go 中，跟 C 中的结构体一样，但面向对象特性做的

常好，在 Go 中以 struct 用来表示一个类，它也有接口、实现、集成等概念，一起来看看吧

package main
    
    import "fmt"
    
    type Hero struct {
        
       //首字母大写代表公有属性 小写代表私有属性 无法被外部类获得 如外部包 Hero.level 是不被允许的 但可以通过 get 方法获得
       Name string
       Ad int
       level int
    }
    
    //this 代表谁能调用这个方法 只有Hero对象可以调用 Show 方法
    //方法首字段用大写代表共有功法 跟 Java 中的 public 一样 小写则是 private
    func (this *Hero) Show() {
        
       fmt.Println(this.Name)
       fmt.Println(this.Ad)
       fmt.Println(this.level)
    }
    
    //这个方法是 public
    func (this *Hero) GetName() string {
        
       return this.Name
    }
    
    //private 屏蔽外部包的访问 
    func (this *Hero) SetName(newName string) {
        
       this.Name = newName
    }
    
    
    func main() {
        
       hero := Hero{
        Name: "zhangsan", Ad: 100}
       hero.Show()
       hero.setName("lisi")
       hero.Show()
    }

强调：在 Go 语言中，函数名的首字母大小写非常重要，它被来实现控制对方法的访问权限。

*  当方法的首字母为大写时，这个方法对于所有包都是Public，其他包可以随意调用
 *  当方法的首字母为小写时，这个方法是Private，其他包是无法访问的。

> Go语言通过首字母的大小写来控制访问权限。无论是方法，变量，常量或是自定义的变量类型，如果首字母大写，则可以被外部包访问，反之则不可以。

## 继承 ##

package main
    
    import "fmt"
    
    // ---------------------父类---------------------
    type Human struct {
        
       name string
       sex string
    }
    //Human对象的 Eat方法
    func (this *Human) Eat() {
        
       fmt.Println("Human eating ...")
    }
    
    func (this *Human) Walk()  {
        
       fmt.Println("Human walking...")
    }
    
    // ------------------子类---------------
    
    type SuperMan struct {
        
      //代笔继承类Human
       Human 
       level int
    }
    
    //方法重写
    func (this *SuperMan) Eat() {
        
       fmt.Println("Superman eating ...")
    }
    
    //子类的新方法
    func (this *SuperMan) Fly() {
        
       fmt.Println("Superman flying ...")
    }
    
    //子类新增方法
    func (this *SuperMan) Print()  {
        
       fmt.Println("name = ",this.name)
       fmt.Println("sex= ",this.sex)
       fmt.Println("level = ",this.level)
    }
    
    func main() {
        
       h := Human{
        "zhang3","female"}
       h.Eat()
       h.Walk()
    
       s := SuperMan{
        Human{
        "lisi" ,"female"},88}
       //walk方法没有重写 所以调用的是父类的
       s.Walk()
       s.Eat()
       s.Fly()
       s.Print()
    
    }

> Human eating …  
> Human walking…  
> Human walking…  
> Superman eating …  
> Superman flying …  
> name = lisi  
> sex= female  
> level = 88

## 接口 ##

package main
    
    import "fmt"
    
    //定义接口
    type Animal interface {
        
       Sleep()
       GetColor() string
       GetType() string
    }
    
    //猫  实现接口方法
    type Cat struct {
        
       color string
    }
    
    func (this *Cat) Sleep()  {
        
       fmt.Println("Cat is Sleep")
    }
    
    func (this *Cat) GetColor() string {
        
       return this.color
    }
    
    func (this *Cat) GetType() string {
        
       return "Cat"
    }
    
    //狗 同样实现接口方法
    type Dog struct {
        
       color string
    }
    
    func (this *Dog) Sleep() {
        
       fmt.Println("Dog is Sleep")
    }
    
    func (this *Dog) GetColor() string {
        
       return this.color
    }
    
    func (this *Dog) GetType() string {
        
       return "Dog"
    }
    
    // 多态
    // 究竟是猫还是狗 取决于传递进来的是猫还是狗
    func showAnimal(animal Animal)  {
        
       animal.Sleep()
       fmt.Println("color = ", animal.GetColor())
       fmt.Println("kind = ", animal.GetType())
    }
    
    
    func main() {
        
       //接口引用  指向 子类对象
       //var animal Animal
       //animal = &Cat{"Green"}
       //animal.Sleep()
       //
       //animal = &Dog{"Yellow"}
       //animal.Sleep()
    
       cat := Cat{
        "Green"}
       dog := Dog{
        "Yellow"}
       showAnimal(&cat)
       showAnimal(&dog)
    }

## 值传递和引用传递 ##

在GO中 传递对象也分引用传递和值传递 如果你传递的不是地址，那么默认都是值传递

注意这点跟 Java 有一定区别 Java 如果是引用传递 那么传递的就是地址

请看 demo

package main
    
    import "fmt"
    
    type Book struct {
        
       title string
       auth string
    }
    
    //传递的是副本 
    func changeBook(book Book)  {
        
       book.auth = "666"
    }
    
    //传递的是引用
    func changeBook2(book *Book)  {
        
       book.auth = "777"
    }
    
    func main() {
        
       var book1 Book
       book1.title = "Golang"
       book1.auth = "zhang3"
    
       fmt.Println(book1)
       changeBook(book1)
       fmt.Println(book1)
       changeBook2(&book1)
       fmt.Println(book1)
      //
      //{Golang zhang3}
    	//{Golang zhang3}
    	//{Golang 777}
    }

## 万能类型interface\{\}与类型断言 ##

package main
    
    import "fmt"
    
    //接收 interface{} 是万能类型
    func myFunc(arg interface{
        })  {
        
       fmt.Println("calld myFunc")
       //如何区分这个万能类型  "类型断言"
       fmt.Println(arg)
       //判断 arg 是否是 string 类型 
       value, ok := arg.(string)
       if !ok {
        
          fmt.Println("arg is not string type")
       }else {
        
          fmt.Println("arg is string type,value = ",value)
          fmt.Printf("value type is %T\n",value)
       }
    }
    
    type Book struct {
        
       auth string
    }
    
    func main() {
        
    
       book := Book{
        "Golang"}
       myFunc(book)
    
       myFunc(100)
       myFunc("Av")
    }

> calld myFunc  
> \{Golang\}  
> arg is not string type  
> calld myFunc  
> 100  
> arg is not string type  
> calld myFunc  
> Av  
> arg is string type,value = Av  
> value type is string