【导语】下面是小编帮大家整理的Go语言中接口组合的实现方法（共7篇），希望对大家的学习与工作有所帮助。
篇1：Go语言中接口组合的实现方法
作者：books1958 字体：[增加 减小] 类型：
这篇文章主要介绍了Go语言中接口组合的实现方法,实例分析了接口中包含接口的实现技巧,需要的朋友可以参考下
本文实例讲述了Go语言中接口组合的实现方法，分享给大家供大家参考。具体实现方法如下：
在Go语言中，可以在接口A中组合其它的一个或多个接口（如接口B、C），这种方式等价于在接口A中添加接口B、C中声明的方法。
代码如下:
//接口中可以组合其它接口，这种方式等效于在接口中添加其它接口的方法
type Reader interface {
read
}
type Writer interface {
write()
}
//定义上述两个接口的实现类
type MyReadWrite struct{}
func (mrw *MyReadWrite) read() {
fmt.Println(“MyReadWrite...read”)
}
func (mrw *MyReadWrite) write() {
fmt.Println(“MyReadWrite...write”)
}
//定义一个接口，组合了上述两个接口
type ReadWriter interface {
Reader
Writer
}
//上述接口等价于：
type ReadWriterV2 interface {
read()
write()
}
//ReadWriter和ReadWriterV2两个接口是等效的，因此可以相互赋值
func interfaceTest0104() {
mrw := &MyReadWrite{}
//mrw对象实现了read()方法和write()方法，因此可以赋值给ReadWriter和ReadWriterV2
var rw1 ReadWriter = mrw
rw1.read()
rw1.write()
fmt.Println(“------”)
var rw2 ReadWriterV2 = mrw
rw2.read()
rw2.write()
//同时，ReadWriter和ReadWriterV2两个接口对象可以相互赋值
rw1 = rw2
rw2 = rw1
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇2：GO语言中的常量
常量是程序中最基础的元素，在定义之后就不能再重新赋值了。Go语言中的常量类型有布尔常量、整数常量、浮点数常量、 字符常量、字符串常量和复数常量 。
布尔常量
代码如下:
const x = true
fmt.Print(x) //输出true
整数常量
代码如下:
const x = 20
fmt.Print(x) //输出20
浮点数常量
代码如下:
constx = 0.618
fmt.Print(x) //输出%f0.618
字符常量
代码如下:
const x = ‘a‘
fmt.Print(x) //输出97
字符串常量
代码如下:
const x = “a”
fmt.Print(x) //输出a
复数常量
代码如下:
const x = 3 + 2i
fmt.Print(x) //输出%v(3+2i)
仔细看的童靴会发现‘a‘和”a”的输出值不一样，单引号的‘a‘表示字符，双引号的”a”表示字符串，
在Go语言里 ‘1′，”1″，1是不一样的值，这个和C语言是一样的。有兴趣的童靴可以自己试试输出试试看。
以上所述就是本文的全部内容了，希望大家能够喜欢。
篇3：go语言中时间戳格式化的方法
作者：heishui 字体：[增加 减小] 类型：
代码如下:
var t int64 = time.Now.Unix()
var s string = time.Unix(t, 0).Format(“-01-02 15:04:05”)
println(s)
这方式比较特别，按照123456来记忆吧：01月02号 下午3点04分05秒
希望本文所述对大家的Go语言程序设计有所帮助，
篇4：GO语io包的常用接口
我没有 C/C++ 基础，没有接口的概念，且从 Python 投奔而来，Python 的极简主义（一个结果往往只提供一个方法），让我在 Golang 中非常迷糊，特别是文件的读写操作，因为 Go 的文件读写操作有很多的方法，让我不知道怎么选择。直到我学习了 interface 的概念，然后由看了 package io 后才慢慢理解，也渐渐的喜欢上了 Golang 的灵活性。以我的经验来说，接口是一个很重要的知识点，是一系列操作的规范，特别是公共接口尤为重要，如：package io
本文仅仅列举最常用的几个接口，如果您想系统的学习io 接口，建议阅读底部参考链接。
一、IO 接口概述
package os 提供了对 I/O 原语的基本接口，使之成为共享的公共接口，这些公共接口抽象出了泛用的函数并附加了一些相关的原语的操作。因为这些接口和原语是对底层实现完全不同的低水平操作的包装，除非得到其它方面的通知，客户端不应假设它们是并发执行安全的。
在 package os 中最重要的是两个接口：Reader 和 Writer 接口。本章所提到的各种接口，都跟这两个接口有关，也就是说，只要实现了这两个接口，它就有了 IO 的功能。
小贴士：
var EOF = errors.New(“EOF”): 在 package io中定义，使用非常频繁。正常情况下当 Read() 无法得到更多返回时就返回 EOF，即文件到达了结尾(end-of-file)。
二、io.Reader 和 io.Writer
定义：
代码如下:
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
Read 将 len(p) 个字节读取到 p 中，当遇到任何错误（包括EOF）会立即返回已读取的字节数，函数结束会返回成功读取的字节数和任何错误。
Write 将 len(p) 字节数据从 p 写入底层的数据流，然后返回成功写入的字节数和任何错误。
从接口名称很容易猜到，一般地，Go中接口的命名约定：接口名以er结尾。注意，这里并非强行要求，你完全可以不以 er 结尾。标准库中有些接口也不是以 er 结尾的。
示例：
代码如下:
func wr() {
f, _ := os.Create(“at.txt”)
defer f.Close()
f.Write([]byte(“Go是一种令人愉悦的编程语言”)) //写入字节流
f.Seek(0, os.SEEK_SET) //将指针重置
p := make([]byte, 2) // 读取 2 byte( len(buf)=2 )
if _, err := f.Read(p); err != nil {
log.Fatal(“[F]”, err)
}
fmt.Printf(“读取字符 ”%s“, 长度为 %d byten”, p, len(p))
p = make([]byte, 50)
if _, err := f.Read(p); err != nil {
if err != io.EOF { //忽略 EOF 错误
log.Fatal(“[F]”, err)
}
}
fmt.Printf(“读取字符 ”%s“, 长度为 %d byten”, p, len(p))
}
读取字符 “Go”, 长度为 2 byte
读取字符 “是一种令人愉悦的编程语言 ”, 长度为 50 byte
三、io.ReaderAt 和 os.WriterAt
定义（off 是 offset 的缩写）：
代码如下:
type ReaderAt interface {
ReadAt(p []byte, off int64) (n int, err error)
}
type WriterAt interface {
WriteAt(p []byte, off int64) (n int, err error)
}
ReadAt() 从基本输入源的偏移量 off 处开始，其他和 Read() 一样；
WriteAt() 从基本输入源的偏移量 off 处开始，其他和 Write() 一样。
示例：
代码如下:
func at() {
f, _ := os.Create(“at.txt”)
defer f.Close()
f.WriteString(“Go是一种令人愉悦的编程语言”)
f.WriteAt([]byte(“程序”), 26) //偏移 26byte 改写“编程”->“程序”
fi, _ := f.Stat() //获取文件信息
p := make([]byte, fi.Size()-2) //文件大小减去偏移值
f.ReadAt(p, 2) //偏移 2 byte
os.Stdout.Write(p)
}
四、io.ReaderFrom 和 os.WriterTo
定义：
代码如下:
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
}
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
}
ReadFrom() 从 r 中读取数据，直到 EOF 或发生错误，
返回读取的字节数和 io.EOF 之外的其他错误。ReadFrom不会返回EOF错误
WriteTo() 将数据写入 w 中，直到没有数据可写或发生错误。返回写入的字节数和任何错误。
示例：
代码如下:
func fromTo() {
r := strings.NewReader(“Go是一种令人愉悦的编程语言”) //创建一个 Reader
w := bufio.NewWriter(os.Stdout) //创建一个 Writer
w.ReadFrom(r) // w 一次性读取 r 的全部内容
w.Flush()
r.Seek(0, os.SEEK_SET) //重置指针
r.WriteTo(w) // r 一次性将内容写入 w 中
w.Flush()
}
五、io.Seeker
定义：
代码如下:
type Seeker interface {
Seek(offset int64, whence int) (ret int64, err error)
}
Seek 设置下一次 Read 或 Write 的偏移量(offset)，它的解释取决于 whence。示例见上文。
whence的值，在os包中定义了相应的常量：
代码如下:
SEEK_SET int = 0 //从文件的起始处开始设置 offset
SEEK_CUR int = 1 //从文件的指针的当前位置处开始设置 offset
SEEK_END int = 2 //从文件的末尾处开始设置 offset
六、io.Closer
定义：
代码如下:
type Closer interface {
Close() error
}
用于关闭数据流，释放资源，不用多废话了吧。
七、其他
代码如下:
type ByteReader interface {
ReadByte() (c byte, err error)
}
type RuneReader interface {
ReadRune() (r rune, size int, err error)
}
ReadByte读取输入中的单个字节并返回。如果没有字节可读取，会返回错误。
ReadRune读取单个utf-8编码的字符，返回该字符和它的字节长度。如果没有有效的字符，会返回错误。
代码如下:
type ByteWriter interface {
WriteByte(c byte) error
}
WriteByte写入一个字节，如果写入失败会返回错误。
参考:
gowalker.org/io
github.com/polaris1119/The-Golang-Standard-Library-by-Example/blob/master/chapter01/01.1.md
希望本文所述对大家的GO语言程序设计有所帮助。
篇5：Go语言使用组合的方式实现多继承的方法
作者：books1958 字体：[增加 减小] 类型：
这篇文章主要介绍了Go语言使用组合的方式实现多继承的方法,实例分析了多继承的原理与使用组合方式来实现多继承的技巧,需要的朋友可以参考下
本文实例讲述了Go语言使用组合的方式实现多继承的方法，分享给大家供大家参考。具体实现方法如下：
在大多数面向对象的编程语言中多继承都是不支持的。因为在基于class的体系中，多继承极大地增加了编译器的复杂性。
Go语言使用组合的方式实现继承，因此也可以很简单的实现多继承。
代码如下:
//使用组合的方式实现多继承
type Phone struct{}
func (p *Phone) Call string {
return “Ring Ring”
}
type Camera struct{}
func (c *Camera) TakeAPicture() string {
return “Click”
}
//多继承
type CameraPhone struct {
Camera
Phone
}
func structTest0803() {
cp := new(CameraPhone)
fmt.Println(“Our new CameraPhone exhibits multiple behaviors ...”)
fmt.Println(“It exhibits behavior. of a Camera: ”, cp.TakeAPicture())
fmt.Println(“It works like a Phone too: ”, cp.Call())
/*Output:
Our new CameraPhone exhibits multiple behaviors ...
It exhibits behavior. of a Camera: Click
It works like a Phone too: Ring Ring
*/
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇6：Go语言中append函数用法分析
作者：books1958 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言中append函数用法,对比使用append函数与不使用append函数的两个实例,详细分析了Go语言中append函数的功能,需要的朋友可以参考下
本文实例分析了Go语言中append函数用法，分享给大家供大家参考。具体如下：
Go语言中append的功能十分强大，使用它可以使很多功能的实现变得更加简洁。以下为简单对比：
.将一个slice插入到另一个slice的指定位置：
不使用append：
代码如下:
func insertSliceAtIndex(slice_origin []int, slice_to_insert []int,
insertIndex int) (result []int, err error) {
if insertIndex > len(slice_origin) {
return nil, errors.New(“insertIndex不能大于slice_origin的长度”)
}
result = make([]int, len(slice_origin)+len(slice_to_insert))
for i := 0; i < len(result); i++ {
if i < insertIndex { //插入点之间
result[i] = slice_origin[i]
} else if i < insertIndex+len(slice_to_insert) { //插入内容
result[i] = slice_to_insert[i-insertIndex]
} else {
result[i] = slice_origin[i-len(slice_to_insert)]
}
}
return
}
使用append时，代码将十分简洁：
代码如下:
d := []string{“Welcome”, “for”, “Tianjin”, “Have”, “a”, “good”, “journey”}
insertSlice := []string{“It”, “is”, “a”, “big”, “city”}
insertSliceIndex := 3
d = append(d[:insertSliceIndex],
append(insertSlice, d[insertSliceIndex:]...)...)
fmt.Printf(“result:%vn”, d)
希望本文所述对大家的Go语言程序设计有所帮助，
篇7：go语言中的interface使用实例
这篇文章主要介绍了go语言中的interface使用实例,go语言中的interface是一组未实现的方法的集合,如果某个对象实现了接口中的所有方法,那么此对象就实现了此接口,需要的朋友可以参考下
go语言中的interface是一组未实现的方法的集合，如果某个对象实现了接口中的所有方法，那么此对象就实现了此接口，与其它面向对象语言不同的是，go中无需显示声明调用了哪个接口。
代码如下:
package main
import (
“fmt”
)
type I interface {
Get() int
Put(int)
}
type S struct{ i int }
func (p *S) Get() int { return p.i }
func (p *S) Put(v int) { p.i = v }
type R struct{ i int }
func (p *R) Get() int { return p.i }
func (p *R) Put(v int) { p.i = v }
func f1(p I) {
fmt.Println(p.Get())
p.Put(1)
}
//interface{}空接口，能接受任何类型。.(I)是类型断言，用于转换something到I类型的接口
func f2(p interface{}) {
if t, ok := p.(S); ok {
fmt.Println(“S:”, t)
} else if t, ok := p.(I); ok {
fmt.Println(“I:”, t.Get())
}
}
func f3(p interface{}) {
switch t := p.(type) {
case S:
fmt.Println(“S:”, t.Get())
case R:
fmt.Println(“R:”, t.Get())
case I:
fmt.Println(“I:”, t.Get())
default:
fmt.Println(“unknow type”)
}
}
func main() {
s := S{101}
f1(&s)
f2(&s)
r := R{1111}
f3(&r)
}
如上结构S实现了I的两个方法，因此S实现了I，
因为S实现了I，因此可以调用f向其传递S类型值得指针。
总结如下：
(1)使用“comma, ok” 来判断一个接口类型是否实现了某个特定接口：
代码如下:
if t, ok := something.(I) ; ok {
// 对于某些实现了接口I 的
// t 是其所拥有的类型
}
(2)声明为 interface 类型的变量，可以存储任何实现了 interface 中所有方法的类型的变量
(3)空接口可代表任何类型，可做形参和返回类型
代码如下:
package main
import “fmt”
func main() {
//interface{}
var i interface{} = 100
var s interface{} = “hello”
fmt.Printf(“i = %d, s = %sn”, i, s)
s = i
fmt.Printf(“i = %d, s = %dn”, i, s)
}
(4)interface组合
将一个 interface1 嵌入到另一个 interface2 的声明中,其作用相当于把 interface1 的函数包含到 interface2 中，但是组合中不同有重复的方法
注：
a. 只要两个接口中的方法列表相同(与顺序无关)，即为相同的接口，可以相互赋值
b. interface1 的方法列表属于另一个 interface2 的方法列表的子集，interface2 可以赋值给 interface1，反之不成立(因为方法缺失)，interface2 中的方法会覆盖 interface1 中同名的方法
c. 可以嵌入包中的 interface
文档为doc格式
