What is the basic difference between And and AndAl- 123docz.net

And and AndAlso operators: AndAlso is used for short circuit evaluation of Boolean values while And is commonly used as a bitwise AND operator. While using AndAlso in comparison, it will terminate evaluating comparisons once it find the false value, hence it is more efficient in a comparison scenario. While And will check each comparison statement before returning the result.

Camel and Pascal Notation: In camel notation, the first character of the identifier appears in lowercase while in Pascal notation, the first character of identifier appears in uppercase.

In both notations the successive words start with uppercase letters while the remaining letters appear in lowercase. In VB.Net camel notation is used for naming fields and Pascal notation is used for naming Methods and Types (Class, Interface, Enum, Structure)

Do While...Loop and Do...Loop While: In a Do Loop...While, the condition is checked after each iteration whereas in a Do While...Loop, the condition is checked before each iteration.

What's Next…

• What is inheritance? Its significance

• Implementing inheritance in VB.Net and its constraints

• Using Protected access modifier

• Using MyBase keyword

• Object Class - the base of all classes

• Polymorphism and its importance

• Implementing with Overridable, Overrides and Shadows modifiers

• Boxing and Unboxing

• Casting (Up, Down-Casting)

Lesson Plan

We will learn the fundamental object oriented features such as inheritance and

polymorphism in VB.Net. We will start with building some understanding of inheritance and then will move towards understanding how VB.Net supports inheritance. We will spend some time exploring the Object class and then we will head towards polymorphism and how polymorphism is implemented within VB.Net. We will close this session with the

understanding of boxing, un-boxing and how the type-casting mechanism works in VB.Net Inheritance

Unless this is your first brush with object oriented programming, you will have heard a lot about Reusability and Extensibility. Reusability is the property of a module (a component, class or even a method) that enables it to be used in different applications without any or little change in its source code. Extensibility of a module is it's potential to be extended (enhanced) as new needs evolve. Reusability in Object Oriented Programming languages is achieved by reducing coupling between different classes while extensibility is achieved by sub-classing. The process of sub-classing a class to extend its functionality is called Inheritance or sub-typing.

The original class (or the class that is sub-typed) is called the base, parent or super class.

While the class that inherits the functionality of base class and extends it in its own way is called a sub, child, derived or an inherited class.

Copyright © 2008 Department of Education - Introduction to Visual Basic – VB.Net Page 80 In the figure above, we have used a UML's (Unified Modeling Language) class diagram to show Inheritance. Here, Shape is the base class while Circle, Rectangle and Curve are its sub-classes.

The Base class usually contains general functionality while the sub-classes possess specific functionality. So, when sub-classing or inheriting, we go 'from specialization to

generalization'.

If class B (sub class) inherits class A (base class), then B would have a copy of all the instance members (fields, methods, properties) of class A, and B can access all the members (except for private members) of class A. Private members of the base class do get inherited in the sub-class but they can not be accessed by the sub-class. Also,

