Le problème qu’on rencontre le plus souvent quand on souhaite apprendre un concept de programmation, c’est de trouver LE tuto qui montre tout ce qu’on doit savoir et surtout qui montre comment programmer sans avoir spécialement de grosses connaissances ou encore s’envahir l’esprit avec un vocabulaire trop pointu. Donc voici un tuto allégé sur la Programmation Orientée Objet en VB.NET.
Problématique
Alors pourquoi ne pas se satisfaire des tutos déjà présent sur internet ?
Pour le simple et bonne raison que je les trouve surchargés, sans réel intérêt dans le sens ou il explique des principes de base sans exemple très parlant. J’ai été amené à faire pas mal de recherche post-tuto pour savoir comment on faisait ceci ou cela, qui sont des principes de base, mais rien de simple à trouver. Donc je réalise ce tuto avec un exemple qui marche (puisque je l’utilise réellement en programmation).
La POO ?
La Programmation Orientée Objet est présente dans plusieurs langages de programmation et a pour objectif de faciliter le traitement des données. Elle présente pas mal d’avantages et peu d’inconvénient.
Actuellement en programmation, quand on veut obtenir une valeur à partir d’une base de données, on fait une requête est on traite les informations au cas par cas. Or un des principes de base est de ne jamais répéter plusieurs fois un code identique. Si on a besoin d’un même bout de code plusieurs fois, on créé une fonction pour le remplacer, ce qui facilite la maintenance du code.
L’idée de la POO est de centraliser la gestion des données et de faciliter leur exploitation grâce à une formulation plus explicite.
Si on compare l’avant et l’après POO :
- Avant : Une multitude de boite qu’on doit ouvrir au pied de biche pour en modifier le contenu
- Après : une commode avec une infinité de tiroir et une jolie clé toute simple pour modifier le contenu
Vocabulaire
Oui j’ai dit qu’on n’allait pas aborder de vocabulaire très poussé, mais il en faut un minimum.
- La POO s’articule autour des Class. Pour faire simple, il s’agit d’une fonction en plus poussée (c’est notre commode).
- Ensuite, chaque Class possède ses attributs qui ne sont que des variables avec une syntaxe particulière (ce sont nos tiroirs).
- Les propriétés qui sont là pour accéder aux tiroirs attributs et les modifier (la clé du tiroir).
- Et pour finir, les méthodes qui sont des sous-fonctions (c’est l’équivalent de la personne qui change le contenu des tiroirs).
Code
Déclaration de la Class
Avant toute chose, histoire d’avoir un code clair, on ouvre un nouveau module de Class et on la déclare. Cette syntaxe ne doit pas vous être étrangère car c’est de cette manière qu’est déclaré une UserForm.
Public Class MaClasse End Class
Alors ça peut paraître très simple, mais c’est parce que ça l’est. Mais on va entrer tout de suite dans le vif du sujet avec une classe assez simple à propos qui contient les informations d’une société.
Ajout des attribus (propriétés)
Là on rajoute les attributs de la classe. Jusque là rien de bien compliqué puisqu’on utilise la même méthode pour déclarer une variable Public.
Public Class Societe
Public Nom As String
Public Adresse As String
Public CP As String
Public Ville As String
End Class
Jusque là ce ne sont que des choses déjà vu et connu mais qu’on ne remarque pas forcément (voir ci-dessous).
Le constructeur
Tout comme une fonction, une classe s’initialise quand on l’appelle. Alors tout l’intérêt de cet appel est qu’il peut intégrer des paramètres pour adapter les variables.
Public Class Societe
Public Nom As String
Public Adresse As String
Public CP As String
Public Ville As String
Sub New(<paramètres comme="" n'importe="" quelle="" fonction="">)
End Sub
End Class
Vous avez déjà vu ce genre de structure avant, quand vous utilisez une Form dans un projet et des variables Public.
Public Class Form1
Public Stockage As String
Private Sub MaSub()
End Sub
End Class
Histoire de faire avancer le schmilblick, on va voir immédiatement comment utiliser le Constructeur en lui passant un paramètre. Ici, on va passer un identifiant unique de la société. On va également prévoir le cas où la base de donnée ne contient pas de société avec cet identifiant et utiliser des valeurs par défaut. Ça évite une erreur en cas d’utilisation d’une variable sans valeur.
Public Class Societe
Public Id As Integer = 0
Public Nom As String = ""
Public Adresse As String = ""
Public CP As String = ""
Public Ville As String = ""
Sub New(ByVal id_societe As String)
'On transforme id_client en membre de la classe
Id = id_client
Dim Dr As OleDbDataReader
Dim Command As OleDbCommand
Connection.Open()
Command = New OleDbCommand("SELECT * FROM SOCIETE WHERE id_societe = " & id_societe & ";", Connection)
Dr = Command.ExecuteReader
While Dr.Read()
Nom = Dr("nom").ToString
Adresse = Dr("adresse").ToString
CP = Dr("code_postal").ToString
Ville = Dr("ville").ToString
End While
Connection.Close()
End Sub
End Class
L’utilisation dans le code
Maintenant qu’on a vu comment ça fonctionne, on va voir comment exploiter ces résultats.
'Création d'une instance "client" Dim client As New Societe(id_client)
Cette simple ligne permet d’instancié le client. Donc pour reprendre l’exemple de la commode à tiroir, client est notre commode. Donc comment utiliser ses tiroirs ? En fait c’est très simple.
'Création d'une instance "client" Dim client As New Societe(id_client) 'On place le nom du client dans une TextBox TextBox1.Text = client.Nom 'On change le contenu d'une valeur client.Ville = TextBox2.Text
Vous comprenez maintenant ? C’est simple, propre, presque beau. Mais on peut encore allé bien plus loin en multipliant les instances. Si je souhaite avoir deux commodes, l’une étant un client l’autre un fournisseur…
'Création d'une instance "client" Dim client As New Societe(id_client) 'Création d'une instance "fournisseur" Dim fournisseur As New Societe(id_fournisseur)
Le client et le fournisseur étant deux sociétés, ils contiennent les mêmes informations : Nom de société, adresse, ville, code postal… Donc ma class société est en fait un archétype que je peux remplir.
Shared !
Le dernier point de ce tuto est l’utilisation de l’option Shared. Cette option permet d’utiliser la variable à laquelle elle a été rattachée sans avoir à instancié la class.
L’exemple ci-dessous devrait vous éclairer.
Public Class Societe
Public Shared Nom As String
Public Ville As String
Sub New()
End Sub
End Class
Sub Instance()
'Initialise la class sans nom
TextBox1.Text = Societe.Nom 'Fonctionne
TextBox2.Text = Societe.Ville 'Ne Fonctionne Pas
'Fonctionne
Dim client As New Societe(id)
TextBox2.Text = client.Ville
End Sub
Conclusion
C’est la fin de la première partie du tuto POO. Pour le moment vous savez déclarer une Class, l’initialiser via un constructeur et exploiter ses données.
Dans la prochaine partie, on verra les class imbriquées et les méthodes (si j’en ai parlé au début).