¿Qué es la herencia en Golang?
Herencia en Golang
La herencia en Golang es una forma de crear una clase infantil que sea una versión modificada de una clase existente o principal. La clase recién creada toma las propiedades de la clase principal existente. La clase de subclase o hijo también puede modificar o agregar algunas propiedades nuevas en la clase principal.
Sintaxis para heredar en Golang
Para heredar de una clase principal en Golang, usamos el estructura Palabra clave e incrusta la clase principal dentro de la clase infantil. Aquí hay un ejemplo:
escribe estructura matriz
propiedad1 cadena
propiedad2 int
Tipo de estructura infantil
Padre
propiedad3 float32
La sintaxis anterior tiene una estructura infantil que incorpora la estructura principal, lo que significa que hereda todas sus propiedades y métodos. La estructura infantil también tiene una nueva propiedad llamada propiedad3.
Por qué Golang no es compatible con la herencia
En la programación tradicional orientada a objetos, la herencia es un concepto fundamental que implica heredar propiedades de una clase principal a una clase infantil. Sin embargo, desde Golang no admite clases, La herencia se implementa utilizando la incrustación de estructura.
En Golang, las estructuras no se pueden extender directamente, por lo que utilizamos la composición para construir nuevos objetos utilizando el estructura. Por lo tanto, es exacto decir que Golang no proporciona apoyo nativo para la herencia, sino que respalda la composición como alternativa.
Cómo lograr la herencia en Golang utilizando la incrustación de estructura
En Golang, la herencia se logra a través de un mecanismo llamado incrustación de estructura. Esto nos permite incrustar una estructura dentro de otra, lo que resulta en una relación como una clase padre e hijos. La estructura infantil puede acceder a los campos y métodos de la estructura principal, como si fueran parte de su propia definición.
Aquí hay un ejemplo de cómo lograr la herencia en Golang utilizando la incrustación de estructura:
Tipo de persona estructura
cadena de nombre
edad int
Tipo de estructura del empleado
Persona // incrustar la estructura de la persona dentro de la estructura del empleado
Empid int
Flotación salarial64
En el código anterior, la estructura de la persona está integrada por la estructura de los empleados utilizando el nombre de campo de la persona sin un tipo, lo que implica que está incrustando la estructura misma. Esto crea una relación padre-hijo entre las dos estructuras, donde la estructura del empleado es el niño, y la estructura de la persona es el padre.
Ahora, se puede acceder a cualquier campos o método definido en la estructura de la persona desde la estructura del empleado. Por ejemplo, podemos acceder al campo de nombre de la estructura de la persona desde la estructura del empleado utilizando la notación del punto:
E: = Empleado persona nombre: "kash", edad: 24, 20, 1000
fmt.Println (e.nombre)
Del mismo modo, podemos definir métodos en la estructura de la persona a las que se puede acceder desde la estructura del empleado:
func (p *persona) introducir ()
fmt.Printf ("Hola, mi nombre es %s y tengo un %de años.\ n ", P.Nombre, P.edad)
func Main ()
E: = Empleado persona nombre: "kash", edad: 24, 20, 1000
mi.introducir()
Ejemplo 1: Programa de Golang para mostrar herencia en la incrustación de estructura
paquete principal
importar "fmt"
Tipo de persona estructura
cadena de nombre
edad int
Tipo de estructura del empleado
Persona // incrustar la estructura de la persona dentro de la estructura del empleado
Empid int
Flotación salarial64
func (p *persona) introducir ()
fmt.Printf ("Hola, mi nombre es %s y tengo un %de años.\ n ", P.Nombre, P.edad)
func (e *empleado) introducir ()
fmt.Printf ("Hola, mi nombre es %s y tengo un %de años. La identificación de mi empleado es %D y mi salario es de $ %.2F.\ n ", e.Nombre, E.Edad, E.Empid, E.salario)
func Main ()
E: = Empleado persona nombre: "kash", edad: 24, 20, 1000
fmt.Println (e.nombre)
mi.introducir()
Aquí, hemos definido una estructura de persona y una estructura de empleados que incrusta la estructura de la persona. Luego definimos el introducir() método en la estructura de la persona, a la que podemos acceder desde la estructura del empleado. En Main (), creamos una nueva instancia de empleado y demostramos cómo podemos acceder a los campos y métodos de la estructura de la persona integrada.
Ejemplo 2: programa de Golang para mostrar múltiples herencias a una estructura
paquete principal
importar "fmt"
Tipo de persona estructura
cadena de nombre
edad int
Tipo de estructura de estudiante
Persona // incrustar la estructura de la persona dentro de la estructura del estudiante
Rollno int
Tipo de maestro estructura
Persona // incrustar la estructura de la persona dentro de la estructura del maestro
Empid int
func (p *persona) introducir ()
fmt.Printf ("Hola, mi nombre es %s y tengo un %de años.\ n ", P.Nombre, P.edad)
FUNC (S *estudiante) estudio ()
fmt.Printf ("%s está estudiando.\ n ", S.nombre)
func (t *maestro) enseñar ()
fmt.Printf ("%s es enseñar.\ n ", t.nombre)
func Main ()
s: = estudiante persona nombre: "kash", edad: 24, 1001
t: = maestro persona nombre: "sam", edad: 30, 2001
s.introducir()
s.estudiar()
T.introducir()
T.enseñar()
En el ejemplo anterior, definimos una estructura de una persona y otras dos estructuras, estudiante y maestro, que incrustaron la estructura de la persona. También definimos los métodos introducir (), estudio () y enseñamos () sobre las estructuras de la persona, el alumno y el maestro, respectivamente.
En Main (), creamos nuevas instancias de estudiante y maestro y demostramos cómo podemos acceder a los campos y métodos de la estructura de la persona integrada, así como los métodos específicos de cada estructura.
Conclusión
La herencia es un concepto esencial en la programación orientada a objetos, y Golang proporciona soporte para la herencia única a través de la incrustación de estructura. Para la herencia múltiple en Golang, se utiliza el método de composición. Este artículo cubre cómo podemos lograr la herencia utilizando el método de composición en Golang. Para obtener más detalles sobre la herencia en Golang, lea el artículo.