POO - TP - 00 - Partie 1 - C#

1 Programmation Orientée Objet : TP 00 H.
FAKHOURI
TP N°00
Objectifs :
Comprendre la Notion de classe d'objet

Définir une nouvelle classe d'objet en VB.Net
Utiliser l’encapsulation des propriétés et des méthodes de cet objet.
Instanciation de l'objet.
Déclaration et protection des propriétés (données membres).
Mettre en œuvre les notions d’héritage et de Polymorphisme.
Constructeurs et destructeur des objets
Surcharge de constructeurs
Propriétés et méthodes de classe
Rappel : les classes
Créer une classe consiste en la définition d’un nouveau type de données. Il s’agit de modéliser de la
manière la plus juste un objet, à partir des possibilités offertes par un langage de programmation.
Il faut donc énumérer toutes les propriétés de cet objet et toutes les fonctions qui vont permettre de
définir son comportement. Ces dernières peuvent être classées de la façon suivante :
propriétés : Les propriétés de l'objet seront implantées sous la forme de données membres
de la classe.
méthodes : Les différentes fonctions ou méthodes seront implémentées sous la forme de
fonctions membres de la classe.
L’encapsulation n’autorise pas l’accès aux éléments internes à l’objet qui peuvent constituer une
grande complexité mais qu’aux éléments exposés au travers de son interface. L’encapsulation
permet ainsi de protéger l’intégrité de l’objet et de nous masquer toute la complexité des calculs
effectués en interne.
Pour qu'un objet ait une existence, il faut qu'il soit instancié. Une même classe peut être instanciée
plusieurs fois, chaque instance ayant des propriétés porteuses de valeurs spécifiques.
Il n'existe qu'une seule manière de créer une instance d'une classe. Cette création d'instance peut se
faire en deux temps :
Déclaration d'une variable du type de la classe de l'objet,
Instanciation de cette variable par l'instruction New.
ClassA var;
var = new ClassA();
La déclaration d'une variable var de classe ClassA n'est pas suffisante. En effet, lors de sa
déclaration var ne contient pas une donnée de type ClassA.
Par défaut, la valeur de cette référence est null, mot clé null en C# signifiant que la variable n'est
pas référencée. La référence d'un objet doit être affectée à cette variable. Ce référencement est
réalisé par l'instruction new au moment de l'instanciation.
Ces deux étapes peuvent être réduites à une seule instruction en instanciant l’objet dans le même
temps que sa déclaration :
ClassA var = new ClassA();
Afin d’implanter correctement le concept d'encapsulation, il convient de verrouiller l'accès aux

champs et de les déclarés private ou protected tout en permettant leurs accès via des méthodes dite
Accesseur en déclarant ces dernières public
class Stagiaire
{
private string _nom;
private string _prenom;
private float _notes;
2 Programmation Orientée Objet : TP 00 H.FAKHOURI
Si les champs sont verrouillés, on ne peut plus y avoir accès de l'extérieur de la classe. Il faut donc
créer des méthodes dédiées à l'accès aux propriétés pour chacune d'elles. Ces méthodes doivent
permettre un accès dans les deux sens (Lecture/Ecriture).
Accès pour lecture : pour connaître la valeur de d’un champ. Ces méthodes sont appelées méthodes
type « Get ».
Accès pour modification : pour modifier la valeur d'un champ. Ces méthodes sont appelées
méthodes type « Set ».
Il est préférable de définir les accès aux attributs d'une classe par des propriétés (une méthode
spéciale qui regroupe les deux types d’accesseurs : Get et Set).
public string Nom
{
get
{
return _nom;
}
set
{
_nom = value;
}
}
Utilisation des "properties"
Stagiaire stg = new Stagiaire();
stg.Nom = "simo";
Console.WriteLine("le nom du stagiaire est: "+stg.Nom);
On peut restreindre l’utilisation d’un champ à la lecture ou à l’écriture si on utilise l’accesseur Get ou
Set à lui seul, comme par exemple.
class ClassA
{
private int _num;
private int _annee;
public int Numero

{ //propriété en lecture seule
get{ return _num; }
}
public int AnneeDeNaissance

{ //propriété en Ecriture seule
set{ _annee=value; }
}
}
À l’utilisation de ces deux propriétés, on peut ne pas affecter une valeur à la propriété Numero et
inversement on ne peut pas lire la valeur de la propriété AnneeDeNaissance
ClassA c = new ClassA();
//Interdit
c.Numero = 40;
Console.WriteLine(c.AnneeDeNaissance);
//Autorisé
c.AnneeDeNaissance=1990 ;
Console.WriteLine(c.Numero) ;
Constructeurs
Quand une instance d'une classe d'objet est créée au moment de l'instanciation d'une variable avec
new, une fonction particulière est exécutée. Cette fonction s'appelle le constructeur. Elle permet,
entre autres choses, d'initialiser chaque instance pour que ses propriétés aient un contenu cohérent
Un constructeur est déclaré comme les autres fonctions membres à deux différences près :
Le nom de l'identificateur du constructeur est le celui de la classe.

Un constructeur ne renvoie pas de résultat (même pas viod).
Il peut y avoir plusieurs constructeurs pour une même classe, chacun d'eux correspondant à une
initialisation particulière. Tous les constructeurs ont le même nom mais se distinguent par le nombre
et/ou le type des paramètres passés.
1. Constructeur d'initialisation :
Ce constructeur permet de procéder à une instanciation en initialisant les propriétés, la valeur de
celles-ci étant passée dans les paramètres ou définie sous forme de constante dans la classe.
Il peut exister plusieurs constructeurs d’initialisation avec plus ou moins d’arguments :
public Stagiaire(string nm,string pr)
{
_nom = nm;
_prenom = pr;
_notes = new float[3];
}
Cela va permettre d'instancier la classe Stagiaire de la façon suivante :
Stagiaire stg = new Stagiaire("Alami”, “karim");
2. Constructeur par défaut :

Sans paramètres.
public Stagiaire()
{
_nom = "";
_prenom = "";
}
3. Constructeur de recopie :
Le constructeur de recopie permet de recopier les propriétés d'un objet existant vers une nouvelle
instance de même type.
public Stagiaire(Stagiaire unStagiaire)

{
_nom=unStagiaire._nom;
_prenom=unStagiaire._prenom;
_note = unStagiaire._note;
}
On peut utiliser ce constructeur pour créer une copie du stagiaire « Alami karim » déjà crée dans
l’exemple précédant.
Stagiaire stg2 = new Stagiaire(stg);
stg2 est un objet différent de stg mais les propriétés des deux objets ont les mêmes valeurs.
Propriétés de classe
Jusqu'à présent, les propriétés déclarées étaient des propriétés d'instance. C'est à dire que les
propriétés de chaque objet, instancié à partir de la même classe, peuvent avoir des valeurs
différentes ( numero, nom, etc ).
Supposons maintenant, que dans la classe Stagiaire, il soit nécessaire de disposer d'un
compteur d'instance, dont la valeur serait le nombre d'instances en cours à un instant donné.
En C#, il est possible de créer des propriétés de classe. Leur valeur est la même pour toutes les
instances d'une même classe. Pour déclarer une telle propriété, on utilise le mot-clé static.
private static int _compteur = 0;
La propriété de classe compteur, initialisée à 0 lors de sa déclaration, sera incrémentée de 1 dans
tous les constructeurs développés pour la classe Stagiaire. Sa valeur sera le nombre d'instances
valides à un instant donné.
Public Sub New()
_compteur = _compteur + 1
Me._num = _compteur
End Sub
Public Sub New(ByVal nomStg As String, ByVal noteStg As Double)
Me._num = _compteur
Me.Nom = nomStg
Me.Note = nomStg
End Sub
Public Sub New(ByVal unStagiaire As Stagiaire)
Me._num = _compteur
Me.Nom = unStagiaire.Nom
Me.Note = unStagiaire.Note
End Sub
Méthodes de classe
Comme pour les autres propriétés déclarées private, il est nécessaire de créer les méthodes
d'accès associées. Pour ce compteur, seule la méthode Get est nécessaire.
Une méthode de classe est déclarée avec le mot-clé Shared. Pour la méthode Get d'accès au
compteur d'instances on déclarerait :
Public Shared Function Compteur() As Integer

Return _compteur
End Function
ou
Public Shared ReadOnly Property Compteur() As Integer
Get
Return _compteur
End Get
End Property
Exemple complet (Stagiaire.vb):

Public Class Stagiaire
'Attributs
Private _num As Integer
Private _nom As String
Private _note As Double
Private Shared _compteur As Integer = 0
'Accesseurs (propriétés)
Public Property Nom() As String
Get
Return _nom
End Get
Set(ByVal value As String)
_nom = value
End Set
End Property
Public Property Note() As Double
Get
Return _note
End Get
Set(ByVal value As Double)
_note = value
End Set
End Property
Public ReadOnly Property Numero() As Integer
Get
Return _num
End Get
End Property
Public Shared ReadOnly Property Compteur() As Integer
Get
Return _compteur
End Get
End Property
'constructeur par defaut

Public Sub New()
Me._num = Compteur
End Sub
'constructeur d'initialisation
Public Sub New(ByVal nomStg As String, ByVal noteStg As Double)
Me._num = _compteur
Me.Nom = nomStg
Me.Note = nomStg
End Sub
'constructeur de recopie
Public Sub New(ByVal unStagiaire As Stagiaire)
Me._num = _compteur
Me.Nom = unStagiaire.Nom
Me.Note = unStagiaire.Note
End Sub
End Class
Exemple d’utilisation (Module1.vb):
Sub Main()
Dim nm As String
Dim nt As Double
Dim stg1, stg2, stg3 As Stagiaire
'mothode 1 pour créer un stagiaire

