Qu'est-ce que l'héritage à Golang
Héritage à Golang
L'héritage à Golang est un moyen de créer une classe d'enfants qui est une version modifiée d'une classe existante ou parentale. La classe nouvellement créée prend les propriétés de la classe parent existante. La sous-classe ou la classe infantile peut également modifier ou ajouter de nouvelles propriétés dans la classe parentale.
Syntaxe pour hériter à Golang
Pour hériter d'une classe parentale à Golang, nous utilisons le structure mot-clé et intégrer la classe parent à l'intérieur de la classe enfant. Voici un exemple:
type parent struct
Property1 String
Property2 int
type child struct
Parent
propriété3 float32
La syntaxe ci-dessus a une structure enfant qui incorpore la structure parentale, ce qui signifie qu'il hérite de toutes ses propriétés et méthodes. L'enfant structure a également une nouvelle propriété appelée propriété3.
Pourquoi Golang ne soutient pas l'héritage
Dans la programmation traditionnelle orientée objet, l'héritage est un concept fondamental qui implique des propriétés héritées d'une classe parentale à une classe d'enfants. Cependant, depuis Golang ne prend pas en charge les cours, L'héritage est mis en œuvre à l'aide de l'intégration de structure.
Dans Golang, les structures ne peuvent pas être étendues directement, nous utilisons donc la composition pour construire de nouveaux objets en utilisant le structure. Par conséquent, il est exact de dire que Golang ne fournit pas le soutien natif pour l'héritage, mais soutient plutôt la composition comme alternative.
Comment réaliser l'héritage à Golang en utilisant la structure intégrée
À Golang, l'héritage est obtenu par un mécanisme appelé intégration de structure. Cela nous permet d'incorporer une structure à l'intérieur d'un autre, ce qui se traduit par une relation comme un parent et une classe d'enfants. L'enfant Struct peut alors accéder aux champs et aux méthodes de la structure parentale, comme s'il faisait partie de sa propre définition.
Voici un exemple de la façon d'atteindre l'héritage à Golang en utilisant l'intégration de structure:
Type personne struct
chaîne de noms
Âge int
Type Struct des employés
Personne // incorporer la structure de la personne à l'intérieur de la structure des employés
Empid Int
salaire float64
Dans le code ci-dessus, la structure de la personne est intégrée par la structure des employés en utilisant le nom du champ de personne sans type, ce qui implique qu'il incorpore la structure elle-même. Cela crée une relation parent-enfant entre les deux structures, où la structure des employés est l'enfant, et la structure de la personne est le parent.
Désormais, tous les champs ou méthodes définis dans la personne qui sont accessibles à partir de la structure des employés. Par exemple, nous pouvons accéder au champ de nom de la structure de la personne à partir de la structure des employés en utilisant la notation de points:
E: = Employé Person Name: "Kash", âge: 24, 20, 1000
fmt.Println (e.nom)
De même, nous pouvons définir des méthodes dans la structure de la personne accessible à partir de la structure des employés:
func (p * personne) introduire ()
fmt.Printf ("Salut, je m'appelle% s et je suis âgé de% D.\ n ", p.Nom, P.âge)
func main ()
E: = Employé Person Name: "Kash", âge: 24, 20, 1000
e.introduire()
Exemple 1: Programme de Golang pour montrer l'héritage de l'intégration de structure
package principal
Importer "FMT"
Type personne struct
chaîne de noms
Âge int
Type Struct des employés
Personne // incorporer la structure de la personne à l'intérieur de la structure des employés
Empid Int
salaire float64
func (p * personne) introduire ()
fmt.Printf ("Salut, je m'appelle% s et je suis âgé de% D.\ n ", p.Nom, P.âge)
func (e * employé) introduire ()
fmt.Printf ("Salut, je m'appelle% s et je suis âgé de% D. Mon identifiant d'employé est% d et mon salaire est $%.2F.\ n ", e.Nom, E.Âge, E.Empid, e.salaire)
func main ()
E: = Employé Person Name: "Kash", âge: 24, 20, 1000
fmt.Println (e.nom)
e.introduire()
Ici, nous avons défini une structure de personne et une structure d'employée qui incorpore la structure de la personne. Nous définissons ensuite le introduire() Méthode sur la structure de la personne, à laquelle nous pouvons accéder à partir de la structure des employés. Dans main (), nous avons créé une nouvelle instance d'employée et démontré comment nous pouvons accéder aux champs et méthodes de la structure de personne intégrée.
Exemple 2: Programme de Golang pour montrer plusieurs héritages à une structure
package principal
Importer "FMT"
Type personne struct
chaîne de noms
Âge int
type Student Struct
Personne // incorporer la structure de la personne à l'intérieur de l'étudiant structure
rollno int
Type Teacher Struct
Personne // incorporer la structure de la personne à l'intérieur de la structure de l'enseignant
Empid Int
func (p * personne) introduire ()
fmt.Printf ("Salut, je m'appelle% s et je suis âgé de% D.\ n ", p.Nom, P.âge)
func (s * étudiant) Study ()
fmt.Printf ("% s étudie.\ n ", s.nom)
func (t * professeur) enseigne ()
fmt.Printf ("% s enseigne.\NT.nom)
func main ()
S: = Student Person Name: "Kash", âge: 24, 1001
t: = enseignant personne nom: "Sam", âge: 30, 2001
s.introduire()
s.étude()
t.introduire()
t.enseigner()
Dans l'exemple ci-dessus, nous définissons une structure personne. Nous définissons également les méthodes introduire (), étude () et enseigner () sur les structures de la personne, des élèves et des enseignants, respectivement.
Dans main (), nous avons créé de nouvelles instances d'étudiant et d'enseignant et avons démontré comment nous pouvons accéder aux champs et méthodes de la structure de personne intégrée, ainsi que les méthodes spécifiques à chaque structure.
Conclusion
L'héritage est un concept essentiel dans la programmation orientée objet, et Golang fournit un support pour l'héritage unique grâce à l'intégration de structure. Pour un héritage multiple à Golang, la méthode de composition est utilisée. Cet article couvre comment nous pouvons réaliser l'héritage en utilisant la méthode de composition à Golang. Pour plus de détails sur l'héritage à Golang, lisez l'article.