Interfaz general de la interfaz
- Abundan en Golang, el corazón y el alma de la interfaz de programación orientado a objetos deben ser, con respecto a otros lenguajes de POO son también muy singular.
- Los teléfonos móviles, cámaras conectadas a un puerto USB del ordenador, se unifican norma, no se preocupe por lo que en el dispositivo de extremo conectado a un ordenador, el enchufe en lo que es lo que nos lleva al concepto de polimorfismo.
- El polimorfismo es dependiente principalmente de la interfaz, el alto-bajo acoplados entre sí.
- Interface define los métodos de unos pocos no realizada crear otros estructuras, complementan cada método, con el fin de lograr diferentes estructura similar a llamar un "hub" para completar todos los métodos de interfaz.
- ★★★ métodos de interfaz no son todos los constructos, es decir, no se implementa el método de interfaz , la interfaz encarna la idea de polimorfismo y alta cohesión y la programación de acoplamiento bajo.
- ★★★ golang interfaz no requiere la realización explícita, siempre y cuando una variable que contiene todos los métodos básicos, entonces la variable en la realización de esta interfaz, no hay ningún implemento de palabras clave.
Ilustración, define una interfaz
package main
import "fmt"
type Usb interface {
/*
声明了两个没有实现的方法
*/
Start() //定义接口类型与结构体类似
Stop() //接口类型中只能定义方法！不能定义属性！
}
type Usb2 interface {
/*
声明了两个没有实现的方法
*/
Start()
Stop()
Test() //下面所有结构体方法都没有Test()，没有实现就不可使用Usb2接口，一定会报错，必须要完全实现方法
}
type Phone struct {
}
func (p Phone) Start() {
fmt.Println("手机开始工作")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作")
}
type Camera struct {
}
func (c Camera) Start() {
fmt.Println("相机开始工作")
}
func (c Camera) Stop() {
fmt.Println("相机停止工作")
}
type Computer struct {
}
func (c1 Computer) Connect(usb Usb) {
usb.Start()
usb.Stop()
}
func main() {
//创建结构体变量
computer := Computer{}
phone := Phone{}
camera := Camera{}
//重点
computer.Connect(phone)
computer.Connect(camera)
}
Interfaz escenario de uso
- El proceso de desarrollo no puede ser hecho por un programador todo el trabajo, el director del proyecto puede proporcionar una interfaz, interfaz consistente a todo el contenido, todos los métodos de cada variable por el programador responsables de su ejecución.
- Puede estar bien controlado y gestionado el progreso del desarrollo de software.
Cuestiones y detalles de la interfaz
- La interfaz en sí misma no puede crear una instancia, pero puede apuntar a un tipo personalizado implementos de las variables de interfaz. // El ejemplo anterior no es la propia interfaz ejemplo USB, pero la cámara del teléfono, y puede utilizar la interfaz para crear un método de instancia
- Todos los métodos de interfaz hay cuerpos de métodos, a saber, no se implementa el método.
- Golang en un tipo personalizado requiere una interfaz! Todos los métodos! Han logrado, se dice que este tipo de encargo implementa la interfaz.
- Mientras el tipo personalizado, se puede implementar la interfaz, no sólo la estructura, int, float se puede, siempre que implementa la interfaz, siempre y cuando todo el camino!
- Un tipo personalizado puede implementar múltiples interfaces, siempre que la realización de todos los métodos! // método de interfaz A 1, método de interfaz B 2, una estructura de implementos variables los métodos 1 y 2, entonces A y interfaces y métodos B se pueden utilizar para lograr la plena.
- Definir el tipo de interfaz no debe contener ninguna variable! No sólo es el método para lograr!
- La interfaz también puede ser hereditaria, heredó la premisa es lograr todo método heredado heredado!
- La interfaz es un tipo de referencia, con diferente estructura, si no se utiliza la inicialización, la salida es nula.
- Interfaz Interfaz de aire {} ninguna manera, por lo que todos los tipos de datos han logrado interfaz de vacío, es decir, podemos asignar cualquier variable a las interfaces vacías.
- ★★★ lograr el método de interfaz debe tenerse en cuenta que el método de enlace func variable (p teléfono) xx () {} y func (p * teléfono) xx () {} son dos concepto completamente diferente, uno es tipo de teléfono de la aplicación, un teléfono es el correspondiente tipo de implementos puntero un método detrás de si las variables de interfaz involucrados, deben corresponder a, o seguramente errores de compilación.
Artículo IX Por ejemplo, vistazo a la interfaz de vacío recibe imprimir qué valor.
package main
import "fmt"
type T1 interface {
}
func main() {
//没有初始化使用，打印出来是nil<nil>
var t1 T1
fmt.Println(t1)
//给空接口传入一个整型
num := 666
var t2 T1 = num
fmt.Println(t2) //666
//直接定义空接口类型，直接实例化出一个t3空接口赋予num1
var num1 = 8.8
var t3 iterface{} = num1
fmt.Println(t3) //8.8
}
Interfaces y relaciones de herencia
- La interfaz no puede lograr mediante la definición del método, como una nueva variable después de la sucesión de expansión, como la espada de la espada hereda ho todo el Juggernaut, al abrir los ojos se dan cuenta de nuevas habilidades, nuevas habilidades se pueden lograr a través de la interfaz.
- Implementar mecanismo de herencia interfaz suplementaria, la interfaz proporciona las normas y estándares comunes.
- Principalmente para resolver la sucesión de reutilización de código y problemas de mantenibilidad, la interfaz principal para diseñar una buena variedad de especificaciones que permiten otros tipos personalizados para poner en práctica este método de especificación.
- La interfaz es más flexible que la herencia, no hay herencia similar está al cien por cien ajuste no es, al igual que una lata.
- código de la interfaz desacoplada hasta cierto punto.
polimorfismo
- Las variables tienen una variedad de formas, la tercera característica importante de orientado a objetos, golang multi-estado se consigue a través de la interfaz.
- Puede seguir diferente para lograr una interfaz unificada llamadas, a continuación, las variables de interfaz asumen diferentes formas.
Interfaz refleja polimorfismos
- parámetros polimórficos: haciendo pasar el parámetro variable para determinar que la aplicación del método de interfaz.
- array polimórfica: almacenar diversos parámetros estructuras polimórficas que participan en una matriz, en el que la estructura también tiene su propio método único se puede invocar, como se detalla en la siguiente afirmación
afirman afirman
-
Una variable de estructura se asigna a un puerto de vacío, y a continuación, especifique una variable de estructura del mismo tipo, las interfaces de aire asignados a esta variable de estructura, no lo hacen directamente (tipo afirmación necesidad)
package main import "fmt" type Zuobiao struct { x int y int } type A interface { } func main() { zuobiao := Zuobiao{3,5} var a A a = zuobiao fmt.Println(a) var zuobiao1 Zuobiao //zuobiao1 = a //返回来赋值是不可以的， //这时候需要使用断言判断是否可以转换，如果不能转换就会报错，因为a指向zuobiao，所以可以转换成功。 zuobiao1 = a.(Zuobiao) //如果希望把空接口重新转换成原类型，那么就要使用断言 <接口变量>.(<回转类型名称>) fmt.Println(zuobiao1) } -
Tipo afirmación: Debido a que la interfaz es un tipo general, no es un tipo específico, para ser convertido en un tipo específico, tenemos que utilizar el tipo de afirmación.
-
Afirmación no es la conversión al azar, pero variable de interfaz vacía a punto de qué tipo, debe utilizar este tipo.
-
Cómo cheques afirmación se llevaron a cabo, llevar el mecanismo de detección, si el éxito no está mal, de lo contrario, no informará de pánico
// detectar el tipo de afirmación con la redacción 1
var b A var zb2 = Zuobiao{6,7} b = zb2 zb2,ok := b.(Zuobiao) //ok本身是布尔类型，这里是重点 if ok { //接下来条件判断，不会产生panic，而是根据判断继续流程控制 fmt.Println("OK,转换成功",zb2) } else { fmt.Println("转换不成功，继续执行后续代码") } fmt.Println("断言已经判断，可以继续执行")// banda afirmado tipo de detección 2 redacción
var b A var zb2 = Zuobiao{6,7} b = zb2 if zb2,ok := b.(Zuobiao); ok { //使用了if并列条件方式，结合了两句话，开发中也常用。 fmt.Println("OK,转换成功",zb2) } else { fmt.Println("转换不成功，继续执行后续代码") } fmt.Println("断言已经判断，可以继续执行")
Caso 1: El tipo de afirmación utiliza con frecuencia cuando: Una interfaz total de variable de estructura en su propia manera única, la forma de garantizar la llamada
package main
import "fmt"
type Usb interface {
/*
声明了两个没有实现的方法
*/
Start() //定义接口类型与结构体类似
Stop() //接口类型中只能定义方法！不能定义属性！
}
type Phone struct {
}
func (p Phone) Start() {
fmt.Println("手机开始工作")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作")
}
func (p Phone) Call() {
fmt.Println("手机可以打电话")
}
type Camera struct {
}
func (c Camera) Start() {
fmt.Println("相机开始工作")
}
func (c Camera) Stop() {
fmt.Println("相机停止工作")
}
type Computer struct {
}
func (c1 Computer) Connect(usb Usb) {
usb.Start()
//如果usb指向是一个phone结构体变量的，还需要使用call()方法
//这时候添加类型断言，这个在今后开发中很重要，常用到
if phone,ok := usb.(Phone) ; ok { //phone对应变量可以随意定义，保证变量与<变量>.Call()一致即可
phone.Call() //手机可以打电话,这种方式可以使每个独特方法的结构体增加美观性。
}
usb.Stop()
}
func main() {
/*
解决共有接口类型的数组结构体又分别有自己独特方法的解决方案
*/
var arrUsb [2]Usb
arrUsb[0] = Phone{}
arrUsb[1] = Camera{}
var c1 Computer
for _ , v := range arrUsb {
c1.Connect(v)
}
}
Caso 2: Escribir una función para determinar el tipo de datos de entrada y muestra el resultado, la atención se centra <elemento de la matriz> (tipo) utiliza esta afirmación.
package main
import "fmt"
func TypeJudge (items ...interface{}) { //传入可变长度类型的空接口
for i , v := range items { //遍历所有传入参数所在数组
switch v.(type) { //switch case循环判定类型为哪些
case bool:
fmt.Println(i," ",v,"为布尔类型")
case string:
fmt.Println(i," ",v,"为字符串类型")
}
}
}
func main() {
/*
定义一个可变参数的空接口
*/
var name = "shit" //字符串
var buer = false //布尔
TypeJudge(name,buer)
}
