One way to understand inheritance is to realize that real-world things of one type may also be of another type. For example, an employee is also a person (despite what some managers may think). That means whatever attributes a person has, an employee has also. A person has a name, address, birthday, and so forth. An employee also has those things, in addition to some new ones such as a salary, job title, office number, and employee ID number.

Similarly, a manager is a type of employee. That means a manager has everything an employee does, which in turn means the manager has everything a person does.

In Visual Basic, classes provide a similar structure through inheritance. One class such as Employee can inherit the properties, methods, and events of another class such as Person.

This kind of inheritance enables you to reuse code in a new way because it means you don't need to write the same properties, methods, and events for the Employee class that you already defined for the Person class.

When you make one class inherit from another one, you derive the new class from the existing class. In that case, the new class is called the child class and the class from which it inherits is called the parent class.

You could build a Person class with properties that all people have: FirstName, LastName, Street, City, State, and Zip. You could then derive the Employee class from Person and add the new properties Salary, JobTitle, MailStop, and EmployeeId.

Next, you could derive the Manager class from Employee and add new manager-related properties such as DepartmentName and DirectReports.

Syntactically, to make a class that inherits from another you add an Inherits statement immediately after the Class statement. For example, the following code shows definitions for a Person class, an Employee class that inherits from Person, and a Manager class that inherits from Employee:

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property Street As String
    Public Property City As String
    Public Property State As String
    Public Property Zip As String
End Class

Public Class Employee
    Inherits Person

    Public Property Salary As Decimal
    Public Property JobTitle As String
    Public Property MailStop As String
    Public Property EmployeeId As Integer
End Class

Public Class Manager
    Inherits Employee

    Public Property DepartmentName As String
    Public Property DirectReports As New List(Of Person)
End Class

Polymorphism is a rather confusing concept that basically means a program can treat an object as if it were any class that it inherits. Another way to think of this is that polymorphism enables you to treat an object as if it were any of the classes that it is. For example, an Employee is a kind of Person so you should be able to treat an Employee as a Person.

Note that the reverse is not true. A Person is not necessarily an Employee (it could be a Customer or some other unrelated person such as a Plumber).

For a more detailed example, suppose you make the Person, Employee, and Manager classes, and they inherit from each other in the obvious way. Now suppose you write a method that takes a Person as a parameter. Employee inherits from Person so you should be able to pass an Employee into this method and the method should be able to treat it as a Person. This makes intuitive sense because an Employee is a Person, just a particular kind of Person.

Similarly, Manager inherits from Employee, so a Manager is a kind of Employee. If an Employee is a kind of Person and a Manager is a kind of Employee, then a Manager must also be a kind of Person, so the same method should be able to take a Manager as its parameter.

This feature enables you to reuse code in ways that make sense. For example, if you write a method that addresses letters for a Person, it can also address letters to Employees and Managers.

In this Try It, you get to experiment with classes, inheritance, and polymorphism. You build Person, Employee, and Manager classes. To test the classes, you build a simple program that creates instances of each class and passes them to a method that takes a Person as a parameter.