Contenido

1. FUNDAMENTOS DE VISUAL BASIC .NET ............................................................................................................... 3

1.1. MOSTRAR DATOS POR LA PANTALLA.......................................................................................................... 3
1.2. EXPRESIONES ARITMÉTICAS ........................................................................................................................... 3
1.3. LEER DATOS DE PANTALLA ............................................................................................................................. 4
1.4. EXPRESIONES CONDICIONALES ..................................................................................................................... 4
1.5. ESCRIBIR NUESTROS PROPIOS PROCEDIMIENTOS ............................................................................... 5
2. INTRODUCCIÓN A LA POO........................................................................................................................................... 6
2.1. Clases y objetos ....................................................................................................................................................... 7
2.2. Mensajes y métodos .............................................................................................................................................. 7
2.3. DISEÑO DE UNA CLASE DE OBJETOS ............................................................................................................ 7
2.3.1. Atributos ............................................................................................................................................................... 8
 1. FUNDAMENTOS DE VISUAL BASIC .NET
1.1. MOSTRAR DATOS POR LA PANTALLA
La biblioteca de Visual Basic .NET proporciona un método, System.Console.WriteLine, vinculado con
la salida estándar, normalmente la pantalla, que permite visualizar datos numéricos de cualquier tipo
y cadenas de caracteres.
El siguiente ejemplo declara tres variables numéricas a, b y c, y una referencia s a una cadena de
caracteres; después asigna valores a las variables y finalmente los muestra.

Module MostrarDatos
Sub Main()
Dim a, b As Double
Dim c As Integer
Dim s As String
a = 3.14
b = 2.71
c = 2
s = "Datos"
System.Console.WriteLine(s & ": ")
System.Console.WriteLine(" a = " & a)
System.Console.WriteLine(" b = " & b)
System.Console.WriteLine(" c = " & c)
System.Console.Read()
End Sub
End Module

Observe que, para mostrar los datos deseados, el procedimiento Main invoca al método WriteLine de
la clase Console del espacio de nombres System de la biblioteca .NET.

1.2. EXPRESIONES ARITMÉTICAS

Una expresión es un conjunto de operandos unidos mediante operadores para especificar una
operación determinada. Todas las expresiones cuando se evalúan retornan un valor.
Visual Basic .NET define siete operadores aritméticos, que son los siguientes:

Operación Tipo de Operandos Tipo del Resultado

+ Suma
Los operandos pueden
- Resta Retorna el tipo del operando menos preciso.
ser enteros o reales
* Multiplicación
/ División Real El resultado es de tipo Double, excepto
cuando un operando es Single y el otro no es
Los operandos pueden Double, en este caso el resultado será Single,
ser enteros o reales o bien si ambos operandos son de tipo
Decimal, entonces será Decimal.
\ División Entera El resultado es entero en todos los casos.
 Mod Residuo Si ambos operandos son enteros el resto
será entero; en otro caso, el resto será real.
^ Exponenciación Los operandos a y b El resultado s Double
ab pueden ser enteros o
reales. Si a es negativo,
b tiene que ser entero.
Cuando en una operación aritmética los operandos son de diferentes tipos, ambos son convertidos al
tipo del operando de precisión más alta.
En una asignación, el resultado obtenido en una operación aritmética es convertido implícita o
explícitamente al tipo de la variable que almacena dicho resultado.
Así mismo, cuando en una expresión intervienen varios operadores aritméticos se ejecutan de
izquierda a derecha y de mayor a menor prioridad.

1.3. LEER DATOS DE PANTALLA

Para leer datos ingresados por el usuario en pantalla se una el método System.Console.ReadLine().
Este método permite asignar el valor leído en una variable, el valor leído tomara el tipo de la variable
a la que es asignado

1.4. EXPRESIONES CONDICIONALES

Una expresión condicional consiste en una o varias comparaciones y devuelve un valor verdadero
(TRUE) o falso (FALSE).
Operadores relacionales o de Comparación

 < ¿Primer operando menor que el segundo?

 > ¿Primer operando mayor que el segundo?
 <= ¿Primer operando menor o igual que el segundo?
 >= ¿Primer operando mayor o igual que el segundo?
 <> ¿Primer operando distinto que el segundo?
 = ¿Primer operando igual que el segundo?