Console.WriteLine("Veuillez saisir les informations du 1er
stagiaires!")
Console.WriteLine("Enter le nom du 1er stagiaire")
nm = Console.ReadLine
Console.WriteLine("Entrer la note du 1er stagiaire")
nt = Console.ReadLine
stg1 = New Stagiaire(nm, nt)
'mothode 2 pour créer un stagiaire

stg2 = New Stagiaire
Console.WriteLine("Veuillez saisir les informations du 2°
stagiaires!")
Console.WriteLine("Enter le nom du 2° stagiaire")
stg2.Nom = Console.ReadLine
Console.WriteLine("Entrer la note du 2° stagiaire")
stg2.Note = Console.ReadLine
'mothode 2 pour créer un stagiaire (créer une copie du 1er

stagiaire)
stg3 = New Stagiaire(stg1)
'affichage des informations

Console.WriteLine("stagiaire N°1")
Console.WriteLine("Numero: " & stg1.Numero)
Console.WriteLine("Nom: " & stg1.Nom)
Console.WriteLine("Note: " & stg1.Note)
Console.ReadKey()
End Sub
Exemple exécution:
Exercice 0_1
Exemple : soit la classe Article:
Article
-_ID : Integer (Numero Auto)
-_Libelle : String
-_PU : Double
+Property ID
+Property Libelle
+Property PU
+Property PUTTC
+Sub new()
+Sub new(unLibelle,unPu)
+Sub new(unArticle :Article)
+function Remise():Double
1. Créer la classe article avec tous ces membres :

a. ID : le numéro de l’article crée
b. PUTTC = PU + PU x 20%
c. Remise = 0% si PU ≤ 500
Remise = 1% si 500 < PU ≤ 1000
Remise = 2% si PU > 1000
2. Créer un module de teste pour créer 3 articles et afficher leurs données.
3. Créer un 2ème module de teste avec le menu suivant :
1- Ajouter un article
2- Afficher la liste des articles
3- Afficher l’article avec le prix maximum
4- Modifier un article
5- Rechercher par libelle
6- Rechercher par mot clé
7- Supprimer un article par ID
8- Trier la liste des articles par prix
0- Quitter
Remarque : utiliser un tableau pour stocker les articles.
Rappel : la surcharge
La surcharge :
La surcharge est une technique simple à utiliser, qui permet d'utiliser le même nom de fonction avec
des paramètres de différents types. Voyons ce que ça donne sur la classe Calcul dans l'exemple de la
fonction additionner.
Public Function additionner(ByVal a As Integer, ByVal b As Integer)

As Integer
End Function
Public Function additionner(ByVal a As Double, ByVal b As Double) As

Double
End Function
Exercice 0_2
Les nombres rationnels sont définis comme étant tout nombre qui peut s’écrire sous la forme d’un
rapport de nombres entiers. C’est-à-dire, tout nombre qui peut s’exprimer sous forme de fraction
ou le numérateur a est un entier et dénominateur b est un entier.
Soient a, b, c, d quatre entiers, avec b et d non nuls.
Les deux nombres rationnels représentés par a/b et c/d sont égaux si et seulement si ad=bc.
L'addition est donnée par :
+
+ =
La multiplication par :
× =
L'opposé par :
a −
− = =
−
L'inverse par :
= ≠0
On en déduit que le quotient est donné par :
/ =
1) Concevez une classe Fraction permettant de représenter des nombres rationnels. Cette classe
doit permettre :
De consulter et de modifier le numérateur et le dénominateur du nombre,
De multiplier un nombre rationnel par un coefficient entier,
D’ajouter, de soustraire, de multiplier, et de diviser deux nombres rationnels,
D'inverser un nombre rationnel,
De réduire un nombre rationnel,
De comparer deux nombres rationnels,
De vérifier l’égalité de deux nombres rationnels,
D’afficher un nombre rationnel sous la forme a/b.
Fraction
-_A : Integer
-_B : Integer
+Property Numerateur
+Property Denominateur
+Sub new ()
+Sub new(N: Integer, D: Integer)
+Sub new(nbrRat :Fraction)
+function multiplierPar(coeff : Integer): Fraction
+function multiplierPar(f: Fraction): Fraction
+function additionnerA (f: Fraction): Fraction
+function soustraireDe (f: Fraction): Fraction
+function diviserPar (f: Fraction): Fraction
+sub inverser ()
+sub reduire()
+function comparerA(f : Fraction) : Integer
+function egaleA(f : Fraction) : boolean
+afficher()
N.B: la classe Fraction doit fournir deux surcharges pour la fonction multiplierPar la première prend
un entier et calcule la multiplication d’un nombre rationnel par un nombre entier, et la deuxième
calcule la multiplication de deux nombres rationnels.
2) Créer un module de teste avec un menu pour la gestion des nombres rationnels.
1-Multiplier par un nombre
2-Multiplication
3-addition
4-Soustraction
5-Division
6-Inverser
7-Réduire
8-Comparer
9-Vérifier l’égalité
0-Quitters
Pour chaque choix le programme doit demander à l’utilisateur d’entrer les données nécessaire.
Exercice 0_3 :
a) Pour gérer les notes des étudiants, on vous propose de créer la classe Etudiant suivante :
Etudiant
-_ID : Integer (Numero Auto)
-_nom : String
-_notes() : Tableau de Double
+Property ID
+Property Nom
+Sub new()
+Sub new(nom)
+Sub new(e :Etudiant)
+Sub ajouterNote(note : Double)
+Sub SupprimerNote(indice :Integer)
+Sub ModifierNote(indice :Integer,nouvelleNote : Integer)
+function moyenne():Double
b) Créer la classe Etudiant et un module TestEtudiant de votre choix pour tester les fonctionnalités
de votre classe.
1. Ajouter un étudiant
2. Afficher la liste des étudiants
3. Modifier un étudiant
1. Afficher l’étudiant
2. Modifier le nom
3. Ajouter une note
4. Modifier la note
5. Supprimer une note
0. Retour
4. Supprimer un étudiant
5. Rechercher
1. Rechercher Par ID
2. Rechercher Par Nom
0. Retour
6. Classer les étudiants par moyenne
0. Quitter
Remarque :
Menu principal 3 (Modifier) le programme doit demander à l’utilisateur l’ID de l’étudiant a
modifie et vérifie sa présence dans la liste avant d’afficher le sous menu de modification
Menu principal 6 (Classer) ce menu doit afficher la liste des étudiants classée en ordre
décroissant par moyenne sous la forme suivante :
1. ID_Etudiant _nom_Etudiant : moyenne_Etudiant
……..
c) Créer une application graphique (Windows Forms) pour la gestion des étudiants en proposant
les mêmes fonctionnalités décrites précédemment.
L’application utilise un contrôle TabControl pour présenter les différents choix à l’utilisateur. Et
un contrôle StatusStrip pour afficher les messages d’informations.
Page Ajouter
Le bouton Ajouter à la liste permet de créer un nouvel étudiant et de l’ajouter à la liste des
étudiants avec le nom saisi dans la zone de texte. Et :
afficher un message de confirmation avec le nombre total des étudiants dans la liste.
Vider la zone de texte
Placer le focus dans la zone de texte
Page Liste
A la sélection de l’onglet Liste le contrôle DataGridView doit être chargé par la liste des
étudiants
Remarque :
La sélection d’une page dans le contrôle TabControl génère un événement
SelectedIndexChanged
Pour charger les éléments d’un tableau t dans une datagridView on utilise la propriété
DataSource : DataGridView1.DataSource=t
Les colonnes affichées dans la grille correspondent aux membres publics property de la
classe.
Page Modifier
A la sélection de la page « modifier » on doit charger le ComboBox avec les IDs et les
noms des étudiants séparé par « : »
Le GroupBox Détails et invisible tant qu’il y a aucun étudiant sélectionné dans le
ComboBox
A la sélection d’un élément dans le ComboBox les informations de l’étudiant sélectionné
(Nom et notes) sont chargées (respectivement dans la zone de texte et la ListBox).
Les boutons Modifier une note et Supprimer une note resteront inactifs tant qu’il y a pas
d’élément sélectionné dans la listBox du notes.
Le bouton Ajouter une note permet d’afficher un InputBox pour la saisie d’une nouvelle
note et de l’ajouter aux notes de l’étudiant sélectionné dans le ComboBox (utiliser les
méthodes de la classe Etudiant)
Le bouton Modifier une note permet d’afficher un InputBox pour la saisie d’une
nouvelle note et de l’ajouter aux notes de l’étudiant sélectionné dans le ComboBox
(utiliser les méthodes de la classe Etudiant)
Le bouton supprimer une note permet de supprimer la note sélectionnée dans la ListBox
des notes (utiliser les méthodes de la classe Etudiant).
Page Supprimer
A la sélection de la page « modifier » on doit charger le ComboBox avec les IDs et les
noms des étudiants séparé par « : »
Le GroupBox Détails et invisible tant qu’il y a aucun étudiant sélectionné dans le
ComboBox
A la sélection d’un élément dans le ComboBox les informations de l’étudiant sélectionné
(Nom et notes) sont chargées (respectivement dans la zone de texte et la ListBox).
Tous les contrôles du GroupBox doivent être inactifs.
Le bouton Supprimer permet de supprimer l’étudiant sélectionné dans le ComboBox
après un message de confirmation « Etes vous sûre de vouloir supprimer l’étudiant ID :
nom.
Page Rechercher
L’option de recherche par défaut est ID

Le résultat de la recherche par ID sera affiché dans le GroupBox Résultat de la Recherche

Le résultat de la recherche par Nom sera affiché dans la grille (puisque plusieurs
étudiants peuvent avoir le même nom).
Page Classer
L’option de Tri par défaut est Moyenne

A la sélection d’un type de tri le grill est trié en ordre descendant.
Remarque :
N’oublie pas d’actualiser les listes à chaque modification des éléments affichés.
N’oublie pas d’afficher les messages d’information dans la barre d’état.
N’oublie pas de vider les listes avant de les recharger à nouveau.
N’oublie pas de restreindre la sélection dans les grills à une ligne entière (utiliser la proprièté
SelectionMode avec la valeur FullRowSelect)
Rappel :l’héritage
L’héritage:
Le concept d’héritage est l’un des principes fondamentaux de la POO ; il consiste en la
création d’une nouvelle classe appelé Classe Fille ou dérivée à partir d’une classe initiale appelé
Classe Mère ou Classe de Base.
L’héritage permet de :
Récupérer les membres publics et protégés de la Classe Mère.
Ajouter d’autres propriétés ou comportements à la Classe Fille pour étendre la
structure de la Classe Mère.
Modifier les comportements de la Classe Mère pour les adapter avec la Classe Fille
(la redéfinition).
Syntaxe :
Public Class ClasseFille
Inherits ClasseMere
End Class
Exemple :
Dans une Entreprise de vente de matériels informatique on veut gérer les employés qui sont
classés en deux catégories des techniciens et des agents commerciaux :
Les techniciens sont caractérisés par :
Matricule
Nom
Spécialité : Réseaux ou développement

Salaire de Base
IR : l’impôt sur le revenu = 19% pour tous les techniciens
Le salaire net est calculé par la formule suivante :
Salaire net = salaire de base – (salaire de base x IR)
Les agents commerciaux sont caractérisés par :
Matricule
Nom
Salaire de base
Chiffre d’affaire : le montant total des produits vendu par l’agent commercial
IR : l’impôt sur le revenu = 19% pour tous les agents commerciaux
Le salaire net est calculé par la formule suivante :
Salaire net = salaire de base – (salaire de base x IR) + (chiffre d’affaire x 2%)
D’où on peut déduire les deux classes Technicien et Agent avec les définitions suivantes :
Technicien Agent
- _ matricule : Integer - _ matricule : Integer
- _nom : String - _nom : String
- _specialite : String - _CA : Double
- _salaireBase : Double - _salaireBase : Double
- _IR : Double - _IR : Double
+propriétés +propriétés
+constructeurs +constructeurs
+function calculerSalaire() : Double +function calculerSalaire() : Double
Amélioration 1 : puisque l’IR a la même valeur pour tous les techniciens, alors on peut le déclarer
partager.
Amélioration 2 :
Afin d’éviter toute redondance de code, on peut créer une classe mère « Employee » avec tous les
membres communs du deux classes « Technicien » et « Agent », comme suite :
Employee
- _ matricule : Integer
- _nom : String
- _salaireBase : Double
- _IR : Double
+propriétés
+constructeurs
+function calculerSalaire() : Double
Technicien Agent
- _specialite : String - _CA
Public Class Employee
Protected _matricule As Integer

Protected _nom As String
Protected _salaireBase As Double
Protected Shared _IR As Double
Public Property Matricule() As Integer

Get
Return _matricule
End Get
Set(ByVal value As Integer)
_matricule = value
End Set
End Property
Public Property Nom() As String
Get
Return _nom
End Get
_nom = value
End Set
End Property
Public Property SalaireBase() As Double

Get
Return _salaireBase
End Get
_salaireBase = value
End Set
End Property
Public Shared ReadOnly Property IR() As Double

Get
Return 0.19
End Get
End Property
Public Sub New()
End Sub
Public Sub New(ByVal mat As Integer, ByVal nm As String, ByVal sal As
Double)
Me.Matricule = mat
Me.Nom = nm
Me.SalaireBase = sal
End Sub
Public Sub New(ByVal e As Employee)

Me.Matricule = e.Matricule
Me.Nom = e.Nom
Me.SalaireBase = e.SalaireBase
End Sub
End Class
Remarque :
Les données protégées seront visibles et accessibles dans les classes dérivées : « Technicien » et
« Agent ».
L’IR est fixe pour tous les employés, est de 19% d’où la création d’une propriété en Lecture seule.
La fonction calculerSalaire ne peut pas être définit dans la classe Employee car les règles de calcul du
salaire ne sont pas communs entre les techniciens et les agents.
La définition de la classe Technicien est alors :
Public Class Technicien
Inherits Employee
Private _specialite As String
Public Property Specialite() As String

Get
Return _specialite
End Get
_specialite = value
End Set
End Property
Public Sub New()

MyBase.New()
End Sub
Public Sub New(ByVal matt As Integer, ByVal nom As String, ByVal sall
As Double, ByVal spee As String)
MyBase.New(matt, nom, sall)
Me.Specialite = spee
End Sub
Public Sub New(ByVal t As Technicien)

MyBase.New(t)
Me.Specialite = t.Specialite
End Sub
Public Function calculerSalaire() As Double

Return Me.SalaireBase - Me.SalaireBase * Technicien.IR
End Function
End Class
La classe Technicien contient en plus de l’attribut Spécialité, les attributs Matricule, Nom, Salaire de
base et l’IR hérités de la classe Employee (héritage des membres publics et protégés).
Chaque constructeur de la classe fille doit faire appel au constructeur correspondant de la classe
mère à la première ligne.
Public sub new (p1 as type1, p2 as type2, p3 as type3, p4 as type4..)
MyBase(p1,p2,p3)
….
….
L’appel au constructeur de la classe mère est fait par le mot clé MyBase
P1, p2 et p3 sont des attributs de la classe mère (dans l’exemple).
P4 … les attributs propres à la classe fille.
La définition de la classe Agent selon le même principe :
Public Class Agent
Inherits Employee
Private _CA As Double
Public Property CA() As Double

Get
Return _CA
End Get
_CA = value
End Set
End Property
Public Sub New()

MyBase.New()
End Sub
Public Sub New(ByVal mat As Integer, ByVal nm As String, ByVal sal As
Double, ByVal c As Double)
MyBase.New(mat, nm, sal)
Me.CA = c
End Sub
Public Sub New(ByVal a As Agent)
MyBase.New(a)
Me.CA = a.CA
End Sub
Public Function calculerSalaire() As Double

Return Me.SalaireBase - Me.SalaireBase * Agent.IR + Me.CA * 0.02
End Function
End Class
Un exemple de module de teste :

Dim t As New Technicien(10500, "alami", 7000, "Reseau")
Console.WriteLine("Technicien")
Console.WriteLine("mat: " & t.Matricule)
Console.WriteLine("nom: " & t.Nom)
Console.WriteLine("Spécialité : " & t.Specialite)
Console.WriteLine("salaire: " & t.calculerSalaire)
Console.WriteLine("----------------------------------------")
Dim a As New Agent(10541, "kasimi", 7000, 25000)
Console.WriteLine("Agent")
Console.WriteLine("mat: " & a.Matricule)
Console.WriteLine("nom: " & a.Nom)
Console.WriteLine("C.A : " & a.CA)
Console.WriteLine("salaire: " & a.calculerSalaire)
Console.ReadKey()
L’exécution donnera :
La redéfinition :
C’est le faite de changer la définition d’une méthode dans les classes dérivées en gardons la même
signature.
Le Terme Overrides associé à une méthode indique que cette méthode définit dans la Classe Fille va
substituer (redéfinir) une méthode qui porte le même nom et qui a la même signature dans la Classe
Mère à condition qu’il le permet (Cette méthode doit être déclaré Overridable dans la Classe Mère).
Afin de facilité l’utilisation des classes, on cherche à ajouter des fonctions afficher permettant
d’afficher les données de chaque classe.
Dans la classe mère « Employee » :
Public Sub afficher()
Console.WriteLine("matricule: " & Me.Matricule)
Console.WriteLine("nom: " & Me.Nom)
End Sub
Dans la classe Fille « Technicien » cette méthode n’a pas le même comportement elle doit afficher en
plus du matricule et du nom, la spécialité et le salaire net du technicien. Donc on doit changer la
définition de la méthode afficher on parle, à ce moment là, de la redéfinition.
Pour cela, cette méthode doit être déclarée Overridable (c-à-d qu’elle peut changer de définition
dans les classes dérivées).
Alors dans la classe mère « Employee » elle devienne :
Public Class Employee
...
Public Overridable Sub afficher()
Console.WriteLine("mat: " & Me.Matricule)
Console.WriteLine("nom: " & Me.Nom)
End Sub
Dans la classe dérivée « Technicien »

...
Public Overrides Sub afficher()
Console.WriteLine("je suis un Technicien")
MyBase.afficher()
Console.WriteLine("Spécialité : " & Me.Specialite)
Console.WriteLine("salaire: " & Me.calculerSalaire)
End Sub
Dans la classe dérivée Agent :

Public Class Agent
...
Public Overrides Sub afficher()
Console.WriteLine("je suis un Agent")
MyBase.afficher()
Console.WriteLine("C.A : " & Me.CA)
Console.WriteLine("salaire: " & Me.calculerSalaire)
End Sub
MyBase.afficher(): Permet de faire appel à la fonction afficher de la classe mère « Employee »
Remarques:
L’utilisation des classes est simplifiée de la façon suivante :
Dim t As New Technicien(10500, "alami", 7000, "Reseau")

