Programmation Object-Oriented (C#)Object-Oriented programming (C#)

C# est un langage orienté objet.C# is an object-oriented language. Quatre des techniques clés utilisées dans la programmation orientée objet sont les suivantes :Four of the key techniques used in object-oriented programming are:

  • L' abstraction signifie masquer les détails inutiles des consommateurs de type.Abstraction means hiding the unnecessary details from type consumers.
  • L’encapsulation signifie qu’un groupe de propriétés, méthodes et autres membres corrélés est traité comme une unité ou un objet unique.Encapsulation means that a group of related properties, methods, and other members are treated as a single unit or object.
  • L’héritage décrit la possibilité de créer des classes à partir d’une classe existante.Inheritance describes the ability to create new classes based on an existing class.
  • Le polymorphisme signifie que plusieurs classes peuvent être utilisées de manière interchangeable, même si chacune des classes implémente les mêmes propriétés ou méthodes de manière différente.Polymorphism means that you can have multiple classes that can be used interchangeably, even though each class implements the same properties or methods in different ways.

Dans le didacticiel précédent, Introduction aux classes , vous avez vu l' abstraction et l' encapsulation.In the preceding tutorial, introduction to classes you saw both abstraction and encapsulation. La BankAccount classe a fourni une abstraction pour le concept d’un compte bancaire.The BankAccount class provided an abstraction for the concept of a bank account. Vous pouvez modifier son implémentation sans affecter le code qui a utilisé la BankAccount classe.You could modify its implementation without affecting any of the code that used the BankAccount class. Les BankAccount classes et Transaction fournissent toutes deux l’encapsulation des composants nécessaires à la description de ces concepts dans le code.Both the BankAccount and Transaction classes provide encapsulation of the components needed to describe those concepts in code.

Dans ce didacticiel, vous allez étendre cette application pour utiliser l’héritage et le polymorphisme pour ajouter de nouvelles fonctionnalités.In this tutorial, you'll extend that application to make use of inheritance and polymorphism to add new features. Vous ajouterez également des fonctionnalités à la BankAccount classe, en tirant parti des techniques d' abstraction et d' encapsulation que vous avez apprises dans le didacticiel précédent.You'll also add features to the BankAccount class, taking advantage of the abstraction and encapsulation techniques you learned in the preceding tutorial.

Créer différents types de comptesCreate different types of accounts

Une fois ce programme créé, vous recevez des demandes d’ajout de fonctionnalités.After building this program, you get requests to add features to it. Il fonctionne très bien dans le cas où il n’existe qu’un seul type de compte bancaire.It works great in the situation where there is only one bank account type. Au fil du temps, des besoins changent et des types de compte associés sont demandés :Over time, needs change, and related account types are requested:

  • Un compte d’intérêt qui accumule des intérêts à la fin de chaque mois.An interest earning account that accrues interest at the end of each month.
  • Une ligne de crédit qui peut avoir un solde négatif, mais lorsqu’il y a un solde, des frais sont facturés chaque mois.A line of credit that can have a negative balance, but when there's a balance, there's an interest charge each month.
  • Un compte de carte cadeau prépayé qui commence par un dépôt unique et qui ne peut être payé.A pre-paid gift card account that starts with a single deposit, and only can be paid off. Il peut être rerempli une fois au début de chaque mois.It can be refilled once at the start of each month.

Tous ces comptes différents sont similaires à ceux de BankAccount la classe définie dans le didacticiel précédent.All of these different accounts are similar to BankAccount class defined in the earlier tutorial. Vous pouvez copier ce code, renommer les classes et apporter des modifications.You could copy that code, rename the classes, and make modifications. Cette technique peut fonctionner à long terme, mais elle serait plus de travail au fil du temps.That technique would work in the short term, but it would be more work over time. Toutes les modifications sont copiées dans toutes les classes affectées.Any changes would be copied across all the affected classes.

Au lieu de cela, vous pouvez créer des types de comptes bancaires qui héritent des méthodes et des données de la BankAccount classe créée dans le didacticiel précédent.Instead, you can create new bank account types that inherit methods and data from the BankAccount class created in the preceding tutorial. Ces nouvelles classes peuvent étendre la BankAccount classe avec le comportement spécifique requis pour chaque type :These new classes can extend the BankAccount class with the specific behavior needed for each type:

public class InterestEarningAccount : BankAccount
{
}

public class LineOfCreditAccount : BankAccount
{
}

public class GiftCardAccount : BankAccount
{
}

Chacune de ces classes hérite du comportement partagé de sa classe de basepartagée, la BankAccount classe.Each of these classes inherits the shared behavior from their shared base class, the BankAccount class. Écrivez les implémentations pour les fonctionnalités nouvelles et différentes dans chacune des classes dérivées.Write the implementations for new and different functionality in each of the derived classes. Ces classes dérivées ont déjà tout le comportement défini dans la BankAccount classe.These derived classes already have all the behavior defined in the BankAccount class.

Il est recommandé de créer chaque nouvelle classe dans un fichier source différent.It's a good practice to create each new class in a different source file. Dans Visual Studio, vous pouvez cliquer avec le bouton droit sur le projet, puis sélectionner Ajouter une classe pour ajouter une nouvelle classe dans un nouveau fichier.In Visual Studio, you can right-click on the project, and select add class to add a new class in a new file. Dans Visual Studio code, sélectionnez fichier , puis nouveau pour créer un nouveau fichier source.In Visual Studio Code, select File then New to create a new source file. Dans l’un ou l’autre des outils, nommez le fichier pour qu’il corresponde à la classe : InterestEarningAccount.cs, LineOfCreditAccount.cset GiftCardAccount.cs.In either tool, name the file to match the class: InterestEarningAccount.cs, LineOfCreditAccount.cs, and GiftCardAccount.cs.

Lorsque vous créez les classes comme indiqué dans l’exemple précédent, vous découvrirez qu’aucune de vos classes dérivées n’est compilée.When you create the classes as shown in the preceding sample, you'll find that none of your derived classes compile. Un constructeur est chargé d’initialiser un objet.A constructor is responsible for initializing an object. Un constructeur de classe dérivée doit initialiser la classe dérivée et fournir des instructions sur la façon d’initialiser l’objet de classe de base inclus dans la classe dérivée.A derived class constructor must initialize the derived class, and provide instructions on how to initialize the base class object included in the derived class. L’initialisation appropriée se produit normalement sans code supplémentaire.The proper initialization normally happens without any extra code. La BankAccount classe déclare un constructeur public avec la signature suivante :The BankAccount class declares one public constructor with the following signature:

public BankAccount(string name, decimal initialBalance)

Le compilateur ne génère pas de constructeur par défaut lorsque vous définissez un constructeur vous-même.The compiler doesn't generate a default constructor when you define a constructor yourself. Cela signifie que chaque classe dérivée doit appeler explicitement ce constructeur.That means each derived class must explicitly call this constructor. Vous déclarez un constructeur qui peut passer des arguments au constructeur de classe de base.You declare a constructor that can pass arguments to the base class constructor. Le code suivant illustre le constructeur pour InterestEarningAccount :The following code shows the constructor for the InterestEarningAccount:

public InterestEarningAccount(string name, decimal initialBalance) : base(name, initialBalance) 
{ 
}

Les paramètres de ce nouveau constructeur correspondent au type de paramètre et aux noms du constructeur de classe de base.The parameters to this new constructor match the parameter type and names of the base class constructor. Vous utilisez la : base() syntaxe pour indiquer un appel à un constructeur de classe de base.You use the : base() syntax to indicate a call to a base class constructor. Certaines classes définissent plusieurs constructeurs, et cette syntaxe vous permet de choisir le constructeur de classe de base que vous appelez.Some classes define multiple constructors, and this syntax enables you to pick which base class constructor you call. Une fois que vous avez mis à jour les constructeurs, vous pouvez développer le code de chacune des classes dérivées.Once you've updated the constructors, you can develop the code for each of the derived classes. La configuration requise pour les nouvelles classes peut être indiquée comme suit :The requirements for the new classes can be stated as follows:

  • Compte de bénéfices intéressants :An interest earning account:
    • Obtient un crédit de 2% du solde de fin de mois.Will get a credit of 2% of the month-ending-balance.
  • Une ligne de crédit :A line of credit:
    • Peut avoir un solde négatif, mais pas une valeur absolue supérieure à la limite de crédit.Can have a negative balance, but not be greater in absolute value than the credit limit.
    • Entraînera un montant de frais pour les intérêts chaque mois où le solde de fin de mois n’est pas égal à 0.Will incur an interest charge each month where the end of month balance isn't 0.
    • Est facturé pour chaque retrait qui dépasse la limite de crédit.Will incur a fee on each withdrawal that goes over the credit limit.
  • Un compte de carte cadeau :A gift card account:
    • Peut être rerempli avec un montant spécifié une fois par mois, le dernier jour du mois.Can be refilled with a specified amount once each month, on the last day of the month.

Vous pouvez voir que ces trois types de compte ont une action qui a lieu à la fin de chaque mois.You can see that all three of these account types have an action that takes places at the end of each month. Toutefois, chaque type de compte effectue des tâches différentes.However, each account type does different tasks. Vous utilisez le polymorphisme pour implémenter ce code.You use polymorphism to implement this code. Créez une virtual méthode unique dans la BankAccount classe :Create a single virtual method in the BankAccount class:

public virtual void PerformMonthEndTransactions() { }

Le code précédent montre comment utiliser le virtual mot clé pour déclarer une méthode dans la classe de base qu’une classe dérivée peut fournir une implémentation différente pour.The preceding code shows how you use the virtual keyword to declare a method in the base class that a derived class may provide a different implementation for. Une virtual méthode est une méthode dans laquelle toute classe dérivée peut choisir de réimplémenter.A virtual method is a method where any derived class may choose to reimplement. Les classes dérivées utilisent le override mot clé pour définir la nouvelle implémentation.The derived classes use the override keyword to define the new implementation. En général, vous faites référence à ceci comme « substitution de l’implémentation de la classe de base ».Typically you refer to this as "overriding the base class implementation". Le virtual mot clé spécifie que les classes dérivées peuvent substituer le comportement.The virtual keyword specifies that derived classes may override the behavior. Vous pouvez également déclarer abstract des méthodes dans lesquelles les classes dérivées doivent remplacer le comportement.You can also declare abstract methods where derived classes must override the behavior. La classe de base ne fournit pas d’implémentation pour une abstract méthode.The base class does not provide an implementation for an abstract method. Ensuite, vous devez définir l’implémentation de deux des nouvelles classes que vous avez créées.Next, you need to define the implementation for two of the new classes you've created. Commencez par le InterestEarningAccount :Start with the InterestEarningAccount:

public override void PerformMonthEndTransactions()
{
    if (Balance > 500m)
    {
        var interest = Balance * 0.05m;
        MakeDeposit(interest, DateTime.Now, "apply monthly interest");
    }
}

Ajoutez le code suivant au LineOfCreditAccount .Add the following code to the LineOfCreditAccount. Le code inverse le solde pour calculer un montant positif qui est retiré du compte :The code negates the balance to compute a positive interest charge that is withdrawn from the account:

public override void PerformMonthEndTransactions()
{
    if (Balance < 0)
    {
        // Negate the balance to get a positive interest charge:
        var interest = -Balance * 0.07m;
        MakeWithdrawal(interest, DateTime.Now, "Charge monthly interest");
    }
}

La GiftCardAccount classe a besoin de deux modifications pour implémenter ses fonctionnalités de fin de mois.The GiftCardAccount class needs two changes to implement its month-end functionality. Tout d’abord, modifiez le constructeur pour inclure une quantité facultative à ajouter chaque mois :First, modify the constructor to include an optional amount to add each month:

private decimal _monthlyDeposit = 0m;

public GiftCardAccount(string name, decimal initialBalance, decimal monthlyDeposit = 0) : base(name, initialBalance)
    => _monthlyDeposit = monthlyDeposit;

Le constructeur fournit une valeur par défaut pour la monthlyDeposit valeur. ainsi, les appelants peuvent omettre un 0 pour aucun dépôt mensuel.The constructor provides a default value for the monthlyDeposit value so callers can omit a 0 for no monthly deposit. Ensuite, remplacez la PerformMonthEndTransactions méthode pour ajouter le dépôt mensuel, s’il a été défini sur une valeur différente de zéro dans le constructeur :Next, override the PerformMonthEndTransactions method to add the monthly deposit, if it was set to a non-zero value in the constructor:

public override void PerformMonthEndTransactions()
{
    if (_monthlyDeposit != 0)
    {
        MakeDeposit(_monthlyDeposit, DateTime.Now, "Add monthly deposit");
    }
}

Le remplacement applique l’ensemble de dépôts mensuels dans le constructeur.The override applies the monthly deposit set in the constructor. Ajoutez le code suivant à la Main méthode pour tester ces modifications pour le GiftCardAccount et le InterestEarningAccount :Add the following code to the Main method to test these changes for the GiftCardAccount and the InterestEarningAccount:

var giftCard = new GiftCardAccount("gift card", 100, 50);
giftCard.MakeWithdrawal(20, DateTime.Now, "get expensive coffee");
giftCard.MakeWithdrawal(50, DateTime.Now, "buy groceries");
giftCard.PerformMonthEndTransactions();
// can make additional deposits:
giftCard.MakeDeposit(27.50m, DateTime.Now, "add some additional spending money");
Console.WriteLine(giftCard.GetAccountHistory());

var savings = new InterestEarningAccount("savings account", 10000);
savings.MakeDeposit(750, DateTime.Now, "save some money");
savings.MakeDeposit(1250, DateTime.Now, "Add more savings");
savings.MakeWithdrawal(250, DateTime.Now, "Needed to pay monthly bills");
savings.PerformMonthEndTransactions();
Console.WriteLine(savings.GetAccountHistory());

Vérifiez les résultats.Verify the results. Ajoutez maintenant un ensemble similaire de code de test pour le LineOfCreditAccount :Now, add a similar set of test code for the LineOfCreditAccount:

var lineOfCredit = new LineOfCreditAccount("line of credit", 0, 2000);
// How much is too much to borrow?
lineOfCredit.MakeWithdrawal(1000m, DateTime.Now, "Take out monthly advance");
lineOfCredit.MakeDeposit(50m, DateTime.Now, "Pay back small amount");
lineOfCredit.MakeWithdrawal(5000m, DateTime.Now, "Emergency funds for repairs");
lineOfCredit.MakeDeposit(150m, DateTime.Now, "Partial restoration on repairs");
lineOfCredit.PerformMonthEndTransactions();
Console.WriteLine(lineOfCredit.GetAccountHistory());

Lorsque vous ajoutez le code précédent et exécutez le programme, un message semblable à l’erreur suivante s’affiche :When you add the preceding code and run the program, you'll see something like the following error:

Unhandled exception. System.ArgumentOutOfRangeException: Amount of deposit must be positive (Parameter 'amount')
   at OOProgramming.BankAccount.MakeDeposit(Decimal amount, DateTime date, String note) in BankAccount.cs:line 42
   at OOProgramming.BankAccount..ctor(String name, Decimal initialBalance) in BankAccount.cs:line 31
   at OOProgramming.LineOfCreditAccount..ctor(String name, Decimal initialBalance) in LineOfCreditAccount.cs:line 9
   at OOProgramming.Program.Main(String[] args) in Program.cs:line 29

Notes

La sortie réelle comprend le chemin d’accès complet au dossier contenant le projet.The actual output includes the full path to the folder with the project. Les noms de dossiers ont été omis par souci de concision.The folder names were omitted for brevity. En outre, selon le format de votre code, les numéros de ligne peuvent être légèrement différents.Also, depending on your code format, the line numbers may be slightly different.

Ce code échoue car le BankAccount suppose que le solde initial doit être supérieur à 0.This code fails because the BankAccount assumes that the initial balance must be greater than 0. Une autre hypothèse intégrée à la BankAccount classe est que le solde ne peut pas être négatif.Another assumption baked into the BankAccount class is that the balance can't go negative. Au lieu de cela, tout retrait qui dédessine le compte est rejeté.Instead, any withdrawal that overdraws the account is rejected. Ces deux hypothèses doivent être modifiées.Both of those assumptions need to change. Le compte de la ligne de crédit commence à 0 et est généralement un solde négatif.The line of credit account starts at 0, and generally will have a negative balance. En outre, si un client emprunte trop d’argent, il est facturé.Also, if a customer borrows too much money, they incur a fee. La transaction est acceptée, mais elle coûte juste plus cher.The transaction is accepted, it just costs more. La première règle peut être implémentée en ajoutant un argument facultatif au BankAccount constructeur qui spécifie le solde minimal.The first rule can be implemented by adding an optional argument to the BankAccount constructor that specifies the minimum balance. La valeur par défaut est 0.The default is 0. La deuxième règle requiert un mécanisme qui permet aux classes dérivées de modifier l’algorithme par défaut.The second rule requires a mechanism that enables derived classes to modify the default algorithm. Dans un sens, la classe de base « demande » le type dérivé qui doit se produire lorsqu’il y a un surplus.In a sense, the base class "asks" the derived type what should happen when there's an overdraft. Le comportement par défaut consiste à rejeter la transaction en levant une exception.The default behavior is to reject the transaction by throwing an exception.

Commençons par ajouter un deuxième constructeur qui comprend un paramètre facultatif minimumBalance .Let's start by adding a second constructor that includes an optional minimumBalance parameter. Ce nouveau constructeur effectue toutes les actions effectuées par le constructeur existant.This new constructor does all the actions done by the existing constructor. En outre, il définit la propriété solde minimal.Also, it sets the minimum balance property. Vous pouvez copier le corps du constructeur existant.You could copy the body of the existing constructor. mais cela signifie que deux emplacements doivent être modifiés à l’avenir.but that means two locations to change in the future. Au lieu de cela, vous pouvez utiliser le chaînage de constructeur pour qu’un constructeur en appelle un autre.Instead, you can use constructor chaining to have one constructor call another. Le code suivant montre les deux constructeurs et le nouveau champ supplémentaire :The following code shows the two constructors and the new additional field:

private readonly decimal minimumBalance;

public BankAccount(string name, decimal initialBalance) : this(name, initialBalance, 0) { }

public BankAccount(string name, decimal initialBalance, decimal minimumBalance)
{
    this.Number = accountNumberSeed.ToString();
    accountNumberSeed++;

    this.Owner = name;
    this.minimumBalance = minimumBalance;
    if (initialBalance > 0)
        MakeDeposit(initialBalance, DateTime.Now, "Initial balance");
}

Le code précédent illustre deux nouvelles techniques.The preceding code shows two new techniques. Tout d’abord, le minimumBalance champ est marqué comme readonly .First, the minimumBalance field is marked as readonly. Cela signifie que la valeur ne peut pas être modifiée après la construction de l’objet.That means the value cannot be changed after the object is constructed. Une fois BankAccount créé, le minimumBalance ne peut pas changer.Once a BankAccount is created, the minimumBalance can't change. Deuxièmement, le constructeur qui accepte deux paramètres utilise : this(name, initialBalance, 0) { } comme implémentation.Second, the constructor that takes two parameters uses : this(name, initialBalance, 0) { } as its implementation. L' : this() expression appelle l’autre constructeur, celle avec trois paramètres.The : this() expression calls the other constructor, the one with three parameters. Cette technique vous permet d’avoir une seule implémentation pour l’initialisation d’un objet même si le code client peut choisir l’un des nombreux constructeurs.This technique allows you to have a single implementation for initializing an object even though client code can choose one of many constructors.

Cette implémentation appelle MakeDeposit uniquement si le solde initial est supérieur à 0 .This implementation calls MakeDeposit only if the initial balance is greater than 0. Cela préserve la règle selon laquelle les dépôts doivent être positifs, tout en permettant au compte de crédit de s’ouvrir avec un 0 solde.That preserves the rule that deposits must be positive, yet lets the credit account open with a 0 balance.

Maintenant que la BankAccount classe a un champ en lecture seule pour le solde minimal, la modification finale consiste à remplacer le code en dur par 0 minimumBalance dans la MakeWithdrawal méthode :Now that the BankAccount class has a read-only field for the minimum balance, the final change is to change the hard code 0 to minimumBalance in the MakeWithdrawal method:

if (Balance - amount < minimumBalance)

Après l’extension de la BankAccount classe, vous pouvez modifier le LineOfCreditAccount constructeur pour appeler le nouveau constructeur de base, comme indiqué dans le code suivant :After extending the BankAccount class, you can modify the LineOfCreditAccount constructor to call the new base constructor, as shown in the following code:

public LineOfCreditAccount(string name, decimal initialBalance, decimal creditLimit) : base(name, initialBalance, -creditLimit)
{
}

Notez que le LineOfCreditAccount constructeur modifie le signe du creditLimit paramètre afin qu’il corresponde à la signification du minimumBalance paramètre.Notice that the LineOfCreditAccount constructor changes the sign of the creditLimit parameter so it matches the meaning of the minimumBalance parameter.

Autres règles de prébrouillonDifferent overdraft rules

La dernière fonctionnalité à ajouter permet au LineOfCreditAccount de payer une taxe pour dépasser la limite de crédit au lieu de refuser la transaction.The last feature to add enables the LineOfCreditAccount to charge a fee for going over the credit limit instead of refusing the transaction.

Une technique consiste à définir une fonction virtuelle où vous implémentez le comportement requis.One technique is to define a virtual function where you implement the required behavior. La Bank Account classe refactorise la MakeWithdrawal méthode en deux méthodes.The Bank Account class refactors the MakeWithdrawal method into two methods. La nouvelle méthode effectue l’action spécifiée lorsque le retrait prend le solde inférieur au minimum.The new method does the specified action when the withdrawal takes the balance below the minimum. La MakeWithdrawal méthode existante a le code suivant :The existing MakeWithdrawal method has the following code:

public void MakeWithdrawal(decimal amount, DateTime date, string note)
{
    if (amount <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(amount), "Amount of withdrawal must be positive");
    }
    if (Balance - amount < minimumBalance)
    {
        throw new InvalidOperationException("Not sufficient funds for this withdrawal");
    }
    var withdrawal = new Transaction(-amount, date, note);
    allTransactions.Add(withdrawal);
}

Remplacez-le par le code suivant :Replace it with the following code:

public void MakeWithdrawal(decimal amount, DateTime date, string note)
{
    if (amount <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(amount), "Amount of withdrawal must be positive");
    }
    var overdraftTransaction = CheckWithdrawalLimit(Balance - amount < minimumBalance);
    var withdrawal = new Transaction(-amount, date, note);
    allTransactions.Add(withdrawal);
    if (overdraftTransaction != null)
        allTransactions.Add(overdraftTransaction);
}

protected virtual Transaction? CheckWithdrawalLimit(bool isOverdrawn)
{
    if (isOverdrawn)
    {
        throw new InvalidOperationException("Not sufficient funds for this withdrawal");
    }
    else
    {
        return default;
    }
}

La méthode ajoutée est protected , ce qui signifie qu’elle ne peut être appelée qu’à partir de classes dérivées.The added method is protected, which means that it can be called only from derived classes. Cette déclaration empêche d’autres clients d’appeler la méthode.That declaration prevents other clients from calling the method. Cela permet également virtual aux classes dérivées de modifier le comportement.It's also virtual so that derived classes can change the behavior. Le type de retour est Transaction? .The return type is a Transaction?. L' ? annotation indique que la méthode peut retourner null .The ? annotation indicates that the method may return null. Ajoutez l’implémentation suivante dans le LineOfCreditAccount pour payer des frais lorsque la limite de retrait est dépassée :Add the following implementation in the LineOfCreditAccount to charge a fee when the withdrawal limit is exceeded:

protected override Transaction? CheckWithdrawalLimit(bool isOverdrawn) =>
    isOverdrawn
    ? new Transaction(-20, DateTime.Now, "Apply overdraft fee")
    : default;

Le remplacement retourne une transaction de frais lorsque le compte est redessiné.The override returns a fee transaction when the account is overdrawn. Si le retrait n’excède pas la limite, la méthode retourne une null transaction.If the withdrawal doesn't go over the limit, the method returns a null transaction. Cela indique qu’il n’y a aucun frais.That indicates there's no fee. Testez ces modifications en ajoutant le code suivant à votre Main méthode dans la Program classe :Test these changes by adding the following code to your Main method in the Program class:

var lineOfCredit = new LineOfCreditAccount("line of credit", 0, 2000);
// How much is too much to borrow?
lineOfCredit.MakeWithdrawal(1000m, DateTime.Now, "Take out monthly advance");
lineOfCredit.MakeDeposit(50m, DateTime.Now, "Pay back small amount");
lineOfCredit.MakeWithdrawal(5000m, DateTime.Now, "Emergency funds for repairs");
lineOfCredit.MakeDeposit(150m, DateTime.Now, "Partial restoration on repairs");
lineOfCredit.PerformMonthEndTransactions();
Console.WriteLine(lineOfCredit.GetAccountHistory());

Exécutez le programme et vérifiez les résultats.Run the program, and check the results.

RésuméSummary

Ce didacticiel a démontré de nombreuses techniques utilisées dans la programmation de Object-Oriented :This tutorial demonstrated many of the techniques used in Object-Oriented programming:

  • Vous avez utilisé l' abstraction quand vous avez conservé de nombreux détails private dans chaque classe.You used Abstraction when you kept many details private in each class.
  • Vous avez utilisé l' encapsulation lorsque vous avez défini des classes pour chacun des différents types de compte.You used Encapsulation when you defined classes for each of the different account types. Ces classes décrivent le comportement de ce type de compte.Those classes described the behavior for that type of account.
  • Vous avez utilisé l' héritage lorsque vous tirez parti de l’implémentation déjà créée dans la BankAccount classe pour enregistrer le code.You used Inheritance when you leveraged the implementation already created in the BankAccount class to save code.
  • Vous avez utilisé le polymorphisme quand vous avez créé virtual des méthodes que les classes dérivées peuvent substituer pour créer un comportement spécifique pour ce type de compte.You used Polymorphism when you created virtual methods that derived classes could override to create specific behavior for that account type.

Félicitations, vous avez terminé tout notre introduction aux didacticiels C#.Congratulations, you've finished all of our introduction to C# tutorials. Pour en savoir plus, consultez les didacticielssuivants.To learn more, try more of our tutorials.