Apprenez à programmer en VB .NET
Last updated on Monday, June 24, 2013
  • 4 semaines
  • Facile

Ce cours est visible gratuitement en ligne.

Paperback available in this course

Ce cours existe en eBook.

Got it!

Notre première classe

Nous venons de voir la théorie concernant la programmation orientée objet, mettons tout cela en pratique !
Nous allons voir dans ce chapitre comment créer notre première classe en Visual Basic .NET, puis comment lui ajouter des attributs et des méthodes, d'autant plus de paramètres qui détermineront la complexité de votre classe.
Pour finir et vous récompenser de votre assiduité, nous allons mettre en pratique le concept de classes pour vous montrer l'utilité concrète de ces dernières.

Notre première classe

Pour commencer notre entrée dans le monde des classes, je vous propose d'attaquer tout de suite sur un petit thème. Pourquoi pas Mario ? Nous allons essayer de faire bouger Mario pour commencer.

Logiquement, puisque nous sommes sur la partie traitant de la POO, notre Mario sera… un objet !

La classe

Créons tout de suite notre « moule » de Mario.

Créez donc un nouveau projet, toujours Windows Forms. Ajoutez ensuite un nouvel élément, comme ce que nous avons fait pour une fenêtre, mais cette fois choisissez Classe, comme le montre la figure suivante.

Nous allons créer une classe
Nous allons créer une classe

Nommez tout de suite ce fichier, « Mario » par exemple. Nous voilà donc avec notre classe totalement vide, juste la déclaration de début et de fin.

L'interface

Retournons dans notre fenêtre et ajoutons-y quelques contrôles pour pouvoir commencer (voir figure suivante).

Ajoutez quelques contrôles
Ajoutez quelques contrôles

Donc j'ai juste ajouté un petit panel dans lequel j'ai spécifié une taille de 20 x 20, ainsi qu'une couleur de fond rouge. J'ai ajouté en bas un petit bouton qui va nous permettre de déplacer ce panel. Pour le moment uniquement vers la droite.

Vous vous doutez que coder l'événement qui va permettre au bouton de déplacer ce panel ne va pas être sorcier : quelques location à définir et le tour est joué. Oui, mais nous allons définir une classe qui va pouvoir s'adapter à d'autres situations (eh oui, vous pourrez utiliser vos classes dans d'autres programmes.)

Réfléchissons un peu

Pour le moment je vous ne demande pas de créer une classe vous-mêmes, nous n'avons pas encore vu comment faire, nous allons le faire ensemble. Je vous demande juste d'essayer de trouver comment rendre cet objet adaptable.

Mario doit être capable de se déplacer par « cases ». Pour le moment la taille de la case est définie par la taille du panel. Donc si mon panel devient de 50 x 50, une case sera égale à 50 x 50 (les cases sont dans votre imagination, mais vous pouvez placer des lignes de manière à faire une grille). Notre classe ne pourra pas agir directement sur notre panel, c'est toujours le code qui l'a appelé qui va devoir le modifier, notre classe va donc devoir nous renvoyer des coordonnées. Les coordonnées de la nouvelle position de Mario.

Donc si vous avez suivi ma (fastidieuse) réflexion, nous allons devoir travailler avec des variables de type Point, nous aurions pu nous envoyer des Int contenant la position en X et en Y, mais la variable Point rassemble le tout. Nous allons aussi devoir passer à la classe la taille de notre panel, pour qu'elle puisse travailler dynamiquement, quelle que soit la taille de notre Mario.

Bon, trêve de commentaires, allons-y.

Notre classe

Dans notre fichier de classe il va falloir tout d'abord définir un constructeur. Rendez-vous dans le fichier Mario.vb (la classe) et insérez la déclaration du constructeur (avec New). On se place dans le Class Mario et on inscrit :

Sub New()

    End Sub

Voilà notre premier constructeur. Il ne demande aucun argument. Nous ferions tout de même bien de spécifier à la classe la position originelle de notre Mario et sa taille. Pour cela commençons par déclarer des variables en privé, car elles ne seront accessibles qu'à partir de la classe.

Juste en dessous de Public Class Mario, déclarez :

Private _CoordonneesActuelles As Point
    Private _Taille As Size

J'ai donc les coordonnées actuelles de notre Mario de type Point, et la taille de type Size.