Dim a As New Agent(10541, "kasimi", 7000, 25000)
t.afficher()
a.afficher()
t.afficher() : permet d’appeler la méthode afficher de la classe Technicien
a.afficher() : permet d’appeler la méthode afficher de la classe Agent
Polymorphisme :
Prenons l’exemple suivant :
Dim e As Employee
e = New Technicien(10500, "alami", 7000, "Reseau")
e.afficher()
e = New Agent(10541, "kasimi", 7000, 25000)
e.afficher()
La référence e est de type Employee, mais elle peut être utilisée pour stocker des objets des classes
dérivées comme un objet Technicien ou un objet Agent.
L’exécution donnera :
Le 1er appel à la méthode e.afficher() : permet d’appeler la méthode afficher de la classe

Technicien car l’objet stocké dans la référence e est de type Technicien.
Le 2ème appel à la méthode e.afficher() : permet d’appeler la méthode afficher de la classe
Agent car l’objet stocké dans la référence e est de type Agent. C’est le polymorphisme !
• La redéﬁnition (en anglais overriding) d’une méthode dans les classes héritière préserve la
sémantique de la méthode initiale en réalisant le travail d’une façon différente. Les
méthodes redéﬁnies doivent posséder exactement le même en tête.
• La surcharge (en anglais overloading) consiste à donner des sémantiques différentes A une
méthode ou à un constructeur. La différenciation se fait sur le nombre de paramètres et/ou
le type des paramètres.
• Le terme Overloads associé à une méthode dans une classe Fille indique que cette méthode
surcharge une méthode qui porte le même nom dans la classe Mère En changeant la signature
de cette dernière (paramètres, Type de retoure..)
Exercice d’application :
En utilisons les 3 classes Employee, Technicien et Agent développez une interface graphique pour la
gestion des employés.
Formulaire Menu : formulaire MDI avec le menu suivant
Le menu Ajouter permet d’ouvrir le formulaire frmAjouter :
Le choix du RadioButton Technicien permet d’afficher le GroupBox Spécialité

Le choix du RadioButton Agent permet d’afficher le GroupBox Chiffre d’affaire
Le ComboBox Spécialité contient les choix Développement et Réseaux

Le bouton Ajouter à la liste permet de créer un nouvel employé (Technicien ou Agent)

et de l’ajouter à un tableau d’employés.
Le menu Mettre à jour / Modifier permet d’ouvrir le formulaire FrmModifier , activer le bouton
Modifier et désactiver le bouton Supprimer.
Le ComboBox choisissez l’employé doit être chargée avec les matricule des employés.
A la sélection d’un élément dans la liste des matricules, les informations de l’employé
sélectionné seront chargées dans les zones de texte, si l’employé est un technicien
afficher le GroupBox Spécialité avec la spécialité correspondante. Si l’employé est un
agent afficher le GroupBox Chiffre d’affaire (pour vérifier le type d’un objet on utilise
typeOf : If TypeOf e Is Technicien Then).
Le bouton Modifier permet de modifier les informations de l’employé sélectionné.

Le menu Mettre à jour / Modifier permet d’ouvrir le formulaire FrmModifier, désactiver le bouton
Modifier et activer le bouton Supprimer.
Le bouton supprimer permet de supprimer l’employé sélectionné.

Le menu Rechercher permet d’ouvrir le formulaire frmRechercher .
La Grill doit être chargé initialement par tous les employés.

A la saisie dans la zone de texte la liste sera filtré par nom (afficher seulement les
employés dont le nom commence avec les le texte saisi dans la zone de texte)
Exercice 0_4 :
On se propose de gérer les moyennes des étudiants d’une école dont la formation est étalée
sur deux ans.
o Un étudiant possède un numéro, un nom et une date de naissance
o En première année la moyenne générale (MG) est calculée sur la base des
moyennes du semestre1 (MS1) et semestre2 (MS2) soit :
MG = (MS1 + MS2)/2
o En deuxième année l’étudiant achève sa formation par un projet de fin d’étude

qui sera noté (note_projet), ce qui change la règle de calcul de la moyenne
générale soit :
MG = (MS1 + MS2 + note_projet)/3
Le but de cette activité consiste à développer principalement la notion d’héritage; on ne va pas

alourdir le programme par la saisie des notes pour le calcul de la moyenne (à chaque instance
de la classe EtudiantPremiereAnnee ou EtudiantSecondeAnnee on saisit directement la
moyenne du semestre1 (MS1) et la moyenne du semestre2 (MS2) respectivement dans MS1,
MS2.
Créez la classe EtudiantPremiereAnnee.
Cette classe possédera 5 propriétés :

Integer numéro;
String nom;
Date dateNaissance;
double MS1;
double MS2;
Créer la classe EtudiantSecondeAnnée qui hérite de la classe Etudiant et qui possède la

propriété suivante :
double noteProjet;
- La classe EtudiantPremiereAnnee
Implémenter les propriétés

Implémentez la méthode affichage qui permet d’afficher les informations de l’étudiant
Implémentez la méthode moyenne pour calculer la moyenne de 1ere année.
Implémentez les trois constructeurs.
- La classe EtudiantSecondeAnnee
Implémenter les propriétés
Implémentez la méthode affichage qui permet d’afficher les informations de l’étudiant
Implémentez la méthode moyenne pour calculer la moyenne de 2ere année
Implémentez les trois constructeurs.
Remarque :
1. Toute classe créer s’insère automatiquement dans l’arboresance d’une classe déjà créé
(bibliothèque de classe) qui représente une hiérarchie entre toutes les classes à partir de la
classe racine (la classe Object).
2. Si on ne spécifie pas de relations d’héritage pour une nouvelle classe, cette dernière héritera
implicitement de la classe Object.
3. La classe Object définit principalement 3 méthodes
Fonction toString : C’est une fonction permettant d’afficher l’état d’un objet sous forme
d’une Chaine de Caractère. Pour rajouter cette méthode à une nouvelle classe créée, on
doit redéfinir la méthode ToString déjà déclarée dans la classe Mère (Object).
Public Overrides Function ToString () As String

….
End Function
Fonction Equals : permet de comparer deux objets de même type en retournant la

Valeur True en cas d’égalité.
Public Overrides Function Equals ( ByVal obj As Object ) As Boolean
….
End Function
Procédure Finalize : En VB.Net, les objets crées via une instanciation de classe peuvent
être détruit par le système ou cas ou ils ne sont plus référencé. Le programme qui ce
charge de cette tâche est appelé Ramasse Miettes (Garbage Collector); En effet, ce
programme permettra de libérer des ressources en mémoire en cas de besoin en
détruisant tous les objets non référencés.
Dans un programme on peut forcer l’exécution du Ramasse Miettes à travers
l’instruction GC.Collect() .
A chaque fois que le Ramasse Miettes détruit un objet, il envoi à ca classe un message
permettant de l’informer; la méthode permettant de répondre à ce message est appelé
Méthode de finalisation.
Protected Overrides Sub finalize ()
…..
End Sub
- Ajouter à la classe EtudiantPremiereAnnee les méthodes :

Equals pour tester l’égalité de deux étudiants (deux étudiants sont égaux s’ils sont le
même numéro). Cette méthode doit être –elle redéfinit dans la classe
EtudiantSecondeAnnee ?
ToString pour afficher les informations d’un étudiant de la première année. Cette
méthode doit être –elle redéfinit dans la classe EtudiantSecondeAnnee ?
Exercice 0_5
Afin de gérer les ventes dans une Usine de fabrication de pièces métallique on vous propose de
créer l’application suivante :
L’usine met en vente deux catégories de produits
Les produits fabriqués par l’usine (Produit maison)
Les produits achetés chez d’autre société et assemblés par l’usine (Produit assemblé)
Un produit est caractérisé par :
Un code
Une Désignation
Une Date de fabrication
La quantité en stock
Si le produit est fabriqué par l’usine il est caractérisé aussi par le coût de main d’œuvre et le coût de
la matière première.
Si le produit est juste assemblé à l’usine il sera caractérisé en plus par le prix d’achat.
Le prix de vente au public est calculé par la formule :
Si c’est un Produit maison :
Prix de Vente = (coût de main d’œuvre + coût de la matière première) x 1.5
Si c’est produit assemblé :
Prix de Vente = (Prix d’achat) x 1.3
1) Créer les classes suivantes :
Produit
# _Code : Integer (Numéro auto)
# _Designation : String
# _DateFabrication : Date
# _QuntitéEnStock : Integer
+propriétés
+propriété PrixVente (lecture seule)
+constructeurs
+equals()
+toString()
ProduitMaison
ProduitImporte
- _coutMO : Double
- _PrixAchat : Double
- _coutMP : Double
+propriétés
+propriétés
+constructeurs
+constructeurs
+Propriété PrixVente
+propriété PrixVente
+toString()
+toString()
La propriété PrixVente de la classe produit retourne 0

La redéfinition de la propriété PrixVente doit calculer et retourner le prix de vente selon la
formule adéquate.
Deux Produit sont égaux s’ils ont le même code
La quantité en stock ne peut pas être négative
Pour gérer les ventes de ces produits le service commercial de l’usine utilise des factures, chaque
facture est caractérisé par :
Le numéro de la facture
La date de vente
Le nom du client
Et les produits vendus chaque un avec une quantité vendue.
Exemple de facture :
Facture N° : 2012548 Le : 04-04-2012

Client : El bardadi karim
N° Produit Désignation Quantité Prix unitaire Montant

1 254 Article 001 10 500,00 5000,00
2 446 Article 002 5 350,00 1750,00
3 332 Article 003 2 680,00 1360,00
Arrêt de la facture à la somme de : 8110,00
2) Créer les classes suivantes :

