Servidor NT 1º

Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Introducción a la Programación Orientada a Objetos.
INDICE
1. Introducción............................................................................................................................................................ 1
2. Clases...................................................................................................................................................................... 2
3. Instancias u Objetos................................................................................................................................................ 3
4. Mensajes................................................................................................................................................................. 3
5. Relación entre clases y objetos............................................................................................................................... 4
Herencia................................................................................................................................................. 4
Agregación............................................................................................................................................. 5
Asociación..............................................................................................................................................5
Instanciación.......................................................................................................................................... 5
6. Conceptos y herramientas de Análisis y Diseño orientado a objetos..................................................................... 6
Diagrama de Objetos y diagrama de Clases.......................................................................................... 6
7. Crear o definir una clase en Visual Basic.Net. ...................................................................................................... 9
Definir los miembros de una clase.........................................................................................................9
Crear un objeto a partir de una clase......................................................................................................9
Acceder a los miembros de una clase.................................................................................................. 10
Ejemplo de cómo usar la herencia....................................................................................................... 10
Resumiendo..........................................................................................................................................13
8. Ejercicios...............................................................................................................................................................14
1.
Introducción
Un programa orientado a objetos está compuesto de varios objetos que presentan una serie de
propiedades y unas cuantas operaciones que saben cómo realizar. Esta idea parte de lo que ocurre en el
mundo real, en el cual múltiples entidades desempeñan su labor en función de los estímulos que reciben de
otras entidades y de los estados que llegan a alcanzar en cada momento.
Objeto = Estado + Comportamiento
La clave de todo está en que cada objeto conoce bien su contenido: una vez construido un objeto
que satisfaga nuestros requisitos, dejaremos de preocuparnos de cómo dicho objeto hace las cosas para
pasar a integrarlo donde nos haga falta. Esto introduce dos conceptos básicos relativos a la programación
orientada a objetos(POO): encapsulación y reusabilidad.
La encapsulación consiste en combinar los datos y el comportamiento de los objetos ocultando los
detalles de su implementación. Esto quiere decir que la forma en que un objeto desempeñe una tarea sólo
concierne a dicho objeto, pero en ningún caso a otros objetos que vayan a hacer uso de este. Lo
verdaderamente importante es que el objeto ofrezca una imagen robusta al exterior, es decir, que no cambie
el modo en que se le solicite realizar una determinada tarea; dicho en términos más técnicos, que presente
un diseño fuerte de su interfaz. De este modo, si en el futuro se descubre un algoritmo más eficiente que el
actual para resolver un problema, o si se encuentra una manera más adecuada de representar los datos, no
será necesario informar a nadie de los cambios, sino que podremos pasar a realizarlos sin preocuparnos de
más.
Por ejemplo, cuando aprendemos a conducir un coche somos capaces de conducir prácticamente
cualquiera. ¿Por qué? porque lo que aprendemos es cómo hacer que ese coche realice su función: para que
acelere, pisamos el pedal del acelerador; para que frene, el pedal del freno, y no nos importa si acelera con
Dpto. Informática.
1
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
más o menos válvulas o que el freno sea de disco o de tambor. Así, si pasamos de tener un Seiscientos a un
BMW no tendremos que aprender a conducir de nuevo. Por otra parte, a nosotros no nos importa cómo
acelere el coche mientras que cuando aceleremos obtengamos la respuesta esperada.
Otra de las razones para defender la encapsulación está en el hecho de que a través de ella es más
fácil controlar los errores, pues nadie mejor que el objeto que guarda los datos podrá saber si existen
valores inconsistentes para los mismos que no se deben permitir.
Como ejemplo supongamos que queremos tener un objeto que represente las fechas del calendario.
Si permitimos que cualquier otro objeto pueda fijar una fecha, sería posible tener como válido el 30 de
febrero de 1998, mientras que si no permitimos acceso directo, nuestro objeto de las fechas podría evitar
que tal cosa ocurriera.
La clave para lograr la encapsulación está en que un objeto de una clase nunca pueda manipular
directamente los datos internos de otro objeto perteneciente a otra clase, sino que, si desea variar alguno de
ellos, tenga que “pedírselo” a quien los guarda. Así, toda la comunicación debe realizarse mediante
mensajes.
La reusabilidad, como su nombre indica, es la facilidad para utilizar código que ya estaba escrito
en nuevos programas sin realizar variaciones sobre él. ¿De qué forma proporcionan los objetos
reusabilidad? La respuesta es sencilla: si programamos los objetos de forma que se responsabilicen de sólo
unas cuantas funciones relacionadas entre sí, como normalmente los programas se parecen unos a otros, no
tendremos que inventar la rueda continuamente.
El ejemplo esta vez se remite al cuerpo humano. Cada uno de nuestros órganos es responsable de
una serie de funciones vitales. Si alguno de nosotros dona un órgano, otra persona podrá recibirlo y ese
órgano realizará la misma función en otro cuerpo porque sabe cómo hacerlo. Así, lo que los objetos ofrecen
es “funcionalidad empaquetada”, de la que sólo necesitamos saber cómo se dispara y que podemos
dispararla en cualquier situación similar a la que nos llevó a desarrollarla.
Estas ideas presentan además otras ventajas claras de cara al desarrollo de software. Por un lado, si
los objetos se responsabilizan de unas cuantas tareas, parecen apropiados para ser repartidos entre distintos
equipos de trabajo independientes entre sí. Por otro lado, el tiempo que llevará localizar y corregir un error
se verá minimizado, pues se sabe qué objetos están involucrados en el problema. Por último, cuando
nuestro software deba ser actualizado por cambios en los requisitos, será sencillo acometer las
modificaciones sin tener que rediseñar el sistema. No obstante, para sacar partido de todas estas
posibilidades de la POO no basta con que el programa sea orientado a objetos, sino que desde el diseño se
debe seguir esta filosofía.
A continuación vamos a definir los términos fundamentales para trabajar con la orientación a objetos.
2.
Clases
Es el término más importante, pues constituye la plantilla o el molde a partir del cual se construyen los
objetos. La clase se define mediante atributos, una serie de propiedades comunes a todos los objetos que
pertenecen a ella y métodos el conjunto de funciones que pueden operar sobre dichos objetos.
Normalmente las clases se identifican en el lenguaje natural por venir precedidas de un artículo
indeterminado, como “un coche”, “una casa”, etc... o por un artículo determinado plural, como “los
coches”, “las casas”,...
Como ya hemos comentado, los atributos de una clase son cada una de las propiedades que presentan los
objetos que pertenecen a esa clase, siendo el valor que tomen lo que distinguirá a unos objetos (o
instancias) de otros.
Dpto. Informática.
2
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Ej: Representación gráfica de la clase Coche.
COCHE
Número de
puertas
Color
Fecha de
matriculación
Matrícula
Acelerar
Frenar
Pintar
Dar número de
puertas
Los métodos y atributos de una clase pueden tener distinto grado de visibilidad:
3.
•
Privado: cuando dichos métodos sólo pueden ser invocados desde la misma clase.
•
Publico: cuando dichos métodos se pueden invocar desde cualquiera de las clases del modelo.
•
Protegido: cuando dichos métodos sólo se pueden invocar desde la misma clase y sus subclases.
Instancias u Objetos
Resultan de concretar el valor de las propiedades que se definen en una clase. Son instancias de
una clase. Así, tendremos que –para la propiedad “color” – diremos “mi coche es rojo” y “tu coche es gris”.
mi_coche : COCHE
Número de puertas = 3
Color = rojo
Fecha de matriculación =
19/05/2000
Matrícula = “1234 BGH”
Acelerar
Frenar
Dar número de puertas
Estado de un objeto, podemos pensar en él como una fotografía del objeto en un instante de
tiempo determinado, en el cual los atributos del objeto tendrán un valor concreto. El estado de un objeto
puede afectar a su comportamiento. Por ejemplo, si un pedido está pagado no querrá aceptar nuevos
artículos, y si de momento es vacío no debe permitir que le borren artículos pues no los tiene.
4.
Mensajes
•
•
•
Definimos un mensaje como una petición enviada a un objeto para que active un método (llamada al
método de un objeto desde otro objeto). Los mensajes constan de tres componentes:
Objeto al que se dirige.
Método que se invoca, entre los que pertenecen al objeto que recibe el mensaje. El método puede ser
propio de la clase a la que pertenece el objeto, o heredado de una de sus superclases (clases padre de la
actual).
Argumentos opcionales que deben pasarse al método.
Los métodos son equivalentes a las llamadas a funciones de la programación estructurada. Al aparecer en
los métodos el nombre del objeto que lo recibe se hacen posibles las siguientes características básicas de la
POO:
Dpto. Informática.
3
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
•
El encapsulamiento, pues el método seleccionado pertenece al objeto que recibe el mensaje y el
objeto que llama sólo conoce el nombre del método y con qué parámetros debe llamarle.
•
El polimorfismo, pues métodos distintos, asociados a objetos distintos, pueden tener el mismo
nombre (se distinguen por el nombre del objeto que los recibe).
•
La herencia, pues el método asociado a un objeto no tiene por qué pertenecer a éste en exclusiva,
sino que puede estar definido en una de sus superclases y ser heredado por él.
Una de las características fundamentales de la OO es el polimorfismo, que permite asignar el mismo
nombre a datos o métodos que pertenezcan a distintas clases de objetos, o incluso dentro de la misma clase.
Lo que sucede, es que se puede definir varios métodos con cabeceras parecidas: el mismo nombre, pero
distinto número o tipo de parámetros. Por ejemplo, supongamos que hemos definido la clase Perro que
implementa el método oler. Ahora bien, si un perro huele comida, se pondrá contento y si huele un gato,
ladrará. Para resolver este problema recurrimos al polimorfismo.
Ej: class Perro {
public void oler ( Comida obj) {
printf(“\n¡Me gusta la comida!\n”);
}
public void oler ( Gato obj) {
printf(“\n¡Odio a los gatoss!\n”);
}
}
5.
Relación entre clases y objetos
Existen diferentes tipos de relaciones:
Herencia
La propiedad fundamental que más distingue a la OO de la programación clásica, es la herencia de
propiedades y programas de unas clases a otras a través de la organización jerárquica a la que pertenecen.
Esta propiedad facilita la reutilización de desarrollos anteriores en aplicaciones completamente nuevas, lo
que las simplifica y reduce el esfuerzo necesario para construirlas.
Entre las clases se puede definir una jerarquía del estilo padre -> hija, de forma que existan una
superclase(padre), con unas características muy generales, y otras subclase(hija), que aprovechan las
características de las anteriores para construir las suyas propias. La clase derivada hereda los atributos y
operaciones de la clase base y, además, puede añadir los suyos propios. Por ejemplo, las clases profesor y
alumno podrían definirse como herederas de una clase más general persona, en la cual se definirían los
atributos y métodos que fueran comunes a ambos. Así, como los atributos edad y nombre los tendrán
ambas clases, lo correcto sería definirlos en la clase persona y que de ella heredaran profesor y alumno. Sin
embargo, los métodos para asignar una tutoría a un profesor o sancionar a un alumno, son específicos de
estas clases, por lo que no son heredados de persona.
La herencia puede ser simple(como en el ejemplo anterior), cuando una clase hereda características de otra,
o múltiple, cuando una clase hereda características de más de una. Por ejemplo, si deseáramos definir las
características de un vehículo anfibio, se podrían aprovechar las características de los vehículos terrestres
automóvil y las de los vehículos acuáticos barco para obtener la clase anfibio.
Dpto. Informática.
4
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
La jerarquía de clases sería:
vehículo
barco
automóvil
camión
anfibio
Agregación
Es una relación entre objetos por la cual uno de ellos tiene definido entre sus atributos a una instancia de la
clase del otro. La agregación implica posesión, es una relación del tipo “forma parte de” o “está
compuesto por”. Físicamente la agregación supone la desaparición del objeto agregado cuando el objeto
agregante deja de existir.
Por ejemplo, los objetos de la clase polígono se pueden definir como una agregación de lados, por lo que
entre sus atributos podrían tener un conjunto de elementos de la clase lado. Cuando un polígono deja de
existir, ¿qué sentido tiene que existan sus lados por separado? Ninguno, por lo que dichos componentes
agregados también desaparecen, físicamente hablando.
Asociación
Es una relación entre objetos similar a la agregación. La gran diferencia estriba en que cuando un objeto de
una clase tiene como asociado a otro de otra clase, no lo tiene definido entre sus atributos y, por tanto, “no
lo posee”. Es decir, la existencia de ambos objetos asociados es independiente, por lo que la desaparición
del primero no implica la del segundo. Las relaciones de asociación representan relaciones de uso, por
medio de las cuales un objeto de una clase realiza algún tipo de procesamiento para otro de otra clase
distinta.
Por ejemplo, una clase que representara a un equipo de fútbol podría definir, a través de sus atributos,
asociaciones con los diferentes jugadores que forman parte de la plantilla. Sin embargo, si el equipo
desapareciera, los jugadores podrían seguir existiendo y jugando en otros equipos.
Instanciación
Es la relación que se establece entre dos objetos cuando uno de ellos “crea” al otro, es decir, ejecuta su
constructor. Evidentemente la instanciación supone una situación de agregación o asociación entre ambos
objetos, pero se distingue de ellas para señalar aquellos casos en los que la relación entre ambos objetos
viene dada, principal o exclusivamente, por este hecho.
Dpto. Informática.
5
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
6.
Conceptos y herramientas de Análisis y Diseño orientado a objetos.
UML es una notación estándar para desarrollo de sistemas usando el enfoque orientado a objeto. UML
comenzó en 1994 como un esfuerzo de Grady Booch y James Rumbaugh para combinar sus metodologías
definiendo una notación estándar para ellas. Después, en 1995, Ivar Jacobson (técnica OOSE , incluyendo
Casos de Uso) se unió al equipo. Paralelamente a este esfuerzo, el Object Management Group
(www.omg.org) hizo una llamada para propuestas de notación y metamodelo orientado a objetos. En
enero de 1997 UML fue entregado.
UML es sólo una notación, no dicta estándares para el proceso de desarrollo. Sin embargo, UML
condiciona dicho proceso de desarrollo al establecer los diagramas e información asociada que debe
representarse. Los diagramas incluidos en UML, agrupados según su ámbito de aplicación, son:
Análisis en el contexto organizacional:
Diagramas de Casos de Uso
Análisis y diseño desde la perspectiva estática
Diagrama de Clase
Diagrama de Objetos
Análisis y diseño desde la perspectiva dinámica
Diagrama de Secuencia
Diagrama de Colaboración
Diagrama de Estados
Implementación
Diagrama de Componentes.
Diagrama de Despliegue.
Existen diferentes herramientas que nos permiten documentar las fases del análisis y diseño OO, una de
ellas es Rational Rose.
Diagrama de Objetos y diagrama de Clases
El diagrama de Clases es el diagrama principal para el análisis y diseño estático. Un diagrama de clases
presenta las clases del sistema con sus relaciones estructurales y de herencia. La definición de clase
incluye definiciones para atributos y métodos.
El trabajo realizado en los diagramas de Casos de Uso, diagramas de Secuencia y diagramas de
Colaboración debería aportar información para la determinación de las clases, objetos, atributos y
métodos. El diagrama de Clases es la especificación de requisitos en su aspecto estático.
La notación de ambos tipos de diagramas, objetos y clases, es similar. La diferencia es el nivel de
abstracción en el cual se trabaja. Normalmente, al principio del desarrollo, cuando aún no está decidido
qué elementos llegarán a ser clases, objetos o datos elementales, se puede modelar dichos elementos
como objetos. Sin embargo cuando se establece la solución todos los elementos están claramente
diferenciados y representados en diagramas de clases (que también podrían incluir representaciones para
objetos, cuando sólo una instancia participa en el sistema).
Dpto. Informática.
6
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Rational Rose proporciona sólo un tipo de diagrama, denominado Class
Diagram. La Toolbox asociada se muestra en la figura de la derecha. Se
activa pulsando en
.
Para agregar atributos a la clase se pulsa con el botón derecho sobre la clase y New Attribute.
Para agregar métodos a la clase se pulsa con el botón derecho sobre la clase y New Operation.
La siguiente figura presenta un diagrama de Clases para un sistema de Líneas aéreas.
Motor
Piloto
1..4
Vendedor
1
1..2
1
Avión 1
*
*
Vuelo 1
*
*
Reserva
*
{di sjunta,com p leta}
Avión Militar
Avión Comercial
1
Linea Aérea
{disjunta,com pl eta}
Avión de Carga
Avión Pasajeros
Clases
Una clase se representa como un rectángulo con tres compartimentos separados por líneas horizontales:
en el superior se muestra el nombre de la clase, en el siguiente se presenta la lista de atributos de la clase,
a continuación se muestran los métodos. Cada atributo o método de una clase es antecedido por un
indicador de visibilidad (privada, publica, protegida).
Asociaciones
Son relaciones bidireccionales entre instancias de clases. En una asociación, una instancia de una clase
puede estar relacionada con un número mínimo y máximo instancias de otra clase o de la misma clase.
Estos números se denominan cardinalidad de la asociación. La notación para cardinalidad de las
asociaciones y relaciones en diagramas de Clase UML es:
Dpto. Informática.
7
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Uno y sólo uno:
1
Cero o uno:
0..1
Uno o más:
1..*
Cero o más:
0..*
Entre N y M : N..M , donde N y M son números naturales y M ≥ N.
Para dibujarlas en el diagrama, se pulsa con el botón derecho sobre la asociación en el lado del cual se
quiera poner la cardinalidad y en el menú emergente sobre Multiplicity. Se ha de repetir la operación en
cada lado de la asociación. Para quitar el sentido de la flecha de la asociación, se pulsa con el botón
derecho y se deshabilita la opción Navigable.
Agregaciones
Las agregaciones también se pueden representar mediante Rational Rose. Un ejemplo sería la asociación
entre Avión y Motor. Se entiende que para el diagrama que se ha hecho solo interesa guardar información
de los motores de aviones que tengamos en activo. Cuando eliminemos un avión, también se deberá
borrar toda la información relativa a sus motores.
Generalización
La generalización es un operador entre clases que permite representar la herencia. Las subclases están
conectadas a las superclases mediante el símbolo “hereda desde”. La siguiente figura muestra un ejemplo
de una jerarquía de generalización. En dicha figura, Empleado es una generalización de Administrativo,
Ejecutivo y Operario, por tanto las subclases heredan las propiedades de la superclase Empleado.
Empleado
{d isjo int, c o m ple te }
Directivo
Administrativo
Obrero
Cada jerarquía o cada conexión de subclase puede estar etiquetada con alguna restricción a cumplir por
las instancias de la subclase. Las siguientes son las restricciones predefinidas usadas para jerarquías:
Overlapping: un objeto puede pertenecer a más de una de las subclases.
Disjoint: un objeto puede pertenecer a lo más a una de las subclases.
Complete: la unión de los objetos instancias de las subclases corresponde exactamente a los objetos
instancia de la superclase.
Incomplete: un objeto instancia de la superclase puede no pertenecer a ninguna de las subclases
declaradas
Dpto. Informática.
8
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
7.
Crear o definir una clase en Visual Basic.Net. 1
Al igual que existen instrucciones para declarar o definir una variable o cualquier otro elemento de un
programa de Visual Basic, existen instrucciones que nos permiten crear o definir una clase.
Para crear una clase debemos usar la instrucción Class seguida del nombre que tendrá dicha clase, por
ejemplo:
Class Cliente
A continuación escribiremos el código que necesitemos para implementar las propiedades y métodos de
esa clase, pero para que Visual Basic sepa que ya hemos terminado de definir la clase, usaremos una
instrucción de cierre:
End Class
Por tanto, todo lo que esté entre Class <nombre> y End Class será la definición de dicha clase.
Definir los miembros de una clase
Para definir los miembros de una clase, escribiremos dentro del "bloque" de definición de la clase, las
declaraciones y procedimientos que creamos convenientes.
Veamos un ejemplo:
Class Cliente
Public Nombre As String
Sub Mostrar()
Msgbox("El nombre del cliente: {0}", Nombre)
End Sub
End Class
En este caso, la línea Public Nombre As String, estaría definiendo una propiedad o "campo" público de la
clase Cliente.
Por otro lado, el procedimiento Mostrar sería un método de dicha clase, en esta caso, nos permitiría
mostrar la información contenida en la clase Cliente.
Esta es la forma más simple de definir una clase. Y normalmente lo haremos siempre así, por tanto
podemos comprobar que es muy fácil definir una clase, así como los miembros de dicha clase.
Pero no sólo de clases vive el Visual Basic... o lo que es lo mismo, ¿para que nos sirve una clase si no
sabemos crear un objeto basado en esa clase...? Así que, sepamos cómo crearlos.
Crear un objeto a partir de una clase
Como te he comentado antes, las clases definen las características y la forma de acceder a los datos que
contendrá, pero sólo eso: los define.
Para que podamos asignar información a una clase y poder usar los métodos de la misma, tenemos que
crear un objeto basado en esa clase, o lo que es lo mismo: tenemos que crear una nueva instancia en la
memoria de dicha clase.
1
Apartado adapatado de los temas preparados por Guillermo Som Cerezo.
Dpto. Informática.
9
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Para ello, haremos lo siguiente:
Definimos una variable capaz de contener un objeto del tipo de la clase, esto lo haremos como con
cualquier variable:
Dim cli As Cliente
Pero, a diferencia de las variables basadas en los tipos visto hasta ahora, para poder crear un objeto
basado en una clase, necesitamos algo más de código que nos permita "crear" ese objeto en la memoria,
ya que con el código usado en la línea anterior, simplemente estaríamos definiendo una variable que es
capaz de contener un objeto de ese tipo, pero aún no existe ningún objeto en la memoria, para ello
tendremos que usar el siguiente código:
cli = New Cliente()
Con esto le estamos diciendo al Visual Basic: crea un nuevo objeto en la memoria del tipo Cliente.
Estos dos pasos los podemos simplificar de la siguiente forma:
Dim cli As New Cliente()
A partir de este momento existirá en la memoria un objeto del tipo Cliente.
Acceder a los miembros de una clase
Para acceder a los miembros de una clase (propiedades o métodos) usaremos la variable que apunta al
objeto creado a partir de esa clase, seguida de un punto y el miembro al que queremos acceder, por
ejemplo, para asignar el nombre al objeto cli, usaremos este código:
cli.Nombre = "Guillermo"
Es decir, de la misma forma que haríamos con cualquier otra variable, pero indicando el objeto al que
pertenece dicha variable.
Como podrás comprobar, esto ya lo hemos estado usando anteriormente tanto en la clase Console como
en las otras clases que hemos usado en entregas anteriores, incluyendo los arrays.
Y para acceder al método Mostrar:
cli.Mostrar()
Pues así es todo lo demás en .NET Framework, así que... ¿para que seguir explicándote?
Bueno, vale... seguiremos viendo más cosas...
Espero que con lo dicho y lo que ya llevamos visto hasta ahora, tengas claro que son las propiedades y los
métodos y si aún tienes dudas, no te preocupes ya que ahondaremos más en estos conceptos y sobre todo
los utilizaremos hasta la saciedad, con lo cual puedes tener la tranquilidad de que acabarás enterándote al
100% de que va todo esto...
A pesar de que aún no estés plenamente informado de todo, vamos a ver un par de ejemplos de cómo usar
las características de la programación orientada a objetos, después, en próximas entregas,
profundizaremos más.
Dpto. Informática.
10
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Ejemplo de cómo usar la herencia
Para poder usar la herencia en nuestras clases, debemos indicar al Visual Basic que esa es nuestra
intención, para ello disponemos de la instrucción Inherits, la cual se usa seguida del nombre de la clase de
la que queremos heredar.
Veamos un ejemplo.
Empezaremos definiendo una clase "base" la cual será la que heredaremos en otra clase.
Ya sabemos cómo definir una clase, aunque para este ejemplo, usaremos la clase Cliente que vimos
anteriormente, después crearemos otra, llamada ClienteMoroso la cual heredará todas las características
de la clase Cliente además de añadirle una propiedad a esa clase derivada de Cliente.
Veamos el código de estas dos clases.
Para ello crea un nuevo proyecto del tipo consola y escribe estas líneas al principio o al final del fichero
que el IDE añade de forma predeterminada.
Class Cliente
Public Nombre As String
Sub Mostrar()
Console.WriteLine("El nombre del cliente: {0}", Nombre)
End Sub
End Class
Class ClienteMoroso
Inherits Cliente
Public Deuda As Decimal
End Class
Como puedes comprobar, para que la clase ClienteMoroso herede la clase Cliente, he usado Inherits
Cliente, con esta línea, (la cual debería ser la primera línea de código después de la declaración de la
clase), le estamos indicando al VB que nuestra intención es poder tener todas las características que la
clase Cliente tiene.
Haciendo esto, añadiremos a la clase ClienteMoroso la propiedad Nombre y el método Mostrar, aunque
también tendremos la nueva propiedad que hemos añadido: Deuda.
Ahora vamos a ver cómo podemos usar estas clases, para ello vamos a añadir código en el procedimiento
Main del módulo del proyecto:
Module Module1
Sub Main()
Dim cli As New Cliente()
Dim cliM As New ClienteMoroso()
'
cli.Nombre = "Guille"
cliM.Nombre = "Pepe"
cliM.Deuda = 2000
'
Console.WriteLine("Usando Mostrar de la clase Cliente")
cli.Mostrar()
'
Console.WriteLine("Usando Mostrar de la clase
ClienteMoroso")
cliM.Mostrar()
'
Dpto. Informática.
11
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Console.WriteLine("La deuda del moroso es: {0}",
cliM.Deuda)
'
Console.ReadLine()
End Sub
End Module
Lo que hemos hecho es crear un objeto basado en la clase Cliente y otro basado en ClienteMoroso.
Le asignamos el nombre a ambos objetos y a la variable cliM (la del ClienteMoroso) le asignamos un
valor a la propiedad Deuda.
Fíjate que en la clase ClienteMoroso no hemos definido ninguna propiedad llamada Nombre, pero esto es
lo que nos permite hacer la herencia: heredar las propiedades y métodos de la clase base. Por tanto
podemos usar esa propiedad como si la hubiésemos definido en esa clase. Lo mismo ocurre con los
métodos, el método Mostrar no está definido en la clase ClienteMoroso, pero si que lo está en la clase
Cliente y como resulta que ClienteMoroso hereda todos los miembros de la clase Cliente, también hereda
ese método.
La salida de este programa sería la siguiente:
Usando Mostrar de la clase Cliente
El nombre del cliente: Guille
Usando Mostrar de la clase ClienteMoroso
El nombre del cliente: Pepe
La deuda del moroso es: 2000
Como puedes ver no es tan complicado esto de la herencia...
Ahora veamos cómo podríamos hacer uso del polimorfismo o al menos una de las formas que nos permite
el .NET Framework.
Teniendo ese mismo código que define las dos clases, podríamos hacer lo siguiente:
Sub Main()
Dim cli As Cliente
Dim cliM As New ClienteMoroso()
'
cliM.Nombre = "Pepe"
cliM.Deuda = 2000
cli = cliM
'
Console.WriteLine("Usando Mostrar de la clase Cliente")
cli.Mostrar()
'
Console.WriteLine("Usando Mostrar de la clase
ClienteMoroso")
cliM.Mostrar()
'
Console.WriteLine("La deuda del moroso es: {0}",
cliM.Deuda)
'
Console.ReadLine()
End Sub
En este caso, la variable cli simplemente se ha declarado como del tipo Cliente, pero no se ha creado un
nuevo objeto, simplemente hemos asignado a esa variable el contenido de la variable cliM.
Dpto. Informática.
12
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
Con esto lo que hacemos es asignar a esa variable el contenido de la clase ClienteMoroso, pero como
comprenderás, la clase Cliente "no entiende" nada de las nuevas propiedades implementadas en la clase
derivada, por tanto sólo se podrá acceder a la parte que es común a esas dos clases: la parte heredada de la
clase Cliente.
Realmente las dos variables apuntan a un mismo objeto, por eso al usar el método Mostrar se muestra lo
mismo. Además de que si hacemos cualquier cambio a la propiedad Nombre, al existir sólo un objeto en
la memoria, ese cambio afectará a ambas variables.
Para comprobarlo, añade este código antes de la línea Console.ReadLine():
Console.WriteLine()
cli.Nombre = "Juan"
Console.WriteLine("Después de asignar un nuevo nombre a
cli.Nombre")
cli.Mostrar()
cliM.Mostrar()
La salida de este nuevo código, sería la siguiente:
Usando Mostrar de la clase Cliente
El nombre del cliente: Pepe
Usando Mostrar de la clase ClienteMoroso
El nombre del cliente: Pepe
La deuda del moroso es: 2000
Después de asignar un nuevo nombre a cli.Nombre
El nombre del cliente: Juan
El nombre del cliente: Juan
La parte en gris es lo que se mostraría antes de realizar el cambio.
Como puedes comprobar, al cambiar en una de las variables el contenido de la propiedad Nombre, ese
cambio afecta a las dos variables, pero eso no es porque haya nada mágico ni ningún fallo, es por lo que
te comenté antes: sólo existe un objeto en la memoria y las dos variables acceden al mismo objeto, por
tanto, cualquier cambio efectuado en ellas, se reflejará en ambas variables por la sencilla razón de que
sólo hay un objeto en memoria.
A este tipo de variables se las llama variables por referencia, ya que hacen referencia o apuntan a un
objeto que está en la memoria. A las variables que antes hemos estado viendo se las llama variables por
valor, ya que cada una de esas variables tienen asociado un valor que es independiente de los demás.
Resumiendo.
Hemos visto las condiciones que un lenguaje debe cumplir para que sea considerado orientado a objetos:
herencia, encapsulación y polimorfismo. También hemos aprendido a definir una clase y a derivar una
clase a partir de otra por medio de la instrucción Inherits. Ya sabemos cómo definir variables cuyo tipo
sea una clase y cómo crear nuevos objetos en memoria a partir de una clase. También hemos comprobado
que el que exista más de una variable del tipo de una clase no significa que exista un objeto independiente
para cada una de esas variables y por último hemos comprobado que son las variables por referencia y
cómo afectan a los objetos referenciados por ellas.
Dpto. Informática.
13
Desarrollo de Aplicaciones Informáticas
- Visual Basic.Net – .
8.
Ejercicios.
1) Identificar clases con sus atributos y métodos para representar la información de una agenda musical.
Principalmente centrandose en grupos, musicos y discos.
2) Identificar clases con sus atributos y métodos para representar la información de descargas de videos,
juegos. Peliculas, etc.
3) Identificar clases con sus atributos y métodos para representar la información de un polideportivo
municipal. Se deberá erflejar información sobre usuarios, actividades, instalaciones,...
Dpto. Informática.
14