introducción básica
Las variables (instancias) tienen muchas formas. La tercera característica importante de la orientación a objetos, en el lenguaje Go, es que las características polimórficas se implementan a través de interfaces (las interfaces pueden reflejar características polimórficas) . Se pueden llamar diferentes implementaciones según una interfaz unificada. En este momento, las variables de la interfaz adoptan formas diferentes.
En el caso anterior de la interfaz USB, el USB puede recibir variables de teléfono móvil y variables de la cámara, lo que refleja las características polimórficas de la interfaz USB. ( Determina automáticamente qué tipo de variable es la variable USB según el contexto )
La interfaz incorpora características polimórficas.
1) Parámetros polimórficos
En el caso anterior de la interfaz USB, el USB puede recibir variables de teléfono móvil y variables de la cámara, lo que refleja el polimorfismo de la interfaz USB.
2) Caso de demostración de matriz polimórfica
: almacene la estructura del teléfono en el cuerpo y la cámara de la matriz USB. Variables de estructura, el teléfono también tiene una llamada de método única (), recorra la matriz USB, si es una variable de teléfono, además de llamar al método declarado por la interfaz USB, también debe llamar a la llamada al método específico del teléfono.
package main
import "fmt"
type Usb interface {
Working()
}
type Phone struct {
}
type Camera struct {
}
func (*Phone) Working() {
fmt.Println("phone start working......")
}
func (*Camera) Working() {
fmt.Println("camera start working......")
}
func test(usb ...Usb) {
for _, v := range usb {
v.Working()
}
}
func main() {
p := new(Phone)
c := new(Camera)
test(p, c)
}A veces es necesario hacer juicios para ver qué tipo de variables se pasan y qué métodos se pueden utilizar. En este momento, es necesario utilizar afirmaciones de tipo.
Este tipo no se puede convertir a ciegas. La interfaz vacía apunta al tipo Punto. Al mismo tiempo, preste atención a si = apunta al tipo de variable de estructura o al tipo de puntero de estructura.
De hecho, es para convertir la interfaz vacía al tipo correspondiente, luego se utilizará la aserción de tipo.
Durante la aserción de tipo, si hay una discrepancia, se informará un error de pánico. Por lo tanto, al realizar la aserción de tipo, asegúrese de que la conversión a la que apunta el tipo de conexión nula original sea el tipo que se va a afirmar. Este juicio evita que la falla de aserción de tipo provoque que todo el programa falle.
Caso de afirmación 1
Agregue una llamada de método única a la estructura del teléfono. Cuando USB recibe la variable Teléfono, también es necesario llamar al método de llamada. Camina el código
package main
import "fmt"
type Usb interface {
Start()
Stop()
}
type Phone struct {
}
type Camera struct {
}
type Computer struct {
}
func (*Phone) Start() {
fmt.Println("phone start work.........")
}
func (*Phone) Call() {
fmt.Println("phone call")
}
func (*Phone) Stop() {
fmt.Println("phone stop work............")
}
func (*Camera) Start() {
fmt.Println("camera start work.........")
}
func (*Camera) Stop() {
fmt.Println("camera stop work.......")
}
func (*Computer) Working(usb ...Usb) {
for _, v := range usb {
v.Start()
if p, ok := v.(*Phone); ok {
p.Call()
}
v.Stop()
}
}
func main() {
computer := new(Computer)
camera := new(Camera)
phone := new(Phone)
u := []Usb{camera, phone}
computer.Working(u...)
}Aquí hay una estructura de teléfono, que tiene su propio método único. Aquí, se utiliza una aserción de tipo para afirmar primero si es un teléfono. Si la devolución es correcta, se llama al método único de la estructura.
Una vez que la afirmación falla, ok devuelve falso y no se ejecutará en absoluto, pero no afectará el funcionamiento de todo el programa y no entrará en pánico.
Aseveración tipo 2
El número y tipo de parámetros pasados de esta manera son inciertos.
elementos...interfaz{}
package main
import "fmt"
func TypeJudge(items ...interface{}) {
for _, v := range items {
switch v.(type) {
case bool:
fmt.Println(v, "type is bool")
case int64, int:
fmt.Println(v, "type is int64")
case string:
fmt.Println(v, "type is string")
case float64:
fmt.Println(v, "type is float64")
case nil:
fmt.Println(v, "type is nil")
default:
fmt.Println(v, "type is unknown")
}
}
}
func main() {
iFace := []interface{}{1, "hello", 2.3456, true}
TypeJudge(iFace...)
}
Como puede ver arriba, es posible no solo juzgar los tipos existentes sino también los tipos personalizados.