a. Classe LigneFacture
LigneFacture
- _Produit : Produit
- _Quantite : Integer
- _PrixUnitaire : Double
+propriétés
+sub New()
+sub New(p :Produit,qte :Integer)
+sub New (lf :LigneFacture)
+function calculerMontant ()
+toString()
Le prix unitaire est en lecture seul, initialisé automatiquement au prix de vente du produit.
La fonction calculerMontant() permet de calculer le montant d’une ligne de facture :
Montant = Prix Unitaire x Quantité
L’attribut _produit est de type Produit
b. Classe Facture :
Facture
- _numero : Integer
- _Client : String
- _DateVente : Date
-_lignes() : Tableau de LigneFacture
+propriétés
+constructeurs
+propriété Lignes (Lecture seule)
+propriété Total ()
+ajouterLigne(L :LigneFacture)
+ ajouterLigne(p :Produit, qte :Integer)
+supprimerLigne(i :Integer)
+InsererLigner(i :Integer,L :LigneFacture)
+effacerTout()
3) L’application MDI pour la gestion des ventes est composé de :

a. Formulaire Menu : formulaire MDI avec le menu Catalogue (Ajouter un produit, mise à jour,
Rechercher), et le menu Facture (Créer, Liste)
b. Formulaire Créer un nouveau Produit : permet d’ajouter un produit au catalogue du produits.
Si l’utilisateur choisi Produit maison on doit afficher une zone avec deux TextBox coût de MO
et coût de MP
Si l’utilisateur choisi Produit importé on doit afficher une zone avec un TextBox prix d’achat
Attention aux positions des contrôles :
Le bouton ajouter permet d’ajouter le produit au tableau des produits

c. Formulaire Mise à jour des produits :
Toutes les zones de saisie sont inactives

Au chargement du formulaire si la table des produits est vide la barre de navigation est
masquée, si non le premier produit de la table est affiché.
Les boutons de navigation permettent de se déplacer entre les produits enregistrés dans le
tableau des produits :
- |<< premier produit dans le tableau
- << produit précédent
- >> produit suivant
- >>| dernier produit dans le tableau
A l’affichage du premier produit dans la table des produits, les boutons |<< et << doivent
être désactivés.
A l’affichage du dernier produit dans la table des produits, les boutons >> et >>| doivent être
désactivés
Si un produit avec une autre position est affiché les boutons seront actifs.
Un produit à la première position
Un produit à la dernière position
Un produit à une autre position
Le bouton Editer permet d’activer le bouton Enregistrer et les zones de saisies (les
radioButton resteront inactive), masquer les boutons de navigation et désactiver le bouton
Editer.
Le bouton Enregistrer permet d’enregistrer les modifications effectuées sur le produit,

désactiver les zones de saisies, activer le bouton Editer, afficher les boutons de navigation et
désactiver le bouton Enregistrer
Le bouton supprimer permet de supprimer le produit affiché dans le formulaire.
Le bouton fermer permet de fermer le formulaire
d. Formulaire Recherche des produits :
La saisie dans les zones de texte permette de filtrer la liste :

- Code égale à
- Désignation commence par
- Date de fabrication supérieure à
- Quantité en stock supérieure à
- Prix de vente supérieur à
Un exemple de filtre : Quantité en stock supérieure à 10
Un exemple de filtre : Quantité en stock supérieure à 10 et Désignation commence par AA
N.B :
- les zones de filtre par Code et par Quantité ne doivent accepter que des nombres
- la zone de filtre par Date doit utiliser un masque de saisi (MaskedTextBox)
e. Formulaire de création d’une nouvelle facture: la création d’une facture passe par 4 étapes
Etape 0 : le bouton suivant permet de créer une facture vide, et afficher la page suivante
Etape 1 : le bouton suivant permet de valider le numéro, la date et le client saisi par
l’utilisateur et afficher la page suivante
Etape 2 : la liste déroulante est chargée avec la liste des produits (Code : Désignation)
La sélection d’un produit permet d’afficher sont prix de vente
le bouton ajouter la ligne permet d’ajouter le produit sélectionné avec la quantité saisie
dans la zone de texte à la facture et calculer le montant total de la facture
le bouton suivant permet d’afficher la page suivante
Etape 3 : Permet d’afficher un compile de la facture, le bouton Terminer permet d’ajouter la

facture créer à la table des factures et réinitialiser l’interface graphique puis afficher la
première page.
N.B : l’utilisateur n’a pas le droit de naviguer entre les pages sans utilisé les boutons suivants.
f. Formulaire liste des factures
Exercice 0_6
L’objectif de cet exercice est de créer une petite application pour la vérification des adresses IP.
Une adresse IP est définie par quatre nombres compris entre 0 et 255 (1octet pour chaque nombre),
séparés par des points. Par exemple : 212.85.150.134. Pour qu’une adresse IP soit valide il faut
vérifier que :
– elle comporte 3 points
– les caractères situés entre les points sont des chiffres compris entre 0 et 255.
Une adresse IP est divisée en deux parties : une partie servant à identifier le réseau (net id) et une
partie servant à identifier un poste sur ce réseau (host id). Il existe 5 classes d'adresses IP. Chaque
classe est identifiée par une lettre allant de A à E.
Ces différentes classes ont chacune leurs spécificités en termes de répartition du nombre d'octet
servant à identifier le réseau ou les ordinateurs connectés à ce réseau :
Une adresse IP de classe A dispose d'une partie net id comportant uniquement un seul octet.
Une adresse IP de classe B dispose d'une partie net id comportant deux octets.
Une adresse IP de classe C dispose d'une partie net id comportant trois octets.
Les adresses IP de classes D et E correspondent à des adresses IP particulières.
Bits de Masque de réseau par

Classe Début Fin Notation CIDR
départ défaut
Classe A 0 0.0.0.0 127.255.255.255 /8 255.0.0.0

Classe B 10 128.0.0.0 191.255.255.255 /16 255.255.0.0
Classe C 110 192.0.0.0 223.255.255.255 /24 255.255.255.0
Classe
1110 224.0.0.0 239.255.255.255 /4 non défini
D (multicast)
Classe
1111 240.0.0.0 255.255.255.255 non défini
E (réservée)
En 1984, devant la limitation du modèle de classes, on a crée le concept de sous-réseau qui introduit
un niveau hiérarchique supplémentaire entre le numéro de réseau et le numéro d'hôte. Ceci permet
par exemple d'utiliser une adresse de Classe B comme 256 sous-réseaux de 254 ordinateurs au lieu
d'un seul réseau de 65534 ordinateurs, sans toutefois remettre en question la notion de classe
d'adresse. Ceci permet plus de flexibilité et d'efficacité dans l'attribution des adresses.
Exemple de sous-réseau dans un réseau de classe A :
1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|0| Réseau | Sous-réseau | Hôte |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Le masque de sous-réseau permet de déterminer les deux parties d'une adresse IP correspondant
respectivement au numéro de sous-réseau et au numéro de l'hôte. Il est obtenu en mettant à 1 les bits
du sous-réseau et à 0 les bits de l'hôte. Le masque 255.255.255.0 correspond par exemple à un sous-
réseau de 24 bits. Bien que les sous-réseaux sont encore fréquemment définis aux frontières d'octet,
les réseaux 24 bits étant les plus courants, d'autres masques sont désormais possibles.
Deux adresses IP appartiennent au même sous-réseau si elles ont en commun les bits du sous-
réseau. Pour déterminer si la machine de destination appartient au même sous-réseau, un hôte utilise
l'opération ET binaire entre l'adresses IP et le masque de sous-réseau, et fait de même avec l'adresse
destination. Si le résultat est identique, alors la destination est dans le même sous-réseau.
1) Afin de créer une application pour identifier la classe réseau (A, B, C, D ou E) d’une
adresse IP et son masque de sous réseau, Créez la classe suivante :
IP
- _t() : Tableau d’Integer
- Classe : Enumération (A, B, C, D, E)
+sub New()
+sub New(p1 :Integer, p2 :Integer, p3 :Integer, p4 :Integer)
+sub New (aip: IP)
+Shared function Parse (s :String) : IP
+property getClasse(): Enum Classe
+property MasqueReseau() : IP
+function getSousReseau(MasqueSR : IP) : IP
+function toString()
+function equals
_t() : un tableau de 4 éléments pour stocker les 4 parties d’une adresse IP. Par exemple
l’adresse IP 192.168.0.5 sera enregistrée comme suite :
_t 192 168 0 5
Sub New() : constructeur par défaut permettant de créer l’adresse par défaut 127.0.0.0
La création de toute nouvelle adresse IP doit vérifier que chaque une des quatre parties
de l’adresse IP est comprise entre 0 et 255.
Sub New(p1,p2,p3,p4): constructeur d’initialisation permettant d’initialiser les 4 parties
d’une adresse IP. Par exemple l’instruction Dim ip1 As New IP(192, 168, 0, 2) doit
permettre de créer l’adresse IP 192.168.0.2
Shared Parse(s : String) : IP : une fonction partagée pour convertir une adresse ip sous forme
d’une chaine de caractère en adresse IP (un objet de type IP). Par exemple les instructions :
Dim p2 As IP
p2 = IP.Parse("192.168.0.5")
Permettent de créer l’adresse IP 192.168.0.5 (séparer la chaine de caractères en 4
nombres et créer un nouvel objet IP)
Property getClasse() : permet de retourner une valeur de type Enumération Classe
représente la classe (A, B, C, D ou E) d’une adresse IP. Soit p1 la première partie (le
premier octet) d’une adresse IP :
- Si 0 ≤ p1 ≤ 127 alors l’adresse IP est de classe A
- Si 128 ≤ p1 ≤ 191 alors l’adresse IP est de classe B
- Si 192 ≤ p1 ≤ 223 alors l’adresse IP est de classe C
- Si 224 ≤ p1 ≤ 239 alors l’adresse IP est de classe D
- Si 240 ≤ p1 ≤ 255 alors l’adresse IP est de classe E
property MasqueReseau() : IP : permet de retourner le masque réseau d’une adresse IP selon la
classe à laquelle elle appartienne (voir le tableau plus haut).
function getSousReseau(MasqueSR : IP) : cette fonction permet de calculer et retourner
l’adresse IP du sous réseau d’une adresse IP à partir du masque de sous réseau. Par exemple
soit l’adresse 192.168.1.2 et le masque 255.255.255.0, pour calculer l’adresse sous réseau on
utilise le ET logique entre les deux adresses :
192.168.1.2 ET_logique 255.255.255.0 = 192.168.1.0
Donc 192.168.1.0 est l’adresse sous réseau de l’adresse IP 192.168.1.2, autrement dit la
machine dont l’adresse IP est 192.168.1.2 appartienne au sous réseau 192.168.1.0
Un autre exemple, l’adresse machine 91.198.174.2 avec le masque SR 255.255.224.0:
91.198.174.2 ET_Logique 255.255.224.0 = 91.198.160.0
Soit en binaire :
01011011.11000110.10101110.00000010
ET 11111111.11111111.11100000.00000000
= 01011011.11000110.10100000.00000000
Donc, l’adresse IP 91.198.174.2 appartienne au sous réseau 91.198.160.0.

Avec l’utilisation de la fonction getSousReseau() :
'création de l'adresse IP 91.198.174.2

Dim hote As New IP()
'création du masque sous réseau 255.255.224.0
Dim mask As New IP()
'calcul de l'adresse ip du sous réseau
Dim sr As IP = hote.getSousReseau(mask)
Console.WriteLine("le SR de l'adresse IP " & _

hote.ToString & " avec un " & _
"masque de " & mask.ToString & _
" est : " & sr.ToString)
Le résultat doit être :
le SR de l'adresse IP 91.198.174.2 avec un masque de 255.255.224.0
est : 91.198.160.0
Remarque : en VB l’operateur logique ET permet de calculer le ET binaire entre deux

nombres entiers.
toString() : la redéfinition de la fonction toString() doit retourner l’adresse IP sous forme d’une
chaine de caractère.
Equals() : la redéfinition de la fonction Equals permet de tester l’égalité de deux adresses IP.
2) Créer l’interface suivant :
Chaque groupBox est contrôlé à l’aide d’une case à coché,

Si la case est cochée le groupBox est développé pour afficher les contrôles qu’il contient et les autres
seront déplacés.
Utiliser les événements suivants relatifs à un groupBox :

Resize : Se produit lorsque le contrôle est redimensionné
Move : se produit lorsque un contrôle est déplacé.
A la saisie d’une adresse IP le programme affiche la Classe de cette adresse (Classe A, B, C, D ou E) et
le masque par défaut correspondant à cette classe.
A la saisie d’un masque de sous réseau on doit afficher le sous réseau.
A la saisie d’une autre adresse IP on doit vérifier si les deux adresses IP appartiennent au même sous
réseau. Et afficher un message convenable dans la zone de texte résultat.
Rappel : les exceptions

Les exceptions : Se sont des arrêts d’exécution qui marquent une ligne jaune où l’erreur s’est
produite. Pour gérer les exceptions on utilise un Bloc try…Catch
Syntaxe :
Try
Partie 1
Catch
Partie 2
Finnaly
Partie 3
End Try
Dans la Partie 1 on écrit les différentes instructions qui peuvent générer une erreur d’exécution.
Dans la partie2 on écrit les instructions qui doivent être exécuté au cas où une erreur d’exécution
s’est produite dans une instruction de la 1ère partie. La partie 3 comprend les instructions qui doivent
être exécuté si on rencontre ou pas une erreur d’exécution.
Exemple :
On considère le programme suivant :

1. Dim A, B, C As Integer
2. A=console.readline()
3. B= console.readline()
4. C=B/A
5. console.writeline(“C= “ & C)
Si l’utilisateur entre au clavier la valeur 0 pour B, le programme généra une exception et se bloquera
à la ligne 4. Pour éviter le blocage de notre programme on peut utiliser le bolc Try…Catch
1. Try
2. Dim A, B, C As Integer
3. A=console.readline()
4. B= console.readline()
5. C=B/A
6. console.writeline(“C= “ & C)
7. Catch ex As Execption
8. console.writeline(ex.message)
9. Finnaly
10. console.writeline(“Arret du Prog”)
11. EndTry
Cette fois ci même si l’utilisateur entre la valeur 0 pour B, le programme affichera un message
d’erreur sans se bloquer.
La classe Exception Représente les erreurs qui se produisent lors de l'exécution de l'application,
Lors de la programmation on peut générer des exceptions personnalisées on faisant l’instanciation
de la Classe Exception :
Throw New Exception(“ Message ”)
Pour générer une exception, on instancie un objet de la classe exception, puis, on peur générer la
levée de l’exception en affichant.
On peut créer nos propres exceptions à l’aide de l’héritage à partir de cette classe Exception. Par
exemple pour créer une exception qui représente l’erreur de division par zéro on peut ajouter une
classe nommé DivisionZeroException :
1. Public Class DivisionZeroException
2. Inherits Exception
3. Public Sub New()
4. MyBase.New("Erreur de division par 0")
5. End Sub
6. End Class
Reprenons l’exercice 0_2, la classe fraction contient une propriété Dénominateur qui ne peut pas
prendre la valeur 0:
1. Public Property Denominateur() As Integer
2. Get
3. Return _B
4. End Get
5. Set(ByVal value As Integer)
6. If value <> 0 Then
7. _B = value
8. Else
9. Throw New DivisionZeroException
10. End If
11. End Set
12. End Property
Si la valeur de B est égale à zéro le programme génère une erreur DivisionZeroException. Pour capter
cette erreur on peut utiliser un bloc Try…Catch avec la propriété Dénominateur de la façon suivante :
1. Dim f As New Fraction
2. Try
3. Console.WriteLine("entrer le Numerateur")
4. f.Numerateur = Console.ReadLine
5. Console.WriteLine("entrer le Denominateur")
6. f.Denominateur = Console.ReadLine
7. Console.WriteLine("Correcte")
8. Catch ex As DivisionZeroException
9. Console.WriteLine(ex.Message)
10. f.Denominateur = 1
11. Finally
12. Console.WriteLine(
Console.WriteLine("Fraction : " & f.ToString)
13. End Try
Si l’utilisateur saisi la valeur 0 à la ligne 6, le programme saute directement à la ligne 9 pour afficher
le message d’erreur produite « Erreur de division par 0 » et initialise le dénominateur à 1.
Puis quelque soit le cas (avec ou sans erreur) le bloc Finally est exécuté (la ligne 12) et affiche la
fraction saisie par l’utilisateur.
Si l’exécution est faite sans erreur le programme affiche :
Correcte
Fraction :......
En cas d’erreur (Dénominateur = 0) le programme affiche :
Fraction :.../1
N.B
Il faut toujours distinguer entre :
celui qui produit l’erreur = la personne qui programme la fonction / la librairie
celui qui gère
re l’erreur = la personne qui utilise la fonction
Exercice 0_7
Un nombre complexe se présente en général en coordonnées cartésiennes,, comme une somme
, où et sont des réels quelconques et (l’unité imaginaire) est un nombre particulier tel
que .
Le réel est appelé partie réelle de et se note ou , le réel est sa partie

imaginaire et se note ou .
Deux nombres complexes sont égaux si et seulement s'ils ont la même partie réelle et la même partie
imaginaire.
Un nombre complexe z est dit imaginaire pur ou totalement imaginaire si sa partie réelle est nulle,
dans ce cas il s'écrit sous la forme z = bi et géométriquement il correspond à un point de l'axe des
imaginaires (axe des ordonnées). A l'autre extrême, un nombre complexe dont la partie imaginaire
vaut 0 est assimilé à un nombre
mbre réel, et géométriquement il correspond à un point de l'axe des réels
(axe des abscisses).
Le nombre réel 0 est le seul qui soit à la fois réel et imaginaire pur. Bien sûr la plupart des nombres
complexes ne sont ni réels ni imaginaires purs (et correspondent
correspondent géométriquement à un point du
plan en-dehors des axes).
L'addition et la multiplication sur les nombres complexes ont les mêmes propriétés d'associativité,
de commutativité et de distributivité que sur les nombres réels. Les règles de calcul s'écrivent donc :
;
.
En particulier, cette formule permet d'obtenir l'égalité

suivante : .
2 2
Puisque la somme a +b de deux carrés de nombres réels est un nombre réel strictement positif
(sauf si a = b = 0),
), il existe un inverse à tout nombre complexe non nul avec l'égalité :
Cette fraction fait apparaître deux expressions importantes pour le nombre complexe :
son conjugué est aussi un nombre complexe ;
son module est un nombre réel positif.
L'application de conjugaison est un automorphisme involutif: ,

