This chapter is from the book
This chapter is from the book
This chapter is from the book
Conversions
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
Array Covariance
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.