inheritance is said to create a 'type of' relationship among classes which means sub-classes are a type of base class. (If this is not clear, don't worry, things will get more clear when we

Inheritance in VB.Net

Before we go on to implementation, here are some key-points regarding inheritance in VB.Net

• VB.Net, like C#, Java and contrary to C++, allows only single class inheritance.

Multiple inheritance of classes is not allowed in VB.Net

• The Object class defined in the System namespace is implicitly the ultimate base class of all the classes in VB.Net (and the .Net framework)

• Interfaces, in VB.Net, can inherit more than one interface. So, multiple inheritance of interfaces is allowed in VB.Net (again similar to C# and Java). We will see interfaces in detail in the coming lessons

• Structures in VB.Net, can only inherit (or implement) interfaces and can not be inherited.

Author's Note: Technically, a class inherits another class while it

implements an interface. It is technically wrong to say that class A inherits interface B. Rather, it should be 'class A implements interface B'. Although, many write-ups don't follow this path, I would recommend using the word

'inherits' only where it makes sense.

VB.Net uses the Inherits keyword to indicate inheritance. Suppose we have a class named Student with the following fields; mRegistrationNumber, mName and mDateOfBirth along with the corresponding properties. The class also has a function called GetAge() which calculates and returns the age of a Student.

Class Student

' private Fields

Private mRegistrationNumber As Integer Private mName As String

Private mDateOfBirth As DateTime ' Student Constructor

Public Sub New()

Console.WriteLine("New student created. Parameter less constructor called...") End Sub

Public Sub New(ByVal pRegistrationNumber As Integer, ByVal pName As String, ByVal pDateOfBirth As DateTime)

mRegistrationNumber = pRegistrationNumber mName = pName

mDateOfBirth = pDateOfBirth

Console.WriteLine("New Student Created.Parameterized constructor called...") End Sub

' public Properties

Public ReadOnly Property RegisterationNumber() As Integer Get

Return mRegistrationNumber End Get

End Property

Public Property Name() As String Get

Return Name End Get

Set(ByVal Value As String) Name = Value

End Set End Property

Public Property DateOfBirth() As DateTime Get

Return DateOfBirth End Get

Set(ByVal Value As DateTime) DateOfBirth = Value End Set

End Property ' public Function

Public Function GetAge() As Integer

Dim age As Integer = DateTime.Now.Year - DateOfBirth.Year Return age

End Function End Class

The Student class above is very simple. We have defined three Private fields, their accessor properties and one function to calculate the age of a student. We have defined two

constructors: the first one takes no parameters and the other takes the values of three parameters. Note that we have only defined the Get property of mRegistrationNumber since

mRegistrationNumber once it is assigned through constructor. Also, note that we did not make GetAge() a property but a function. The reason for this is that properties are generally supposed to be accessors for getting/setting values of fields and not for

calculating/processing data. Hence, it makes sense to declare GetAge() as a function.

Let us declare another class named SchoolStudent that inherits the Student class but with additional members such as marks of different subjects and methods for calculating total marks and percentages.

Class SchoolStudent Inherits Student ' Private Fields

Private mTotalMarks As Integer

Private mTotalObtainedMarks As Integer Private mPercentage As Double

' Public Constructors Public Sub New()

Console.WriteLine("New school student created. Parameter less constructor called...")

End Sub

Public Sub New(ByVal pRegNum As Integer, ByVal pName As String, ByVal pDob As DateTime, _

ByVal pTotalMarks As Integer, ByVal pTotalObtainedMarks As Integer) ' call to base class constructor

MyBase.New(pRegNum, pName, pDob) mTotalMarks = pTotalMarks

mTotalObtainedMarks = pTotalObtainedMarks

Console.WriteLine("New school student is created. Parameterized constructor called...")

End Sub

' Public Properties

Public Property TotalMarks() As Integer Get

Return mTotalMarks End Get

Set(ByVal Value As Integer) mTotalMarks = Value End Set

End Property

Public Property TotalObtainedMarks() As Integer Get

Return mTotalObtainedMarks End Get

Set(ByVal Value As Integer) mTotalObtainedMarks = Value End Set

End Property ' Public Function

Public Function GetPercentage() As Double

mPercentage = TotalObtainedMarks / TotalMarks * 100 Return mPercentage

End Function End Class

Our SchoolStudent class inherits Student class by using the Inherits keyword Class SchoolStudent

The SchoolStudent class inherits all the members of the Student class. In addition, it also declares its own members: three private fields (mTotalMarks, mTotalObtainedMarks and mPercentage) with their corresponding properties, two constructors (a parameter less one and a parameterized one) and one instance the function (GetPercentage()). For now, forget about the second (parameterized) constructor of our SchoolStudent class. Lets make our Test Module and Main() method.

' program to demonstrate inheritance Module Test

Public Sub Main()

Dim st As New Student(1, "Fraz", New DateTime(1980, 12, 19)) Console.WriteLine("Age of student, {0}, is {1}" & vbCrLf, _ st.Name, st.GetAge())

Dim schStd = New SchoolStudent() schStd.Name = "Newton"

schStd.DateOfBirth = New DateTime(1981, 4, 1) schStd.TotalMarks = 500

schStd.TotalObtainedMarks = 476

Console.WriteLine("Age of student, {0}, is {1}. {0} got {2}% marks.", _ schStd.Name, schStd.GetAge(), schStd.GetPercentage())

End Sub End Module

In the Main() method, first we made an object of the Student class (st) and printed the name and age of a Student st. Next, we made an object of the SchoolStudent class

(schStd). Since, we used parameter less constructor to instantiate schStd, we set the values of its fields through properties and then printed the name, age and percentage of

SchoolStudent (schStd). Note that we are able to access the properties Name and

DateOfBirth (defined in Student class) because our SchoolStudent class is inherited from the Student class, thus inheriting the public properties too. When we execute the above

program, we get the following output

New Student Created. Parameterized constructor called...

Age of student, Fraz, is 24

New student created. Parameter less constructor called...

New school student created. Parameter less constructor called...

Age of student, Newton, is 23. Newton got 95.2% marks.

Press any key to continue

The output of the first two lines is as expected. But, notice the output when we create the SchoolStudent object. First, the parameter less constructor of Student is called and then the constructor of SchoolStudent is called.

New student created. Parameter less constructor called...

New school student created. Parameter less constructor called...

Infact, when we instantiate the sub-class (SchoolStudent), the compiler first instantiates the base-class (Student) by calling one of its constructors and then calls the constructor of the sub-class. Suppose now we want to use the second constructor of the SchoolStudent class.

For this, we need to comment the line with the MyBase keyword in SchoolStudent's second constructor declaration and make other changes as below:

Public Sub New(ByVal pRegNum As Integer, ByVal pName As String, ByVal pDob As DateTime,

ByVal pTotalMarks As Integer, ByVal pTotalObtainedMarks As Integer) ' call to base class constructor

' MyBase.New(pRegNum, pName, pDob) Me.Name = pName

Me.DateOfBirth = pDob mTotalMarks = pTotalMarks

mTotalObtainedMarks = pTotalObtainedMarks

Console.WriteLine("New school student is created. Parameterized constructor called...")

End Sub

This constructor takes as parameters the fields defined by SchoolStudent and those defined by its base class (Student). Also it sets the values accordingly using properties. Now, we need to change the Main method as

Public Sub Main()

Dim schStd As New SchoolStudent(2, "Newton", _ New DateTime(1983, 4, 1), 500, 476)

Console.WriteLine("Age of student, {0}, is {1}. {0} got {2}% marks.", _ schStd.Name, schStd.GetAge(), schStd.GetPercentage())

End Sub

In the Main() method, we made an object of SchoolStudent using a parameterized constructor and then printed the name, age and percentage of the SchoolStudent. The output of the program is

New student created. Parameter less constructor called...

New school student is created. Parameterized constructor called...

Age of student, Newton, is 21. Newton got 95.2% marks.

Press any key to continue

Look at the constructor calls as shown in the output. First, the parameter less constructor of base-class (Student) is called and then the parameterized constructor of sub-class

(SchoolStudent) class is called. It shows that the compiler does create an object of the base class before it instantiates the sub-class.

Now, let us comment the parameterless constructor of the Student class Class Student

...

' Student Constructor 'Public Sub New()

' Console.WriteLine("New student created. Parameter less constructor called...")

...

End Class

Now, when we try to compile the program, we get the error

First statement of this 'Sub New' must be a call to 'MyBase.New' or 'MyClass.New' because base class 'VBDotNetSchoolLesson4.Student' of

'VBDotNetSchoolLesson4.SchoolStudent' does not

have an accessible 'Sub New' that can be called with no arguments.

The compiler is unable to find the zero argument (parameter less) constructor of the base- class. What should be done here?

Keyword MyBase - Calling Constructors of a base-class explicitly

We can explicitly call the constructor of a base-class using the keyword MyBase.

MyBase.New must be the first line of constructor body like Class SubClass

Inherits BaseClass

Public Sub New(ByVal id As Integer)

MyBase.New()' explicit base class constructor call ' some code goes here

End Sub End Class

In the code above, the parameterized constructor of sub-class (SubClass) is explicitly calling the parameter less constructor of base class. We can also call the parameterized constructor of base-class through the MyBase keyword, like

Class SubClass Inherits BaseClass

Public Sub New(ByVal id As Integer)

MyBase.New(id)' explicit base class constructor call ' some code goes here

End Sub End Class

The constructor of SubClass-> New(int) will explicitly call the constructor of the base-class (BaseClass) that takes an Integer argument.

Lets practice with our SchoolStudent class again. Revert the changes we made to its second constructor configuration and make it looks like below

Public Sub New(ByVal pRegNum As Integer, ByVal pName As String, ByVal pDob As DateTime,

ByVal pTotalMarks As Integer, ByVal pTotalObtainedMarks As Integer) ' call to base class constructor

MyBase.New(pRegNum, pName, pDob) mTotalMarks = pTotalMarks

mTotalObtainedMarks = pTotalObtainedMarks

Console.WriteLine("New school student is created. Parameterized constructor called...")

The constructor above calls the parameterized constructor of the base-class (Student), delegating the initialization of inherited fields to the base-class's parameterized constructor.

Public Sub New(ByVal pRegistrationNumber As Integer, ByVal pName As String, _ ByVal pDateOfBirth As DateTime)

mRegistrationNumber = pRegistrationNumber mName = pName

mDateOfBirth = pDateOfBirth

Console.WriteLine("New Student Created. Parameterized constructor called...") End Sub

This is also important as the field mRegistrationNumber is Private and provides the Get public property only. So, in no way, we can assign mRegistrationNumber of a student except for calling a constructor. MyBase.New best fits this scenario.

The Main() method would be like Public Sub Main()

Dim schStd As New SchoolStudent(2, "Newton",New DateTime(1983, 4, 1), 500,476) Console.WriteLine("Age of student, {0}, is {1}. {0} got {2}% marks.", schStd.Name, schStd.GetAge(), schStd.GetPercentage()) End Sub

When we run this program, following output is displayed on console New Student Created. Parameterized constructor called...

New school student is created. Parameterized constructor called...

Age of student, Newton, is 20. Newton got 95.2% marks.

Press any key to continue

You can see from the output above that first the parameterized constructor of the Student (base-class) is called and then the parameterized constructor of the SchoolStudent (sub- class) is called and sets the appropriate values. This is exactly what we wanted to do. It then simply prints the name, age and percentage of SchoolStudent.

Note that although we write MyBase after the sub-class's constructor declaration, the constructor of the base-class is always called before the constructor of the sub-class.

Author's Note: VB.Net's MyBase keyword is similar to C#'s base and Java's super keyword. However C# has adopted the syntax of MyBase from Java's super constructor calls.

Within the Student class, mRegistrationNumber is made Private with only the Get property set, so that no user of the Student class can modify the mRegistrationNumber from outside the class. It may be possible that we need to modify this field (mRegistrationNumber) in the SchoolStudent class but we can not do this. VB.Net provides the Protected access modifier just for this. Protected members of a class can be accessed either inside the containing class or inside its sub-class. Users still won't be able to call the Protected members through

object references and if one tries to do so, the compiler will complain and generate an error.

Suppose we have a class A with a protected method DoWork() Class A

Protected Sub DoWork()

Console.WriteLine("DoWork called...") End Sub

End Class

If we try to call DoWork in the Main() method of the Test module, the compiler will generate an error

Module Test

Sub Main()

Dim aObj As new A() aObj.DoWork()

End Sub

End Module

When we try to compile it, the compiler says

'VBDotNetSchoolLesson4.A.Protected Sub DoWork()' is not accessible in this context because it is 'Protected'.

But, if we declare another class B which inherits A. This class can call the DoWork() method inside its body

Class B

Inherits A Public Sub New() DoWork() End Sub End Class

here, we inherited the class B from A and called DoWork() of its base-class (A) in its constructor. Now, when we write

Public Sub Main()

Dim bObj As New B() End Sub

DoWork called...

Press any key to continue

This shows that we can access the Protected members of a class inside its sub-classes. Note that it is still an error to try and compile the following

Sub Main()

Dim bObj As new B()

bObj.DoWork() ' error

End Sub

We can not access Protected members, even with the reference of the sub-class.

Protected Friend Access Modifier

In a similar way, the Protected Friend access modifier allows a member (field, property and method) to be accessed

• Inside the containing class, or

• Inside the same project, or

• Inside the sub-class of containing class.

Hence, the Protected Friend acts like 'Protected OR Friend', i.e., either protected or friend.

The NotInheritable class

Finally, if you don't want your class to be inherited by any classes, you can mark it with the NotInheritable keyword. No class can inherit from a NotInheritable class.

NotInheritable Class A ...

End Class

If one tries to inherit another class B with class A Class B

Inherits A ...

End Class

The compiler will generate following error:

'B' cannot inherit from class 'A' because 'A' is declared 'NotInheritable'.

Author's Note: VB.Net's NotInheritable keyword is identical to C#'s sealed and Java's final keyword when applied to classes.

The Object class - ultimate base of all classes

In VB.NET (and the .NET framework) all the types (classes, structures and interfaces) are implicitly inherited from the Object class defined in the System namespace. This class provides the low-level services and general functionality to each and every class in the .NET framework. The Object class is extremely useful when it comes to polymorphism (which we

What is the basic difference between And and AndAlso, Camel and Pascal

We saw that constructors are called in the order from top to bottom (parent to child class) in inheritance hierarchy. In which order are the Finalize() called