et .
L'application module est une valeur absolue car elle est strictement positive en dehors de 0,
sous-additive et multiplicative .
Les réels sont les seuls nombres complexes qui sont égaux à leur conjugué. Les réels positifs sont
les seuls complexes égaux à leur module.
Le nombre 0 est le seul nombre complexe dont le module vaut 0.
Pour réaliser une mini-calculatrice
calculatrice des nombres complexes, créez une classe Complexe pour
regrouper les opérations citées plus haut.
Complexe
- _re : double
- _im : double
+sub New()
+sub New(re:double,
re:double, im:double)
im:double
+sub New (c:Complexe
c:Complexe)
+property Imaginaire
+property Reelle
+property Module (lecture seule)
+function toString()
+function Equals()
+function add(c: Complexe): Complexe
+function multi(c: Complexe): Complexe
+function div(c : Complexe) : Complexe
+function conjugu()
conjugu( : Complexe
+function invers() : Complexe
Créer une exception personnalisée DivisionZeroException avec le message : Erreur

de division par 0.
property Module (lecture seule): calculer le module du nombre complexe
function toString(): renvoi le nombre complexe sous forme d’une chaine de caractères :
- a + ib si b >0
- a - ib si b>0
- a si b=0
Les nombres a et b doivent être affichés avec 2 chiffres après la virgule (utilisez la
fonction Format).
function add(c: Complexe): calculer la somme de deux nombres complexes.
function multi(c: Complexe) : calculer la multiplication de deux nombres complexes.
Function div(c : Complexe) : calculer la division entre deux nombres complexes, si le
dénominateur est égale à 0 on génère l’exception DivisionZeroException.
Function conjugu() : calculer le conjugué du nombre complexe.
Function invers() : calculer l’inverse du nombre complexe s’il est pas nul, si le nombre est nul
on génère l’exception DivisionZeroException.
Créer l’interface suivant :

A la saisie du premier nombre complexe,

calculer et afficher le module, le conjugué
et l’inverse de ce nombre.
A la saisie du 2ème nombre complexe,

calculer et afficher le module, le conjugué
et l’inverse de ce nombre.
Au remplissage de toutes les zones de

textes, calculer et afficher la somme, la
multiplication, la division et l’égalité de
ces deux nombres.
Rappel : les Classes abstraites et les interfaces

Une méthode abstraite est une méthode déclarée mais non définit
Une classe abstraite est une classe qui peut contenir des attributs et des méthodes normales mais
qui contiennent au moins une seule méthode abstraite
Une classe abstraite est une classe générique qui ne peut pas être instancié.
Une méthode abstraite est déclarée à l’aide de MustOverride
Une classe abstraite est déclarée à l’aide de MustInherit
Une classe qui hérite à partir d’une classe abstraite C1 doit définir toutes les méthodes abstraites de
la classe mère C1 (la classe abstraite), si non la classe dérivée (la classe Fille) sera de même abstraite.
Exemple :
Reprenons l’exemple à la page 12 (les classes Employe, Technicien et Agent) :
Employee
- _ matricule : Integer
- _nom : String
- _salaireBase : Double
- _IR : Double
+propriétés
+constructeurs
+function calculerSalaire() : Double
Technicien Agent
- _specialite : String - _CA
Pour calculer le salaire d’employé on peut utiliser l’une des deux règles suivantes :
Pour un Technicien :
Salaire net = salaire de base – (salaire de base x IR)
Pour un Agent :
Salaire net = salaire de base – (salaire de base x IR) + (chiffre d’affaire x 2%)
On en déduit que pour un employé on ne peut pas calculer le salaire sans savoir s’il s’agit d’un
technicien ou un agent. En outre un employé doit obligatoirement avoir une méthode pour calculer
son salaire. Donc cette méthode salaire sera créer abstraite (non définit) dans la classe Employee, et
définit dans les classe Agent et Technicien selon l’une des règles ci-dessus.
La classe Employee devienne
Public MustInherit Class Employee
...
...
Public MustOverride Function calculerSalaire() As Double
...
End Class
La classe Technicien devienne

Inherits Employee
...
Public Overrides Function calculerSalaire() As Double
Return Me.SalaireBase - Me.SalaireBase * Technicien.IR
End Function
End Class
La classe Agent ne changera pas

Public Class Agent
Inherits Employee
...
Public Overrides Function calculerSalaire() As Double
Return Me.SalaireBase - Me.SalaireBase * Agent.IR + Me.CA * 0.02
End Function
End Class
Exercice 0_8
Une société de vente par correspondance propose des articles dans différents rayon : habillement,
électroménager, vidéo/hi-fi et culturel. Chaque article est caractérisé par une désignation (son nom),
une référence (incrémenté de 1 pour un nouvel article), un prix HT. Il est possible de calculer prix TTC
d’un article et d’afficher les informations le concernant.
Les vêtements sont en plus définis par leur composition qui énumère les matières qui les composent
(c) et dans quelles proportions. Le taux TVA sur les vêtements est de 19.6%. Les frais de port sont 1
MAD par vêtement.
Les articles de l’électroménager et de la vidéo/hi-fi possèdent une consommation électrique, une
durée de garantie, un poids (en Kg) et des dimensions (l x h x p) en cm. Le taux TVA sur les articles est
de 20%. Les frais du port sont de 2 MAD tous les trois kilos, majorés de 10% pour les
électroménagers si le volume de l’article dépasse 0.1 m3. La garantie est de 1 an en électroménager
et de 2 ans en vidéo/hi-fi.
Les articles culturels possèdent un genre, et ils sont répartis entre livres et disques. La TVA sur les
livres est de 5.5 % alors qu’elle est de 20 % sur les disques. Les frais de port sont nuls pour les
produits culturels.
N.B : les membres en italique correspond aux membres abstraits.

Pour chaque classe vous devez définir les trois constructeurs.
Lisez attentivement le sujet avant de commencer.
La classe Article (classe abstraite)

La référence est un numéro auto
La fonction fraisPort() est abstraite
La fonction prixTTC() est abstraite
Si la valeur attribuée au prix hors taxe est négative le programme génère l’exception
PrixException
_n est compteur partagé du nombre des objets crées
Classe Composition
Une classe pour représenter les matières qui composent les vêtements
MatiereP est énumération pour représenter les matières qui peuvent composent un
vêtement (Cotton, Acrylic, Nylon)
Classe Vetement
La TVA est une constante qui vaut 19,6%.
Un tableau de type Composition pour stocker les matières composent un vêtement.
Les deux fonctions ajouterMatiere() / retirerMatiere() permet d’ajouter / retirer des matières
au tableau.
La variable _nc permet de compter le nombre d’élément ajouté.
A l’ajout d’une composition au tableau, vous devez vérifier l’inexistence de celle-ci, et
l’homogénéité de la proportion choisie : la somme des proportions ≤ 1.
Réalisez les vérifications nécessaires avant la suppression d’une composition.
Redéfinition de la fonction fraisPort().
Redéfinition de la fonction Prix TTC : Prix HT + TVA x Prix HT + Frais de port.
Classe Electrique (Classe abstraite)
_h : hauteur en m
_l : Longueur en m
_p : Profondeur en m
Volume : propriété en lecture seule (Volume = hauteur x longueur x profondeur)
DureeGarantie() : propriété abstraite en lecture seule
Classe VideoHiFi
DureeGarantie() : propriété en lecture seule (la durée de garantie pour les Video / HiFi est 2)
Redéfinissez la fonction fraisPort() : Les frais du port sont de 2 MAD tous les trois kilos.
Redéfinissez la fonction prixTTC : Prix HT + TVA x Prix HT + Frais de port.
Classe Electromenager
DureeGarantie() : propriété en lecture seule (la durée de garantie pour les électroménager
est 1)
Redéfinissez la fonction fraisPort() : Les frais du port sont de 2 MAD tous les trois kilos,
majorés de 10% si le volume de l’article dépasse 0.1 m3.
Redéfinissez la fonction prixTTC : Prix HT + TVA x Prix HT + Frais de port.
Classe Culturel (Classe Abstraite)
Redéfinissez la fonction fraisPort() : Les frais de port sont nuls pour les articles culturels.
Classe Livre
Le TVA est une constante qui vaut 5,5%
Redéfinissez la fonction prixTTC : Prix HT + TVA x Prix HT
Classe Disque
Le TVA est une constante qui vaut 20%
Redéfinissez la fonction prixTTC : Prix HT + TVA x Prix HT
1) Développer toutes les classes en respectant le digramme de classes et les contraintes ci-dessus.
2) Ajouter à la classe Article un attribut _img de type Image pour stocker l’image bitmap d’un
article.
Remarque : pour charger une image à partir d’un fichier on utilise la syntaxe :
Dim im as Image = new Bitmap(chemin_de_l_image)
Pour charger l’image exo1.jpg qui se trouve dans C: par exemple
Dim im as Image=new Bitmap(“C:\exo1.jpg”)
3) Ajouter une propriété Image en lecture seule pour retourner l’image de l’article
4) Ajouter une procédure choisirImage(img as Image) pour définir l’image d’un article
5) Surcharger cette procédure, pour créer une 2ème qui prend en paramètre le chemin de l’image à
définir : choisirImage(chemin As String).
6) Suivez les étapes ci-dessous pour créer une application SDI « vente par correspondance »
a. Formulaire gestion des articles : ce formulaire permettra à l’utilisateur de naviguer entre les
articles à l’aide des boutons de navigation ; d’ajouter un nouvel article en cliquant sur le
bouton nouveau pour vider et activer les champs puis saisir les données de l’article et cliquer
sur ajouter pour valider l’ajout de cet article; de supprimer ; rechercher un article par
référence et de modifier un article en cliquant sur le bouton Editer pour activer les champs,
puis réaliser les modification et cliquer sur le bouton Enregistrer pour valider.
Composer de 4 GroupBox :
Type d’article avec trois boutons d’options (d’une apparence Bouton), permettent de
sélectionner le type d’article à afficher dans le GroupBox principal (par défaut inactif)
- Si l’utilisateur choisi l’option « Vêtement » le cadre sera titré vêtement et contient:
- Si l’utilisateur choisi l’option «Electronique » le cadre sera titré Electroménager &

Vidéo/Hi Fi et contient:
- Si l’utilisateur choisi l’option «Culturel » le cadre sera titré Electroménager & Vidéo/Hi Fi
et contient:
Vous pouvez ajouter trois panels et modifier leurs visibilités selon le type d’article choisi,
le rectangle en rouge dans l’image suivante indique la zone des panels :
Soit un panel nommé panel1 :

Panel1.visible = true permet d’afficher le panel
Panel1.top = y
Panel1.left = x permet de déplacer le panel à la position (x,y)
Pour les vêtements, la liste déroulante matière est chargée avec Cotton, Acrylic et
Nylon. Le contrôle ListView doit contenir deux colonnes (Matière et proportion). Le
bouton « >>> » permet d’ajouter la matière choisi dans la liste déroulante et le taux saisi
dans la zone de texte Proportion à la ListeView. Le bouton « <<< » permet de supprimer
la ligne sélectionnée dans le contrôle ListView.
Pour les articles électriques, au remplissage des trois zones de texte hauteur, largeur et
profondeur (en cm) un contrôle Lable permettra d’afficher le volume en m3
Les zones de texte numérique doivent être validées avec le contrôle ErrorProvider
Et la zone proportion est validée si la saisie est une valeur numérique entre 0 et 100.
Le bouton parcourir « … » permet d’afficher une boîte de dialogue Ouvrir pour
permettre à l’utilisateur de choisir l’image d’un article et de l’afficher dans le contrôle
PictureBox à côté.
Vous pouvez utiliser le code suivant pour charger l’image choisi dans une boîte de
dialogue.
If OpenFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then
Dim chemin As String = OpenFileDialog1.FileName
PB1.ImageLocation = chemin
End If
Limiter l’affichage des fichiers dans la boîte de dialogue aux images jpeg (*.jpg).
Le Groupbox Navigation : contient les boutons de navigation entre les enregistrements :
- Bouton premier : afficher le 1er article du tableau des articles
- Bouton Précédent : afficher l’article précédent
- Bouton suivant : afficher l’article suivant
- Bouton dernier : afficher le dernier article
- Si la table des articles est vide les 4 boutons seront inactifs
- A l’affichage du 1er article désactiver les boutons Premier et précédent.
- A l’affichage du dernier article désactiver les boutons suivant et dernier.
Le groupBox Boîte à outils contient les boutons suivants :

- Bouton Nouveau : permet d’activer les boutons ajouter et Annuler et de désactiver les
boutons Supprimer, rechercher, lister, les groupBox de navigation et de type d’article et
d’activer le groupBox principal.
Effacer toutes les zones de texte.
Calculer et afficher la référence du nouvel article (égale au compteur des articles crées +
1).
- Bouton Ajouter : permet d’ajouter un article selon le type choisi par l’utilisateur
(Vêtement, Electronique : Electroménager ou Vidéo/HiFi, Culturel : Livre ou Disque).
Et rétablir l’état initial des boutons et des groupBox
- Bouton Editer : permet d’activer le cadre principal pour que l’utilisateur puisse réaliser
les modifications nécessaires puis cliquer sur enregistrer pour sauvegarder ces
modifications dans la table des articles (N.B l’utilisateur ne peut pas modifier le type ni
la référence de l’article). Ci-dessous l’apparence de l’interface après le clic sur le bouton
Editer.
- Bouton Enregistrer : permet d’enregistrer les modifications effectuées sur l’article

affiché et rétablir l’état initial de l’interface graphique.
- Bouton Annuler : pour annuler un clic sur le bouton Nouveau ou Editer et rétablir l’état
initial de l’interface.
- Bouton supprimer : supprimer l’article affiché.
- Bouton rechercher : permet d’inviter l’utilisateur à entrer la référence de l’article
recherché via un InputBox et d’affiché l’article ou un message d’erreur s’il est
introuvable.
- Bouton Lister : ouvrir le formulaire Liste des articles.

- Bouton Fermer : Quitter l’application
b. Formulaire Liste des articles : ce formulaire servira à afficher la liste des articles classés par
type via le contrôle ListView qui fournit différentes style d’affichage (Liste, détails, petites
icones, grandes icones et mosaïque). L’ajout et le paramétrage de la listView sera fait par code.
Les boutons d’options (Vêtement, Electronique et culturel) permettent de choisir le type
d’article à affiché dans la liste
Les boutons d’options (Détails, Liste, Petites icones, grandes icones et mosaïque) permettent
de choisir le style d’affichage dans la liste.
A l’affichage des articles électroniques créer deux groupes dans la liste électroménager et
Video / HiFi
Article électronique avec affichage Détails.

A l’affichage des articles culturels créer deux groupes dans la liste Livre et Disque
Articles électroniques / affichage Petites icones
Articles électroniques / affichage Grandes icones

Articles électroniques / affichage Liste
Articles électronique / affichage Mosaïque
c. Formulaire Détails d’un article : cette boîte de dialogue affiche des informations détaillées
avec option zoom sur l’image, et la possibilité d’ajouter l’article au panier.
La zone réserver à l’image doit être redimensionné automatiquement si l’utilisateur agrandit
la fenêtre.
Ce formulaire est affiché après double clic sur l’article dans la liste.
Pour l’affichage des informations d’un article, utilisez la fonction toString

Pour lier la taille de l’image à la taille de la fenêtre, utilisez des panels et la propriété Anchor du
contrôle PictureBox.
Pour créer un formulaire de type boite de dialogue, choisissez le modèle boite de dialogue à
l’ajoute du formulaire FrmDetail
Le bouton Ajouter au panier (Bouton OK) permet d’ajouter l’article à un tableau panier, qui
contient les articles commandés. Le lien hypertexte affiche le nombre des articles dans le
panier et le montant total de ces articles.
d. Formulaire Aperçu du panier : ce formulaire sans bordures affiche un aperçu du panier, avec la
référence, la désignation et le prix TTC de l’article. En bas le nombre des articles et le montant
total.
Le bouton Retirer permet de supprimer l’article sélectionné du panier et mettre à jour le

nombre des articles commandés et le montant.

POO - TP - 00 - Partie 1 - C#

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

POO - TP - 00 - Partie 1 - C#

Titre original :

Transféré par

Droits d'auteur :

1 Programmation Orientée Objet : TP 00 H.

Comprendre la Notion de classe d'objet

Afin d’implanter correctement le concept d'encapsulation, il convient de verrouiller l'accès aux

public int Numero

public int AnneeDeNaissance

Le nom de l'identificateur du constructeur est le celui de la classe.

2. Constructeur par défaut :

public Stagiaire(Stagiaire unStagiaire)

Public Shared Function Compteur() As Integer

Exemple complet (Stagiaire.vb):

'constructeur par defaut

'mothode 1 pour créer un stagiaire

'mothode 2 pour créer un stagiaire

'mothode 2 pour créer un stagiaire (créer une copie du 1er

'affichage des informations

1. Créer la classe article avec tous ces membres :

Public Function additionner(ByVal a As Integer, ByVal b As Integer)

Public Function additionner(ByVal a As Double, ByVal b As Double) As

L’option de recherche par défaut est ID

Le résultat de la recherche par ID sera affiché dans le GroupBox Résultat de la Recherche

L’option de Tri par défaut est Moyenne

Spécialité : Réseaux ou développement

Public Class Employee

Protected _matricule As Integer

Public Property Matricule() As Integer

Public Property SalaireBase() As Double

Public Shared ReadOnly Property IR() As Double

Public Sub New()

Public Sub New(ByVal e As Employee)

Public Property Specialite() As String

Public Sub New()

Public Sub New(ByVal t As Technicien)

Public Function calculerSalaire() As Double

Public Property CA() As Double

Public Sub New()

Public Function calculerSalaire() As Double

Un exemple de module de teste :

Dans la classe dérivée « Technicien »

Dans la classe dérivée Agent :

MyBase.afficher(): Permet de faire appel à la fonction afficher de la classe mère « Employee »

L’utilisation des classes est simplifiée de la façon suivante :

Dim t As New Technicien(10500, "alami", 7000, "Reseau")

Prenons l’exemple suivant :

Le 1er appel à la méthode e.afficher() : permet d’appeler la méthode afficher de la classe

Le menu Ajouter permet d’ouvrir le formulaire frmAjouter :

Le choix du RadioButton Technicien permet d’afficher le GroupBox Spécialité

Le ComboBox Spécialité contient les choix Développement et Réseaux

Le bouton Ajouter à la liste permet de créer un nouvel employé (Technicien ou Agent)

Le bouton Modifier permet de modifier les informations de l’employé sélectionné.

Le bouton supprimer permet de supprimer l’employé sélectionné.

La Grill doit être chargé initialement par tous les employés.

o Un étudiant possède un numéro, un nom et une date de naissance

o En deuxième année l’étudiant achève sa formation par un projet de fin d’étude

MG = (MS1 + MS2 + note_projet)/3

Le but de cette activité consiste à développer principalement la notion d’héritage; on ne va pas

Créez la classe EtudiantPremiereAnnee.

Cette classe possédera 5 propriétés :

Créer la classe EtudiantSecondeAnnée qui hérite de la classe Etudiant et qui possède la

Implémenter les propriétés

Public Overrides Function ToString () As String

Fonction Equals : permet de comparer deux objets de même type en retournant la

- Ajouter à la classe EtudiantPremiereAnnee les méthodes :

La propriété PrixVente de la classe produit retourne 0

Facture N° : 2012548 Le : 04-04-2012

N° Produit Désignation Quantité Prix unitaire Montant