En ocasiones interesará dirigir el flujo de ejecución de un programa por un camino u otro en función
del valor de una expresión. Para ello, Visual Basic .NET proporciona la sentencia If…Else (Si…Si no)
Para ver cómo se utiliza esta sentencia, vamos a realizar un programa que verifique si un número es
par. En caso afirmativo imprimirá un mensaje “Número par” y si no es afirmativo imprimirá un
mensaje “Número impar”.
Module OperadoresDeRelacion
Sub Main()
Dim num As Integer
System.Console.Write("Ingrese un Número: ")
num = System.Console.ReadLine()
If num Mod 2 = 0 Then 'si el resto de la división es igual a 0,
System.Console.WriteLine("Número par")
Else 'si el resto de la división no es igual a 0,
System.Console.WriteLine("Número impar")
End If
System.Console.Read()
End Sub
End Module
La sentencia If de este otro ejemplo se interpreta así: si la condición especificada, num Mod 2 = 0, es
cierta, se invoca a WriteLine y se escribe “Número par” y si no, se invoca a WriteLine y se escribe
“Número impar”. En cualquiera de los dos casos se continúa con la siguiente sentencia del programa.

1.5. ESCRIBIR NUESTROS PROPIOS PROCEDIMIENTOS

De la misma forma que la biblioteca .NET proporciona métodos predefinidos como WriteLine (un
procedimiento definido en una clase generalmente se le denomina método), nosotros también
podemos añadir a nuestro programa nuestros propios procedimientos e invocarlos de la misma
forma que lo hacemos con los predefinidos.
Por ejemplo, en el programa siguiente el procedimiento Main muestra la suma de dos valores
cualesquiera; dicha suma la obtiene invocando a un procedimiento sumar añadido por nosotros que
recibe en sus parámetros x e y los valores a sumar, realiza la suma de ambos y, utilizando la sentencia
Return, devuelve el resultado solicitado por Main.

Module Aritmetica
' Procedimiento sumar:
' parámetros x e y de tipo Double
' devuelve x + y
'

Function sumar(ByVal x As Double, ByVal y As Double) As Double

Dim resultado As Double = 0
resultado = x + y
Return resultado
End Function

Sub Main()
Dim a, b, r As Double
System.Console.Write("Ingrese el valor1: ")
a = System.Console.ReadLine()
System.Console.Write("Ingrese el valor2: ")
b = System.Console.ReadLine()
r = sumar(a, b) 'llamado a la función sumar
System.Console.WriteLine("Valor1 + Valor2 = " & r)
System.Console.Read()
End Sub
End Module

Si un procedimiento empieza con la palabra reservada Function es porque retorna un valor; en este
caso su bloque de código finaliza con End Function. Y si empieza con Sub es porque no retorna un
valor; en este caso su bloque de código finaliza con End Sub.
Ejercicios de la Unidad
1. Escriba una aplicación que visualice en el monitor los siguientes mensajes:
Bienvenido al mundo de Visual Basic.
Podrás dar solución a muchos problemas.

2. Decida qué tipos de valores necesita para escribir un programa que calcule la suma y la media
de cuatro números de tipo Integer. Escriba un programa como ejemplo.
3. Escriba un programa que incluya un procedimiento denominado calcular que devuelva como
resultado el valor de la expresión:

2. INTRODUCCIÓN A LA POO
La programación orientada a objetos (POO) es un modelo de programación que utiliza objetos, ligados
mediante mensajes, para la solución de problemas. La idea central es simple: organizar los programas
a imagen y semejanza de la organización de los objetos en el mundo real.
¿A qué objetos nos referimos? Veamos un ejemplo. Considere una entidad bancaria. En ella
identificamos entidades que son cuentas: cuenta del cliente 1, cuenta del cliente 2, etc. Pues bien, una
cuenta puede verse como un objeto que tiene unos atributos, nombre, número de cuenta y saldo, y un
conjunto de métodos como IngresarDinero, RetirarDinero, AbonarIntereses, SaldoActual,
Transferencia, etc. Ordenar una transferencia de una cuenta a otra podría hacerse así:
cuenta01.Transferencia(cuenta02)

Transferencia sería el mensaje que el objeto cuenta02 envía al objeto cuenta01, solicitando le sea
hecha una transferencia, siendo la respuesta a tal mensaje la ejecución del método Transferencia.
Trabajando a este nivel de abstracción, manipular una entidad bancaria resultará muy sencillo.
 2.1. Clases y objetos
Del ejemplo expuesto anteriormente podemos deducir que la POO se basa en la observación de que,
en el mundo real, los objetos se construyen a partir de otros objetos. La combinación de estos objetos
es un aspecto de dicha programación, pero también incluye mecanismos y características que hacen
que la creación y el uso de objetos sea sencillo y flexible. Un mecanismo importantísimo es la clase, y
el encapsulamiento y la herencia son dos propiedades o características poderosas.
¿Qué es una clase de objetos? Pongamos un ejemplo: piense en un molde para hacer flanes; el molde
es la clase y los flanes los objetos. Esto es, si disponemos de un molde de un litro para hacer flanes de
vainilla (ingredientes: leche, vainilla, azúcar, etc.), el molde agrupa las propiedades comunes a todos
los flanes de vainilla, pero no todos los flanes tienen por qué tener la misma cantidad de cada
ingrediente. Esto es, una clase equivale a la generalización de un tipo específico de objetos, pero cada
objeto que construyamos de esa clase tendrá sus propios datos.
Un objeto de una determinada clase se crea en el momento en que se invoca al operador New para
dicha clase. Por ejemplo, la siguiente línea crea un objeto de la clase o tipo CCuenta y asigna a la
variable cuenta01 una referencia al mismo.
Dim cuenta01 As CCuenta = New CCuenta() ' nueva cuenta

Cuando se escribe un programa utilizando un lenguaje orientado a objetos, no se definen objetos

verdaderos, se definen clases de objetos, donde una clase se ve como una plantilla para múltiples
objetos con características similares.

2.1.1. Mensajes y métodos

Cada Objeto es una entidad que tiene unas propiedades particulares, los atributos, y unas formas de
operar sobre ellos, los métodos. Por ejemplo, una ventana de una aplicación Windows es un objeto.
El color de fondo, la anchura, la altura, etc. Son atributos. Las rutinas, lógicamente transparentes al
usuario, que permiten maximizar la ventana, minimizarla, etc. son los métodos.
Cuando se ejecuta un programa orientado a objetos, los objetos están recibiendo, interpretando y
respondiendo a mensajes de otros objetos. En la POO un mensaje está asociado con un método, de tal
forma que cuando un objeto recibe un mensaje la respuesta a ese mensaje es ejecutar el método
asociado.
Un método se escribe en una clase de objetos y determina cómo tiene que actuar el objeto cuando
recibe el mensaje vinculado con ese método. A su vez, un método puede también enviar mensajes a
otros objetos solicitando una acción o información. En adición, los atributos definidos en la clase
permitirán almacenar información para dicho objeto.

2.2. DISEÑO DE UNA CLASE DE OBJETOS

Cuando escribimos un programa orientado a objetos, lo que hacemos es diseñar un conjunto de clases,
desde las cuales se crearán los objetos necesarios cuando el programa se ejecute. Cada una de estas
clases incluye dos partes fácilmente diferenciables: los atributos y los métodos. Los atributos definen
el estado de cada uno de los objetos de esa clase y los métodos su comportamiento.
Normalmente, los atributos, la estructura más interna del objeto, se ocultan a los usuarios del objeto,
manteniendo como única conexión con el exterior los mensajes.
Esto quiere decir que los atributos de un objeto solamente podrán ser manipulados por los métodos
del propio objeto.
Podemos crear una clase de objetos CCuenta que represente una cuenta bancaria.
Class CCuenta
' Cuerpo de la clase: atributos y métodos
End Class

2.2.1. Atributos
Los atributos son las características individuales que diferencian un objeto de otro.
Pensando en la clase de objetos CCuenta, elegimos los atributos de interés que van a definir esta clase
de objetos:

 _nombre: nombre del cliente del banco al que pertenece la cuenta.

 _cuenta: número de la cuenta.
 _saldo: saldo actual de la cuenta.
 _tipoDeInteres: tipo de interés en tanto por cien.
Todos los atributos son definidos en la clase por variables:
Class CCuenta
Private _nombre As String
Private _cuenta As String
Private _saldo As Double
Private _tipoDeInteres As Double
' ...
End Class
Un miembro declarado privado (Private) es accesible solamente por los métodos de su propia clase.
Esto significa que no se puede acceder a él por los métodos de cualquier otra clase, incluidas las
subclases.

2.2.2. Propiedades y métodos

El comportamiento de un objeto queda definido por las acciones que puede emprender. Por ejemplo,
pensando acerca de un objeto de la clase CCuenta, esto es, de una cuenta de un cliente de un
determinado banco, algunas acciones que se pueden realizar sobre ella son: