zoukankan      html  css  js  c++  java
  • Go语言学习笔记(3)——面向对象编程

    把存货赶紧更新一波(捂脸)

    1. 类型系统

    类型系统,就是说一种编程语言怎么设计的它的类型的体系结构。

    比如基础类型啊,复合类型啊,一些可以指向任意对象的类型啊,以及类型的语义,面向对象的特性,接口,这些内容。

    2. 类型的方法

    在Golang里,可以给任意类型添加方法。

    比如:

    type Integer int
    
    func (i Integer)Less (b Integer) bool {
        return a<b
    }

    Integer与int没有本质的不同。我们声明了一个属于Integer的函数Less()。这样我们就可以把整型当作普通的类来使用:

    func main() {
        var a Integer = 1
        if a.Less(2) {
            fmt.Println(a, "Less 2")
        }
    }

    那么类型的方法到底是什么呢?我们把刚才的Less()和下面的方法做个对比:

    func NewLess(a Integer, b Integer) bool {
        return a<b
    }

    这里,我刻意没有把a和b写在一起。对比刚才的Less()方法,我们发现,所谓的类型方法,关键在于隐藏的this指针。如果我们把类型a放到传递参数的部分,我们就发现这两个函数并没有区别。

    如果我们需要在类型方法中对类型的实例本身进行修改,那么在声明的时候,就需要声明成指针。这也很好理解,就跟传递参数的时候传递指针是一样的道理。

    func (i *Integer)Less (b Integer) bool {
        return a<b
    }

    关于成员函数,再加一个例子

    type T struct {
        num int
    }
    
    func (t T) add1() {
        t.num += 5
    }
    
    func (t *T) add2() {
        t.num += 5
    }
    
    func main() {
        t1 := T{5}
        t2 := &T{5}
        fmt.Println(t1)
        fmt.Println(t2)
        t1.add1()
        fmt.Println(t1.num)
        t1.add2()
        fmt.Println(t1.num)
        t2.add1()
        fmt.Println(t2.num)
        t2.add2()
        fmt.Println(t2.num)
    }

    其结果如下:

    shell> go run main.go
    {5}
    &{5}
    5
    10
    5
    10

    3. 值语义和引用语义

    值语义和引用语义的区别主要在于赋值。

    b = a
    b.Modify()

    如果此时a没有变化,就是值类型,反之是引用类型。

    Golang中大部分类型都是值类型。

    所以只要记住引用类型即可。他们是切片,map,channel和接口。

    4. 结构体和结构体的初始化

    结构体struct跟其他语言的struct和class差不多。不过golang没有传统意义上的继承。

    type Rect struct {
        x, y float64
        width, height float64
    }

    struct的实例的初始化方法如下:

    rect1 := new(Rect)
    rect2 := Rect{}
    rect3 := Rect{0, 0, 100, 200}
    rect4 := Rect{ 100, height: 200}

    需要注意的是,没有显式初始化的成员都会初始化为该类型的0值。

    另外golang中没有构造函数的概念。如果需要类似的构造函数,通常是创建一个全局函数进行新对象的创建。

    5. 结构体的组合

    前面提到golang并没有传统意义上的继承,但是,golang提供了组合。

    type Base struct {
        Name string
    }
    
    func (base *Base) Foo() {...}
    func (base *Base) Bar() {...}
    
    type Foo struct {
        Base
        ...
    }
    
    func (foo *Foo) Bar() {
        foo.Base.Bar()
        ...
    }

    可以看到,上面的代码定义了一个Base类,实现了Foo()和Bar()两个方法。然后定义了一个Foo类,该类中组合了Base类。

    从形式了,Foo类“继承”了Base类,并改写了Bar()方法,同时在Bar()方法中调用了Base基类中的Bar()方法。

    对于没有被改写的方法,就相当于是被“继承”了,同时仍然可以通过组合的类型来访问方法。比如,foo.Foo()和foo.Base.Foo()的效果是一致的。

    6. 可见性

    跟前面提到的相同,golang使用首字母大小写区别public和private。

    7. 接口

    Golang中的接口是非入侵式的。一个类只要实现了接口要求的所有函数,这个类就实现了该接口。

    未完待续

  • 相关阅读:
    Balance的数学思想构造辅助函数
    1663. Smallest String With A Given Numeric Value (M)
    1680. Concatenation of Consecutive Binary Numbers (M)
    1631. Path With Minimum Effort (M)
    1437. Check If All 1's Are at Least Length K Places Away (E)
    1329. Sort the Matrix Diagonally (M)
    1657. Determine if Two Strings Are Close (M)
    1673. Find the Most Competitive Subsequence (M)
    1641. Count Sorted Vowel Strings (M)
    1679. Max Number of K-Sum Pairs (M)
  • 原文地址:https://www.cnblogs.com/wangzhao765/p/9533345.html
Copyright © 2011-2022 走看看