|< Day Day Up >|
When a class derives from another class, it automatically inherits all the members of the base class. As a result, a derived class can always be safely converted to one of its base classes. For example:
Class Person Public Name As String Public Address As String Public City As String Public State As String Public ZIP As String End Class Class Employee Inherits Person Public Salary As Integer End Class Module Test Sub Main() Dim p As Person = New Employee() p.Name = "John Doe" End Sub End Module
In this example, the Framework can allow an instance of Customer to be assigned to a variable of type Person because it knows that a Customer is also a Person . Thus, a Customer can be treated like a Person , and the fields that Customer inherits from Person can be changed. If the preceding example had tried to access fields that were specific to Customer or Employee , however, an error would be given because when an instance is viewed as as a Person , only the members defined by Person can be used, as the following example illustrates.
Module Test Sub Main() Dim p As Person p = New Customer() ' Error: CustomerID is not a member of Person p.CustomerID = 10 p = New Employee() ' Error: Salary is not a member of Person p.Salary = 34923.23 End Sub End Module
Conversely, an instance of a base class can be converted to a derived class, but the conversion is not always guaranteed to succeed. A variable typed as Person could contain an instance of the Employee class, but it could also contain an instance of some other type.
Module Test Sub Main() Dim p As Person = New Employee() ' Error: Can't convert Employee to Customer Dim c As Customer = CType(p, Customer) End Sub End Module
The Customer class also inherits from Person , so it can be converted to Person . However, the instance stored in the variable is still a Customer ; as such, it cannot be treated as an instance of the Employee class. In this case, the Framework will throw a System.InvalidCastException exception at runtime when the conversion is executed.
The important principle to keep in mind is that when you create an instance of a class, it always stays that type, no matter what it is converted to. A Customer class converted to Person is still a Customer , even if the additional fields that Customer adds to the Person class are not visible. The power of inheritance is that it allows code to be written that works on the most general type in a hierarchy, which means that code can be written very broadly. For example, a method that takes a Person and prints the name and address of that Person can take a Customer or an Employee , instead of having to write separate methods for Customer and Employee .
Module Test Sub PrintAddress(ByVal p As Person) Console.WriteLine(p.Name) Console.WriteLine(p.Address) Console.WriteLine(p.City & ", " & p.State & " " & p.ZIP) End Sub Sub Main() Dim c As Customer Dim e As Employee PrintAddress(c) PrintAddress(e) End Sub End Module
Inheritance conversions extend to arrays as well. In general, an array of a particular type cannot be converted to any other type, because the array storage is allocated based on the type of the array. For example, it is not possible to covert a one-dimensional array of Integer to a one-dimensional array of Long , because Integer and Long do not have the same size . Thus, an array of ten Integer values could not hold ten Long values within the same space. However, because classes are reference types, the size of an array that holds ten Customer instances is the same size as an array that holds ten Employee instances. Thus, an array of a reference type may be converted to an array of another reference type, provided that the element types themselves convert to one another. For example:
Module Test Sub Main() Dim Customers(9) As Customer Dim People() As Person For Index As Integer = 0 To 9 Customers(Index) = New Customer() Next Index People = Customers For Index As Integer = 0 To 9 People(Index).Name = "John Doe" Next Index End Sub End Module
The one-dimensional array of Customer can be converted to a one-dimensional array of Person because a Customer can be converted to a Person .
This conversion behavior of arrays is called covariance . Covariance is useful in the same way that inheritance is.
Module Test Sub SetCityState(ByVal People() As Person, ByVal City As String, _ ByVal State As String) For Each Person As Person In People Person.City = City Person.State = State Next Person End Sub Sub Main() Dim Employees(9) As Employee ... SetCityState(Employees, "Akron", "OH") End Sub End Module
In this example, the base class Person provides a method that will set the City and State fields for an array of Person instances. The Main method can pass an array of Employee instances to the method because an array of Employee can be converted to an array of Person . One important thing to note, though, is that even though the array has been converted to an array of Person , it still can only hold Employee instances. Thus, an attempt to assign any other type into the array will cause a System.InvalidCastException exception. For example:
Module Test Sub FillArray(ByVal People() As Person) For Index As Integer = 0 To People.Length -1 People(Index) = New Person() Next Index End Sub Sub Main() Dim Employees(9) As Employee FillArray(Employees) End Sub End Module
This example will throw an exception because the array being passed in to FillArray is an array of Employee , not Person , so only Employee instances can be stored in the array.
|< Day Day Up >|