go语言------接口，Stringer，错误，Reader，图像

最新推荐文章于 2024-01-21 03:34:43 发布

Studying！！！

最新推荐文章于 2024-01-21 03:34:43 发布

阅读量228

点赞数

分类专栏： go语言基础文章标签： golang

本文链接：https://blog.csdn.net/qwerty1372431588/article/details/118099699

版权

go语言基础专栏收录该内容

25 篇文章 3 订阅

订阅专栏

接口

0.接口定义与示例
1.接口
2. 接口与隐式实现
3. 接口值
4. 底层为nil的接口值
5. 接口与结构体结合(指针与值)
6. 一个结构体实现多个接口
7.接口嵌套
8.类型断言
9.类型选择
10. Stringer
11.练习：Stringer
12.错误
13.练习：错误
14.Reader
15.图像

0.接口定义与示例

在这里插入图片描述

package main

import "fmt"

//接口是一种规范
type Usber interface {
	start()
	stop()
}
// 如果接口里面有方法的话，必须要通过结构体或者通过自定义类型实现这个接口。
//如果要实现usb接口，就必须实现接口中的所有方法
type Phone struct {
	Name string
}

func (p Phone) start() {
	fmt.Println(p.Name,"start")
}
func (p Phone) stop()  {
	fmt.Println(p.Name,"stop")
}

func main()  {
	p := Phone{
		Name: "HUIWEI",
	}
	var p1 Usber   //golang中接口是一种数据类型
	p1 = p         //表示手机实现usb接口
	p1.stop()      //实现stop方法
}

package main

import "fmt"

//接口是一种规范
type Usber interface {
	start()
	stop()
}
// 如果接口里面有方法的话，必须要通过结构体或者通过自定义类型实现这个接口。
//如果要实现usb接口，就必须实现接口中的所有方法
type Phone struct {
	Name string
}

func (p Phone) start() {
	fmt.Println(p.Name,"start")
}
func (p Phone) stop()  {
	fmt.Println(p.Name,"stop")
}
type Computer struct {
}

func (c Computer) work(usb Usber)  {
	usb.start()
	usb.stop()
}
func main()  {
	var computer Computer
	var phone =Phone{
		Name: "HUIWEI",
	}
	computer.work(phone)
}

//
HUIWEI start
HUIWEI stop

1.接口

接口类型是由一组方法签名定义的集合。
接口类型的变量可以保存任何实现了这些方法的值。
注意: 示例代码的 22 行存在一个错误。由于 Abs 方法只为 *Vertex （指针类型）定义，因此 Vertex（值类型）并未实现 Abser。

package main
import (
	"fmt"
	"math"
)

type Abser interface {
	Abs() float64
}

func main() {
	var a Abser
	f := MyFloat(-math.Sqrt2)
	v := Vertex{3, 4}

	a = f  // a MyFloat 实现了 Abser
	a = &v // a *Vertex 实现了 Abser

	// 下面一行，v 是一个 Vertex（而不是 *Vertex）
	// 所以没有实现 Abser。
	//a = v 
	
	fmt.Println(a.Abs())
}

type MyFloat float64

func (f MyFloat) Abs() float64 {
	if f < 0 {
		return float64(-f)
	}
	return float64(f)
}

type Vertex struct {
	X, Y float64
}

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

2. 接口与隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements”关键字。
隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。
因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

package main
import "fmt"
type I interface {
	M()
}

type T struct {
	S string
}

// 此方法表示类型 T 实现了接口 I，但我们无需显式声明此事。
func (t T) M() {
	fmt.Println(t.S)
}

func main() {
	var i I = T{"hello"}
	i.M()
}

3. 接口值

接口也是值。它们可以像其它值一样传递。
接口值可以用作函数的参数或返回值。
在内部，接口值可以看做包含值和具体类型的元组：
(value, type)
接口值保存了一个具体底层类型的具体值。
接口值调用方法时会执行其底层类型的同名方法。

package main
import (
	"fmt"
	"math"
)

type I interface {
	M()
}

type T struct {
	S string
}

func (t *T) M() {
	fmt.Println(t.S)
}

type F float64

func (f F) M() {
	fmt.Println(f)
}

