Y a-t-il des cours en golang ?

Il n'y a pas de cours en golang. Golang n'est pas un pur langage de programmation orienté objet. Il n'a pas de concept de classe et il n'y a pas d'héritage. Cependant, Go peut également simuler une programmation orientée objet. Dans Go, struct peut être comparé à une classe dans d'autres langages ; une structure est définie via struct pour représenter un type d'objet, tel que "type person struct {...}".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Trois caractéristiques majeures de l'orientation objet : l'encapsulation, l'héritage et le polymorphisme.

Go n'est pas un pur langage de programmation orienté objet. Il n'a pas de concept de classe et il n'y a pas d'héritage. Mais Go peut également simuler une programmation orientée objet, c'est-à-dire que struct peut être comparé aux classes d'autres langages.

Objects

Go n'a pas de concept de classe. Il définit une structure via struct pour représenter un type d'objet.

type person struct {
	Age  int
	Name string
}

Les objets sont des organismes d'état et de comportement. Par exemple, le code Java suivant :

public class Person {

    int age;

    String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Contrairement à Java, les méthodes de Go n'ont pas besoin d'être liées aux données de classe dans une définition de classe, doivent seulement être définies dans le même package . Cela peut sembler étrange aux étudiants qui débutent sur Go.

type person struct {
	Age  int
	Name string
}

func (p *person) GetAge() int {
	return p.Age
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) GetName() string {
	return p.Name
}

func (p *person) SetName(name string) {
	p.Name = name
}

Constructor

Go n'a pas de constructeur et le support de données de l'objet est une structure. Java prend en charge les constructeurs. Le nom du constructeur est le même que le nom de la classe. Plusieurs constructeurs sont implémentés via une surcharge de fonctions.

Le constructeur Go est simulé via une fonction d'usine. Un exemple est le suivant :

type person struct {
	Age  int
	Name string
}

/**
	构造函数1--通过名字初始化
 */
func newPersonByName(name string) *person {
	return &person{
		Name: name,
	}
}

/**
	构造函数2--通过年龄初始化
 */
func newPersonByAge(age int) *person {
	return &person{
		Age: age,
	}
}

Il convient de noter que la première lettre du nom de la structure de la personne doit être en minuscule pour éviter un contournement direct externe du constructeur simulé

Autorisations d'accès

Java a quatre autorisations d'accès, comme suit :

caractère de contrôle d'accès Java

	public	protégé	convivial (par défaut)	privé
même classe	oui	oui	oui	oui
Même forfait	oui	oui	oui	non
sous-classes différentes	oui	oui	non	non
différents packages non-sous-classes	oui	non	non	non

Go est simplifié. La granularité minimale de visibilité est le package. Autrement dit, Go retient deux types, convivial et public. Si la première lettre du nom d'une variable Go est en minuscule, cela signifie qu'elle est visible dans le package ; si la première lettre est en majuscule, cela signifie qu'elle est visible n'importe où.

Encapsulation

Encapsulation, liant la structure abstraite aux fonctions qui opèrent sur les données à l'intérieur de la structure. Les programmes externes ne peuvent modifier l'état interne de la structure qu'en fonction de l'API de la fonction exportée (méthode publique).

L'encapsulation présente deux avantages :

Masquer l'implémentation : nous souhaitons uniquement que les utilisateurs utilisent directement l'API pour faire fonctionner l'état interne de la structure sans connaître la logique interne. Comme un iceberg, on ne voit que la partie au dessus de l’eau.

Protéger les données : nous pouvons imposer des mesures de sécurité sur la modification et l'accès aux données. Lors de l'appel de la méthode setter, nous pouvons vérifier les paramètres lors de l'appel de la méthode getter, nous pouvons ajouter des journaux d'accès, etc.

Une définition simple du bean est la suivante :

type person struct {
	Age  int
	Name string
}

func NewPerson(age int, name string) *person{
	return &person{age, name}
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) SetName(name string) {
	p.Name = name
}

func main() {
	p:= NewPerson(10, "Lily")
	p.SetName("Lucy")
	p.SetAge(18)
}

Il convient de noter que la méthode Go est une fonction spéciale, qui est juste une sorte de sucre syntaxique pour le compilateur. Le compilateur nous aide à utiliser la référence de l'objet comme une fonction. le premier paramètre. Par exemple, le code suivant est équivalent à

func main() {
	p:= NewPerson(10, "Lily")

	p.SetName("Lily1")
	// 等价于下面的写法
	// p是一个引用，函数引用
	setNameFunc := (*person).SetName
	setNameFunc(p, "Lily2")
	fmt.Println(p.Name)
}

inherit

inheritance Si une classe enfant hérite de la classe parent, elle obtiendra les caractéristiques et les comportements de la classe parent. L’objectif principal de l’héritage est de réutiliser le code. Les deux principaux outils Java de réutilisation du code sont l'héritage et la composition.

Go n'a aucune notion de classe et il n'y a pas d'héritage. Mais Go peut simuler l’héritage grâce à une composition anonyme.

Comme indiqué ci-dessous, Cat obtient automatiquement les méthodes move() et Shout() d'Animal en agrégeant anonymement la structure Animal :

type Animal struct {
	Name string
}

func (Animal) move()  {
	fmt.Println("我会走")
}

func (Animal) shout()  {
	fmt.Println("我会叫")
}

type Cat struct {
	Animal // 匿名聚合
}

func main() {
	cat := &Cat{Animal{"猫"}}

	cat.move()
	cat.shout()
}

Polymorphisme

Polymorphisme, déclaré comme variable de la classe de base, vous pouvez pointer vers différentes sous-classes pendant l'exécution et appeler les méthodes de différentes sous-classes. Le but du polymorphisme est d’atteindre l’uniformité.

Nous implémentons le polymorphisme via des interfaces. En Java, nous définissons les interfaces via des interfaces et implémentons des interfaces via des implémentations.

interface Animal {

    void move();

    void shout();
}

class Dog implements Animal {

    @Override
    public void move() {
        System.out.println("我会走");
    }

    @Override
    public void shout() {
        System.out.println("我会叫");
    }
}

Et Go déduit grâce au type de canard que tant qu'un objet ressemble à un canard et cancane comme un canard, alors c'est un canard. Autrement dit, l'interface de Go est relativement cachée. Tant qu'un objet implémente toutes les méthodes déclarées par l'interface, il est considéré comme appartenant à l'interface.

type Animal interface {

	move()
	shout()
}

type Cat struct {
	Animal // 匿名聚合
}

func (Cat)move()  {
	fmt.Println("猫会走")
}

func (Cat)shout()  {
	fmt.Println("猫会叫")
}

type Dog struct {
	Animal  // 匿名聚合
}


func (Dog)move()  {
	fmt.Println("狗会走")
}

func (Dog)shout()  {
	fmt.Println("狗会叫")
}

func main() {
	cat := Cat{}
	dog := Dog{}
    // 申明接口数组
 	animals := []Animal{cat, dog}
	for _,ele := range animals {
        // 统一访问
		ele.move()
		ele.shout()
	}
}

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!