Lecture 10: Inheritance

Outline
 In the previous lecture, we introduced Objects
 And discussed the basics of Object-Oriented Programming…
 Members, Methods, Properties, etc
 Defining Objects: Classes
 We also discussed Console Applications:
 When to abandon a GUI-based Approach.
 In favor of a command-line interface.
 Our Example: The J_Train Class
 We now continue our discussion of O.O. Programming:
 Defining Constructors, which allow:
 Convenient encapsulation of default characteristics.
 Clients to create new Object instances with specified characteristics.
 The concept of Inheritance
 By which we may create ‘derived Classes’...
 Which inherit and expand upon the characteristics of a Base Class
 Our Example: The JFreightTrain Class
 Which inherits from JTrain.
 Constructors
 Earlier, we created a single JTrain instance (JTrain001)…
 And provided it with natural, default characteristics…
 Based automatically on the initialized Member values (not very elegant).
 We then set the desired characteristics of JTrain001 manually.
 However, what if we wanted to create another JTrain instance…?
 But, we want the new instance to start its life with different values…

 Object characteristics may be set on instantiation via a Contructor :

 A special-purpose Method defined for Initialization only.
 This Method is always called New().
 Once defined, New() is called each time a new instance is created…
 Using the New Keyword.
 Note: Earlier, New() was called implicitly when making our JTrain001…
 Even though we had not yet defined any Constructor…
 How so? The System handed us a default (and empty) New() Method…
 Which gave us a JTrain instance with Members set to our default values.
 We can define several New() methods…each with a different Parameter set.
 However, we should always give a zero parameter New() method (for inheritance!).
 For instance: a 0-parameter New() constructor + a detail-specific constructor.

 Now, let’s add two such Constructors to our JTrain Class…

J-Train Ex.: Adding Constructors
J-Train Ex.: Constructor (cont)
 Inheritance
 As we noted, a strength of O.O. Programming is Code Reusability
 After defining the JTrain Class, we can instantiate (make) any number.
 However, the concept of reusability can be extended…
 For instance, consider ‘derived classes of things’ in the real world…
 A Bear is a kind of of Animal.
 A ‘Freight Train’ is a more specific kind of ‘Train’
 Such ‘derived’ classes broadly have two types of characteristics:
 Possessed by a more general kind of of thing (e.g., animal).
 Only possessed by the specific kind of thing (e.g., bear).

 The concept of Inheritance neatly captures this relationship:

 A new Class can begin with all the characteristics of a more general class.

 More characteristics are then added, to quickly compose a more specific class.
 This is accomplished in VB.NET using the keyword, Inherits.
 Such a derived Class is said to Inherit from the original (base) Class.
 Again, this is very similar to real-world objects…

 To illustrate, let’s make our own JFreightTrain as a type of JTrain…

 With the new capacity to carry Wagons that hold freight.
Inheritance Ex.: JFreightTrain
Inheritance Ex.: JFreightTrain
JFreightTrain (cont.)
 Changing Default Instantiation
 A Base Class usually defines a zero-parameter New() Method
 It will be called (implicitly) by the system, for derived classes.
 Providing Default Instatiation details for instances.
 Ex: Our JFreightTrain somehow was Blue with 3 cars (mysterious…)
 Why? Because the System called BaseClass.New() automatically!

 It is often desirable to expand or modify this behavior:

 Since Derived Class instances generally have additional characteristics.

 Defining a new Constructor for a derived class is straightforward...

 No special keywords are required (just define it, normally).
 But (!!)… If the Base Class defines a zero-argument Constructor…
 This Base Class Constructor will be called FIRST, automatically.
 Combined Effect: BaseClass Constructor Effect + new Constructor Effect!

 If we wish to use a different constructor of the Base Class, instead…

 We can do this on the new constructor’s 1st line: MyBase.New( param_list )
 In this case, the zero-parameter BaseClass Constructor is not called.

 To illustrate, let’s add two Constructors to JFreightTrain…

Example: JFreightTrain (cont.)
Conclusion / Forward
 In the last lecture, we continued our discussion of Objects…
 Creating and Using Constructors:
 Used to create object instances with differing characteristics.
 Example: JTrain (cont.)

 Inheritance
 Used to create ‘derived Classes’...
 Which inherit the characteristics of a Base Class
 Example: The JFreightTrain Class
 We also discussed Overriding Base Class Constructors

 Next lecture, we continue our discussion of overriding:

 With Polymorphism, a simple but powerful concept…
 Form 1 : Overriding Base Class Methods and Properties.
 Form 2 : The Ability of Methods to Accept ‘Related’ Classes.

 We also present a generalized Multiple_JTrain Example.