Book II 7 in C#

Creation USS Code 39 in C# Book II 7

The following output from this program may or may not be confusing, depending on what you expected:

When invoked through intermediary BankAccount balance is $10000 SavingsAccount balance is $10000 Press Enter to terminate

This time, rather than perform a withdrawal in Main(), the program passes the bank account object to the method MakeAWithdrawal() The first question is fairly straightforward: Why does the MakeAWithdrawal() method even accept a SavingsAccount object when it clearly states that it s looking for a BankAccount The answer is obvious: Because a SavingsAccount IS_A BankAccount (See 6 of this minibook)

The second question is subtle When passed a BankAccount object, MakeAWithdrawal() invokes BankAccountWithdraw() that s clear enough But when passed a SavingsAccount object, MakeAWithdrawal() calls the same method Shouldn t it invoke the Withdraw() method in the subclass The prosecution intends to show that the call baWithdraw() should invoke the method BankAccountWithdraw() Clearly, the ba object is a BankAccount To do anything else would merely confuse the state The defense has witnesses back in Main() to prove that although the ba object is declared BankAccount, it is in fact a SavingsAccount The jury is deadlocked Both arguments are equally valid In this case, C# comes down on the side of the prosecution: The safer of the two possibilities is to go with the declared type because it avoids any miscommunication The object is declared to be a BankAccount and that s that However, that may not be what you want

Using the declared type every time (Is that so wrong )

In some cases, you don t want to choose the declared type What you want (or, what you really, really want, to quote the popular Spice Girls song) is to make the call based on the real type the runtime type as opposed to the declared type For example, you want to use the SavingsAccount stored in a BankAccount variable This capability to decide at runtime is known as polymorphism, or late binding Using the declared type every time is called early binding because it sounds like the opposite of late binding The ridiculous term polymorphism comes from the Greek language: Poly means more than one, morph means transform, and ism is a fairly useless Greek term But we re stuck with it Polymorphism and late binding aren t exactly the same concept but the difference is subtle: Polymorphism refers to the general ability to decide which method to invoke at runtime Late binding refers to the specific way a language implements polymorphism Polymorphism is the key to the power of object-oriented (OO) programming It s so important that languages that don t support it can t advertise themselves as OO languages (I think it s an FDA regulation: You can t label a

language that doesn t support it as OO unless you add a disclaimer from the surgeon general, or something like that) Languages that support classes but not polymorphism are object-based languages Visual Basic 60 (not VBNET) is an example of such a language Without polymorphism, inheritance has little meaning Let me spring another example on you to show you why Suppose that you had written a boffo program that uses a class named (just to pick a name out of the air) Student After months of design, coding, and testing, you release this application to rave reviews from colleagues and critics alike (You ve even heard talk of starting a new Nobel Prize category for software, but you modestly brush such talk aside) Time passes and your boss asks you to add to this program the capability of handling graduate students, who are similar but not identical to undergraduate students (The graduate students probably claim that they aren t similar in any way) Suppose that the formula for calculating the tuition amount for a graduate student is completely different from the formula for an undergrad Now, your boss doesn t know or care that, deep within the program, are numerous calls to the member method CalcTuition() (A lot of things happen that your boss doesn t know or care about, by the way) The following example shows one of those many calls to CalcTuition():

void SomeMethod(Student s) // Could be grad or undergrad { // whatever it might do sCalcTuition(); // continues on }