Pourquoi avoir mis un underscore (« _ ») devant tes variables ?

C'est une vieille habitude, lorsque je déclare des membres ou des attributs privés, je les précède d'un underscore, mais vous n'êtes pas obligés de faire comme moi.

Ces variables sont déclarées en Global, elles seront donc accessibles partout dans la classe.

Changeons notre constructeur de manière à demander en arguments ces valeurs :

Sub New(ByVal PositionOriginelle As Point, ByVal TailleMario As Size)
        _CoordonneesActuelles = New Point(PositionOriginelle)
        _Taille = New Size(TailleMario)
    End Sub

Et entrons-les dans les variables. Vu que Point et Size sont eux-mêmes des objets, il faut les instancier avec New.

Nous voilà donc avec la taille et les coordonnées de notre Mario.

Des méthodes et des attributs

Je rappelle rapidement ce que sont les méthodes et les attributs. Les méthodes sont des fonctions de type privé, leur nécessité est interne, rien n'est visible depuis l'extérieur. Les attributs sont publics, visibles depuis l'extérieur, accessibles.

Codons quelques fonctions qui vont nous permettre de déplacer notre Mario. À première vue, rien de problématique, on va jouer sur la propriété .X de nos coordonnées pour déplacer Mario en horizontal, .Y pour le vertical. Mais de combien allons-nous le bouger ?

C'est là que notre notion de « case » et de taille intervient. On va le faire bouger d'une case.

Créons une nouvelle fonction de type Public. Cette fonction sera destinée à faire avancer Mario d'une case. Appelons-la donc Avance.

Public Sub Avance()
        _CoordonneesActuelles.X = _CoordonneesActuelles.X + _PasX()
    End Sub

C'est quoi _PasX ?

Une petite fonction qui nous renvoie la taille en longueur de Mario (pour savoir quelle est la valeur de la case en longueur). Eh oui, je ne lésine pas sur les fonctions. Elle est précédée d'un underscore car c'est un attribut, elle est private :

#Region "Fonctions privées"

    Private Function _PasX()
        Return _Taille.Width
    End Function

    Private Function _PasY()
        Return _Taille.Height
    End Function

#End Region

Je renvoie simplement la longueur, et pour le _PasY, c'est la hauteur. Si vous avez suivi, cette méthode publique va déplacer Mario d'une case sur la droite. Mais ce n'est pas une fonction, on n'a aucun retour, comment est-ce que notre panel va bien pouvoir se déplacer ? Il va falloir se servir des propriétés.

Les propriétés

Vous savez déjà ce que sont les propriétés, vous en assignez tout le temps quand vous modifiez vos contrôles. On va apprendre à faire de même pour nos objets.

La syntaxe de déclaration d'une propriété est assez particulière. Il va falloir gérer lorsqu'on assigne cette propriété et lorsqu'on la récupère. Pour commencer, voici la syntaxe :

Public Property Position()
        Get

        End Get
        Set(ByVal value)

        End Set
    End Property

Vous voyez qu’elle fonctionne comme une fonction sauf qu'à l'intérieur on a deux nouveaux mots-clés :

  • Set : sera appelée lorsque l'on assignera une valeur à cette propriété ;

  • Get : sera appelée lorsque l'on demandera une valeur à cette propriété.

Pour le moment l'argument fourni au Set n'a pas de type défini, ce qui est renvoyé non plus. Commençons par les définir :

Public Property Position() As Point
        Get

        End Get
        Set(ByVal value As Point)

        End Set
    End Property

On attend donc un Point et on renvoie un Point.

Notre propriété va seulement assigner la valeur à la variable _CoordonneesActuelles et renvoyer sa valeur, rien de bien sorcier (vous pouvez même le faire par vous-mêmes) mais on aurait pu effectuer beaucoup d'autre choses en même temps. Assigner plusieurs variables, incrémenter un compteur, les possibilités sont infinies. :D

Voici donc la propriété au final :

Public Property Position() As Point
        Get
            Return _CoordonneesActuelles
        End Get
        Set(ByVal value As Point)
            _CoordonneesActuelles = value
        End Set
    End Property

On assigne la valeur, on la retourne.

Avec cette nouvelle propriété et la fonction précédente, on peut désormais retourner sur notre code relatif à la fenêtre et faire bouger Mario simplement en quelques lignes :

