一、 go语言中的类与对象
package mian
import (
"fmt"
)
//面向对象
//面向对象首先写一个类，但是go里面没有类，只有struct
//方法不写在结构体中，写在全局，在方法名前面传入对象， 做值传递，真的很神奇。这种写法，第一次见，长见识了
type Node struct{
value int;
l,r *Node;
}//好了，这并不陌生，这是一个结构体，go语言里面没有class
func createNode(value int) *Node{
return &Node{value:value};
}
func (node *Node) setValues(value int) { //这个相当于是node的方法，前面的是值传递，如果不用指针，那么就是复制一份拷贝，
//根本不会发生改变，注意的是就算用指针，调用的时候也不用取地址，
node.value = value
}
//如上写就可以：对象.setValues(values)。这种调用方法。
func visitBefore(root *Node) { //树的前序遍历
if root
== nil {
return ;
}
fmt.Println(root.value)
visitBefore(root.l)
visitBefore(root.r)
}
func main() {
//新建节点
var root
Node;
root = Node{value:3} //这样指定了其他参数就默认为zero value
root.l = &Node{6,nil,nil}//因为是指针
root.r = &Node{}
root.r.l = new(Node) // new 一个结构体相当于也是新建一个结构体变量
root.l.r = createNode(5) //因为是指针，所以返回的记过需要是一个指针
// 3
//
6 0
// 5 0
//
root.r.l.setValues(4) //把右下角改成4
visitBefore(&root)
nodes := []Node{
Node{value:3},
Node{3,nil,nil},
{},
}//建立一个node数组
fmt.Println(nodes) //[{3 <nil> <nil>} {3 <nil>
<nil>} {0 <nil> <nil>}]
}
二、 go语言中的“继承”
package mian
import "fmt"
//go语言的“继承”，go 语言是没有继承的，知识模拟继承，为了实现其他面向对象语言的继承特点，
//在go语言中采用组合和或者取别名的方式来实现继承的特点。
type Go struct {
v int; //好了这是一个类
}
//下面通过组合来实现继承
type GoChlid struct { //这样就可以对原来的类型进行一个扩充
go_ *Go //这里可以不用指针也没关系
gogo Go //另个组合，都拥有v这个成员
}
//这里要提出来，对于go语言中的封装，变量名首字母小写表示私有（private），变量名大写表示公有（public）
type GoCC Go //这样相当于给go去了个别名
func (g *GoCC)fun() int{
return g.v //别名加一个方法
}
func main() {
g := Go{1}
a := g.v
fmt.Println(a)
}
三、 go语言面向对象
看下目录结构
package main
import (
"../forclass"
"fmt"
)
func main() {
c := forclass.Class{1,2} //完美的面向对象
c.Print()
c.SetV(2)
fmt.Println(c.GetV())
//c.test() //很明显，这个包里面是访问不到首字母小写的
}
package forclass
import "fmt"
type Class struct {
V int //这个变量小写的话，构造对象的时候就会报错，应为不能被访问到
C int
}
func (c *Class)SetV(v int) {
c.V = v
}
func (c *Class)GetV() int {
return c.V
}
func (c *Class)Print() {
//c.test() //类内部访问完全没有问题！
fmt.Println(c.V)
}
func (c *Class)test() {
fmt.Println("试试能不能调用成功")
}