La herencia significa heredar las propiedades de la superclase en la clase base y es uno de los conceptos más importantes en la Programación Orientada a Objetos. Dado que Golang no admite clases, la herencia se realiza mediante la incorporación de estructuras. No podemos extender estructuras directamente, sino usar un concepto llamado composición donde la estructura se usa para formar otros objetos. Entonces, puede decir que no hay concepto de herencia en Golang .
En la composición, las estructuras base se pueden incrustar en una estructura secundaria y los métodos de la estructura base se pueden llamar directamente en la estructura secundaria, como se muestra en el siguiente ejemplo.
Ejemplo 1:
// Golang program to illustrate the
// concept of inheritance
package main
import (
"fmt"
)
// declaring a struct
type Comic struct{
// declaring struct variable
Universe string
}
// function to return the
// universe of the comic
func (comic Comic) ComicUniverse() string {
// returns comic universe
return comic.Universe
}
// declaring a struct
type Marvel struct{
// anonymous field,
// this is composition where
// the struct is embedded
Comic
}
// declaring a struct
type DC struct{
// anonymous field
Comic
}
// main function
func main() {
// creating an instance
c1 := Marvel{
// child struct can directly
// access base struct variables
Comic{
Universe: "MCU",
},
}
// child struct can directly
// access base struct methods
// printing base method using child
fmt.Println("Universe is:", c1.ComicUniverse())
c2 := DC{
Comic{
Universe : "DC",
},
}
// printing base method using child
fmt.Println("Universe is:", c2.ComicUniverse())
}
Producción:
Universe is: MCU Universe is: DC
Las herencias múltiples tienen lugar cuando la estructura secundaria puede acceder a múltiples propiedades, campos y métodos de más de una estructura base. Aquí, la estructura secundaria incorpora todas las estructuras base como se muestra a través del siguiente código:
Ejemplo 2:
// Golang program to illustrate the
// concept of multiple inheritances
package main
import (
"fmt"
)
// declaring first
// base struct
type first struct{
// declaring struct variable
base_one string
}
// declaring second
// base struct
type second struct{
// declaring struct variable
base_two string
}
// function to return
// first struct variable
func (f first) printBase1() string{
// returns a string
// of first struct
return f.base_one
}
// function to return
// second struct variable
func (s second) printBase2() string{
// returns a string
// of first struct
return s.base_two
}
// child struct which
// embeds both base structs
type child struct{
// anonymous fields,
// struct embedding
// of multiple structs
first
second
}
// main function
func main() {
// declaring an instance
// of child struct
c1 := child{
// child struct can directly
// access base struct variables
first{
base_one: "In base struct 1.",
},
second{
base_two: "\nIn base struct 2.\n",
},
}
// child struct can directly
// access base struct methods
// printing base method
// using instance of child struct
fmt.Println(c1.printBase1())
fmt.Println(c1.printBase2())
}
Producción:
In base struct 1. In base struct 2.
Publicación traducida automáticamente
Artículo escrito por vanigupta20024 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA