Documentación del curso de Visual Basic.

Net

Programación Orientada a Objetos

Contenido
Introducción ....................................................................................................................................................... 4
¿Qué es un paradigma de programación? ......................................................................................................... 5
¿Qué es la programación orientada a objetos? ................................................................................................. 5
¿Qué es una clase? ............................................................................................................................................. 5
¿Qué son los atributos de una clase? ............................................................................................................ 6
¿Qué son los métodos de una clase? ............................................................................................................. 6
¿Qué es un objeto? ............................................................................................................................................ 7
¿Qué es el encapsulamiento?............................................................................................................................. 7
Métodos Getters y Setters ............................................................................................................................. 8
¿Para qué sirve un método set? ................................................................................................................ 8
¿Para qué sirve un método get? ................................................................................................................ 8
Propiedades ............................................................................................................................................... 8
¿Para qué sirve un método constructor? ........................................................................................................... 9
¿Qué es la sobrecarga de métodos? .................................................................................................................. 9
¿Qué es la sobrecarga de Constructores? ........................................................................................................ 10
Uso de shared en VB.Net .................................................................................................................................. 10
¿Qué es la asociación?...................................................................................................................................... 11
¿Qué es la Herencia? ........................................................................................................................................ 12
Jerarquía de Herencia .................................................................................................................................. 12
Array de objetos ............................................................................................................................................... 13
¿Qué es una Interfaz? ....................................................................................................................................... 13
Características de las interfaces ................................................................................................................... 13
¿Qué es una Interfaz Predefinida? ............................................................................................................... 14
¿Qué es el polimorfismo? ................................................................................................................................. 14
¿Qué es la Sobre escritura de métodos? .......................................................................................................... 16
Clase Object ...................................................................................................................................................... 16
¿Qué es el Casting? ...................................................................................................................................... 17
¿Qué es una clase abstracta? ........................................................................................................................... 17
Características de una clase abstracta ......................................................................................................... 17
Modificadores de acceso .................................................................................................................................. 18
¿Qué son las excepciones? ............................................................................................................................... 19
Uso de Finally ............................................................................................................................................... 19
¿Qué son los tipos enumerados? ..................................................................................................................... 20
 Introducción
Qué bien, entramos ya a el capítulo más importante de este curso, el en cual vamos a comprender
el paradigma de la Programación Orientada a Objetos, puesto que el lenguaje que estamos
estudiando, es un lenguaje orientado a objetos, es decir que a lo largo de este curso hemos realizado
alguna instrucción de código que tiene una relación con algún concepto de este paradigma.
¿Qué es un paradigma de programación?
Un paradigma de programación, es un modelo o estilo de programación. A lo largo del curso hemos
utilizado un paradigma llamado secuencial, es decir, que las instrucciones las realizamos una debajo
de otra, y el programa las ejecuta tal cual como las colocamos.

¿Qué es la programación orientada a objetos?

Es un paradigma de programación que pretende imitar a los objetos de la vida real o parte de ellos
en código de programación. Es decir, que este modelo trata desde la programación simular el
mundo como lo conocemos mediante los objetos de la vida cotidiana, por ejemplo, un aire
acondicionado es un objeto, que cuenta con características (atributos) y acciones (métodos), o bien
un objeto abstracto (es decir que no tiene cuerpo físico) como una cuenta bancaria, que también
cuenta con características y acciones.

¿Qué es una clase?

Una clase tiene como propósito categorizar un grupo de objetos en común, de modo que sirva como
plantilla para la posterior creación de objetos.
¿Qué son los atributos de una clase?
Los atributos hacen referencia a las características de nuestra clase, por ejemplo, de la clase
AireAcondicionado, podemos abstraer atributos como marca, modelo, color, voltaje entre otros.

Ahora bien, al concepto de la POO para obtener las características o atributos de una clase se le
denomina Abstracción, que consiste en colocar los atributos que sean necesarios en nuestra clase,
teniendo en cuenta las necesidades del sistema.

¿Qué son los métodos de una clase?

