go语言学习-接口_1(十八)

翻译自:https://golangbot.com/interfaces-part-1/

什么是接口

在面向对象语言中,接口一般被定义为 :接口定义了对象的一系列行为。接口仅仅指定了一个对象应该做什么。具体怎么做(实现细节)是由对象决定的。

在 Go 中,接口是一组方法签名。当一个类型定义了所有接口里的方法时,就说这个类型实现了这个接口。这和 面向对象OOP 很像。接口指定了一个类型应该具有什么方法,而该类型决定怎么实现这些方法。

例如 WashingMachine是一个包含两个方法 Cleaning()Drying()的接口。任何提供了 Cleaning()Drying() 方法定义的类型就可以说它实现了 WashingMachine 接口。

接口的声明与实现

让我们通过一个程序看一下如何声明和实现一个接口.

package main

import (
	"fmt"
)

//interface definition
type VowelsFinder interface {
	FindVowels() []rune
}

type MyString string

//MyString implements VowelsFinder
func (ms MyString) FindVowels() []rune {
	var vowels []rune
	for _, rune := range ms {
		if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
			vowels = append(vowels, rune)
		}
	}
	return vowels
}

func main() {
	name := MyString("Sam Anderson")
	var v VowelsFinder
	v = name // possible since MyString implements VowelsFinder
	fmt.Printf("Vowels are %c", v.FindVowels())

}

程序的第8行创建了一个名为 VowelsFinder 接口类型,它有一个方法 FindVowels() []rune

在下一行 MyString 类型被创建。

在第15行我们添加了一个方法 FindVowels() []rune 到接受器类型 MyString。现在可以说 MyString 实现了 VowelsFinder 接口。这与Java等其他语言完全不同,java中一个类必须用 implements 关键字显式的标明实现了一个接口。这在Go中是不需要的,这是隐式实现的,在Go中,如果一个类型包含了一个接口声明的所有方法,那么这个类型就隐式地实现了这个接口。

在第28行,我们将 MyString 类型的变量 name 赋值给 VowelsFinder 类型的变量 v。这是合法的,因为 MyString 实现了 VowelsFinder。在下一行,v.FindVowels()MyString 类型上调用 FindVowels 方法打印在 Sam Anderson 中所有的元音。程序的输出为:Vowels are [a e o]

恭喜!你已经创建并实现了你的第一个接口。

接口的实际用途

上面的程序告诉我们怎么创建和实现接口,但是没有展示接口的实际用途。在上面的程序中,我们可以使用 name.FindVowels()替代 v.FindVowels(),程序照样可以工作,并且不需要声明接口,那么为什么我们还需要接口呢?

现在让我们来看接口的实际用途。

我们将编写一个简单的程序,根据员工的个人工资计算公司的总支出。为简洁起见,我们假设所有费用均以美元计算。

package main

import (
	"fmt"
)

type SalaryCalculator interface {
	CalculateSalary() int
}

type Permanent struct {
	empId    int
	basicpay int
	pf       int
}

type Contract struct {
	empId    int
	basicpay int
}

//salary of permanent employee is sum of basic pay and pf
func (p Permanent) CalculateSalary() int {
	return p.basicpay + p.pf
}

//salary of contract employee is the basic pay alone
func (c Contract) CalculateSalary() int {
	return c.basicpay
}

/*
total expense is calculated by iterating though the SalaryCalculator slice and summing
the salaries of the individual employees
*/
func totalExpense(s []SalaryCalculator) {
	expense := 0
	for _, v := range s {
		expense = expense + v.CalculateSalary()
	}
	fmt.Printf("Total Expense Per Month $%d", expense)
}

func main() {
	pemp1 := Permanent{1, 5000, 20}
	pemp2 := Permanent{2, 6000, 30}
	cemp1 := Contract{3, 3000}
	employees := []SalaryCalculator{pemp1, pemp2, cemp1}
	totalExpense(employees)

}

上面程序的第7行,定义了一个名为 SalaryCalculator 接口类型,该接口只声明了一个方法:CalculateSalary() int

我们公司有两种类型的员工:PermanentContract ,分别为第 1117 行定义的结构体。永久性员工的工资是 basicpaypf 的总和,而对于合同制员工的工资只是基本工资 basicpay。这分别在第23行和第28行的方法 CalculateSalary 中表示。通过声明这个方法,PermanentContract 都实现了 SalaryCalculator 接口。

36行声明的 totalExpense 函数展示了使用接口的美妙之处。这个函数接收一个 SalaryCalculator 接口的切片 []SalaryCalculator 作为参数。在第49行,我们将一个包含了 PermanentContract 类型的切片给函数 totalExpensetotalExpense 函数通过调用各自类型的 CalculateSalary 方法来计算总支出。这是在第 39行完成的。

这样做的最大优点是totalExpense可以扩展到任何新员工类型而无需更改任何代码。假设公司增加了一种新的员工类型 Freelancer和不同的计算工资的方法。 Freelancer 可以被包含在传递给 totalExpense 的切片参数中,而不需要修改 totalExpense 的代码。这个方法将完成它应该做的事情,因为 Freelancer 也实现了 SalaryCalculator 接口。

程序的输出为:Total Expense Per Month $14050

接口的内部表示

可以认为接口内部是这样一个元组 (type, value)type 是接口包含的具体类型,value 是接具体类型的值。

让我们写一个程序来更好地理解。

package main

import (
	"fmt"
)

type Test interface {
	Tester()
}

type MyFloat float64

func (m MyFloat) Tester() {
	fmt.Println(m)
}

