VB.NET Classes and Object

A class is a group of different data members or objects with the same properties, processes, events of an object, and general relationships to other member functions. Furthermore, we can say that it is like a template or architect that tells what data and function will appear when it is included in a class object. For example, it represents the method and variable that will work on the object of the class.

Objects are the basic run-time units of a class. Once a class is defined, we can create any number of objects related to the class to access the defined properties and methods. For example, the Car is the Class name, and the speed, mileage, and wheels are attributes of the Class that can be accessed by the Object.

Creating the Class

We can create a class using the Class keyword, followed by the class name. And the body of the class ended with the statement End Class. Following is the general syntax for creating classes and objects in the VB.NET programming language.

[ Access_Specifier ] [ Shadows ] [ MustInherit | NotInheritable ] [ Partial ] Class ClassName
' Data Members or Variable Declaration
' Methods Name
' Statement to be executed
End Class

Where,

Access_Specifier: It defines the access levels of the class, such as Public, Private or Friend, Protected, Protected Friend, etc. to use the method. (It is an optional parameter).
Shadows: It is an optional parameter. It represents the re-declaration of variables and hides an identical element name or set of overloaded elements in a base class.
MustInherit: It is an optional parameter that specifies that the class can only be used as a base class, and the object will not directly access the base class or the abstract class.
NotInheritable: It is also an optional parameter that representing the class not being used as a base class.
Partial: As the name defines, a Partial represents the partial definition of the class (optional).
Implements: It is used to specify interfaces from which the class inherits (optional).

My_program.vb

Public Class My_program
' properties, method name, etc
' Statement to be executed
End Class

In the above syntax, we have created a class with the name 'My_program' using the Class keyword.

The Syntax for creating an object

Dim Obj_Name As Class_Name = New Class_Name() ' Declaration of object
Obj_Name.Method_Name() ' Access a method using the object

In the above syntax, we have created an instance (Obj_Name) for the class Class_Name. By using the object name 'Obj_Name' to access all the data members and the method name of Class_Name.

Let's create a program to find the Area and Parameter of a rectangle using the class and object in VB.NET.

My_program.vb

Imports System
Module My_program
    Sub Main()
        Dim rect As Rectangle = New Rectangle() 'create an object
        Dim rect2 As Rectangle = New Rectangle() 'create an object
        Dim area, para As Integer

        'rect specification
        rect.setLength = (5)
        rect.setBreadth= (6)

        'rect2 specification
        rect2.setLength = (5)
        rect2.setBreadth = (10)

        'Area of rectangle 
        area = rect.length * rect.Breadth
        'area = rect.GetArea()
        Console.WriteLine(" Area of Rectangle is {0}", area)

        'Parameter of rectangle 
        'para = rect.GetParameter()
         para = 2 (rect2.length + rect.Breadth)
        Console.WriteLine(" Parameter of Rectangle is {0}", para)
        Console.WriteLine(" Press any key to exit...")
        Console.ReadKey()
    End Sub
    Public Class Rectangle
        Public length As Integer
        Public Breadth As Integer

        Public Sub setLength(ByVal len As Integer)
            length = len
        End Sub

        Public Sub setBreadth(ByVal bre As Integer)
            Breadth = bre
        End Sub
        Public Function GetArea() As Integer
            Return length * Breadth
        End Function

        Public Function GetParameter() As Integer
            Return 2 * (length + Breadth)
        End Function
    End Class
End Module

Output:

Member Function

The member function of a class is used to define the structure of member inside the definition of the class. It can be accessed by all defined objects of the class and operated on the data member. Furthermore, member variables are the attributes of an object to be implemented to a member function. And we can access member variables using the public member function.

Constructor and Destructor

In VB.NET, the constructor is a special method that is implemented when an object of a particular class is created. Constructor is also useful for creating and setting default values for a new object of a data member.

When we create a class without defining a constructor, the compiler automatically creates a default constructor. In this way, there is a constructor that is always available in every class. Furthermore, we can create more than one constructor in a class with the use of New keyword but with the different parameters, and it does not return anything.

Default Constructor: In VB.NET, when we create a constructor without defining an argument, it is called a default constructor.

VB.NET Default Constructor Syntax

The following is the syntax for creating a constructor using the New keyword in VB.NET.

Public Class MyClass
' Creates a Constructor using the New       
Public Sub New()
	'Statement to be executed
       End Sub
End Class 

Let's create a program to define the default constructor in a VB.NET programming language.

Default_Const.vb

Imports System
Module Default_Const
    Class Tutor
        Public name As String
        Public topic As String
        ' Create a default constructor
        Public Sub New()
            name = "JavaTpoint"
            topic = "VB.NET Tutorial"
        End Sub
    End Class
    Sub Main()
        ' The constructor will automatically call when the instance of the class is created
        Dim tutor As Tutor = New Tutor() ' Create an object as a tutor
        Console.WriteLine(" Your Site Name is : {0}", tutor.name)
        Console.WriteLine(" Your Topic Name is : {0}", tutor.topic)
        Console.WriteLine(" Press any key to exit...")
        Console.ReadKey()
    End Sub
End Module

Output:

In the above example, we created a class 'Tutor' and defined a default constructor method with New() keyword without passing any arguments. When the object (tutor) is created, the default constructor is called into the class.

Parameterized Constructor

In VB.NET, when we pass one or more arguments to a constructor, the constructor is known as a parameterized constructor. And the object of the class should be initialized with arguments when it is created.

Let's create a program to use the parameterized constructor to pass the argument in a class.

Para_Const.vb

Imports System
Module Para_Const
    Class Tutor
        Public name As String
        Public topic As String
        ' Create a parameterized constructor to pass parameter
        Public Sub New(ByVal a As String, ByVal b As String)
            name = a
            topic = b
            Console.WriteLine(" We are using a parameterized constructor to pass the parameter")
        End Sub
    End Class
    Sub Main()
        ' The constructor will automatically call when the instance of the class is created
        Dim tutor As Tutor = New Tutor("JavaTpoint", "VB.NET Constructor")
        Console.WriteLine(" Your Site Name is : {0}", tutor.name)
        Console.WriteLine(" Your Topic Name is : {0}", tutor.topic)
        Console.WriteLine(" Press any key to exit...")
        Console.ReadKey()
    End Sub
End Module

Output:

VB.NET Destructor

In VB.NET, Destructor is a special function that is used to destroy a class object when the object of the class goes out of scope. It can be represented as the Finalize() method and does not accept any parameter nor return any value. Furthermore, it can be called automatically when a class object is not needed.

VB.NET Destructor Syntax

Destructor using the Finalize() method in VB.NET.

Class My_Destructor
 ' define the destructor 
    Protected Overrides Sub Finalize()
' Statement or code to be executed 
End Sub
End Class

Let's create a program to use the Finalize() method in VB.NET Destructor.

Destruct.vb

Imports System
Module Destruct
    Class Get_Destroy
        Public Sub New()
            Console.WriteLine(" An Object of the class is being created")
        End Sub
        ' Use Finalize() method of Destructor
        Protected Overrides Sub Finalize()
            Console.WriteLine(" An Object of the class is being destroyed")
            Console.WriteLine(" Press any key to exit")
        End Sub
    End Class

    Sub Main()
        Get_Details() ' After invoking the Get_Details() method, garbage collector is called automatically
        GC.Collect()
        Console.ReadKey()
        End Sub
    Public Sub Get_Details()
        Dim dest As Get_Destroy = New Get_Destroy()
    End Sub
End Module

Output:

Constructor Overloading

In VB.NET, the overloading of constructors is a concept in which we can overload constructors by defining more than one constructor with the same name but with different parameter lists to perform different tasks.

Let's create a program to use the Constructor Overloading in a class.

Const_Over.vb

Imports System
Module Const_Over
    Class Details
        Public name As String
        Public course As String
        ' Define Default Constructor
        Public Sub New()
            name = "Prince"
            course = "Coputer Science"
            Console.WriteLine(" Uses of Overloading Constructor")
        End Sub
        ' Create a parametrized constructor
        Public Sub New(ByVal a As String, ByVal b As String)
            name = a
            course = b
        End Sub
    End Class
    Sub Main()
        ' Called default constructor
        Dim det As Details = New Details()
        ' Called the parametrized constructor 
        Dim det1 As Details = New Details("Peter", "Knowledge of Data Mining")
        Console.WriteLine(" Your Details are: Name : {0} and Course : {1}", det.name, det.course)
        Console.WriteLine(" Your Overloaded Details are: Name : {0} and Course :{1}", det1.name, det1.course)
        Console.WriteLine(" Press any key to exit...")
        Console.ReadKey()
    End Sub
End Module

Output:

Inheritance

In VB.NET, Inheritance is the process of creating a new class by inheriting properties and functions from the old class and extending the functionality of the existing class. It also provides a reusable and faster implementation time of the code. When we create a derived or inherited class, inheritance allows us to inherit all the properties of the existing class. The old class is known as the base class, and the inherited class is known as the derived class.

Inheritance Syntax

The following is the syntax of Inheritance in VB.NET.

<access_modifier> Class <Name_of_baseClass>
' Implementation of base class
End Class
<access_modifier> Class <Name_of_derivedClass>
Inherits Name_of_baseClass
' Implementation of derived class
End Class

Let's create a program to understand the concept of Inheritance in VB.NET

Simple_Inherit.vb

Imports System
Module Simple_Inherit
    Public Class Vehicle
        Public Sub speed()
            Console.WriteLine(" 4 Wheeler cars are more luxurious than 2 Wheeler")
        End Sub

        Public Overridable Sub perform()
            Console.WriteLine(" Both Vehicles are good, but in a narrow lane, two-wheeler are more comfortable than 4-Wheeler")
        End Sub
    End Class

    Class Bike
        Inherits Vehicle
        Public Overrides Sub perform()
            Console.WriteLine(" Two-wheeler are lesser weight as compared to 4 wheeler")
        End Sub
    End Class
    Class Car
        Inherits Vehicle
        Public Overrides Sub perform()
            Console.WriteLine(" It is 4 wheelar car")
        End Sub
    End Class

    Sub Main()
        Dim vehicle As Vehicle = New Vehicle()
        Dim bike As Bike = New Bike()
        Dim car As Car = New Car()
        vehicle = bike
        vehicle.perform()
        vehicle = car
        vehicle.perform()
        Console.WriteLine(" Press any ley to exit...")
        Console.ReadKey()
    End Sub
End Module

Output:

Let's create a program of inheritance using the MyBase in VB.NET.

Inherit_class.vb

Module Inherit_class
    Class Circle   'base class
        Protected radius As Integer
        Public Const PI As Double = 3.14
        Public Sub New(ByVal r As Integer)
            radius = r
        End Sub
        Public Function GetAreaCircle() As Double
            Return (PI * radius * radius)
        End Function
        Public Overridable Sub Show()
            Console.WriteLine(" Radius of circle : {0}", radius)
            Console.WriteLine(" Area of circle is {0}", GetAreaCircle())
        End Sub
    End Class

    'Derived Class
    Class MyDeriveClass : Inherits Circle
        Private dimen As Double
        Public Sub New(ByVal r As Integer)
            MyBase.New(r)
        End Sub
        Public Function Getdimen() As Double
            Dim dimen As Double
            dimen = GetArea() * 50
            Return dimen
        End Function
        Public Overrides Sub Show()
            MyBase.Show()
            Console.WriteLine("Total Cost: {0}", Getdimen())
        End Sub
    End Class

    Class Circle_Class
        Shared Sub Main()
            Dim c As MyDeriveClass = New MyDeriveClass(5)
            c.Show()
            Console.WriteLine("Press any key to exit")
            Console.ReadKey()
        End Sub
    End Class
End Module

Output:

Multi-Level Inheritance

VB.NET only supports single inheritance that means a class can be inherited from the base class. However, VB.NET uses hierarchical inheritance to extend one class to another class, which is called Multi-Level Inheritance. For example, Class C extends Class B, and Class B extends Class A, Class C will inherit the member of both class B and Class A. The process of extending one class to another is known as multilevel inheritance.

Public Class A
     ' implementation of code
End Class

Public Class B
      Inherits A
      ' Implementation of Code
End Class

Public Class C
       Inherits A
       ' Implementation of code
End Class

Let's create a program to understand the concept of Multi-Level Inheritance in VB.NET

Multi_inherit1.vb

Module Multi_inherit1
    Public Class A
        Public SName As String
        Public Sub Display()
            Console.WriteLine(" Name of Student : {0}", SName)
        End Sub
    End Class
    Public Class B
        Inherits A
        Public place As String
        Public Sub GetPlace()
            Console.WriteLine(" Address : {0}", place)
        End Sub
    End Class

    Public Class C
        Inherits B
        Public rollno As Integer
        Public Sub GetRollno()
            Console.WriteLine(" Student Roll no. {0}", rollno)
        End Sub
    End Class

    Class Profile
        Public Sub Main(ByVal args As String())
            Dim c As C = New C()
            c.SName = "Donald Trump"
            c.place = "USA"
            c.rollno = 102
            c.Display()
            c.GetPlace()
            c.GetRollno()
            Console.WriteLine(" Press any key to exit")
            Console.ReadKey()
        End Sub
    End Class
End Module

Output:

Interface

In VB.NET, the interface is similar to a class for inheriting all properties, methods, and events that a class or structure can implement. Using the interface in VB.NET, we can use multiple inheritances of classes. It uses the Implements keyword to implement the interfaces, and the Interface keyword is used to create the interface. All interfaces in VB.NET starts with i.

The Syntax for implementing an interface in a class.

Class MyClass
	Inherits IClass
	Private Sub FetchDetails() Implements IClass.FetchDetails
	' Method Implementation 
	End Sub
End Class

In the above snippets, we inherited an interface (IClass) in the Class MyClass that implemented to the interface method defined in a class.

Let's create and implement an instance using a class in VB.NET.

Get_Interface.vb

Module Get_Interface
    Interface IStudent
        Sub Details(ByVal y As String)
    End Interface
    Class Student
        Implements IStudent
        Public Sub Details(ByVal a As String) Implements IStudent.Details
            '       Throw New NotImplementedException()
            Console.WriteLine(" Name of Student: {0}", a)
        End Sub
    End Class

    Class Student1
        Implements IStudent
        Public Sub Details(ByVal a As String) Implements IStudent.Details
            'Throw New NotImplementedException()
            Console.WriteLine(" Course: {0}", a)
        End Sub
    End Class
    Sub Main(ByVal args As String())
        Dim stud As IStudent = New Student()
        stud.Details(" James Watt")
        Dim stud1 As IStudent = New Student1()
        stud1.Details("Computer Science")
        Console.WriteLine(" Press any key to exit...")
        Console.ReadKey()
    End Sub
End Module 

Output: