C# ПІДРУЧНИКИ / c# / MS Press - Oop With MS Vb Net And C# Step By Step (2002)

you saw in Chapter 5. In this chapter, you’ll create an abstract class, one from which you must inherit. In the definition of the abstract class, you’ll determine the members that the derived class must implement. You’ll see that the Microsoft .NET Framework provides several abstract classes, designed solely as base classes for developers to use to create typed collection classes. You’ll also learn how to create members of a base class and a derived class that have the same name, yet don’t behave polymorphically.

Abstract Classes

In Chapter 5, you created the fully functional base class, BankAccount. You then created two derived classes, SavingsAccount and CheckingAccount. If you think about a real bank (remembering that classes should model the real world), you might wonder whether you could ever open a generic bank account. Most likely, a bank would offer you a selection of kinds of accounts, and you would choose one. The bank manager would be completely unable to create a generic bank account. So it should be for your BankAccount class. The BankAccount class should define the common behavior of a generic bank account, even though you would never create one. You still want to handle accounts polymorphically, perhaps to send out advertisements. So you will still use inheritance to create the account classes.

Another reason not to create a base class that you can instantiate is that you might then be tempted to add functionality to the base class that isn’t appropriate for the derived classes. Making this mistake is all the more likely if your design started with one class and then you derived a new class from it. Suppose your bank started by offering only savings accounts; for that purpose, you created a SavingsAccount class. When your bank became successful, you wanted to add a checking account and decided to derive it from SavingsAccount. Because your checking account service was going to pay interest, just like a savings account, the only thing you needed to add was the service charge for processing checks. Then when the incidence of new savings accounts dropped, you decided to offer a new toaster for each new savings account opened. So you added a GiveToaster method to the SavingsAccount class. Through inheritance, you must now offer all the new checking account customers a new toaster! The solution to this problem is to create a base class for SavingsAccount and CheckingAccount. Then add the new toaster behavior only in the SavingsAccount class.

Visual Basic and Visual C# both offer a mechanism for enforcing the concept that you create only instances of the derived class. You set this limitation by creating abstract base classes. Abstract classes can’t be instantiated, although you can create derived classes from them. You can completely implement an abstract class, or you can simply define what the derived class must implement. You can declare references to the abstract class, but you can’t make instances of them. As a result, you don’t lose any of the polymorphic behavior of the derived classes.

The BankAccount Class Revisited

In Chapter 5, the BankAccount class was fully functional, which could lead to errors in the program if you ever instantiated the class because its behavior would be neither that of a SavingsAccount class nor a CheckingAccount class. In this chapter, you’ll create the BankAccount class as an abstract class. You might recall that the BankAccount classes had an ID property whose format depended on the account type. Because the ID property depends on the type of account, there’s no reason to implement this method in the base class, and furthermore, you don’t want to implement it in the base class. If you did, the implementation wouldn’t be correct for either type of account. Using an abstract property forces you to implement this method. In this chapter, you’ll also add the abstract PrintStatement method to the base class. The SavingsAccount statement will include the deposits, withdrawals, and interest paid. The CheckingAccount statement will include deposits, withdrawals, and the number of checks written. If this method were implemented in the base class, it would be valid for neither of the derived classes.

You might be thinking at this point, “I can implement the PrintStatement method in the base class. I’ll just check the type of the instance and then print the correct statement.”

This solution would work as long as you know all the derived classes of the base class, but doing this would limit the reusability of the base class. In general, base classes shouldn’t contain code that depends on the derived classes.

Describing the Design Using the Unified Modeling Language

The Unified Modeling Language (UML) is a graphical tool for describing object-oriented designs. Development tools such as UML allow developers to discuss designs using a common vocabulary. Such tools also decrease ambiguity in a specification. In previous chapters, the class designs have been specified by tables listing the properties and methods. In this and subsequent chapters, I’ll use a UML class diagram to specify designs. The basic unit of the class diagram is the box, which represents the class:

The class element has two sections below the name, one to specify the properties and one to specify the methods:

The preceding diagram describes the abstract base class you’ll implement, BankAccount. The italic title shows that BankAccount is an abstract class. The UML lists the properties and their default values, and it specifies public properties by preceding them with a plus sign. The lower section of the class element lists the public methods defined in the class. The UML also indicates the parameters for the methods and their return values. In UML, the in word indicates that the parameter is passed by value in Visual Basic.

The UML also shows the derived classes with the inheritance relationship denoted by an arrow pointing toward the base class, usually placed above the derived class. The derived classes are assumed to inherit everything from the base class, so only the additions are shown in the derived class. Here’s the complet e UML class diagram for this chapter:

Note that the UML class diagram doesn’t specify any of the behavior of the interface. For example, the class diagram doesn’t explain the interaction of the Deposit method and the Balance property. It doesn’t explain how the ID property should be implemented in the SavingsAccount and CheckingAccount classes.

You can create UML diagrams yourself using anything from drawing tools to high-end professional development tools. Some tools can generate code from your diagrams or generate diagrams from your code. Even a simple, quickly drawn diagram can convey the basic structure of your object-oriented program.

Creating the Abstract Class

The first class you’ll create is the BankAccount class. This class implements some methods and leaves others as abstract. Declaring just one member as abstract makes your entire class abstract.

Create the class

1.Create a new project and name it ABetterBank.

2.On the Project menu, click Add Class. The Add New Item dialog box appears.

3.Name the file BankAccount.vb or BankAccount.cs, depending on the language you’re using.

4.Add the MustInherit or abstract keyword to the class declaration, as you see here:

5.‘ Visual Basic

6.Public MustInherit Class BankAccount

7.

8.// Visual C#

public abstract class BankAccount

Add the nonabstract members

1.Add the following code for the Balance property:

2.‘ Visual Basic

3.Private m_balance As Decimal = 0D

4.Public ReadOnly Property Balance() As Decimal

5.Get

6.Return m_balance

7.End Get

8. End Property

9.

10.// Visual C#

11.private decimal m_balance;

12.public decimal Balance {

13.get { return m_balance; }

14.}

15.Add the following code for the TotalDeposits property. The TotalDeposits property is the total of all the deposits for the lifetime of the instance.

16.‘ Visual Basic

17.Private m_totalDeposits As Decimal = 0D

18.Public ReadOnly Property TotalDeposits() As Decimal

19.Get

20.Return m_totalDeposits

21.End Get

22.End Property

23.

24.// Visual C#

25.private decimal m_totalDeposits;

26.public decimal TotalDeposits {

27.get { return m_totalDeposits; }

}

28.Add the following code for the TotalWithdrawals property. The TotalWithdrawals property is the total of all the withdrawals for the lifetime of the instance.

29.‘ Visual Basic

30.Private m_totalWithdrawals As Decimal = 0D

31.Public ReadOnly Property TotalWithdrawals() As Decimal

32.Get

33.Return m_totalWithdrawals

34.End Get

35.End Property

36.

37.// Visual C#

38.private decimal m_totalWithdrawals;

39.public decimal TotalWithdrawals {

40.get { return m_totalWithdrawals; }

}

41.Add the following code for the Withdraw and Deposit methods:

42.‘ Visual Basic

43.Public Function Deposit(ByVal amount As Decimal) As Decimal

44.m_balance += amount

45.m_totalDeposits += amount

46.Return (m_balance)

47.End Function

public abstract string PrintStatement();

Again, the declaration isn’t followed by an implementation, and all the derived classes are required to implement the method.

The abstract BankAccount class is complete. You can’t create an instance of BankAccount, although you can create a reference variable to BankAccount. Now create the derived class SavingsAccount.

Writing the SavingsAccount Class

Here’s what you do to implement the SavingsAccount class:

§Add a constructor.

§Add the Interest property.

§Add the AddInterest method.

§Define the PrintStatement method.

§Define the ID property.

Create the class

1.On the Project menu, click Add Class. The Add New Item dialog box appears.

2.Name the file SavingsAccount.vb or SavingsAccount.cs, depending on the language you’re using.

3.Add the boldface text to the class declaration to indicate that SavingsAccount inherits from the BankAccount class:

4.‘ Visual Basic

5.Public Class SavingsAccount

6.Inherits BankAccount

7.End Class

8.

9.// Visual C#

10.public class SavingsAccount : BankAccount {

11.:

12.}

Define the constructor

§Add this code for the constructor. Now that the ID property is defined only in the derived classes, the m_owner field is moved to the SavingsAccount class. If you’re using C#, replace the parameterless constructor with this constructor:

§‘ Visual Basic

§Private m_owner As String

§Public Sub New(ByVal owner As String)

§m_owner = owner

§End Sub

§

§// Visual C#

§private string m_owner;

§public SavingsAccount(string owner) {

§m_owner = owner;

}

Add the Interest property and the AddInterest method

1.Add this code for the Interest property:

2.‘ Visual Basic

3.Private m_interest As Decimal = 0.01D

4.Public Property Interest() As Decimal

5.Get

6.Return m_interest

7.End Get

8.Set(ByVal Value As Decimal)

9.m_interest = Value

10.End Set

11.End Property

12.

13.// Visual C#

14.private decimal m_interest = 0.01M;

15.public decimal Interest {

16.get { return m_interest; }

17.set { m_interest = value; }

}

18.Add this code for the AddInterest method:

19.‘ Visual Basic

20.Private m_totalInterest As Decimal = 0D

21.Public Function AddInterest() As Decimal

22.Dim interest As Decimal = m_interest * Me.Balance

23.m_totalInterest += interest

24.Me.Deposit(interest)

25.Return Me.Balance

26.End Function

27.

28.// Visual C#

29.private decimal m_totalInterest = 0M;

30.public decimal AddInterest() {

31.decimal interest = m_interest * this.Balance;

32.m_totalInterest += interest;

33.this.Deposit(interest);

34.return this.Balance;

}

Define the inherited abstract members

1.Add this code to define the PrintStatement method. Even though the PrintStatement method was only declared and not implemented in the BankAccount class, you still use the Overrides or override keyword when implementing the method.

2.‘ Visual Basic

3.Public Overrides Function PrintStatement() As String

4.Dim statement As String = String.Format("{1}{0}" & _

5."Opening balance: $0.00{0}Deposits: {2:C}{0}" & _

6."Withdrawals: {3:C}{0}Interest: {4:C}{0}" & _

7."Ending balance: {5:C}{0}", _

8.New Object() {ControlChars.CrLf, Me.ID, _

9.Me.TotalDeposits - m_totalInterest, _

10.Me.TotalWithdrawals, Me.m_totalInterest, Me.Balance})

11.Return statement

12.End Function

13.

14.// Visual C#

15.public override string PrintStatement() {

16.string statement = String.Format("{0}\n" +

17."Opening balance: $0.00\nDeposits: {1:C}\nWithdrawals: {2: C}\n" +

18."Interest: {3:C}\nEnding balance: {4:C}\n",

19.new object[] { this.ID, this.TotalDeposits - m_totalInterest,

20.this.TotalWithdrawals, this.m_totalInterest, this.Balance});

21.return statement;

}

You can choose from many ways to build strings in .NET. This method, using one of the overloads of String.Format, shows just one. In Visual C#, you can indicate a new line by means of the \n escape character. That escape character isn’t recognized in Visual Basic, but you can simply replace the \n character with the formatting expression {0} and match it with ControlChars.CrLf in the argument list.

The total deposits to the savings account, maintained in the base class, include the interest payments. The program deducts the interest payments from the total deposits before reporting the deposits. The program reports the interest payments separately.

22.Add this code to define the ID property:

23.‘ Visual Basic

24.Public Overrides ReadOnly Property ID() As String

25.Get

26.Return m_owner & "-S"

27.End Get

28.End Property

29.

30.// Visual C#

31.public override string ID {

32.get { return m_owner + "-S"; }

}

Writing the CheckingAccount Class

Here’s what you do to implement the CheckingAccount class:

§Override the Withdraw method.

§Define the PrintStatement method.

§Define the ID property.

Create the class

1.On the Project menu, click Add Class. The Add New Item dialog box appears.

2.Name the file CheckingAccount.vb or CheckingAccount.cs, depending on the language you’re using.

3.Add the boldface text to the class declaration to indicate that BankAccount is the derived class:

4.‘ Visual Basic

5.Public Class CheckingAccount

6.Inherits BankAccount

7.End Class

8.

9.// Visual C#

10.public class CheckingAccount : BankAccount {

11.§

12.}

Define the constructor

§Add this code for the constructor. Now that the ID property is defined only in the derived classes, the m_owner field is moved to the

CheckingAccount class. If you’re using C#, replace the parameterless constructor with this constructor.

§‘ Visual Basic

§Private m_owner As String

§Public Sub New(ByVal owner As String)

§m_owner = owner

§End Sub

§

§// Visual C#

§private string m_owner;

§public CheckingAccount(string owner) {

§m_owner = owner;

}

Define the overridden Withdraw method

§Add this code to override the Withdraw method:

§‘ Visual Basic

§Dim m_checks As Integer = 0

§Public Overrides Function Withdraw(ByVal amount As Decimal) A s Decimal

§m_checks += 1

§Return MyBase.Withdraw(amount + 0.25D)

§End Function

§

§// Visual C#

§private int m_checks = 0;

§public override decimal Withdraw(decimal amount) {

§m_checks++;

§return (base.Withdraw(amount + 0.25M));

}

Define the inherited abstract members

1.Add this code to define the PrintStatement method:

2.‘ Visual Basic

3.Public Overrides Function PrintStatement() As String

4.Dim statement As String = String.Format("{1}{0}" & _

5."Opening balance: $0.00{0}Deposits: {2:C}{0}" & _

6."Withdrawals: {3:C}{0}Checks written: {4}{0}" & _

7."Checking charges: {5:C}{0}Ending balance: {6:C}{0}", _

8.New Object() { ControlChars.CrLf, Me.ID, _

9.Me.TotalDeposits, Me.TotalWithdrawals -

(m_checks * 0.25D), _

10. Me.m_checks, Me.m_checks * 0.25D, Me.Balance}) 11.

12.Return statement

13.End Function

14.

15.// Visual C#

16.public override string PrintStatement() {

17.string statement = String.Format(

18."{0}\nOpening balance: $0.00\nDeposits: {1:C}\n" +

19."Withdrawals: {2:C}\nChecks written: {3}\n" +

20."Checking charges: {4:C}\nEnding balance: {5:C}\n",

21.new object[] { this.ID, this.TotalDeposits,

22.this.TotalWithdrawals - (m_checks * 0.25M),

23.this.m_checks, this.m_checks * 0.25D, this.Balance});

25.return statement;

}

The withdrawals from the checking account are lumped with the check amounts, so the service charges are deducted from the withdrawals and reported separately.

26.Add this code to define the ID property:

27.‘ Visual Basic

28.Public Overrides ReadOnly Property ID() As String

29.Get

30.Return m_owner & "-C"

31.End Get

32.End Property

33.

34.// Visual C#

35.public override string ID {

36.get { return m_owner + "-C"; }

}

The base and derived classes are complete. The public interface of the classes hasn’t changed, except for the addition of the PrintStatement method. You can therefore use the same form you used to test the classes in Chapter 5.

Testing the Classes

Even though you changed the implementation of the BankAccount classes, you can still use the same user interface from Chapter 5.

Create the user interface

1.In the Solution Explorer, right-click Form1 and click Delete on the shortcut menu. Click OK to confirm the deletion of Form1.

2.On the Project menu, click Add Existing Item.

3.In the Add Existing Item dialog box, navigate to the form you created for the project TheBank in Chapter 5 and click Open. A copy of the form is added to the ABetterBank project folder.

4.If you’re using C#, you want to rename the namespace in which the form is contained. Right -click the form in the Solution Explorer, and click View Code on the shortcut menu. Modify the namespace declaration near the top of the file this way:

namespace ABetterBank

5.Open the form in the form designer by double-clicking Form1.vb or Form1.cs in the Solution Explorer.

6.Drag a Button onto Form1. Set its Name property to printStatement and its Text property to Print. Here’s the complete user interface:

Add the code for the Print button

1.In the designer, double-click the Print button to create the Click event method and edit it in the code editor.

2.Add this code to print the statement for the selected account: 3. ‘ Visual Basic