Polimorfiso y Clases Virtuales

POLIMORFISMO


FUNCIONES VIRTUALES-CLASES ABSTRACTAS


EJEMPLO CLASE ABSTRACTA


Ejemplo 2 clases abstractas

Prácticas con Sobrecargo

Creación de una calculadora

Métodos y Sobrecargo

Hay algunos casos cuando una clase necesita realizar la misma actividad empezando con los mismos valores de entrada-esto es, con diferentes argumentos. Hemos visto algunos ejemplos de este comportamiento cuando vimos constructores. Las mismas reglas aplican para los métodos con sobrecargo.

Create Overloaded Methods in VB.NET
VB.NETs method overloading allows VB programmers to develop different logic for methods that share the same name. Edward Cartagena shows how overloaded methods in VB.NET eliminates workarounds and gives VB programmers more time to develop business solutions.

Visibilidad y Herencia Jerarquica

Visibilidad
Hemos visto que los miembros de una clase puede tener uno de los tres modificadores de acceso estandares (Public, Private, y Friend). Tambien hemos mencionado, que podemos tener miembros declarados como protected y veremos como son y como usarlos. Dar click para ver ejemplos

Herencia Jerárquica
La herencia puede tener multiples niveles. Esto es, una clase base puede tener clases derivadas, cada una de las cuales puede tener clases derivadas, y continuar heredando.Estas clases constituyen lo que conocido como herencia jerárquica o arbol de herencia.
Dar click para ver ejemplos

Tarea con de Herencia

Estos son las respectivas clases asi como el modulo que se generó del trabajo encargado:
Clase alumno
clase docente
clase administrativo
clase heredada
Módulo principal

Herencia

Mexicali, Baja California a 26 de Mayo de 2006.
¿Qué es la herencia?
Azumamos que necesitamos modelar y programar un sistema de Recursos Humanos (RH), el cual maneja empleados de la compañía y clientes, entre otras entidades. La aproximación basada de lo que conocemos hoy en día sería diseñar dos clases: una para los empleados y otra para los clientes. Esto se vería como en el diagrama siguiente e implementado de la siguiente manera.

Empleado
-nombre: String
-fechanac: Date
-email: String
-Salario: Decimal

+New (nombre : String)

Cliente
-nombre: String
-fechanac: Date
-email: String
-compañia : String
+New (name : String)

La implementación de la clase empleada seria de la siguiente manera.
Public Class Empleado
Private m_nombre As String
Private m_fechanac As Date
Private m_email As String
Private m_salario As Decimal

Public Property nombre() As String
Get
Return m_nombre
End Get
Set(ByVal Value As String)
m_nombre = Value
End Set
End Property

Public Property fechanac() As Date
Get
Return m_fechanac
End Get
Set(ByVal Value As Date)
m_fechanac = Value
End Set
End Property

Public Property email() As String
Get
Return m_email
End Get
Set(ByVal Value As String)
m_email = Value
End Set
End Property
Public Property salario() As Decimal
Get
Return m_salario
End Get
Set(ByVal Value As Decimal)
m_salario = Value
End Set
End Property
End Class


Public Class cliente
Private m_nombre As String
Private m_fechanac As Date
Private m_email As String
Private m_compania As String

Public Property nombre() As String
Get
Return m_nombre
End Get
Set(ByVal Value As String)
m_nombre = Value
End Set
End Property

Public Property fechanac() As Date
Get
Return m_fechanac
End Get
Set(ByVal Value As Date)
m_fechanac = Value
End Set
End Property

Public Property email() As String
Get
Return m_email
End Get
Set(ByVal Value As String)
m_email = Value
End Set
End Property

Public Property compania() As String
Get
Return m_compania
End Get
Set(ByVal Value As String)
m_compania = Value
End Set
End Property

End Class

Como habrás notado que una gran parte del código se repite, los campos y las propiedades para nombre, fecha de nacimiento y correo electrónico.

Puntos que observar:
• El código se repite
• Costo en mantenimiento
• Realización de Rutinas muy parecidas para implementar cada clase

Public Sub EnviarFelicitacionesE(ByVal empleado() As Empleado)
Dim e As Empleado
If e.fechanac = Now Then
Console.WriteLine("Se le enviara una tarjeta de felicitacion")
End If
End Sub
Public Sub EnviarFelicitacionesC(ByVal cliente() As cliente)
Dim c As cliente
If c.fechanac = Now Then
Console.WriteLine("Se le enviara una tarjeta de felicitacion")
End If
End Sub


No podemos reutilizar el primer procedimiento para el objeto cliente porque son de tipo diferente como el objeto empleado. Entonces necesitamos un segundo procedimiento. Entre mas clases tengamos que compartan código común, requeriremos mas procedimientos. Como consecuencia el programa se vuelve más complejo.

La herencia resuelve ambos puntos:
• Permite que exista código común en un solo lugar y que no sea duplicado en todas las clases que lo comparten. Esto tambien resuelve el problema de mantenimiento, porque estando en un solo lugar, el código puede ser cambiado. El cambio se verá reflejado en la clase que lo utilice.
• Permite a las clases que comparten un subset de propiedades y métodos que puedan ser tratados en la misma manera.

Entonces, ¿qué es la herencia? Herencia es definida como el proceso de extender la funcionalidad de una clase añadiendo nuevas propiedades y métodos y creando de esta manera una nueva clase. La nueva clase (conocida como una derivada o una clase especializada) contiene todos los métodos y propiedades de la clase original (conocida como la clase base), mas un set de propiedades y métodos que le pertenecen. De la nueva clase se dice que hereda de la clase base. Todos estos términos son equivalentes y pueden ser usados intercambiadamente.

Si tuviéramos una clase llamada Carro el cual representa el concepto general de un carro(un objeto que nos permite transportarnos de un lugar a otro) podríamos subcategorizarlo: Carros compactos, Suburvans, camiones, carros voladores. Todos estos están compartiendo todas las propiedades de un carro, y tienen algunas otras características diferentes y propias.

El proceso recursivo de ir de lo particular a lo general (conocido como generalización, o abstracción) busca un set de clases y determina propiedades y comportamientos similares. Estas propiedades comunes y comportamientos son utilizados para construir una nueva clase. La cual es la generalización o abstracción de las clases particulares.

HERENCIA SIMPLE
¿Cómo es resuelve la herencia el punto de los empleados y los clientes? Bien, Podemos aplicar el proceso de generalización y movernos de lo particular a lo general. En ejemplo vimos que tres de las propiedades eran iguales en las dos clases. Eso significa que podemos tener una clase base llamada Persona, por ejemplo.

Public Class Persona
Private m_nombre As String
Private m_fechanac As Date
Private m_email As String

Public Property nombre() As String
Get
Return m_nombre
End Get
Set(ByVal Value As String)
m_nombre = Value
End Set
End Property


Public Property fechanac() As Date
Get
Return m_fechanac
End Get
Set(ByVal Value As Date)
m_fechanac = Value
End Set
End Property

Public Property email() As String
Get
Return m_email
End Get
Set(ByVal Value As String)
m_email = value
End Set
End Property


End Class

Clase Empleado
Public Class Empleado_h
Inherits Persona

Private m_salario As Decimal

Public Property salario() As Decimal
Get
Return m_salario
End Get
Set(ByVal Value As Decimal)
m_salario = Value
End Set
End Property

End Class


Clase Cliente
Public Class Cliente_h
Inherits Persona

Private m_compania As String
Public Property compania() As String
Get
Return m_compania
End Get
Set(ByVal Value As String)
m_compania = Value
End Set
End Property


End Class

Module Module1

Sub Main()
Dim e As New Empleado_h
e.nombre = "Guillermo"
e.fechanac = #1/1/1950#
e.email = "Guille_50@hotmail.com"
e.salario = 45000

Dim c As New Cliente_h
c.nombre = "Ana"
c.fechanac = #5/5/1982#
c.email = "ana_82@hotmail.com"
c.compania = "la nueva CO"


Console.WriteLine("nombre: {0}, fecha: {1} email: {2} salario: {3}", e.nombre, e.fechanac, e.email, e.salario)
Console.WriteLine("nombre: {0}, fecha: {1} email: {2} compañia: {3}", c.nombre, c.fechanac, c.email, c.compania)
Console.ReadLine()

End Sub

End Module


Bibliografia VB .NET by Example p .306-312

Métodos

Mexicali, Baja California a 22 de Mayo de 2006.
Métodos
Métodos dentro de una Clase
Ya hemos definido anteriormente que una clase es un set de objetos que comparten caracteristicas comunes y comportamiento. Los objetos son parte de este set y son conocidos como instancias de la clase. Hemos visto que los atributos de una clase son implementados como campos y propiedades. Sabemos ahora que los campos contienen los datos de un objeto y las propiedades proveen acceso controlado a este estado.

Veremos ahora el comportamiento, el cual es la segunda dimensión de las clases. El comportamiento significa describir que es lo que puede hacer una instancia de la clase. Por ejemplo, un caballo puede trotar, brincar, comer, entre otras cosas. Todos los caballos pueden realizar estas acciones. El set de todas las acciones, que los objetos de una clase pueden realizar son llamados, Comportamiento. En la programación, el comportamiento es representado como métodos de una clase.

Un método es una función o una subrutina definida dentro del cuerpo de una clase, la cual realiza alguna acción cuando es llamada. Por ejemplo, un método que se llame Jump en la clase Horse podria calcular que tan alto puede brincar el caballo basado en su altura y regresar el valor al que lo mando llamar. Veamos el siguiente ejemplo:

Public Class Horse
Private m_name As String
Private m_color As String
Private m_height As Single

Public ReadOnly Property name() As String
Get
Return m_name
End Get
End Property

Public ReadOnly Property color() As String
Get
Return m_color
End Get
End Property

Public Property height() As Single
Get
Return m_height
End Get
Set(ByVal Value As Single)
If 1 <= Value And Value <= 2.5 Then
m_height = Value
End If
End Set
End Property

Public Sub New(ByVal name As String, ByVal Color As String, Optional ByVal height As Single = 1.5)
m_name = name
m_color = Color
MyClass.height = height

End Sub

Public Function jump() As Single
Return CSng(1.75 * m_height)
End Function
End Class


Aquí tenemos todos los campos declarados como privados, y tambien tenemos propiedades publicas para los atributos. El nombre y el color deben de ser proveidos cuando se construya el objeto caballo porque las propiedades nombre y color son declaradas como Readonly. La altura es opcional y puede ser modificada después.

La Nueva función Jump es un metodo de la clase que regresa la altura que el caballo puede brincar. En este ejemplo sencillo, siempre es el 75% de su altura. Este valor es calculado, convertido a Single y regresado.

Para usar el nuevo método que definimos:
Module Module1

Sub Main()
Dim C As Horse = New Horse("Negro", "Negro", 2.5)
Console.WriteLine("Nombre: {0} Color{1}", C.name, C.color)
Console.WriteLine("Distancia Brincada: {0}", C.jump)
Console.ReadLine()

End Sub

End Module

Los métodos normales de una clase (no constructors o propiedades) pueden ser llamados usando la notacion-punto familiar y proveyendo los paréntesis después de llamar al método. Si un método tuviera un argumento definido, necesitaríamos poner los valores de los parámetros dentro de los paréntesis. Si tuvieramos mas de un valor, necesitaríamos separarlos por comas.

Los métodos de las clases tiene modificadores de acceso, similares a los campos y propiedades. Estos pueden ser Public, Private, Protected, o Friend. El significado de los modificadores son los mismos como para las propiedades y los campos. Los métodos Publicos pueden ser llamados por cualquiera; los privados pueen serllamados solo por otros métodos o propiedades de la misma clase.

Como vimos del ejemplo anterior, los metodos tienen acceso a los otros miembros de la clase. Por ejemplo el metodo Jump usa el campo m_height para desarrollar su tarea. Algunos métodos pueden alterar alguno de los atributos del objeto, tambien a traves de propiedades (properties) (como un constructor, donde se use la propiedad height) o a traves del uso de los campos de la clase.

Si tuvieramos que crear dos objetos del tipo Horse, cada uno de ellos con su propia altura (height), y después llamar el Metodo Jump los valores que regresaria serian diferentes porque en cada caso el metodo regresaria el 75 porciento de la altura del objeto que mandamos llamar.

Module Module1
Sub Main()
Dim H as Horse = New Horse (“Bucefalus”, “black”, 2)
Dim g as Horse = New Horse (“Lightning”, “brown”, 1.75)

Console.WriteLine (“The horse {0} el color: {1} y la altura: {2}”, H.name, H.color, H.Jump())

Console.WriteLine (“The horse {0} el color: {1} y la altura: {2}”, g.name, g.color, g.Jump())
End Sub
End Module

En resumen podríamos decir que un método es una subrutina o una funcion definida dentro del cuerpo de la clase que podemos mandar llamar de un objeto (usando la notacion-punto) para pedirle al objeto que realice una tarea especifica.




Bibliografia VB .NET by Example p .276-278

Trabajos de Investigacion por Alumnos

Ana Laura Lopez Corona
Alfredo Herrera Ruiz
Ernesto Vidal Pinto Villarino
Ernesto Alonso Aguilar Burgoin
Patricia Gonzalez Valdez

Estructuras

Estructuras

Una Estructura es un tipo de datos complejo que consiste de uno o mas miembros (conocidos como campos).

Module Module1

Structures PixelCoord
Public x As Single
Public y as Single
End Structure

Sub Main()
Dim p as PixelCoord

p.x= 200
p.y =100

Console.WriteLine(“El valor p.x es {0}”, p.x)
Console.WriteLine (“El valor de p.y es {0}”, p.y)
Console.ReadLine ()

End Sub
End Module

De aquí podemos ver en el codigo que la declaracion de la estructura se hace con Structure, seguido de el nombre de la estructura, y el final de la pabra end Structure, la cual marca el final de la estructura. Dentro de la declaracion de la estructura tenemos los miembros de la estructura. Cada miembro de una estructura es una variable con un tipo especifico. Usamos una sintaxis similar al los enunciados Dim pero exepto que estamos utilizando Public el cual es visible fuera de la estructura.




Bibliografia VB .NET by Example p 128-131

Propiedades

Propiedades
¿Que son las propiedades?
En los ejemplos anteriores vimos una clase llamada horse, la cual tenia varios campos, nombre, color y altura. En el constructor buscábamos que la altura estuviera dentro del rango de entre 1 y 2.5 metros. Esto nos aseguraba de que fuera que el objeto tuviera valores reales. Pero, aun asi, el usuario podia tener acceso directamente al valor dentro de la clase m_height.

Dim h as horse = New horse (“Bucefalo”, “black”, 2)
h._mheight = -250.34

Si el usario le cambia la altura al caballo a valores negativos entonces, ya tendríamos un objeto no valido. Se dice de un objeto invalido que tiene un estado inconsistente, significa que tiene valores que no coinciden o valores incorrectos entre los campos de la clase (miembros de los datos).

El caso aquí es que, si usamos el campo como publico (m_height) para representar la un atributo altura en la clase, el usuario de la clase puede inadvertidamente cambiarlo a un valor invalido. Podemos limitar el acceso al campo haciendolo Friend, y solamente el código del ensamble puede dañar la clase. Pero entonces nadie fuera del entorno podría saber cual es la altura del caballo. Esta es una limitacion severa en la funcionabilidad. Para solucionar este tipo de problema, se introdujo las propiedades de la clase.

De un punto de vista conceptual, los campos y las propiedades son similares: Ambos son utilizados para implementar el valor de un atributo de la clase. Hemos visto que los los campos son solamente variables que retienen datos. Las propiedades son una forma de procedimiento que te permite ajustar y la manera en como se comportara un atributo dentro de una clase. Normalmente utiliza un campo private o protected.


Public Class Horse
Public m_name As String
Public m_color As String
Private m_height As Single = 1.5

Public Property altura() As Single
Get
Return m_height
End Get
Set(ByVal Value As Single)
If 1 <= Value And Value <= 2.5 Then
m_height = Value
End If
End Set
End Property

Public Sub New(ByVal name As String, ByVal color As String, ByVal height As Single)
m_name = name
m_color = color
MyClass.altura = height

End Sub

End Class

La primera cosa que hay que observar es que m_height es ahora privado; puede ser accedida desde el miembro de la clase, pero será invisible para cualquiera fuera de la clase.
Hemos agregado el enunciado Property el cual es muy similar a un enunciado de una funcion. Tiene un tipo, el cual nos indica el tipo de propiedad. En este caso la propiedad es Single. El enunciado de la Propiedad se compone de dos partes (bloque y enunciados): un bloque GET y otro bloque SET. Por lo menos uno de los dos bloques debe de estar presente. Veremos cual de los dos puede ser omitido.
El bloque GET es el que es ejecutado cuando el usuario accesa la propiedad. Esto es conocido como bloque de lectura. El bloque es delimitado por GET y el enunciado END GET. Este bloque puede contener cualquier enunciado regular y debe terminar regresando el valor de la propiedad. El valor que regresa debe coincidir con el tipo de la propiedad. En este caso regresamos el valor del campo privado m_height.

El bloque SET, es usado para cambiar el valor de la propiedad. Esto pasa cuando un usuario intenta cambiar el valor. Se ejecuta cuando el usuario intente cambiar este valor. Se espera que el valor se guarde en algún lugar (por ejemplo en un campo privado) y cuando se lea después, se regrese. Como el bloque GET, el Bloque SET esta delimitado por las palabras SET y END SET. Dentro del bloque, podemos tener enunciados regulares. Normalmente tenemos código que verifica que el valor cambiado por el usuario sea valido. Es importante que entendamos que este valor es del mismo valor que el del tipo de la propiedad (single) y que esta representado por la palabra Value. Esta palabra no esta declarada por ningún lado, y debe de ser accedida dentro del bloque SET. Dentro de nuestro ejemplo vimos que verificamos que el valor se encuentra dentro de los rangos para la altura de un caballo,.

Usando Propiedades
Las propiedades pueden ser usadas exactamente como los campos son usados. Por ejemplo, si usamos la clase que ya hemos definido antes, podemos escribir el siguiente código:

Dim caballo As Horse
caballo = New Horse("Caballito", "Blanco", 2.2)
Console.WriteLine("Nombre: {0}", caballo.m_name)
Console.WriteLine("Color: {0}", caballo.m_color)
Console.WriteLine("Tamaño: {0}", caballo.altura)
Las propiedades son muy útiles si tenemos una propiedad que es solo-lectura o algunas veces solo-escritura. Algunas veces querremos prevenir que los usuarios cambien directamente una propiedad. Si tenemos una clase llamada persona esto modela una persona con un nombre y una fecha de nacimiento, podríamos elegir en inicializar el nombre de la persona y la fecha de nacimiento y hasta crear un nuevo objeto y no permitir al usuario cambiarlos después. Esto puede ser posible usando una propiedad de solo lectura. Esta es una propiedad que los usuarios pueden leer (get) pero no cambiar:

Public Class Person
Private m_name As String
Private m_dob As Date

Public ReadOnly Property name() As String
Get
Return m_name
End Get
End Property
Public ReadOnly Property dob() As Date
Get
Return m_dob
End Get
End Property

Public Sub New(ByVal name As String, ByVal dob As Date)
m_name = name
m_dob = dob

End Sub

End Class

Ambas propiedades de esta clase usan el modificador de solo-lectura que indican que solo hay un bloque GET definido- que esta propiedad no puede ser cambiada (SET).

El ejemplo del modulo es el siguiente:




Module Module1

Sub Main()
Dim p As Person
p = New Person("Daniel", #7/4/1972#)
Console.WriteLine("Nombre: {0} Fecha: {1}", p.name, p.dob)
Console.ReadLine()

End Sub

End Module

Si el usuario escribiera el siguiente código p.name = “Ragnar D.” Esto no se compilaria. Esto es un mecanismo empleado en el encapsulamiento (protección) de datos para las instancias de una clase.

Puedes usar propiedades de solo-escritura usando el modificador WriteOnly para la propiedad del bloque SET. Esto forzará a la propiedad de solo aceptar asignaciones, pero no permitirá lecturas, es el opuesto de una propiedad ReadOnly. WriteOnly es utilizado solo algunas veces y normalmente para datos volatiles (por ejemplo en el flujo de datos, como en la salida a la consola) Por ejemplo:

Public Class OutTextStream
Public WriteOnly Property outText() As String
Set(ByVal Value As String)
Console.WriteLine(Value)
End Set
End Property

End Class

Module Module1

Sub Main()
Dim o As OutTextStream
o = New OutTextStream
o.outText = "Esto es la salida"
Console.ReadLine()

End Sub

End Module

Creamos una clase que nos permite tener salida de texto hacia la consola cambiando el valor de una propiedad llamada outText. En esta ocasión no hay ningún campo en donde guardar datos, asi que no tiene sentido tener un GET, que regresaríamos?

Bibliografia VB .NET by Example p .258-263

Constructores y Sobrecargos

Constructores de Clases

Te puedes encontrar con casos en el que después de haber creado un objeto, después tengas que cambiar un valor casi inmediatamente. Por ejemplo, si continuamos usando el código de la clase Horse:
Module Module1
Sub Main ()
Sub Main()
Dim h As New Horse
With h
.m_color = "White"
.m_name = "Bucefalo"
.m_height = 1.9
End With
Console.WriteLine("Nombre {0}", h.m_name)
Console.WriteLine("Color {0}", h.m_color)
Console.WriteLine("Altura {0}", h.height)
Console.ReadLine()
End Sub
End Module

El ejemplo es muy común: Crear un objeto y cambiarle los valores para estos campos. Esta tarea se vuelve tediosa, especialmente para las clases con un gran numero de campos. Esa es una de las razones por la cual se utilizan los constructores de clases ( o constructores ) y fueron introducidos en los lenguajes Orientados a Objetos. Un constructor es un procedimiento Sub Especial, el cual se llama con New , el cual permite a un nuevo objeto ser inicializado de una cierta manera. El siguiente ejemplo nos muestra la clase Horse con un constructor.

Public Class Horse
Public m_name As String
Public m_color as String
Friend m_height As Single = 1.5

Public Sub New (ByVal name As String, ByVal color As String, ByVal height As Single)
m_name = name
m_color = color
m_height = height
End Sub
End Class

El Constructor es un procedimiento Sub normal, excepto que tiene una palabra especial llamada (New), y debe de ser declarada como parte de la clase. Los procedimientos de las Clases y las funciones son usualmente conocidos como Métodos de las Clases (o Métodos). Es por eso, que los constructores son un tipo especial de método. Lo puedes declarar con cualquier argumento que creas apropiado para la clase. El constructor será llamado cuando construyas un nuevo objeto al cual le pasaras los parámetros que coincidan con la lista de argumentos.


Module Module1
Sub Main ()
Dim h as Horse = New Horse (“Lightning”, ”Brown”, 1.9)
Console.WriteLine("Nombre {0}", h.m_name)
Console.WriteLine("Color {0}", h.m_color)
Console.WriteLine("Altura {0}", h.height)
Console.ReadLine()
End Sub
End Module


Dim h as Horse
h = New Horse (“Lightning”, ”Brown”, 1.9)

El constructor se ejecutará en ambos casos, con los argumentos enviados. Un constructor es un Sub Procedimiento regular, y puede contener otros enunciados que pueden ser parte de un procedimiento. Si quisiéramos evaluar un valor para la altura dentro de los limites rasonables (por lo menos un metro y en el ultimo de los casos 2.5 metros de alto). Podriamos modificar el codigo de la siguiente manera.

Public Class Horse
Public m_name As String
Public m_color As String
Public m_height As Single = 1.5

Public Sub New(ByVal name As String, ByVal color As String, ByVal height As Single)
m_name = name
m_color = color
If 1 <= height And height <= 2.5 Then
m_height = height
End If
End Sub
End Class

Si son estas condiciones (la altura entre 1 y 2.5) el campo m_height será cambiado al del parametro; de otra manera tendra los valores por default de 1.5.

En UML se representaría el método de la clase (conocida en UML como operación) en el tercer compartimiento de la clase como se muestra.

Horse
+m_name: String
+m_color: String
m_height: Single
+New ()

Que pasaria en nuestro ejemplo si quisiéramos construir un Objeto llamado Horse y algunas veces mandarle solo 2 argumentos y otras 3. Tenemos dos opciones:

• Podríamos usar un constructor con argumentos opcionales
• Podríamos tener mas de un constructor

Los dos ejemplos serán ilustrados;


Public Class Horse
Public m_name As String
Public m_color As String
Public m_height As Single = 1.5

Public Sub New(ByVal name As String, Optional ByVal color As String = "", Optional ByVal height As Single = 0)
m_name = name
m_color = color
If 1 <= height And height <= 2.5 Then
m_height = height
End If
End Sub
End Class
En este caso declaramos los dos ultimos argumentos opcionales, podriamos llamar al constructor como:
Dim h As Horse = New Horse("Lightning")
Dim h As Horse = New Horse("Lightning", , 2.4)
Dim h As Horse = New Horse("Lightning", "Brown")
Dim h As Horse = New Horse("Lightning", "Brown", 2.4)
La segunda solución de este problema envuelve el uso de Metodos sobrecargo. Metodos Sobrecargo son metodos que tienen el mismo nombre pero que tienen un código diferente. Cuando uno de estos metodos sobrecargados es llamado, el compilador determinará cual de ellos llamar, basado en el código (numero, orden, y tipo de los parámetros que son enviados)

Si tienes dos constructores con el mismo nombre debes especificar Sobrecargo para ambos, de otra manera el programa no se compilara.

Public Class Horse
Public m_name As String
Public m_color As String
Friend m_height As Single = 1.5

Public Sub New(ByVal name As String, ByVal color As String, ByVal height As Single)
m_name = name
m_color = color
If 1 <= height And height <= 2.5 Then
m_height = height
End If
End Sub
*********************************
Public Sub New(ByVal name As String, ByVal color As String)
m_name = name
m_color = color
End Sub
End Class
************************************
Module Module1
Sub Main()
Dim h As Horse
h = New Horse("nombre", "Black", 1.8)
MsgBox(h.m_height)
End Sub
End Module

Bibliografia VB .NET by Example p .246-250

Campos de las Clases

Mexicali, Baja California a 8 de Mayo de 2006.
(Continuación…)
Campos de las Clases

Los campos de una clase conforman sus datos, es lo que el compilador reservará en memoria cuando un objeto de esta clase es instanciada. Los campos son fundamentales en la clase: Definir los campos correctos es crucial. Esto normalmente se realiza como parte en la etapa del diseño de la vida del ciclo del desarrollo del software (Software Development Life Cycle SDLC).

• Public Significa que el campo puede ser accedido por cualquiera en el proyecto y en otros proyectos que utilicen la clase. Cualquiera puede tomar el valor del campo y cambiarlo (si no es un campo constante).
• Private Significa que el campo no es visible o accesible por cualquiera, pero si por si mismo. Los elementos son accesibles del mismo modulo, clase o estructura.
• Protected Es un modificador usado en la herencia jerárquica. Los elementos son accesibles desde la misma clase o de una clase derivada.
• Friend Se usa para definir campos que pueden ser accedido por cualquiera en la misma en el mismo ensamblaje, pero no podra ser visible por aquellos fuera del ensamblaje. En efecto significa publico para el propósito del ensamblaje que se esta realizando y privado para el resto del mundo. Quiere decir que puede ser usado dentro del mismo proyecto pero no desde otro proyecto por fuera.


Si quisieras prevenir que tuvieran acceso los usuarios externos de la clase horse al campo m_height, lo puedes hacer Friend. Eso te va a permitir seguir teniendo acceso a el desde el código en este ensamblador e importar la clase Horse.

Public Class Horse
Public m_name As String
Public m_color As String
Friend m_height As Single
End Class

Si cambias el campo height a Private (Privado), nadie, (excepto el código en la clase Horse) puede tener acceso a el. Esto va a causar que el ejemplo anterior marque error en la compilación.

Mencionamos que las clases son normalmente definidas en la etapa de diseño del SDLC (Software Development life cycle). Necesitaras representar clases y campos gráficamente, hacer diagramas con clases, y en general visualmente representar clases y sus miembros. Representaras las nociones fundamentales requeridas para entender la notación que usas –La cual es casi universalmente aceptada la notación simbólica conocida como Unified Modeling Language ó UML. (Lenguaje Modelado Unificado)

Las clases son representadas como rectángulos con dos o tres compartimentos. El nombre de la clase siempre se encuentra en la parte superior del recuadro; los atributos de la clase están siempre en el segundo nivel. El tercer nivel es usado para los métodos.

Horse
+m_name: String
+m_color: String
m_height: Single

Representación UML de la clase Horse

Los atributos UML corresponden a nuestros campos. La convencion para indicar que tipo de atributo tiene es.

NombreAtributo : TipodeNombre

Esto significa que el NombreAtributo es del tipo TipodeNombre.
• + es usado para indicar visibilidad Public
• # es usado para indicar visibilidad Protected
• - es usado para indicar visibilidad Private

La visibilidad Friend esta indicada en la no utilización de cualquiera de estas notaciones.


Los tipos de campos en una clase puede ser cualquier valor valido. Pueden ser tipos de datos fundamentales. Puede contener estructuras, enumeraciones, o arreglos. Puede contener objetos de otra clase, y hasta objetos de la misma clase.

Los campos de una clase pueden ser inicializados a un valor por default, como se muestra a continuación.

Public Class Horse
Public m_name As String
Public m_color As String
Friend m_height As Single = 1.5
End Class

Cada ves que un objeto es creado, todos los campos serán inicializados en sus valores por default especificados en la definición de la clase. Si no existe ningún valor por default, el valor será asignado al valor por default según el tipo. Cero para los valores numéricos, valor vació para los tipo String (Cadena), Falso para Bolean (Boleanos), Nothing para los objetos.

En este ejemplo cuando creas la instancia u objeto para la clase horse, m_name y m_color se le autoasignara una cadena vacia (“ “) y para el campo m_height tendrá un valor de 1.5.

Podemos verificar esto con el siguiente código:

Module Module1
Sub Main ()
Dim h As New Horse
With h
.m_color = "White"
.m_name = "Bucefalo"
End With
Console.WriteLine("El Valor {0}", h.m_height)
Console.ReadLine()
End Sub
End Module

Creamos una instancia para Horse, y sin hacer nada mas, nuestra salida fue el valor de 1.5.

Bibliografía: VB . NET by Example p. 243-246

Definiendo Clases y Objetos

Mexicali, Baja California a 3 de Mayo de 2006.


Introducción a Objetos y Clases

Todos sabemos lo que es un objeto: una piedra encontrada en la playa, un árbol de roble frente a una casa, o Bucéfalo-el caballo de Alejandro el Grande. Todos estos ejemplos de objetos, cada uno de ellos con sus propias características, y diferentes de otros objetos. Podemos describirle un objeto a alguien que jamás lo ha visto y transmitir una idea de cómo es el objeto. Por ejemplo, nunca hemos visto el caballo de Alejandro el Grande, quizás tu tampoco, pero leyendo la descripción de los historiadores, podemos saber y darnos una idea de como era bucéfalo. La imagen de Bucéfalo se formará en tu mente, basado en lo que sabemos sobre caballos de nuestra propia experiencia más la descripción hecha por algún historiador, lo cual nos lleva a un detalle sobre las características especiales y particulares que tenia Bucéfalo. Esto es, usamos nuestros conocimientos generales sobre caballos y la información particular sobre este caballo en particular (lo que distingue este caballo de otros) para construir la representación de Bucéfalo.

Esta combinación general/particular es un mecanismo muy poderoso de transmitir información. Es considerada uno de los mecanismos fundamentales que sostiene el lenguaje (representación simbólica) usada por humanos. Un mecanismo similar es usado por los Lenguajes de programación Orientada a Objetos (OO).

La Información general a cerca de un set especifico de objetos es conocida como una clase. En el ejemplo sabias que hay un tipo de objetos llamado caballo, los cuales tienen cuatro piernas, cabeza, una cola, dos orejas, son usados para montar, entre otras cosas. Si agrupas toda la información común de todos los caballos y agrupas esta información bajo el nombre abstracto de caballo, tienes una idea de lo que es una clase. Caballo es pues el nombre genérico para cualquier miembro del set de todos los caballos particulares.

La información Particular que diferencia un caballo de otros caballos es usado para construir una imagen mental de un caballo (o en el caso general de cualquier objeto) en nuestra mente. Por ejemplo: la clase caballo genérica tiene un color, el cual es una característica de la clase. Esto es, sabes que cualquier caballo tiene un color. No puedes predecir que color podría tener un caballo en particular sin más información a cerca del caballo. Esta información podría ser el color actual del caballo, el cual es en efecto el valor de la característica del color de la clase.

El mismo mecanismo general/particular es usado en Lenguajes de Programación OO para definir clases y objetos. Una clase es un tipo de información definida por el usuario que describe un set de objetos que comparten algunas características. Un objeto es un miembro de este set. Se dice que un objeto es una instancia de una clase al que pertenece. Un objeto no puede pertenecer a mas de una clase, un objeto no puede ser un caballo y una piedra a la ves. Veremos mas tarde cuando veamos herencia, que este enunciado se debe de entender de una forma.

Nota:
Por ejemplo puedes tener una clase mas general llamada Mamífero, que incluiría todos los Mamíferos, y por lo tanto todos los caballos. En términos matemáticos es un superset de la clase caballo. Por lo tanto, en este sentido, un caballo también es un mamífero. El echo es que las clases Mamífero y Caballo están relacionadas en una forma especial, mientras que las clases caballo y piedra no están relacionadas (presumiblemente).

Una clase es una manera de agrupar objetos que comparten un numero de características: atributos (como nombre, color, altura, peso, etc.) y el comportamiento (como habilidades para brincar, correr, nadar, etc.) Por ejemplo todos los objetos en la clase caballo tendrán un atributo llamado altura. Esto significa que todos los objetos en esa clase tienen una altura-el valor del atributo altura será diferente para cada instancia de la clase (ej. Para cada caballo en particular). Este es un concepto muy importante que se necesita entender: Todas las instancias de una clase (objetos) tienen todos los atributos definidos por la clase. Cada objeto individual tiene su propio valor(es) para estos atributos.

Formalmente una clase es un set de objetos que comparten una estructura de datos comunes y comportamiento. Un objeto es una estructura de datos (también conocido como estado) y el comportamiento asociado con el.

Definiendo una clase en Visual Basic .NET
Una clase es un tipo de dato definido por el usuario. Su declaración es similar a la declaración de estructuras. Puedes declararlas como parte de un modulo; sin embargo, por el echo de que las clases tienden a ser mas grandes (tienen mas líneas de código) que las estructuras, son declaradas en archivos separados (usando la misma extensión .vb).

Crear un proyecto de consola y dale el nombre sugerido
ClassExample1. Del menú del proyecto selecciona Add Class y cambia el filename de Class1.vb a Horse.vb. Introduce las lineas de código mostradas en negro en el siguiente ejemplo:

Public Class Horse
Public m_name As String
Public m_color As String
Public m_height As Single
End Class

Esta es la definición de una clase. Aparentemente no hay diferencias mayores entre una clase y una estructura (excepto la palabra Class, la cual reemplaza Structure). Una clase puede tener campos, el cual tiene la misma semántica de los campos en una estructura. En este ejemplo se tiene tres campos públicos m_name, m_color, y m_height.

Nota:
El prefijo m_ es una notación convencional usada por los campos clases y permanece para miembros de datos. Usaremos esta convención a través de este libro. Es de gran ayuda ya que nos permite distinguir entre campos y propiedades.

Todas las instancias de esta clase tendrán estos tres campos; cada instancia puede tner diferentes valores para los campos. Esto es similar en la vida real, donde todos los caballos tienen un nombre, altura, y color, pero cada caballo tiene sus propios valores para estos atributos. La idea detrás del paradigma Orientado-a-Objetos es de tratar y emular la vida real en una forma natural e intuitiva.

Puedes ahora usar la clase que definimos. Podemos declarar variables par este tipo de datos, los cuales son conocidos como variables objetos. Estas variables son los objetos o instancias del tipo de caballo. Podemos usar una variable declarada en esta forma para acceder a los miembros de la clase (campos, como en el ejemplo). Podemos cambiar los valores para estos campos, y en general usar las variables como las usarías en cualquier estructura, con una diferencia importante: Los Objetos tienen una tarea por-referencia semántica. Esto significa, que asignando una variable del tipo caballo a otra no va a hacer una copia del objeto, pero tendrá una referencia al mismo objeto que el primero.

Introducir el siguiente código en Sub Main, en Modulo1. El código ilustra un ejemplo de usar la clase caballo.




Module Module1
Sub Main ()
Dim h As horse = New Horse()
h.m_name= “Bucefalo”
h._m_color = “black”
h.m_height = 2

Dim g as Horse
g= h

g.m_height = 1.8
Console.WriteLine (“Altura para h es ahora {0}”, h.m_height)
End Sub
End Module

Primero declaramos una variabe nueva del tipo caballo y la inicializamos. Podriamos decir en otras palabras que creamos una instancia de un caballo, o creamos un objeto caballo. Esto es echo usando la palabra New . New (nuevo) es usado para crear un nuevo objeto de un tipo especifico. Es proseguido por el nombre de la clase y los paréntesis. El nuevo operador le da la instrucción al compilador de reservar la memoria requerida para un objeto de una clase especificada.

Bibliografía: VB .Net By Example. P. 238-241

RESULTADOS FINALES

Nota: El promedio final con o sin redondeo lo establece la Universidad.

Funciones y Subrutinas

EL SIGUIENTE PROGRAMA DEBERÁ CONTENER LOS TRES TIPOS DE FUNCIONES Y UNA SUBRUTINA LOS CUALES REALIZARAN LO SIGUIENTE:

1) Función sin argumentos que no devuelve nada
a. Realizará una pausa en el programa al ser llamada la función.
b. La función tendrá el nombre de pausa

2) Función con argumentos que no devuelve ningún valor
a. Le mandaras una cadena (un mensaje) y un valor numérico a la función
b. El mensaje se desplegará en pantalla tantas veces lo indique el valor numérico que recibe la función.
c. Mandará llamar la función pausa al terminar el ciclo
d. La función tendrá el nombre de Mensaje

3) Función con argumentos que recibe y regresa valor
a. Se le enviará dos cadenas y las comparará, si son iguales regresara un mensaje indicando: son iguales o son diferentes el cual desplegara fuera de la función.
b. Usar la función del sistema SrtComp (cad1, cad2)
c. La función tendrá el nombre de Compara

4) Subrutina que recibe argumentos y modifica el valor de la variable.
a. La subrutina recibirá dos variables y se modificará el contenido de ellas. Pero solamente una de las variables mantendrá su valor original al salir de la subrutina.
b. Mostrará en pantalla los valores desde programa principal y los valores desde la subrutina, demostrando así que fue solamente una variable modificada.
c. La Subrutina tendrá el nombre de Modifica.

5) Teórico (Explica y Contesta claramente lo que se pide)
a. ¿Porqué y cuando es necesario utilizar Procedimientos (Funciones o subrutinas)?
b. ¿Cuál es el error más común en un programador cuando no utiliza procedimientos?
c. Explicar como pasar argumentos a una subrutina o función, como son afectadas globalmente las variables dependiendo en la manera en que recibe, como se regresa un valor de un procedimiento y en que tipo es solamente permitido.




Module Module1

Sub Main()
Dim Num1 As Integer = 10, Num2 As Integer = 10
pausa()
Mensaje("hola", 2)
Console.WriteLine("Iguales o diferentes: {0}", Compara("mensaje1", "mensaje1"))
Console.WriteLine("antes de modificar: {0} {1}", Num1, Num2)
Modifica(Num1, Num2)
Console.WriteLine("Despues de modificar: {0} {1}", Num1, Num2)

pausa()

End Sub

‘Función sin argumentos que no devuelve nada
Function pausa()
Console.ReadLine()
End Function

‘Función con argumentos que no devuelve ningún valor
Function Mensaje(ByVal mens As String, ByVal num As Integer)
Dim x As Integer
For x = 1 To num
Console.WriteLine("{0}", mens)
Next
pausa()
End Function

‘Función con argumentos que recibe y regresa valor
Function Compara(ByVal cad1 As String, ByVal cad2 As String) As String
If StrComp(cad1, cad2) = 0 Then
Return "son iguales"
Else
Return "son diferentes"
End If
End Function
‘Subrutina que recibe argumentos y modifica el valor de la variable.
Sub Modifica(ByVal Num1 As Integer, ByRef Num2 As Integer)
Num1 = 0
Num2 = 0
Console.WriteLine("Los valores dentro de la subrutina: {0} {1}", Num1, Num2)
Mensaje("Presiona Enter para continuar", 1)
End Sub
End Module

