Cenários de aplicativos de interface
Para iniciantes, não é muito difícil entender o conceito de interfaces. O difícil é não saber quando usar interfaces. Aqui estão alguns cenários de aplicação:
1. Se os Estados Unidos querem agora fabricar bombardeiros e helicópteros armados, os especialistas só precisam determinar as funções/especificações exigidas pela aeronave e depois deixar que outros as implementem.
Se você quiser escrever uma estrutura, existem alguns métodos na estrutura. Definitivamente, não é bom para um programador escrever esses métodos. Se você quiser envolver todos, você pode perguntar ao gerente do projeto. O gerente do projeto pode definir um interface. Todos podem simplesmente implementar esta interface e pronto. Desta forma, o andamento do projeto de gestão pode ser bem controlado.
Na verdade, é apenas pegar a especificação da definição e deixar que outros implementem a especificação.
Se quiser classificar, você só precisa implementar esta interface de dados.
Na verdade, todos os métodos que implementam a interface interface são passados. Então você pode chamar o método sort no pacote e passar esse tipo.
Há uma função Sort no pacote sort. Sort aceita dados. É uma interface. Portanto, contanto que as variáveis passadas implementem todos os métodos na interface e passadas, ela irá classificá-los naturalmente para você. Ao implementar a interface, a função Classificar o ajudará automaticamente a implementar a classificação.
Se, conforme mostrado abaixo, você usou e-mail para enviar informações de alarme antes e depois, se quiser mudar para dingding para enviar alarmes, então o código precisa ser alterado.
//如果产生了一个告警，将告警发送给相关的人
//email sms weixin
type EmailSender struct {
}
type DingDingSender struct {
}
func (e *EmailSender) Send(msg string) error {
fmt.Println(msg)
return nil
}
func (d *DingDingSender) Send(msg string) error{
fmt.Println(msg)
return nil
}
func test(e *EmailSender,msg string) {
e.Send(msg)
}
func main() {
sender := new(EmailSender)
sender.Send("email send")
}Se precisar modificá-lo, modifique-o da seguinte maneira. Você deve modificar todos os códigos relacionados ao e-mail. Caso contrário, a compilação falhará.
Para resolver este problema, você pode definir interfaces. Uma característica dessas estruturas é que todas elas possuem métodos Send. Dessa forma, você pode definir interfaces apenas com métodos Send, e então os tipos de parâmetros podem usar o tipo de interface.
Seria muito mais conveniente se a interface fosse definida, bastando alterar apenas um local, que é o local onde a estrutura é instanciada.
type Sender interface {
Send(string) error
}
sender := new(DingDingSender)
test(sender,"dingding send")
sender1 := new(EmailSender)
test(sender1,"email send")2. Suponha que haja um gerente de projeto que gerencia três programadores e desenvolve uma função de software. Para controlar e gerenciar o software, o gerente de projeto pode definir algumas interfaces, que são então implementadas pelos programadores.
O gerente do projeto só precisa definir a interface e deixar que os programadores completem o resto. Desta forma, o progresso do desenvolvimento de software pode ser controlado.
Notas e detalhes
1) A interface em si não pode criar uma instância, mas pode apontar para uma variável (instância) de um tipo personalizado que implementa a interface
type interfaceA interface {
Say()
}
type Student struct {
}
func (*Student) Say() {
fmt.Println("I am a student")
}
func main() {
var i interfaceA
student := new(Student)
i = student //结构体变量实现了接口的方法
i.Say()
}2) Todos os métodos da interface não possuem corpo de método, ou seja, são todos métodos sem implementação.
3) Em Golang, um tipo customizado precisa implementar todos os métodos de uma interface. Dizemos que esse tipo customizado implementa a interface.
4) Somente quando um tipo personalizado implementa uma interface uma instância (variável) do tipo personalizado pode ser atribuída ao tipo de interface.
5) Contanto que seja um tipo de dados personalizado, você pode implementar a interface, não apenas o tipo de estrutura.
type interfaceA interface {
Say()
}
type integer int
func (i *integer) Say() {
fmt.Println("i地址为:", &i, "i的值为:", *i)
}
func main() {
var i interfaceA
var a integer = 5
a.Say()
}6) Um tipo personalizado pode implementar múltiplas interfaces
7) Não pode haver nenhuma variável na interface Golang
Como você pode ver acima, é diferente do oop tradicional, pois implementa essa interface com base em métodos. Em Java, eles são implementados explicitamente e você deve especificar explicitamente qual interface implementar. Golang não se importa com qual interface é implementada, apenas com qual método é implementado.
8) Uma interface (como a interface A) pode herdar várias outras interfaces (como as interfaces B e C), neste caso, se você deseja implementar a interface A, também deve implementar todos os métodos das interfaces B e C.
Você pode ver que existem dois métodos na interface A, o que equivale a herdar essas duas interfaces. Então você precisa implementar os métodos na interface herdada e seus próprios métodos.
9) O tipo de interface é padronizado como um ponteiro (tipo de referência).Se for usado sem inicializar a interface, nil será gerado ( ao passar parâmetros, como estruturas, o que é passado não é um tipo de valor, mas uma referência type. , ou seja, &struct{} )
10) A interface vazia não possui nenhum método, então todos os tipos implementam a interface vazia (a interface vazia é na verdade um tipo de dados. Variáveis de qualquer tipo de dados podem ser atribuídas à interface vazia. Se o parâmetro for um parâmetro formal de a interface vazia, então significa que qualquer tipo de dados pode ser aceito)
Como você pode ver abaixo, a estrutura implementa a interface vazia por padrão. Outros tipos também estão disponíveis, incluindo strings inteiras.
type T interface {
}
type student struct {
age int
name string
}
func main() {
s := &student{
age: 10,
name: "lucas",
}
var t T = s
fmt.Println(reflect.TypeOf(t))
fmt.Println(t)
var t3 interface{} = s
fmt.Println(t3)
}
*main.student
&{10 lucas}
&{10 lucas}Qualquer variável pode ser atribuída à interface vazia