func main() {
	var i I

	i = &T{"Hello"}
	describe(i)     //调用describe函数，输出结果
	i.M()         //调用M()函数，输出结果

	i = F(math.Pi)
	describe(i)     //调用describe函数，输出结果
	i.M()         //调用M()函数，输出结果
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}
//答案：
	(&{Hello}, *main.T)
	Hello
	(3.141592653589793, main.F)
	3.141592653589793

4. 底层为nil的接口值

nil是go语言中预先的标识符
我们可以直接使用nil，而不用声明它。
nil可以代表很多类型的零值
在go语言中，nil可以代表下面这些类型的零值：
指针类型（包括unsafe中的）
map类型 (映射)
slice类型(切片)
function类型(函数)
channel类型(通道)
interface类型(接口)
即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。
在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。
注意: 保存了 nil 具体值的接口其自身并不为 nil。

package main
import "fmt"
type I interface {
	M()
}

type T struct {
	S string
}

func (t *T) M() {
	if t == nil {
		fmt.Println("<nil>")
		return
	}
	fmt.Println(t.S)
}

func main() {
	var i I

	var t *T
	i = t
	describe(i)
	i.M()

	i = &T{"hello"}
	describe(i)
	i.M()
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}
//答案：
	(<nil>, *main.T)
	<nil>
	(&{hello}, *main.T)
	hello

nil 接口值
nil 接口值既不保存值也不保存具体类型。
为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。

package main
import "fmt"
type I interface {
	M()
}

func main() {
	var i I
	describe(i)
	i.M()
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}
//答案：
	(<nil>, <nil>)
	panic: runtime error: invalid memory address or nil pointer dereference
	[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x498fcf]
	
	goroutine 1 [running]:
	main.main()
		/tmp/sandbox974562449/prog.go:10 +0x8f

- ***空接口***

指定了零个方法的接口值被称为 空接口：
interface{}
空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）
空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

package main
import "fmt"
func main() {
	var i interface{}
	describe(i)

	i = 42
	describe(i)

	i = "hello"
	describe(i)
}

func describe(i interface{}) {
	fmt.Printf("(%v, %T)\n", i, i)
}
//答案
	(<nil>, <nil>)
	(42, int)
	(hello, string)

空接口实现map、切片功能

package main
import "fmt"
func main() {
	var m1 = make(map[string]interface{})   //空接口实现map
	m1["1"]=1
	m1["2"]="你好"
	m1["3"]=true
	fmt.Printf("%v,%T \n",m1,m1) //map[1:1 2:你好 3:true],map[string]interface {}

	var s1 = []interface{}{1,"nihao",true}
	fmt.Printf("%v,%T",s1,s1)   //[1 nihao true],[]interface {}
}

5. 接口与结构体结合(指针与值)

package main
import "fmt"
//定义一个Animal接口，Animal中定义了Setnam和Getname方法，使用Dog结构体
type Animaler interface {
	Setname(string)
	Getname() string
}
type Dog struct {
	Name string
}
func (d *Dog) Setname(name string) {   //有参数，但是没有返回值
	d.Name = name
}
func (d Dog) Getname() string  {    //有返回值，没有参数
	return d.Name
}
func main()  {
	d:=&Dog{             //使用指针动态设置Dog结构体内容
		Name: "xiaohei",
	}
	var d1 Animaler =d        //实例化接口
	fmt.Println(d1.Getname())
	d1.Setname("aaa")
	fmt.Println(d1.Getname())
}

6. 一个结构体实现多个接口

package main

import "fmt"

//定义一个Animal接口，Animal中定义了Setnam和Getname方法，使用Dog结构体
type Animaler1 interface {
	Setname(string)
}
type Animaler2 interface {
	Getname() string
}
type Dog struct {
	Name string
}
func (d *Dog) Setname(name string) {
	d.Name = name
}
func (d Dog) Getname() string  {
	return d.Name
}
func main()  {
	d:=&Dog{
		Name: "xiaohei",
	}
	var d1 Animaler1 =d   //表示让Dog实现Animal1接口
	var d2 Animaler2 =d	  //表示让Dog实现Animal2接口
	d1.Setname("aaa")
	fmt.Println(d2.Getname())
}
//aaa

7.接口嵌套