5) Teórico (Explica y Contesta claramente lo que se pide)
a) ¿Porqué y cuando es necesario utilizar Procedimientos (Funciones o subrutinas)?
Habrá ocasiones en que el programa deberá ser partido en pequeñas unidades, llamados procedimientos, los cuales ejecutan una determinada tarea. Las razones para partir un programa es porque el programa puede convertirse muy grande para entenderse y, lo mas importante, puede haber partes del programa que hagan lo mismo (o una tarea muy similar) una y otra ves. Si se tiene un procedimiento que permite ejecutar una tarea específica, puedes llamar a este procedimiento cada ves que sea necesario.

b)¿Cuál es el error más común en un programador cuando no utiliza procedimientos?
Es actualmente uno de los errores mas usuales en programas reales. La técnica de duplicar porciones de código en diferentes lugares en el programa (con algunas diferencias) es conocido como la tecnica Copy-Paste. El error mas común relacionado al copy-paste es que modifican el código en algunos lugares y olvidan cambiarlo en otros.

c) Explicar como pasar argumentos a una subrutina o función, como son afectadas globalmente las variables dependiendo en la manera en que recibe, como se regresa un valor de un procedimiento y en que tipo es solamente permitido.
En la declaración de una subrutina o función se definen los tipos de argumentos que recibirá de igual forma el tipo de argumento que se regresara solo desde la función, ya que la subrutina no puede regresar valores. Los tipos de argumentos pueden ser del tipo de variable que va a recibir (Integer, String, Decimal …)

Argumentos multiples y ByVal versus ByRef
La palabra ByVal (By Value) le indica al compilador de una forma precisa como manejar los valores enviados a través de la subrutina. La alternativa es ByRef (By Referente). Como lo indica o sugiere el nombre (ByVal), el compilador envía el valor de la variable. Esto es, hará una copia de la variable, y lo pasara la copia a la subrutina. La subrutina puede cambiar el valor, pero cuando la subrutina termine, el valor de la variable original no va a cambiar.


‘Dentro del cuerpo del programa:
Modifica(Num1, Num2)


‘Subrutina que recibe argumentos y modifica el valor de la variable.
Sub Modifica(ByVal Num1 As Integer, ByRef Num2 As Integer)
Num1 = 0
Num2 = 0
Console.WriteLine("Los valores dentro de la subrutina: {0} {1}", Num1, Num2)
Mensaje("Presiona Enter para continuar", 1)
End Sub

En este ejemplo vemos como se manda llamar la subrutina y a la cual se le envían dos valores tipo Integer. La Subrutina (declarada al final de la subrutina principal) recibe dos parámetros, uno por valor y otro por referencia. El primero no modifica el espacio en memoria reservado para esa variable. Pero en cambio la segunda, al ser Referida, modifica la variable convirtiéndola en variable global.

PEMEX vs USA

Hacer un programa que calcule el costo por litro de gasolina comparando la cantidad en litros.

Se Insertaran los valores del costo por litro de PEMEX y el costo por Galon en USA. Ademas se tendra que insertar el precio del Dollar.

El calculo se realizara a partir del total de consumo. El cual mostrara la cantidad de combustible despachado en litros. Esto nos mostrara cual de los dos combustibles nos da mas litros por peso.

Convertidor Numerico a Texto (programa)

Module Module1
'uno dos tres cuatro cinco seis site ocho nueve diez
'once doce trece catorce quince diesiseis diesisiete diesiocho diesinueve
'veinte veintiuno veintidos veintitres veinticuatro veinticinco veintiseis veintisiete veintiocho veintinueve

