Environnement de développement

Ce matériel couvre les concepts fondamentaux de la programmation orientée objet (P.O.O.) en Visual Basic .Net. Il s'adresse aux étudiants et débutants souhaitant comprendre la création et la manipulation des classes, l'encapsulation, l'héritage, le polymorphisme ainsi que les notions de classes abstraites et interfaces.

Introduction à la programmation orientée objet en VB.Net

VB.Net est un langage de programmation orientée objet qui repose sur trois concepts clés :

• Encapsulation : regrouper les données et les méthodes qui manipulent ces données dans une même unité, la classe.
• Héritage : permettre à une classe d'hériter des propriétés et méthodes d'une autre classe.
• Polymorphisme : capacité d'une méthode à se comporter différemment selon le contexte.

Une classe est composée de :

• Champs (attributs)
• Constructeurs et destructeurs
• Méthodes
• Accesseurs (getters et setters)

Définition d'une classe

Une classe peut être définie avec différents modificateurs d'accès :

• Public, Private, Protected, Friend, Protected Friend
• MustInherit pour une classe abstraite (non instanciable)
• NotInheritable pour une classe finale (ne peut pas être héritée)

Syntaxe générale :

[Public | Private | Protected | Friend | Protected Friend]
[MustInherit | NotInheritable]
Class nom_classe
  [Inherits nom_classe_base]
  [Implements nom_classe_interface]
  ' propriétés, méthodes ...
End Class

Exemple simple de déclaration et instanciation :

Public Class Personne
  Dim nom As String
  Dim prenom As String
  Dim date_naiss As Date
End Class

Dim p1 As Personne
p1 = New Personne

With p1
  .nom = "AAA"
  .prenom = "BBB"
End With

Constructeurs et destructeurs

Constructeur

Le constructeur est une méthode spéciale utilisée pour créer et initialiser une instance d'une classe. Son nom est toujours Public Sub New([paramètres]). Il peut être défini avec ou sans paramètres.

Public Sub New()
  nom = ""
  prenom = ""
  date_naiss = ""
End Sub

Public Sub New(n As String, p As String, d As Date)
  nom = n
  prenom = p
  date_naiss = d
End Sub

Destructeur

Le destructeur sert à détruire une instance, mais il est généralement géré automatiquement par le système. Sa signature est :

Protected Overrides Sub Finalize()
  ' Code pour libérer des ressources, par exemple fermer une connexion
End Sub

Accesseurs (Getters et Setters)

Les accesseurs permettent de récupérer ou modifier les valeurs des champs privés d'un objet. Ils sont définis sous forme de propriétés avec des blocs Get et Set.

Public Class Personne
  Private nom As String
  Private prenom As String
  Private date_naiss As Date

  Public Property Nom() As String
    Get
      Return nom
    End Get
    Set(Value As String)
      nom = Value
    End Set
  End Property
  ' Autres propriétés similaires...
End Class

Utilisation :

Dim p1 As New Personne
p1.Nom = "AAA"
Dim n As String
n = p1.Nom
Console.WriteLine(n)  ' Affiche AAA

Note : le mot-clé Shared désigne un membre statique partagé par toutes les instances d'une classe.

Méthodes d'une classe

Les méthodes sont des procédures ou fonctions définies dans une classe pour manipuler ses attributs. Elles sont généralement déclarées Public.

La surcharge de méthodes permet de définir plusieurs méthodes du même nom mais avec des paramètres différents (en nombre ou en type). Le modificateur utilisé est Overloads.

Attention, les éléments suivants ne distinguent pas deux méthodes surchargées :

• Le nom des paramètres
• Le type de retour
• Les modificateurs ByVal ou ByRef

Exemple de surcharge de méthodes

Public Class Personne
  ' Attributs de la classe

  Public Overloads Sub affichage()
    Console.Write("Mr {0} {1} né le {2}", nom, prenom, date_naiss)
  End Sub

  Public Overloads Sub affichage(ByVal langue As String)
    Select Case langue
      Case "fr"
        Console.Write("Mr {0} {1} né le {2}", nom, prenom, date_naiss)
      Case "en"
        Console.Write("Mr {0} {1} was born the {2}", nom, prenom, date_naiss)
    End Select
  End Sub