Los métodos hacen referencia a las acciones que puede realizar un objeto, tomando de nuevo como
referencia la clase AireAcondicionado, podemos realizar preguntas como, ¿Qué acciones puede
hacer un Aire acondicionado?, aunque en el desarrollo de un proyecto las acciones de un objeto se
rigen por los requerimientos funcionales que se obtuvieron antes del diseño del mismo.

Figure 1.Ejemplo de una clase en Diagrama de clases UML.

¿Qué es un objeto?
Un objeto es una instancia o ejemplar de una clase, siendo dicho objeto al que se le establecen o
asignan los valores de los atributos.

Figure 2.Instancia o creación de un objeto en Diagrama de clases UML.

¿Qué es el encapsulamiento?
El encapsulamiento, consiste en ocultar los atributos o características de un objeto, para que estos
no sean accedidos desde otros objetos, de modo que, al utilizar el objeto este cumpla con las
operaciones por la cual fue creado, pero ocultando el funcionamiento interno del mismo a los
objetos que interactúan entre sí.

Por lo tanto, se hace necesario ocultar esas propiedades funcionales de nuestros objetos, no solo
por convención, si no para evitar que los modifiquen y pierdan su funcionalidad.

Para utilizar este concepto en Visual Basic. Net, tenemos que utilizar el modificador de acceso
Private en los atributos de nuestras clases.

Figure 3.Ejemplo de encapsulamiento en Diagrama de clases UML.

Métodos Getters y Setters
Estos métodos permiten el acceso y modificación de los atributos de una clase, dentro de
las pautas de las buenas prácticas en el paradigma orientado a objetos(encapsulación), es
decir, se pueden acceder a dichos atributos usando métodos de retorno como lo es el
Procedimiento Function de y de procedimientos de no retorno como los son los
Procedimientos Sub.

¿Para qué sirve un método set?

El método Set, permite modificar el valor de un atributo por medio de un procedimiento
Sub, que recordemos que no devuelven ningún valor, los cuales son propicios para la
modificación de las características de una clase.

¿Para qué sirve un método get?

El método Get, nos permiten acceder a los valores de los atributos, por medio de un
Procedimiento Function, cuyo valor de retorno será lo que contiene dicho atributo, el cual
debe estar relacionado con el tipo de dato de retorno de la característica.

Propiedades
En Visual Basic.NET, tenemos otra forma de desarrollar por decirlo de alguna forma, los
métodos Getter y Setter en una sola función, tal función se denominan Propiedades, la
cuales permiten incluir en su interior los métodos de modificación y acceso, sin necesidad
de desarrollar dos funciones por aparte. Cabe resaltar que en algunos casos en mejor utilizar
los métodos Getter y Setter por separado.

Figure 4.Ejemplo de Metodos Get y Set en Diagrama de clases UML.

¿Para qué sirve un método constructor?
El método constructor o método inicializador, se encarga de darle un estado inicial al objeto
cuando es creado, es decir que, en vez de asignarle un valor a un atributo por medio de una
propiedad, lo podemos realizar por medio de nuestro método constructor.

Figure 5.Método Constructor en Diagrama de clases UML.

¿Qué es la sobrecarga de métodos?

El termino sobrecarga hace referencia a los múltiples métodos que tiene una clase con el mismo
nombre, pero con diferentes parámetros. Es decir, una clase puede tener varios métodos con el
mismo nombre, pero no con los mismos parámetros, por lo tanto, para que se aplique la sobrecarga,
los métodos tienen que tener diferentes parámetros.

Figure 6.Sobrecarga de Métodos en Diagrama de clases UML.

¿Qué es la sobrecarga de Constructores?
El termino sobrecarga en los constructores es similar a la sobrecarga de método normales de las
clases, puesto que consiste en implementar varios métodos constructores con diferentes
parámetros.

Figure 7.Sobrecarga de Constructores en Diagrama de clases UML.

Uso de shared en VB.Net

Esta palabra clave nos permite declarar una variable, propiedad, función o método y asociarlo solo
a la clase y no a la instancia.

Su implementación es la siguiente:

• En el caso de las variables o atributos de clase que implementen esta palabra clave, el
valor solo será de la clase y no copia de una instancia u objeto.

• En el caso de los métodos, para utilizarlos no se debe crear una instancia de la clase para
acceder a ellos, sino que se coloca el nombre de la clase seguido del método (esto es el
equivalente de los métodos estáticos en lenguajes como por ejemplo Java).
¿Qué es la asociación?
La asociación es cuando un objeto se relaciona con otro para desarrollar una tarea específica o
para una solución de un problema.

En la Programación orientada a objetos las asociaciones se describen como atributos de la clase

asociada.

Ejemplo de cómo establecer asociación en diagrama de clases

Figure 8.Forma correcta de establecer una asociación entre clases en Diagrama de clases UML.

Sin embargo, esta sería la forma de implementarlo en Visual Basic. Net si se pudiera establecer en
un diagrama de clases UML.

Figure 9. Forma incorrecta de establecer una asociación entre clases en Diagrama de clases UML.
¿Qué es la Herencia?
En programación orientada a objetos, la herencia consiste en reutilizar los atributos y métodos de
una clase base o también llamada clase padre, donde la clase que hereda dichas características y
acciones es denominada clase derivada o clase hija.

Jerarquía de Herencia
Cuando utilizamos este concepto, en realidad estamos creando un esquema donde estamos
representando la clase base y las clases derivadas, en el mundo de la programación orientada a
objetos se le denomina jerarquía de herencia, donde las clases derivadas entre más abajo estén en
dicha jerarquía son más específicas, es decir, son más completas y funcionales, puesto que cuentan
con más atributos y métodos que sus clases bases, por otro lado, en el caso que las clases derivadas
estén en la cúspide o se encuentren más arriba en la jerarquía de herencia son más genéricas o
menos funcionales.

Figure 10.Ejemplo de Herencia.

Figure 11.Ejemplo de Herencia II.

En Visual Basic. Net para establecer que una clase hija hereda de una clase padre tenemos que
hacer uso de la palabra clave inherits.

Array de objetos
Las sintaxis de estos Arrays son iguales a los que trabajamos con anterioridad, la única diferencia
es que no utilizamos tipos de datos primitivos, sino clases para poder almacenar objetos.

¿Qué es una Interfaz?

Una interfaz permite definir las propiedades, métodos y eventos que las clases pueden
implementar, es decir que, una interfaz permite especificar algunos aspectos de la operatividad de
una clase y son algunas de estas operaciones que una clase presenta a otra.

Características de las interfaces

• Las interfaces se pueden implementar una o varias de estas, a diferencia de la herencia, que
no permite heredar de varias clases.

• Una interfaz no desarrolla los eventos, métodos o propiedades, solo los declara, parecido a
lo que realiza una clase Abstracta y en particular a los métodos Abstractos.

• Obliga a las clases que la implemente a desarrollar los eventos, métodos o propiedades que
esta alberga.
Figure 12.Implemetanción de una interfaz en una clase en Diagrama de clases UML.

¿Qué es una Interfaz Predefinida?

En Visual Basic.NET, al igual que las clases tenemos Interfaces predefinidas que nos permitirán
agregarle más funcionalidad a nuestros programas, incluyendo los métodos necesarios en relación
a la interfaz a utilizar. Por ejemplo, la clase Array que es una clase que nos permite crear, manipular,
buscar y ordenar datos en un vector, tiene un método Shared (compartido o estático) llamado Sort
(), que permite ordenar una Array de acuerdo al valor que se escoja para organizarlo, sin embargo
para poder utilizar este método, tenemos que tener en cuenta el tipo de dato del Array que se le
pase como parámetro a este método, en el caso de una clase, será esta la que debe implementar la
interfaz IComparable y su método CompareTo.

¿Qué es el polimorfismo?
El polimorfismo es la propiedad de la herencia que permite a los objetos comportarse de distintas
maneras, es decir, una operación de un objeto puede tener el mismo nombre que otra operación
de otro objeto, no obstante, los dos métodos se comportan de manera diferente para cada objeto.

Por ejemplo, tenemos una clase base llamada FiguraGeometrica con un método dibujar(), luego de
esa clase derivan dos que son Triangulo y Cuadrado, ambas heredan el método dibujar(), pero ¿si
se dibuja un triángulo de la misma forma que un cuadrado?, es aquí donde entra el polimorfismo,
porque ambas clases tienen el mismo método dibujar(), pero este se tiene que comportar de forma
diferente para cada una.
Figure 13.Ejemplo de Polimorfismo en Diagrama de clases UML.

Figure 14. Ejemplo de Polimorfismo en Diagrama de clases UML II.

El polimorfismo en Visual Basic. Net se puede realizar de dos formas, la primera forma es utilizando
solo la herencia, sobrescribiendo el método en cada clase para que este se comporte de forma
distinta en cada una de ellas. Por otro lado, la segunda forma es utilizar la herencia complementada
con una Interfaz, es decir, en cada clase implementamos la interfaz que tiene en su interior el
método en común, pero que se va a comportar diferente forma en cada una de las clases que lo
implementen.

¿Qué es la Sobre escritura de métodos?

Es la forma que tienen las clases derivadas o las clases hijas de modificar o reemplazar el
comportamiento de un método que hereda de la clase base.

Para realizar la sobre escritura de métodos o propiedades, la clase base debe implementar la palabra
clave Overridable, en el método o la propiedad que se le va a modificar o reemplazar el
comportamiento desde las clases derivadas. Ahora bien, para que una clase derivada puede
reemplazar el comportamiento de un método o propiedad heredado tiene que implementar la
palabra clave Overrides.

Clase Object
Es la clase base que se encuentra en lo más alto en la jerarquía de clases en Visual Basic.NET, por lo
que todas las clases predefinidas y las creadas por el programador heredan de ella.

Algunas características:

• En Visual Basic.NET, si una clase quiere heredar de Object, no es necesario utilizar la palabra
reservada Inherits, puesto que, al crear una clase, VB.NET automáticamente nos realiza esta
tarea.

• La principal funcionalidad de esta superclase o también llamada clase de jerarquía de tipos,

es que podemos almacenar cualquier tipo de objeto en esta clase sin necesidad de
especificar el tipo de dato de la variable almacenadora.

Figure 15.Ejemplo de Jerarquía de clases-Clase Object.

Figure 16.Almacenando un objeto de tipo Persona en un objeto de tipo Object.

Por lo tanto, el uso de la clase Object para almacenar valores de cualquier tipo nos permiten realizar
programas que reciban cualquier objeto, pero a un precio muy alto en relación a rendimiento,
puesto que no podemos utilizar los métodos del objeto que almacenamos en una variable de tipo
Object, esto debido a lo que ya hemos visto en temas anteriores en la Herencia, y es que, si
almacenamos un objeto hijo en un objeto padre, solo podremos utilizar los métodos de la clase
padre, además tenemos que hacer mucho uso del Casting.

¿Qué es el Casting?
El casting es el proceso que permite cambiar o transformar el tipo de dato de una variable a otra,
siempre y cuando haya una relación entre ellas, más concretamente con las clases, debe existir una
relación de herencia entre dichas clases.

Para realizar el casting en vb. Net se utilizan varias formas, la más efectiva es utilizar la función
TryCast.

¿Qué es una clase abstracta?

Es una clase que de la cual no se pueden crear instancias. Por lo tanto, permiten a una clase, ser la
base o la máxima clase en la Jerarquía de Herencia de un conjunto de objetos. A partir de ella se
derivarán un número n de clases, las cuales tendrán los atributos y métodos de dicha clase.

Características de una clase abstracta

• No se pueden crear instancias de esa clase.

• Para que una clase sea abstracta deber tener por lo menos un método abstracto.

• Un método abstracto es un tipo de acción que se declara dentro de la clase abstracta, pero
que no se define o se le asigna alguna función, para que esto ocurra, el método debe ser
heredado por otra clase, la cual si tendrá por obligación definir las instrucciones que este
realizará.

En Visual Basic.NET, para que una clase sea abstracta se utiliza la palabra reservada MustInherit,
por otra parte, para que un método sea abstracto en VB.NET, se coloca la palabra reservada
MustOverride.
Figure 17.Forma para que una clase sea Abstracta en Vb.Net

Figure 18.Forma para que un método sea Abstracto en Vb.Net

Modificadores de acceso
Los modificadores de Acceso nos permiten establecer el alcance que tendrá algún elemento
perteneciente a nuestro programa o proyecto, dichos elementos pueden ser clases, atributos,
métodos, módulos, entre otros. En Visual Basic.NET, tenemos cuatro formas de acceder a los
atributos y métodos de una clase, a un módulo o a una variable en particular, dichos accesos son el
Public, Private, Protected, y el modificador por defecto. A continuación, se mostrarán el alcance de
los modificadores de acceso anteriormente descritos.

Modificador Acceso

Public Puede ser accedido desde cualquier parte del programa.

Private Puede ser accedido solamente desde la clase o módulo.

Puede ser accedido desde la clase o módulo y de las subclases que

Protected hereden de esta.

Por defecto Puede ser accedido desde la clase y desde el espacio de nombre.

Figure 19.Modificadores de Acceso en Vb.Net.

¿Qué son las excepciones?
Las excepciones son errores que se producen en tiempo de ejecución (Run Time). Estos errores son
diferentes a los errores que comúnmente cometemos a la hora de escribir código (Errores de
Sintaxis) que se producen antes de compilar, es decir que, si el programa tiene algún error de
sintaxis, no se podrá compilar y, por consiguiente, el programador lo corregirá en tiempo de pre
compilación. Por lo tanto, una excepción sí que compila, pero se puede producir un error en algún
momento del programa y si este no se trata, el programa se termina.

En Visual Basic.NET, existen una gran variedad de excepciones. Cada error en tiempo de ejecución
tiene una excepción particular y deberá ser tratada como tal, sin embargo, se pueden capturar varias
de estas excepciones en un solo bloque de código, para cada uno de los casos utilizamos las palabras
reservadas Try (Intenta) y Catch (Captura), donde las instrucciones del Try serán las líneas de código
que intentaremos ejecutar y las del Catch, será para capturar la excepción y si se quiere, mostrar un
mensaje que ayude al usuario a ejecutar bien nuestro programa.

Figure 20.Ejemplo de algunas excepciones en Vb.Net.

En algunas ocasiones, nuestros programas no constan de algunas excepciones que necesiten ser
controladas con un bloque Try Catch, sin embargo, hay situaciones particulares donde seamos
nosotros los que lancemos una Excepción y no el lenguaje VB.NET como tal.

Para ello utilizamos la cláusula Throw, que permite lanzar una Excepción de acuerdo a las
necesidades del programador.

Uso de Finally
Es un bloque de código que se ejecuta siempre, incluso si falla al intentar ejecutar la aplicación por
el lanzamiento de una Excepción. Por lo tanto, si queremos utilizar este bloque es necesario saber
que código queremos que se ejecute en el caso de que ocurra una Excepción.
¿Qué son los tipos enumerados?
Los tipos enumerados permiten manejar un conjunto de valores constantes en nuestros
programas. Para usarlos se deben tener en cuenta las siguientes características:

• No son clases, por lo tanto, no deben ser tratados como tal.

• Sus miembros son nombres identificativos según la creación o nombre del tipo
Enumerado.

• La nomenclatura o asignación de nombre a un tipo enumerado, la primera letra debe ir en

mayúscula.

• Deben de tener un modificador de Acceso

• Deben ir dentro de una clase, modulo o estructura.

• Para usarlos, lo tenemos que realizar de igual manera como una clase, se coloca el nombre
del tipo Enumerado, seguido del nombre del miembro.