'treinta treinta y uno treinta y cuatro treinta y cinco treinta y siete treinta y ocho treinta y nueve
'cuarenta cuarenta y uno, cuarenta y...
'cincuenta
'sesenta, setenta, ochenta, noventa cien
Sub Main()
Dim Numero As String
Dim tam As Integer
Dim unidad As String, decen As String, centena As String, millar As String
Dim textoNum As String
Dim Miles() As String = {"", "mil", "dos mil", "tres mil", "cuatro mil", "cinco mil", "seis mil", "siete mil", "ocho mil", "nueve mil"}
Dim Centenas() As String = {"", "cien", "docientos", "trecientos", "cuatrocientos", "quinientos", "seiscientos", "setecientos", "ochocientos", "novecientos"}
Dim Decimales() As String = {"", "", "", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa"}

Dim CeroVeinte() As String = {"", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez", _
"once", "doce", "trece", "catorce", "quince", "dieciseis", "diecisiete", "dieciocho", "diecinueve", _
"veinte", "veintiuno", "veintidos", "veintitres", "veinticuatro", "veinticinco", "veintiseis", _
"veintisiete", "veintiocho", "veintinueve"}

Do

Numero = Console.ReadLine()
tam = Numero.Length
'Regresa la longitud de la cadena

If tam = 1 Then
unidad = GetChar(Numero, 1)
End If

If tam = 2 Then
decen = GetChar(Numero, 1)
unidad = GetChar(Numero, 2)
ElseIf tam = 3 Then
centena = GetChar(Numero, 1)
decen = GetChar(Numero, 2)
unidad = GetChar(Numero, 3)

ElseIf tam = 4 Then
millar = GetChar(Numero, 1)
centena = GetChar(Numero, 2)
decen = GetChar(Numero, 3)
unidad = GetChar(Numero, 4)
End If

'***************************************** 1000-9000
If tam > 3 Then
'Console.WriteLine("{0}", Miles(CInt(millar)))
textoNum += Miles(CInt(millar)) & " "
End If

'***************************************** 200-900

If tam >= 3 And centena > 1 Then
'Console.WriteLine("{0}", Centenas(CInt(centena)))
textoNum += Centenas(CInt(centena)) & " "
End If

'************************************** 100to
If tam >= 3 And centena = 1 And unidad = 0 Then
'Console.WriteLine("{0}", Centenas(CInt(centena)))
textoNum += Centenas(CInt(centena)) & " "
End If

If tam >= 3 And centena = 1 And unidad > 0 Then
'Console.WriteLine("{0}", Centenas(CInt(centena)))
textoNum += Centenas(CInt(centena)) & "to "
End If

'********************************************** 30-99
If CInt(Right(Numero, 2)) > 29 Then
'Console.WriteLine("{0}", Decimales(CInt(decen)))
textoNum += Decimales(CInt(decen)) & " "
If CInt(unidad) > 0 Then
'Console.WriteLine("y {0}", CeroVeinte(CInt(unidad)))
textoNum += CeroVeinte(CInt(unidad)) & " "
End If
End If
'************************************* 0-29
If CInt(Right(Numero, 2)) < 30 Then
'Console.WriteLine("{0}", CeroVeinte(CInt(Right(Numero, 2))))
textoNum += CeroVeinte(CInt(Right(Numero, 2))) & " "
End If

If tam = 1 And unidad = 0 Then
textoNum = "cero"
End If

Console.WriteLine(textoNum)
textoNum = ""
Loop While CInt(Numero) < 10000

End Sub

End Module

Ejercicio Convertor Numerico a Enunciado

Hacer un programa que convierta un valor númerico a enunciado.

Es decir, si tenemos el número 345, debe de imprimir en pantalla:
"trecientos cuarenta y cinco"

2743: "dos mil setecientos cuarenta y tres"

El programa reconocera numeros desde 0 hasta 9999.
Tendras entonces en tu programa: unidad de millar, centenas, decenas y unidades.

Funciones para el manejo de Cadenas

length ()
GetChar()
Right ()
Left ()

length()
Te devuelve la cantidad de caracteres en una cadena
ej.
Dim tot as Integer, Dim cadena as String = "4527"
Dim caracter as String
Dim cad2 as String
tot = length(cadena)
'tot tendra el valor de 4



GetChar ()
Devuelve el caracter en determinada posicion de una cadena
ej.
caracter = GetChar (cadena,1)
'caracter tendra el valor de 4

right()
Regresa un determinado numero de caracteres contando desde la derecha
cad2 = Right(cadena,2)
'cad2 tendra el valor de 27


left()
Regresa un determinado numero de caracteres contando desde la izquierda
cad2 = Left(cadena,2)
'cad2 tendra el valor de 45

Ordenamiento de Arreglos

Ordenamiento de Arreglos

El método que vimos el día de hoy fue el MÉTODO DE LA BURBUJA.
El programa verifica desde la primera posición y compara con la posición siguiente si es mayor. De ser así, intercambia el contenido. Este proceso lo realiza hasta llegar al final del arreglo. Lo realiza tantas veces como elementos tenga en el arreglo.

Dim x as Integer, y as Integer
Dim numeros() as Integer = {5, 25, 50, 80, 0, 20}
Dim temp as Integer

for x = 0 to 5
console.WriteLine ("{0}",numeros(x))
Next
'imprimimos en pantalla el contenido completo del arreglo

for x= 0 to 5
for y = x + 1 to 5

if numeros (x) > numeros(y) Then
temp = numeros (x)
numeros(x) = numeros(y)
numeros(y) = temp
End If
Next
Next

for x = 0 to 5
console.WriteLine ("{0}",numeros(x))
Next
'imprimimos en pantalla el contenido completo del arreglo ya ordenado

Ejercicio:
Ordenar (del programa de alumnos) los alumnos dados de alta (ver imagen)
Nota:
1.- Tomar en cuenta que las calificaciones tambien deben de coincidir con las de los alumnos.
2.- Utilizar una funcion que recibira parametros (los arreglos) la funcion hace el ordenamiento.

Solución:

Function Ordenar(ByRef Alumnos, ByRef Calif, ByVal y)
Dim pos As Integer, x As Integer, z As Integer
Dim Temp As String
Dim Temp2 As Integer

Console.WriteLine("Ordenacion Metodo de la Burbuja ")
For pos = 0 To y
For x = pos + 1 To y
If StrComp(Alumnos(pos), Alumnos(x)) = 1 Then
Temp = Alumnos(pos)
Alumnos(pos) = Alumnos(x)
Alumnos(x) = Temp

For z = 0 To 4
Temp2 = Calif(pos, z)
Calif(pos, z) = Calif(x, z)
Calif(x, z) = Temp2
Next


End If
Next
Next

End Function

Manejo de Operadores Abreviados

Operadores abreviados de asignación
Estos operadores simplifican la escritura de expresiones, facilitando la creación de nuestro código. El resultado empleando operadores abreviados en una expresión, es el mismo que utilizando la sintaxis normal, pero con un pequeño ahorro en la escritura de código. Cuando pruebe el lector estos ejemplos,ejecute por separado la sintaxis normal, y después la abreviada, para evitar resultados inesperados.

Multiplicación: *=
División real: /=
División entera: \=
Suma: +=
Resta: -=
Concatenación: &=
Potencia: ^=

Ejemplos:
+= -= *= /=


Dim valor as Integer = 8

valor+=2
'valor = 10

valor/=2
'valor = 5

valor-=2
'valor = 3

valor *=2
'valor = 6



Fuente:
Fundamentos de Programación con Visual Studio .NET p.97