introducción a la programación orientada a...

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................................................................................................................................................. 4Agregación.............................................................................................................................................5Asociación..............................................................................................................................................5Instanciació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.........................................................................................................9Crear un objeto a partir de una clase......................................................................................................9Acceder a los miembros de una clase.................................................................................................. 10Ejemplo de cómo usar la herencia....................................................................................................... 10Resumiendo..........................................................................................................................................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


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.



Ej: Representación gráfica de la clase Coche.

COCHE

Número de puertasColorFecha de matriculaciónMatrícula

AcelerarFrenarPintarDar número de puertas

Los métodos y atributos de una clase pueden tener distinto grado de visibilidad:

• 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.

3. 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 = 3Color = rojoFecha de matriculación = 19/05/2000Matrícula = “1234 BGH”

AcelerarFrenarDar 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. MensajesDefinimos 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:



• 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.


vehículo

barcoautomóvil

anfibiocamión


La jerarquía de clases sería:

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.



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 UsoAnálisis y diseño desde la perspectiva estáticaDiagrama de ClaseDiagrama de ObjetosAnálisis y diseño desde la perspectiva dinámicaDiagrama de SecuenciaDiagrama de ColaboraciónDiagrama de EstadosImplementaciónDiagrama 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 ClasesEl 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).



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.

ClasesUna 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).

AsociacionesSon 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:


{d isjunta,com pleta}

Avión Militar Avión Comercial

{d i sjunta,com p leta}

Avión de Carga Avión Pasajeros

Vendedor

Reserva

1

*

1

*

Piloto

Linea Aérea

Vuelo

*

1

*

1

1..2

*

1..2

*

*

1

*

1

Avión *1 *1

Motor

1..4

11

1..4


Uno y sólo uno: 1Cero o uno: 0..1Uno 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.

AgregacionesLas 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ónLa 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.

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


Empleado

Directivo Administrativo Obrero

{d isjo int, c om plete}


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 clasePara 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 SubEnd 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 claseComo 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.



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 clasePara 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.



Ejemplo de cómo usar la herenciaPara 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 SubEnd Class

Class ClienteMoroso Inherits Cliente Public Deuda As DecimalEnd 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() '



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 ClienteEl nombre del cliente: GuilleUsando Mostrar de la clase ClienteMorosoEl nombre del cliente: PepeLa 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.



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 ClienteEl nombre del cliente: PepeUsando Mostrar de la clase ClienteMorosoEl nombre del cliente: PepeLa deuda del moroso es: 2000

Después de asignar un nuevo nombre a cli.NombreEl nombre del cliente: JuanEl 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.



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,...


introducción a la programación orientada a...

Documents