func describe(t Test) {
	fmt.Printf("Interface type %T value %v\n", t, t)
}

func main() {
	var t Test
	f := MyFloat(89.7)
	t = f
	describe(t)
	t.Tester()
}

Test 接口提供了一个方法 Tester()MyFloat 类型实现了这个接口。在第 24 行,我们将 MyFloat 类型的变量 f 赋值给 Test 类型的变量 t 。现在 t 的具体类型是 MyFloat 而它的值是 89.7。在第17行, describe 函数打印接口的值和具体类型。程序的输出为:

Interface type main.MyFloat value 89.7  
89.7  
空接口

没有任何方法的接口称为空接口。它表示为interface{}。由于空接口没有任何方法,因此所有的类型都实现了空接口。

package main

import (
	"fmt"
)

func describe(i interface{}) {
	fmt.Printf("Type = %T, value = %v\n", i, i)
}

func main() {
	s := "Hello World"
	describe(s)
	i := 55
	describe(i)
	strt := struct {
		name string
	}{
		name: "Naveen R",
	}
	describe(strt)
}

在上面的程序第7行中,该describe(i interface{})函数将空接口作为参数,因此可以传递任何类型。

我们分别为13行,15行和21行将stringintstruct传递给describe函数。

该程序打印:

Type = string, value = Hello World  
Type = int, value = 55  
Type = struct { name string }, value = {Naveen R}  
类型断言

类型断言type assertion)用来提取接口的实际类型的值。

i.(T)是用来获取接口 i 的实际类型 T 的值的语法。

一个程序胜过千言万语。让我们写一个类型断言。

package main

import (
	"fmt"
)

func assert(i interface{}) {
	s := i.(int) //get the underlying int value from i
	fmt.Println(s)
}
func main() {
	var s interface{} = 56
	assert(s)
}

上面程序第12行,s 的实际类型是 int。在第8 行我们使用 i.(int) 来获取 iint 值。程序的输出为:56

如果实际类型不是 int,那么上面的程序会发生什么?让我们来试一下:

package main

import (
	"fmt"
)

func assert(i interface{}) {
	s := i.(int)
	fmt.Println(s)
}
func main() {
	var s interface{} = "Steven Paul"
	assert(s)
}

在上面的程序中,我们将实际类型为 string 的变量 s 传递给 assert 函数,assert 函数尝试从其中提取出一个 int 值。该程序会报错: panic: interface conversion: interface {} is string, not int

要解决上述问题,我们可以使用以下语法

v, ok := i.(T)

如果 i 的具体类型是 T,则 v 将具有 i 的实际值,oktrue

如果 i 的具体类型不是 T,则 ok 将为 falsev 将具有 T零值,程序不会报错。

package main

import (
	"fmt"
)

func assert(i interface{}) {
	v, ok := i.(int)
	fmt.Println(v, ok)
}
func main() {
	var s interface{} = 56
	assert(s)
	var i interface{} = "Steven Paul"
	assert(i)
}

Steven Paul 传递给 assert 函数,ok 将是 false 因为 i 的实际类型不是 int 并且 v 的值将是int零值,也就是0。程序将输出:

56 true  
0 false
Type Switch

Type Switch用来将一个接口的具体类型与多个 case 语句指定的类型进行比较。这和一般的 switch 语句很像。唯一不同的是 type switchcase 指定的是类型,而一般的 switch 语句中 case 指定的是值。

type switch 的语法与类型断言很相似。在类型断言 i.(T)中,将类型 T 替换为关键字 type 就变成了 type switch。让我们看看下面的程序如何工作。

package main

import (
	"fmt"
)

func findType(i interface{}) {
	switch i.(type) {
	case string:
		fmt.Printf("I am a string and my value is %s\n", i.(string))
	case int:
		fmt.Printf("I am an int and my value is %d\n", i.(int))
	default:
		fmt.Printf("Unknown type\n")
	}
}
func main() {
	findType("Naveen")
	findType(77)
	findType(89.98)
}

上面程序第8行,switch i.(type) 是一个 type switch。每个case语句都将具体类型与i特定类型进行比较。如果一个 case 匹配,则打印相应的语句。程序的输出为:

I am a string and my value is Naveen  
I am an int and my value is 77  
Unknown type  

在第20行,89.98flaot64 类型,并不匹配任何一个 case。因此在会后一行打印:Unknown type

还可以将类型与接口进行比较。如果我们有一个类型,并且该类型实现了一个接口,则可以将此类型与它实现的接口进行比较。

让我们写一个程序,以便更清晰。

package main

import "fmt"

type Describer interface {
	Describe()
}
type Person struct {
	name string
	age  int
}

func (p Person) Describe() {
	fmt.Printf("%s is %d years old", p.name, p.age)
}

func findType(i interface{}) {
	switch v := i.(type) {
	case Describer:
		v.Describe()
	default:
		fmt.Printf("unknown type\n")
	}
}

func main() {
	findType("Naveen")
	p := Person{
		name: "Naveen R",
		age:  25,
	}
	findType(p)
}

在上面的程序中,Person 结构体实现了 Describer 接口。在第 19 行的 case 语句,vDescribe 接口进行比较。由于 p 实现了 Describer 接口因此这个 case 匹配成功,在第32findType(p)PersonDescribe() 方法被调用。

该程序的输出为:

unknown type  
Naveen R is 25 years old  
深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预测任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预测与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
【4层】3100平米综合办公楼毕业设计(含计算书、建筑结构图) 、1资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 、1资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值