OOPS IN VB.

NET
Introduction

Object-Oriented Programming (OOP) is a software development paradigm that suggests

developers to split a program in building blocks known as objects. The OOP paradigm allows
developers to define the object's data, functions, and its relationship with other objects.

Microsoft created the .NET Framework using OOP, and knowing this concepts has helped me to
understand the .NET Framework and to design and develop better software components. The
purpose of this article is to describe the basic OOP concepts using real world scenarios and to
provide some code samples that demonstrate how to work with OOP and .NET.

Class

The most common definition states that a class is a template for an object. Suppose that someone
builds a paper pattern for a shirt. All the shirts done with the same paper pattern will be identical
(same design, size, etc.). In this sample, the paper pattern is the class and the shirt is the object.
To build the same exact shirt over and over, you need the paper pattern as a template. Another
great example are house plans and blueprints. The plans and blueprints define the number of
rooms, the size of the kitchen, the number of floors, and more. In this real world sample, the
house plans and blueprints are the class and the house is the object. In OOP you program a class
as a template for a specific object or groups ob objects that will always have the same features.

Class Members
A class has different members, and developers in Microsoft suggest to program them in the
following order:

Constructors

Constructors are special member functions, which are used for initializing the class data
members. In the earlier object oriented programming languages constructors were quite
important since initialization of the data members was not allowed at the time of declaration. C#
however allows us to have the member variables to be initialized along with declarations. Then
the variables may not always be initialized to some constants but can also be initialized with the
values specified by the user. There can also be certain kind of processing to be done while a class
is instantiated. So a constructor happens to be quite important member function in the class as far
as initialization is concerned.

C# supports following types of constructors

• Default Constructors
• Parameterized constructors
• Private constructors
• Static Constructors

Destructors
C# also supports automatic memory cleanup by having a garbage collector element. So no more
botheration for de-allocating memory from the heap and no more nightmares about dangling
pointers

• Namespace: The namespace is a keyword that defines a distinctive name or last name for
the class. A namespace categorizes and organizes the library (assembly) where the class
belongs and avoids collisions with classes that share the same name.
• Class declaration: Line of code where the class name and type are defined.
• Fields: Set of variables declared in a class block.
• Constants: Set of constants declared in a class block.
 • Constructors: A method or group of methods that contains code to initialize the class.
• Properties: The set of descriptive data of an object.
• Events: Program responses that get fired after a user or application action.
• Methods: Set of functions of the class.
• Destructor: A method that is called when the class is destroyed. In managed
code, the Garbage Collector is in charge of destroying objects; however, in some cases
developers need to take extra actions when objects are being released, such as freeing handles or
deallocating unmanaged objects. In .NET, there is no concept of deterministic destructors. The
Garbage Collector will call the Finalize () method at a non-deterministic time while reclaiming
memory for the application.

Access Keywords

Access keywords define the access to class members from the same class and from other
classes. The most common access keywords are:

• Public: Allows access to the class member from any other class.
• Private: Allows access to the class member only in the same class.
• Protected: Allows access to the class member only within the same class and
from inherited classes.
• Internal: Allows access to the class member only in the same assembly.
• Protected internal: Allows access to the class member only within the same
class, from inherited classes, and other classes in the same assembly.
• Static: Indicates that the member can be called without first instantiating the
class.

Object

Objects are the building blocks of OOP and are commonly defined as variables or data structures
that encapsulate behavior and data in a programmed unit. Objects are items that can be
individually created, manipulated, and represent real world things in an abstract way.

Object composition
Every object is composed by:

• Object identity: Means that every object is unique and can be differentiated from other
objects. Each time and object is created (instantiated) the object identity is defined.
• Object behavior: What the object can do. In OOP, methods work as functions that
define the set of actions that the object can do.
• Object state: The data stored within the object at any given moment. In OOP, fields,
constants, and properties define the state of an object.

Structures

Not everything in the real world should be represented as a class. Structures are suitable to
represent lightweight objects. Structures can have methods and properties and are useful for
defining types that act as user-defined primitives, but contain arbitrary composite fields. The
.NET Framework defines some structures such as System.Drawing.Rectangle,
System.Drawing.Point, and System.Drawing.Color.

Inheritance

In the real world there are many objects that can be specialized. In OOP, a parent class can
inherit its behavior and state to children classes. This concept was developed to manage
generalization and specialization in OOP and is represented by a is-a relationship.

The following OO terms are commonly used names given to parent and child classes in OOP:

• Super class: Parent class.

• Subclass: Child class.
• Base class: Parent class.
• Derived class: Child class

The most common real world sample to explain inheritance is the geometric shapes object
model. Squares, circles, triangles, rectangles, pentagons, hexagons, and octagons are geometric
shapes.
 The concept of generalization in OOP means that an object encapsulates common state an
behavior for a category of objects. The general object in this sample is the geometric shape. Most
geometric shapes have area, perimeter, and color. The concept of specialization in OOP means
that an object can inherit the common state and behavior of a generic object; however, each
object needs to define its own special and particular state and behavior. Inheritance makes code
elegant and less repetitive.

The .NET framework has many base classes. Everything is derived from System.Object. You
can create almost anything you imagine using the built-in functionality provided in the .NET
Framework Class Library.

To create a derived class in C#, the class declaration should be done as:

Class child: parent

To create a derived class in VB.NET, the class declaration should be done as:

Class child
Inherits parent
End Class

Multiple inheritance

Multiple inheritance is the possibility that a child class can have multiple parents. Human beings
have always two parents, so a child will have characteristics from both parents.

In OOP, multiple inheritance might become difficult to handle because it allows ambiguity for
the compiler. There are programming languages such as C++ that allow multiple inheritance;
however, other programming languages such as Java and the .NET Framework languages do not
allow multiple inheritance. Multiple inheritance can be emulated in .NET using Multiple
Interface Inheritance, which I will explain in Part 3 of this series.

Sealed class

A sealed class is a class that does not allow inheritance. Some object model designs need to
allow the creation of new instances but not inheritance, if this is the case, the class should be
declared as sealed.
To create a sealed class in C#, the class declaration should be done as:

sealed class Shape

To create a sealed class in VB.NET, the class declaration should be done as:

Non Inheritable Class Shape

Abstraction

Abstraction is "the process of identifying common patterns that have systematic variations; an
abstraction represents the common pattern and provides a means for specifying which variation
to use".

An abstract class is a parent class that allows inheritance but can never be instantiated. Abstract
classes contain one or more abstract methods that do not have implementation. Abstract classes
allow specialization of inherited classes.

Figure 2 shows a Shape class, which is an abstract class. In the real world, you never calculate
the area or perimeter of a generic shape, you must know what kind of geometric shape you have
because each shape (eg. square, circle, rectangle, etc.) has its own area and perimeter formulas.
The parent class shape forces all derived classes to define the behavior for CalculateArea() and
CalculatePerimeter(). Another great example is a bank account. People own savings accounts,
checking accounts, credit accounts, investment accounts, but not generic bank accounts. In this
case, a bank account can be an abstract class and all the other specialized bank accounts inherit
from bank account.

To create an abstract class in C#, the class declaration should be done as:

abstract class Shape

To create an abstract class in VB.NET, the class declaration should be done as:

MustInherit Class Shape

Polymorphism

Polymorphism allows objects to be represented in multiple forms. Even though classes are
derived or inherited from the same parent class, each derived class will have its own behavior.
Polymorphism is a concept linked to inheritance and assures that derived classes have the same
functions even though each derived class performs different operations.