Go面向对象(三)

go语言中的大多数类型都是值予以,并且都可以包含对应的操作方法,在需要的时候你可以给任意类型增加新方法。二在实现某个接口时,无需从该接口集成,只需要实现该接口要求的所有方法即可。任何类型都可以被any类型引用。any类型是空接口 interface{}

值语义和引用语义                  

a :=10
b := a
b = b +1
fmt.Println(b)
fmt.Println(a)
输出:11,10
c :=10
d :=&c
*d +=1
fmt.Println(c)
fmt.Println(*d)
输出:11,11

Go语言中有4个类型比较特别,看起来像引用类型

接口(interface):对一组满足某个契约的类型的抽象

结构体                           

package main
//person类
type Personstruct{
Namestring
Ageint
Sexstring
}
//person构造函数
func NewPerson(name string, sex string, age int)*Person{
return&Person{Name: name,Sex: sex,Age: age}
}
//person类ResetName1方法 (传值)
func (ps Person)ResetName1(name string){
ps.Name= name
}
//person类ResetName1方法 (传址)
func (ps *Person)ResetName2(name string){
ps.Name= name
}
//student类
type Studentstruct{
Classstring
Gradestring
*Person
}
//student构造函数
func NewStudent(name string, sex string, age int,classstring, grade string)*Student{
return&Student{Person:NewPerson(name, sex, age),Class:class,Grade: grade}
}

匿名组合:类的继承是使用了匿名组合的方式            

可见性                            

1. 入侵接口
   c#和Java中的接口时入侵是接口
2. 非入侵接口
   go的接口是非入侵式接口

type File struct {

// ...

}

func (f *File) Read(buf []byte) (n int, err error)

func (f *File) Write(buf []byte) (n int, err error)

func (f *File) Seek(off int64, whence int) (pos int64, err error)

func (f *File) Close() error

type IFile interface {

Read(buf []byte) (n int, err error)

Write(buf []byte) (n int, err error)

Seek(off int64, whence int) (pos int64, err error)

Close() error

}

type IReader interface {

Read(buf []byte) (n int, err error)

}

type IWriter interface {

Write(buf []byte) (n int, err error)

}

type ICloser interface {

Close() error

}

var file1 IFile = new(File)

var file2 IReader = new(File)

var file3 IWriter = new(File)

var file4 ICloser = new(File)

其一,Go语言的标准库,再也不需要绘制类库的继承树图。你一定见过不少C++、Java、C#类库的继承树图。在Go中,类的继承树并无意义,你只需要知道这个类实现了哪些方法,每个方法是啥含义就足够了。

其二,实现类的时候,只需要关心自己应该提供哪些方法,不用再纠结接口需要拆得多细才合理。接口由使用方按需定义,而不用事前规划。

其三,不用为了实现一个接口而导入一个包,因为多引用一个外部的包,就意味着更多的耦合。接口由使用方按自身需求来定义,使用方无需关心是否有其他模块定义过类似的接口

1. package one
   type ReadWriterinterface{
   Read(buf []byte)(n int, err error)
   Write(buf []byte)(n int, err error)
   }
   package two
   type IStreaminterface{
   Write(buf []byte)(n int, err error)
   Read(buf []byte)(n int, err error)
   }

   
   

1. 任何实现了one.ReadWriter接口的类,均实现了two.IStream;

2. 任何one.ReadWriter接口对象可赋值给two.IStream,反之亦然;

3. 在任何地方使用one.ReadWriter接口与使用two.IStream并无差异。

1. var file1 two.IStream=new(File)
   var file2 one.ReadWriter= file1
   var file3 two.IStream= file2

type Writer interface {

Write(buf []byte) (n int, err error)

}

var file1 two.IStream = new(File)

var file4 Writer = file1

1. // OOPTest project main.go
   package main
   type IStudentinterface{
   Go2School()
   }
   type IPersoninterface{
   Speak(word string)
   Eat(food string)
   }
   func main(){
   //std := NewStudent("Jessica", "male", 18, "class1", "grade1")
   //psn := NewPerson("James", "female", 20)
   //语句switch中的value必须是接口类型,变量str的类型为转换后的类型。/
   varIStdinterface{}=NewStudent("Jessica","male",18,"class1","grade1")
   switch per :=IStd.(type){
   caseIStudent:
   per.Go2School()
   caseIPerson:
   per.Eat("pig")
   }
   }

   
   

类型断言

1. // OOPTest project main.go
   package main
   type IStudentinterface{
   Go2School()
   }
   type IPersoninterface{
   Speak(word string)
   Eat(food string)
   }
   func main(){
   //std := NewStudent("Jessica", "male", 18, "class1", "grade1")
   //psn := NewPerson("James", "female", 20)
   //语句switch中的value必须是接口类型,变量str的类型为转换后的类型。
   varIStdinterface{}=NewStudent("Jessica","male",18,"class1","grade1")
   //switch per := IStd.(type) {
   //case IStudent:
   // per.Go2School()
   //case IPerson:
   // per.Eat("pig")
   //}
   //上面的转换有一个问题,如果该值不包含一个字符串,则程序会产生一个运行时错误。为了避免这个问题,可以使用"comma, ok"的习惯用法来安全地测试值是否为一个字符串:
   if types, ok :=IStd.(IStudent); ok {
   types.Go2School()
   }elseif types, ok :=IStd.(IPerson); ok {
   types.Eat("pig")
   }
   }
   
   

接口组合:接口的继承

type IStudentinterface{
Go2School()
}
type IPersoninterface{
Speak(word string)
Eat(food string)
}
type Animalinterface{
IPerson
IStudent
}

var v1 interface{}=1// 将int类型赋值给interface{}
var v2 interface{}="abc"// 将string类型赋值给interface{}
var v3 interface{}=&v2 // 将*interface{}类型赋值给interface{}
var v4 interface{}=struct{ X int}{1}
var v5 interface{}=&struct{ X int}{1}

func Printf(fmt string, args ...interface{})
func Println(args ...interface{})

本文来自:博客园

感谢作者:anbylau2130

查看原文:Go面向对象(三)

• 编辑
• 预览