Public Class PlateauDeJeu

    'Mario déclaré en global
    Dim MonMario As Mario
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        'Un nouveau Mario
        MonMario = New Mario(Me.PAN_MARIO.Location, Me.PAN_MARIO.Size)
    End Sub

    Private Sub BT_AVANCE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_AVANCE.Click
        'On le fait avancer
        MonMario.Avance()
        'On recupère la nouvelle position
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub

End Class

Je déclare un Mario en variable globale, donc il sera accessible et utilisable pendant toute la durée de vie de la fenêtre. Je l'instancie au load de la fenêtre en passant la position du panel et ses dimensions en paramètres au constructeur. Puis lors du clic sur le bouton, on fait avancer Mario et on récupère sa nouvelle position pour l'affecter au panel.

Vous pouvez essayer, ça fonctionne !

Notre petit Mario

Cette section est là pour vous donner le reste du code de notre déplacement de Mario, on s'en servira sûrement plus tard.

La figure suivante vous montre à quoi ressemble ma fenêtre finale (on mettra une image de Mario plus tard ;) )

Des flèches pour déplacer Mario dans toutes les directions
Des flèches pour déplacer Mario dans toutes les directions

Ma classe :

Public Class Mario

    Private _CoordonneesActuelles As Point
    Private _Taille As Size

    Sub New(ByVal PositionOriginelle As Point, ByVal TailleMario As Size)
        _CoordonneesActuelles = New Point(PositionOriginelle)
        _Taille = New Size(TailleMario)
    End Sub

    Public Sub Avance()
        _CoordonneesActuelles.X = _CoordonneesActuelles.X + _PasX()
    End Sub

    Public Sub Recule()
        _CoordonneesActuelles.X = _CoordonneesActuelles.X - _PasX()
    End Sub

    Public Sub Monte()
        _CoordonneesActuelles.Y = _CoordonneesActuelles.Y - _PasY()
    End Sub

    Public Sub Descend()
        _CoordonneesActuelles.Y = _CoordonneesActuelles.Y + _PasY()
    End Sub

    Public Property Position() As Point
        Get
            Return _CoordonneesActuelles
        End Get
        Set(ByVal value As Point)
            _CoordonneesActuelles = value
        End Set
    End Property

#Region "Fonctions privées"

    Private Function _PasX()
        Return _Taille.Width
    End Function

    Private Function _PasY()
        Return _Taille.Height
    End Function

#End Region

End Class

Et le code final avec la gestion des touches :

Public Class PlateauDeJeu

    'Mario déclaré en global
    Dim MonMario As Mario

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        'Se met en écoute des touches
        Me.KeyPreview = True
        'Un nouveau Mario
        MonMario = New Mario(Me.PAN_MARIO.Location, Me.PAN_MARIO.Size)
    End Sub

    Sub Form1_KeyDown(ByVal sender As Object, ByVal e As KeyEventArgs) Handles Me.KeyDown
        Select Case e.KeyCode
            Case Keys.Z
                MonMario.Monte()
            Case Keys.S
                MonMario.Descend()
            Case Keys.Q
                MonMario.Recule()
            Case Keys.D
                MonMario.Avance()
        End Select
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub


#Region "Boutons de l'interface"

    Private Sub BT_AVANCE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_AVANCE.Click
        'On le fait avancer
        MonMario.Avance()
        'On recupère la nouvelle position
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub

    Private Sub BT_RECULE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_RECULE.Click
        'On le fait reculer
        MonMario.Recule()
        'On recupère la nouvelle position
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub

    Private Sub BT_DESCEND_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_DESCEND.Click
        'On le fait descendre
        MonMario.Descend()
        'On recupère la nouvelle position
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub

    Private Sub BT_MONTE_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_MONTE.Click
        'On le fait monter
        MonMario.Monte()
        'On recupère la nouvelle position
        Me.PAN_MARIO.Location = MonMario.Position
    End Sub

#End Region

End Class

Voilà. Amusez-vous bien. :)

  • Une classe contient des variables au même titre que notre programme principal.

  • Pour chaque classe instanciée, la variable va être différente.

  • Donc chaque classe est unique et se comportera différemment en fonction des ses attributs et méthodes.

Example of certificate of achievement
Example of certificate of achievement