package main
import "fmt"
//定义一个Animal接口，Animal中定义了Setnam和Getname方法，使用Dog结构体
type Animaler1 interface {
	Setname(string)
}
type Animaler2 interface {
	Getname() string
}
type Animaler3 interface { //接口嵌套
	Animaler1
	Animaler2
}
type Dog struct {
	Name string
}
func (d *Dog) Setname(name string) {
	d.Name = name
}
func (d Dog) Getname() string  {
	return d.Name
}
func main()  {
	d:=&Dog{
		Name: "xiaohei",
	}
	fmt.Println(d.Getname())
	var d1 Animaler3 =d   //表示让Dog实现Animal1接口
	d1.Setname("aaa")
	fmt.Println(d1.Getname())
}
//xiaohei
//aaa

8.类型断言

类型断言提供了访问接口值底层具体值的方式。
t := i.(T)
该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。
若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。
为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。
t, ok := i.(T)
若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。
否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生恐慌。
请注意这种语法和读取一个映射时的相同之处。

package main
import "fmt"
func main() {
	var i interface{} = "hello"

	s := i.(string)
	fmt.Println(s)

	s, ok := i.(string)
	fmt.Println(s, ok)

	f, ok := i.(float64)     //带bool值的时候，如果为False,则不会报错，且将float64类型的零值赋值给i
	fmt.Println(f, ok)

	f = i.(float64) // 报错(panic)  //不带bool值，则直接报错
	fmt.Println(f)
}
//答案：
	hello
	hello true
	0 false
	panic: interface conversion: interface {} is string, not float64
	
	goroutine 1 [running]:
	main.main()
		/tmp/sandbox757741068/prog.go:15 +0x1fe

9.类型选择

类型选择是一种按顺序从几个类型断言中选择分支的结构。
类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

	switch v := i.(type) {
	case T:
	    // v 的类型为 T
	case S:
	    // v 的类型为 S
	default:
	    // 没有匹配，v 与 i 的类型相同
	}

类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。

此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。

package main
import "fmt"
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}

func main() {
	do(21)
	do("hello")
	do(true)
}
//答案：
	Twice 21 is 42
	"hello" is 5 bytes long
	I don't know about type bool!

10. Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

type Stringer interface {
String() string
}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

package main
import "fmt"
type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {
	return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
	a := Person{"Arthur Dent", 42}
	z := Person{"Zaphod Beeblebrox", 9001}
	fmt.Println(a, z)
}
//答案：
	Arthur Dent (42 years) Zaphod Beeblebrox (9001 years)

11.练习：Stringer

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。
例如，IPAddr{1, 2, 3, 4} 应当打印为 “1.2.3.4”。

package main
import "fmt"
type IPAddr [4]byte