End Class

Héritage et redéfinition de méthodes

L'héritage établit une relation entre deux classes où une classe dérivée hérite des attributs et méthodes d'une classe de base.

Public Class A
  Inherits B
  ' Attributs et méthodes supplémentaires
End Class

Exemple d'héritage avec redéfinition :

Public Class Client
  Inherits Personne

  Private code As Integer

  Public Sub New(n As String, p As String, d As Date, co As Integer)
    MyBase.New(n, p, d)
    code = co
  End Sub

  Public Overrides Sub affichage()
    MyBase.affichage()
    Console.Write(" Code Client : {0}", code)
  End Sub
End Class

Utilisation :

Dim c As Client
c = New Client("AAA", "BB", #12/12/1990#, 1123)
c.affichage()
' Affiche : Mr AAA BB né le 12/12/1990 Code Client : 1123

Classes abstraites

Une classe abstraite est une classe qui peut ne pas implémenter toutes ses méthodes et ne peut pas être instanciée directement. Elle sert de classe mère pour factoriser du code commun aux classes dérivées.

Une classe qui hérite d'une classe abstraite doit implémenter les méthodes abstraites restantes.

Public MustInherit Class classAbs
  ' Contient au moins une méthode avec le modificateur MustOverride
End Class

Trois types de méthodes dans une classe abstraite :

• Public Overridable Sub X() : méthode pouvant être redéfinie
• Public Sub Y() : méthode ne pouvant pas être redéfinie
• Public MustOverride Sub Z() : méthode devant obligatoirement être redéfinie dans la classe dérivée

Classes interfaces

Une interface est une classe qui ne contient aucune implémentation de ses méthodes, seulement leur déclaration. Elle décrit les services offerts.

Une classe qui implémente une interface doit obligatoirement définir toutes les méthodes déclarées dans cette interface.

Une classe peut implémenter plusieurs interfaces.

Public Interface interf1
  ' Public Sub X()
  ' ...
End Interface

Public Class c1
  Implements interf1

  Public Sub X() Implements interf1.X
    ' Implémentation de la méthode X
  End Sub
End Class

Glossaire des termes clés

• Classe : structure définissant des attributs et méthodes regroupés.
• Encapsulation : principe de regrouper données et méthodes dans une même unité.
• Constructeur : méthode spéciale pour initialiser une instance.
• Destructeur : méthode pour libérer les ressources d'une instance.
• Accesseurs (Getters/Setters) : méthodes pour accéder et modifier les champs privés.
• Méthode : fonction ou procédure définie dans une classe.
• Surcharge de méthodes : plusieurs méthodes du même nom avec des signatures différentes.
• Héritage : mécanisme permettant à une classe d'en dériver une autre.
• Polymorphisme : capacité d'une méthode à avoir plusieurs formes.
• Classe abstraite : classe non instanciable servant de base à d'autres classes.
• Interface : classe ne contenant que des déclarations de méthodes à implémenter.
• Shared : membre statique partagé par toutes les instances.

Points clés à retenir

• VB.Net est un langage orienté objet basé sur l'encapsulation, l'héritage et le polymorphisme.
• Une classe contient des champs, des constructeurs, des méthodes et des accesseurs.
• Les constructeurs initialisent les objets, les destructeurs libèrent les ressources.
• Les accesseurs permettent de protéger l'accès aux champs privés.
• La surcharge permet d'avoir plusieurs méthodes du même nom avec des paramètres différents.
• L'héritage permet de créer des classes spécialisées à partir de classes générales.
• Les classes abstraites ne peuvent pas être instanciées et imposent la redéfinition de certaines méthodes.
• Les interfaces définissent un contrat que les classes doivent respecter en implémentant toutes leurs méthodes.