Quelle est la similitude et la différence entre une classe normale et une classe abstraite?

En Golang, il n'existe pas de concept de "classe ordinaire" et "classe abstraite" tel qu'ils existent dans des langages orientés objet comme Java ou C#.

Cependant, leur fonctionnalité peut être imitée en utilisant des structures et des interfaces.

Similarités (en utilisant des structures et des interfaces en Golang):

• État (données): La structure peut contenir des champs, comme une classe ordinaire qui stocke des propriétés.
• Comportement (méthodes): Des méthodes peuvent être attachées à la structure, définissant son comportement, similaire aux méthodes d'une classe ordinaire.
• Contrat commun (pour classe abstraite et interface): L'interface en Golang définit un ensemble de méthodes que toute structure "implémentant" cette interface doit définir. Cela ressemble à la façon dont une classe abstraite ou une interface dans d'autres langages définit un contrat pour les classes qui héritent ou implémentent.

Différences (dans le contexte de Golang):

Caractéristique	"Classe ordinaire" (structure avec méthodes)	"Classe abstraite" (interface + structures)
Création directe	On peut créer une instance de la structure.	On ne peut pas créer une instance de l'interface.
Implémentation des méthodes	Toutes les méthodes attachées à la structure ont une implémentation.	L'interface déclare seulement des méthodes, mais pas leur implémentation.
Héritage	Il n'y a pas d'héritage explicite au sens classique. La composition (inclusion de structures) peut être utilisée.	L'interface n'hérite pas, mais est implémentée par des structures.
Obligation d'implémentation	Il n'y a pas d'obligation d'implémenter un ensemble spécifique de méthodes, sauf celles attachées à la structure.	Toute structure qui "implémente" l'interface Golang doit fournir l'implémentation de toutes ses méthodes.
Stockage d'état (champs)	La structure peut contenir des champs de données.	L'interface ne contient pas de champs de données.

Exemple d'imitation:

// interface imitant une classe abstraite
type Shape interface {
	Area() float64
	Perimeter() float64
}

// structure imitant une classe ordinaire
type Circle struct {
	Radius float64
}

// implémentation des méthodes de l'interface pour Circle
func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
	return 2 * 3.14 * c.Radius
}

// Une autre structure implémentant l'interface
type Rectangle struct {
	Width, Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

Dans cet exemple, Shape agit comme un contrat (similaire à une classe abstraite ou une interface dans d'autres langages), et Circle et Rectangle sont des implémentations concrètes (analogues à des classes normales). Nous pouvons créer des instances de Circle et Rectangle, mais pas de Shape directement. De plus, les deux structures doivent implémenter les méthodes Area() et Perimeter() pour "respecter" l'interface Shape.