// TODO: 给 IPAddr 添加一个 "String() string" 方法
func (v IPAddr) String() string {
    return fmt.Sprintf("%v.%v.%v.%v", v[0], v[1], v[2], v[3])
}
func main() {
	hosts := map[string]IPAddr{    //将IP地址映射到主机名上
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for name, ip := range hosts {
		fmt.Printf("%v: %v\n", name, ip)
	}
}
//答案：
	loopback: 127.0.0.1
	googleDNS: 8.8.8.8

12.错误

Go 程序使用 error 值来表示错误状态。
与 fmt.Stringer 类似，error 类型是一个内建接口：
type error interface {
Error() string
}
（与 fmt.Stringer 类似，fmt 包在打印值时也会满足 error。）
通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。
i, err := strconv.Atoi(“42”)
if err != nil {
fmt.Printf(“couldn’t convert number: %v\n”, err)
return
}
fmt.Println(“Converted integer:”, i)
error 为 nil 时表示成功；非 nil 的 error 表示失败。

package main
import (
	"fmt"
	"time"
)

type MyError struct {
	When time.Time
	What string
}

func (e *MyError) Error() string {
	return fmt.Sprintf("at %v, %s",
		e.When, e.What)
}

func run() error {
	return &MyError{
		time.Now(),
		"it didn't work",
	}
}

func main() {
	if err := run(); err != nil {
		fmt.Println(err)
	}
}
//答案：
	at 2009-11-10 23:00:00 +0000 UTC m=+0.000000001, it didn't work

13.练习：错误

从之前的练习中复制 Sqrt 函数，修改它使其返回 error 值。
Sqrt 接受到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新的类型
type ErrNegativeSqrt float64
并为其实现
func (e ErrNegativeSqrt) Error() string
方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 “cannot Sqrt negative number: -2”。

注意: 在 Error 方法内调用 fmt.Sprint(e) 会让程序陷入死循环。可以通过先转换 e 来避免这个问题：fmt.Sprint(float64(e))。这是为什么呢？
修改 Sqrt 函数，使其接受一个负数时，返回 ErrNegativeSqrt 值。

package main
import (
	"fmt"
)
type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {     //错误函数
	return fmt.Sprintf("cannot Sqrt negative number:  %v", float64(e))
}

func Sqrt(x float64) (float64, error) {
	if x < 0 {
		return 0, ErrNegativeSqrt(x)
	}
	return 0, nil
}

func main() {
	fmt.Println(Sqrt(2))
	fmt.Println(Sqrt(-2))
}
//答案：
	0 <nil>
	0 cannot Sqrt negative number:  -2

14.Reader

io 包指定了 io.Reader 接口，它表示从数据流的末尾进行读取。
Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。
io.Reader 接口有一个 Read 方法：
func (T) Read(b []byte) (n int, err error)
Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。
示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。、

package main
import (
	"fmt"
	"io"
	"strings"
)

func main() {
	r := strings.NewReader("Hello, Reader!")

	b := make([]byte, 8)
	for {
		n, err := r.Read(b)
		fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
		fmt.Printf("b[:n] = %q\n", b[:n])
		if err == io.EOF {
			break
		}
	}
}
//答案：
	n = 8 err = <nil> b = [72 101 108 108 111 44 32 82]
	b[:n] = "Hello, R"
	n = 6 err = <nil> b = [101 97 100 101 114 33 32 82]
	b[:n] = "eader!"
	n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
	b[:n] = ""

练习：Reader
实现一个 Reader 类型，它产生一个 ASCII 字符 ‘A’ 的无限流。

package main
import "golang.org/x/tour/reader"

type MyReader struct{}

// TODO: 给 MyReader 添加一个 Read([]byte) (int, error) 方法
func (r MyReader) Read(b []byte) (int,error){
    //赋值并返回
    b[0] = 'A'
    return 1,nil
}

func main() {
	reader.Validate(MyReader{})
}
//答案：  OK！

15.图像

image 包定义了 Image 接口：
package image
type Image interface {
ColorModel() color.Model
Bounds() Rectangle
At(x, y int) color.Color
}
注意: Bounds 方法的返回值 Rectangle 实际上是一个 image.Rectangle，它在 image 包中声明。
（请参阅文档了解全部信息。）
color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由 image/color 包定义。

package main
import (
	"fmt"
	"image"
)

func main() {
	m := image.NewRGBA(image.Rect(0, 0, 100, 100))
	fmt.Println(m.Bounds())
	fmt.Println(m.At(0, 0).RGBA())
}
//答案：
	(0,0)-(100,100)
	0 0 0 0

练习：图像
还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 image.Image 的实现而非一个数据切片。
定义你自己的 Image 类型，实现必要的方法并调用 pic.ShowImage。
Bounds 应当返回一个 image.Rectangle ，例如 image.Rect(0, 0, w, h)。
ColorModel 应当返回 color.RGBAModel。
At 应当返回一个颜色。上一个图片生成器的值 v 对应于此次的 color.RGBA{v, v, 255, 255}。

在这里插入图片描述

package main
import "golang.org/x/tour/pic"
import "image"
import "image/color"

type Image struct{
	w int
	h int
}

func (i Image) Bounds() image.Rectangle {
	return image.Rect(0,0,i.w,i.h)
}	
func (i Image) ColorModel() color.Model {
	return color.RGBAModel
}
func (i Image) At(x, y int) color.Color {
	return color.RGBA{uint8(x),uint8(y),uint8(255),uint8(255)}
}
func main() {
	m := Image{255,255}
	pic.ShowImage(m)
}
//答案如下图

在这里插入图片描述

Studying！！！

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
go语言------接口，Stringer，错误，Reader，图像

接口1.接口2. 接口与隐式实现3. 接口值4. 底层为nil的接口值5.类型断言6.类型选择7. Stringer8.练习：Stringer9.错误10.练习：错误11.Reader1.接口接口类型是由一组方法签名定义的集合。接口类型的变量可以保存任何实现了这些方法的值。注意: 示例代码的 22 行存在一个错误。由于 Abs 方法只为 *Vertex （指针类型）定义，因此 Vertex（值类型）并未实现 Abser。package mainimport ( "fmt" "math")
复制链接

扫一扫