序

最近在学习go，go里没有class，像C一样是面向过程的。但是实际上也能实现封装，继承，多态这三个面向对象核心思想。回想起平时工作中的代码，虽然是用java写的，但大部分写的其实都是和面向过程的代码。回想起以前看过的一篇公众号文章，略有感悟。

封装，继承，多态

kotlin例子

open class Person(
    open val name: String,
    open val age: Int
) {
    open fun work(): String {
        return "do something..."
    }
}

class Teacher(
    override val name: String,
    override val age: Int,
    val school: String
) : Person(name, age) {

    override fun work(): String {
        return "teaching at $school"
    }
}

class Student(
    override val name: String,
    override val age: Int,
    val school: String
) : Person(name, age) {

    override fun work(): String {
        return "learning at $school"
    }
}

fun main() {
    val li: Person = Teacher("li", 30, "yu cheng high school")
    val wong: Person = Student("wong", 18, "yu cheng high school")
    work(li) // li work: teaching at yu cheng high school
    work(wong) // wong work: learning at yu cheng high school
}

fun work(person: Person) {
    println("${person.name} work: ${person.work()}")
}

封装：Person类封装了name，age属性和work方法
继承：Teacher和Student类继承了Person，并扩展了school属性。重载了work方法
多态：${person.work()}根据不同的类，有不同的行为

一个很简单的例子，还是体现了封装，继承，多态思想。kotlin作为面向对象语言实现起来还是很轻松容易的。

go例子

type Person struct {
    name string
    age  int
}

type Worker interface {
    work() string
}

func (p Person) work() string {
    return "do something..."
}

type Teacher struct {
    Person
    school string
}

func (t Teacher) work() string {
    return fmt.Sprintf("teaching at %v", t.school)
}

type Student struct {
    Person
    school string
}

func (t Student) work() string {
    return fmt.Sprintf("learning at %v", t.school)
}

func main() {
    li := Teacher{Person: Person{name: "li", age: 30}, school: "yu cheng high school"}
    wong := Student{Person: Person{name: "wong", age: 18}, school: "yu cheng high school"}
    work(li) // worker: teaching at yu cheng high school
    work(wong) // worker: learning at yu cheng high school
}

func work(worker Worker) {
    fmt.Printf("worker: %v\n", worker.work())
}

封装：Person struct封装了name，age属性。(p Person) work()封装了work方法
继承：go没有继承，但是可以通过组合来实现。
多态：通过Worker interface接口作为多态扩展

go作为一门面向过程语言，虽然实现面向对象不如其他面向对象语言那么容易，毕竟没有直接的相关概念，但也的的确确能实现，而且个人认为也直指本质。

• 封装说白了其实就是数据结构+行为函数，其他面向对象语言用一个关键字整合了一下罢了。
• 继承事实上劣于组合，平时工作中也提倡组合优先于继承。
• 多态本质上其实是函数指针，运行时执行指针指向的具体函数罢了。

指针

以前大一刚开始学习编程的时候，入门就是C语言，相信很多同学都是从C开始的。指针是C语言的精华，但是以前一直不理解，只知道指针本质就是内存地址，但是作用啥的，一直理解不了。而且java里也没指针，所以后来一直没有思考过这个问题。

在学习go的过程中，官网教程里有一段代码

type Vertex struct {
    X, Y float64
}

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func main() {
    v := Vertex{3, 4}
    v.Scale(10)
    fmt.Println(v.Abs())
}

type Vertex struct {
    X, Y float64
}

func Abs(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func Scale(v *Vertex, f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func main() {
    v := Vertex{3, 4}
    Scale(&v, 10)
    fmt.Println(Abs(v))
}

v.Scale(10) 看起来很像面向对象的风格对吧，instance.method()。但是呢，实际上这个和Scale(&v, 10)本质上是一样的。如果把指针v换一下，换成SELF，那么看起来是不是和python一样了。如果语言支持隐式的SELF，那么写起来是不是就和java一样。所以，java class里的方法，其实都隐含了一个指向自己的SELF指针，或者叫做this，所以java其实也是有指针的。

总结

以前有个leader说过一句"名言"：重要的是思想。一门语言是面向过程还是面向对象其实并不重要。面向过程语言也能写得和面向对象一样，而面向对象语言 ，如果不理解面向对象思想的话，写出来的代码还是和面向过程一样的。