CHAPTER 2 (Data types,Variables) in Visual Basic Programming

CHAPTER 2:
DATA TYPES,
VARIABLES And
Constants

Variables and Data Types
• A variable is a letter or name that can store a value. More
technically we can define a variable as a pointer to a block of
memory that stores information.
• When you create computer programs, you can use variables to
store numbers, such as the height of a building, or words, such
as a person's name. Simply put, you can use variables to
represent any kind of information your program needs.

• You might ask, "Why use a variable when I could just use the
information instead?" As the name implies, variables can
change the value that they represent as the program is running.
• The information that is stored in a variable is of a certain data
type.
• That data may be an integer like "23", a floating point number
like "23.23", a string like "Hello World!", and many other data
type.
Variables and Data Types

Using a Variable
To use a variable, you must give it a name. There are rules you
should, and usually must, follow when naming your variables.
The name of a variable:
• Must begin with a letter
• Cannot have a period (remember that we use the period to
set a property; in other words the period is an operator)
• Can have up to 255 characters. Please, just because it is
allowed, don't use 255 characters.
• Must be unique inside of the procedure or the module it is
used in.

Good habits with variables
For the sake of making sure other people can look at your code and
know what you were thinking:
• Prefix your variable name with the appropriate prefix for your
variable's data type.
• Make sure the body of your variable name makes it easy to tell
what its used for.
• Don't use an ambiguous name like "intBlabla" or "strX" unless its
use is within a very small scope of the program, and even then try
not to do it much. Try using descriptive names. For example,
IntTotSalary to design the total of a salary.

Visual Basic Data Types
Visual Basic type Common language
runtime type structure
Value range
Boolean Boolean True or False
Byte Byte 0 through 255 (unsigned)
Char (Single
character)
Char 0 through65535 (unsigned)
Date Date and Time 0:00:00 (midnight) on January 1, 0001
through 11:59:59 PM on December 31, 9999
Decimal Decimal -
Double Double -
Integer Int32 -2,147,483,648 through 2,147,483,647
Long (long
integer)
Int64 -9,223,372,036,854,775,808 through
9,223,372,036,854,775,807

Visual Basic type Common language
runtime type structure
Value range
Object Object (class) Any type can be stored in a variable of type
Object
SByte SByte -128 through 127
Short (short
integer)
Int16 -32,768 through 32,767
Single single -
String (Variable
length)
String (class) 0 to approximately 2 billion Unicode
characters
UInteger UInt32 0 through 4,294,967,295
ULong UInt64 0 through 18,446,744,073,709,551,615
UShort UInt16 0 through 65,535
Visual Basic Data Types

There are two principle ways to add variables to your applications.
• implicit declaration : is to let Visual Basic automatically create the variable for you.
For an implicit declaration, Visual Basic automatically creates a variant for each
identifier it recognizes as a variable in an application.
• At first glance, this codes look the same. But because the tempVal variable is
misspelled as the argument to Sqrt, the compiler creates an additional local variable
called temVal, which is never assigned a value, and your function always returns
zero.
Declaring Variables (Implicit Declaration)
Function safeSqrt(num)
' Make sure num is positive for square root.
tempVal = Math.Abs(num)
Return Math.Sqrt(tempVal)
End Function
Return Math.Sqrt(temVal)
End Function

• The second approach to declaring variable is to explicitly declare them with
one of the following keywords: Dim, Static, Private, and Public. The choice
of keyword has a profound effect on the variable’s scope within the
application and determines where the variable can be used in the program.
By default, the Visual Basic compiler enforces explicit declaration (what I also
strongly advice), which requires that you declare every variable before you
use it. You can remove this requirement and permit implicit declaration.
Declaring Variables (Explicit declaration)
Static tempVal as Integer
Return Math.Sqrt(temVal)
End Function
ERROR MESSAGE

Declaring Variables (Explicit declaration)
• Now that you have an understanding of the allowable types in VB .NET, you
need to learn how to use these types in your code.
• To declare a variable, you use a variable declaration statement. The
following is the basic syntax for variable declaration in VB .NET:
• The following would be an example of the variations of the declaration
statement:
Dim intX as Integer
Privat e intX as Integer
Public intX as Integer
Static intX as Integer
Protected intX as Integer
Friend intX as Integer
[ Dim | Public | Protected | Friend | Protected Friend | Private |
Static ] variablename As [ New type] = [expression]

Variable defaults
When you declare a variable of a type without assigning a value to it,
the variable has a default value based on the type of variable you have
assigned as the type. The following are the default values for different
types:
 Numbers: 0 (zero)
 Boolean: False
 String: Nothing
 Object: Nothing
 Date: 12:00:00 AM

Constants
• A constant allows you to use a friendly name for a variable value that does
not change throughout the execution of your application.
• Constants in Visual Basic .NET act exactly as they did in previous versions.
• To declare a constant, you use the Const keyword within a procedure or at
the declarations section of your classes or modules.
• Constants can be declared with the scope of Private, Public, Friend,
Protected, or Protected Friend.
• The following is the usage of the Const statement:
[Public | Private | Friend | Protected | Protected Friend ] Const
constantname As [ New type ] = [expression]

• When you declare a constant, you must declare it as a certain type.
• Constants can be declared as Boolean, Byte, Char, DateTime, Decimal,
Double, Integer, Long, Short, Single, or String data types.
• In the following code, you are declaring several constants and then using
them in the procedure within the module.
Constants
Module Module1
Private Const BillsSalary As Double = 10,000
Private Const MySalary As Byte = 1,000
Private Const strMsg As String = "Try Again Please"
Private Function Test_Salary() As Boolean
If MySalary > BillsSalary Then
Console.WriteLine(strMsg)
End If
End Function
End Module

CHAPTER 2 (Data types,Variables) in Visual Basic Programming

Recommended

More Related Content

Similar to CHAPTER 2 (Data types,Variables) in Visual Basic Programming (20)

More from abacusgtuc (6)

Recently uploaded (20)

CHAPTER 2 (Data types,Variables) in Visual Basic Programming