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

Nuevas Instrucciones (Visuales)

Normalmente cuando queremos imprimir en pantalla utilizamos el comando:

Console.WriteLine ("nuestro mensaje")
Y Cuando queremos solicitar llenar un dato por medio de la consola, hacemos lo siguiente:

Dim nombre As String
nombre = Console.ReadLine ()

Esta es una instrucción que habre una ventana mostrando una etiqueta y solicita el llenado de una variable:

nombre = InputBox ("Dame el nombre: ")

Para abrir ventanas mostrando un mensaje con un boton tecleamos lo siguiente:

MsgBox ("Mensaje")

Arreglo Inicializado

Arreglo Inicializado

En el siguiente ejercisio utilizaran un arreglo bidimencional que contendrá los nombres de las materias.

Dim NomMaterias() As String = {"Matematicas", "Fisica", "Algebra", "Programacion", "Electricidad"}

Utilizar este arreglo y copiarlo en la matriz Materia(,)
Todos los alumnos tiene las mismas materias en COMÚN.


Hacer la modificación respectiva en la seccion de ALTAS para que ya no les pida el nombre de la materia, simplemente la desplegarán y posterior a esto capturaran la calificaciÓn que corresponde a la materia.


Se Revisará el trabajo en clase.

Solución:
El trabajo como vieron es muy sencillo:
Tenemos un arreglo de una sola dimención la cual esta ya inicializada. De esta forma, todos los alumnos tienen las mismas materias en común. No hay necesidad de volver a llenar los campos de NomMaterias.

Lo mas práctico es utilizar solo el arreglo inicializado. Pero por ejercicio, copiaremos el vector inicializado a la matriz vacia.

for y=0 to 6
for x = 0 to 6
materias(y,x) =NomMaterias(x)
Next
Next

De esta forma, cada registro contendra el mismo listado de materias.

Solución al problema Modificaciones (arreglos)

case 3

Console.WriteLine ("Nombre del alumno: ")
busqueda = Console.ReadLine ()

for pos = 0 to y -1

if strComp (alumno(pos),busqueda) = 0 Then
for x = 0 to 5
Console.WriteLine ("Materia: {0}, Calif a modificar: {1}", materia(pos, x), calif(pos, x))
calif(pos,x) = Console.ReadLine ()
Next
End if

Next

Esta sección de programa se le agregará a un nuevo case.
El funcionamiento de este código es muy sencillo. Primero busca en el arreglo donde estan almacenados los nombres. Si es encontrado (=0) entonces al tener la posicion donde se encuentra la cadena buscada. Modificamos en otro ciclo anidado dentro de la condicion IF los valores que corresponden al renglón donde se encontró la cadena buscada.

Arreglos (Trabajo)

El mismo programa que hemos estado haciendo de la captura de alumnos con sus materias.

Anexarle al menú una opcion más:

Modificación

Que es lo que va a realizar:
Preguntará por nombre del alumno y si lo encuentra, modificará solamente las calificaciones. No volvera a capturar ni el nombre del alumno ni las materias, solo las calificaciones que le corresponden a cada materia y del alumno al que se le hizo la busqueda.

Este ejercicio lo revisaremos en clase. Por favor hagan un esfuerzo por realizarlo. Voy a tomar en cuenta este trabajo

Arreglos Bidimencionales (ejecicio1)

REPASO:
Hemos estado viendo como declarar un arreglo (Dim arreglo1(3,3) As Integer), como inicializarlo en la declaración. Vimos también la declracion de un arreglo de 3 dimenciones (Dim arreglo3 (3,3,3) As String).
Ejemplos



En la figura superior, vemos dos tipos de arreglos, de una dimención y de dos. Es importante que puedan visualizar mientras programan el acceso a los datos en forma (renglón, columna), o (y, x); sobre el eje de las 'y' y eje de las 'x'.

Para el acceso de un arreglo de (3,3) vimos lo siguiente:
Dim Arreglo(3,3) As String

for y=0 to 3
for x=0 to 3
Arreglo(y,x) = "("&y.ToString()&","x.ToString()&")"
Next
Next

En este leve ejercicio, simplemente le cargamos la posicion que le corresponde del renglon y columna.

Arreglos Bidimencionales (EN CLASE)

Vimos la declración de arreglos de dos dimenciones (Matrices)

Dim Vect1 (2,2) As Integer
Dim Vect2 (,) As Integer = {{100,80,60},{25,45,10},{6,8,1})
Dim Vect3 (3,3) As Integer
Vect2 es un arreglo de 3X3 elementos. Para acceder al numero 100 del arreglo Vect2 lo vamos a hacer de la siguiente manera:

Console.WriteLine ("{0}", vect2(0,0)) 'Imprime 100

En el siguiente ejemplo podemos imprimir en pantalla los siguientes valores:
Console.WriteLine ("{0}", vect2(0,1)) 'Imprime 80
Console.WriteLine ("{0}", vect2(0,2)) 'Imprime 60

La forma mas sencilla de visualizar la información es haciendo una imagen de una matriz, donde tenemos (renglones, columnas).

Para leer el contenido de todo el arreglo de 3X3 necesitariamos dos ciclos for Anidados

Dim x As Integer
Dim y As Integer

for y = 0 to 2
for x = 0 to 2
Console.WriteLine (" {0} ", vect2(y,x))
Next
Next
Esto imprimiria en pantalla:
100
80
60
25
45
10
6
8
1

De esta forma veriamos todo el contenido del arreglo

Trabajo: ¿Cómo llenarian el vector desde el programa? ¿Cómo lo capturarian?

Arreglos Bidimencionales (Matrices)

Matrices

Este ejemplo sencillo nos sirve para ilustrar como declarar e inicializar los valores en un arreglo, y después como acceder a estos valores. Un arreglo es muy similar al concepto matemático de una matriz con una dimensión (para los ejemplos que acabamos de ver). Pero como veremos a continuación, los arreglos pueden tener más de una dimensión. Por ejemplo, para representar los valores de los balances de las cinco cuentas en el transcurso de 5 años necesitarías tres arreglos (uno por cada año, cada arreglo con cinco valores para el balance de cada año) o podrías usar una matriz con dos dimensiones. En programación este arreglo se le conoce arreglo de dos dimensiones. Los arreglos en Visual Basic pueden tener hasta 60 dimensiones (dimensiones, no elementos!), sin embargo mas de tres dimensiones es muy inusual.

Declarar un arreglo multidimencional es muy similar como declarar el de una dimensión. El siguiente ejemplo nos lo muestra:

Dim balance (2, 4) As Decimal

Esta declaración declara un arreglo de dos-dimensiones del tipo Decimal. El límite Superior de la primer dimensión es 2; el límite superior de la segunda dimensión es 4. Esto es muy similar a una matriz de 3X5 elementos, donde cada elemento de la matriz corresponde a un elemento del arreglo (un valor Decimal en nuestro ejemplo). Si necesitaras que tu arreglo tuviera mas dimensiones, los tamaños para las dimensiones se separan con una coma (,) exactamente como el ejemplo anterior. Un arreglo de tres dimensiones se miraría de la siguiente forma:

Dim coordenadas (9, 9, 9) As Double

Esto declara un arreglo de tres dimensiones, el limite superior de cada dimensión es 9 (un total de 1,000 elementos Dobles). Como puedes ver el tamaño del arreglo se incrementa muy rápido con arreglos multidimensionales, de tal manera que uno debe de ser cuidadoso cuando y como estos arreglos son usados.

Para acceder a un elemento de un arreglo de un arreglo multidimencional necesitas especificar un índice para cada dimensión del arreglo. En el caso de un arreglo de dos dimensiones podríamos usar el siguiente ejemplo:

Dim balance(2, 4) As Decimal
balance (0, 2) = 300

Este ejemplo le asigna el valor de 300 al índice (0,2). En el caso de un arreglo bidimensional (de dos dimensiones) puedes hacer una imagen en términos de renglones y columnas. Donde el primer índice corresponde a los renglones y el siguiente índice corresponde a las columnas. Este tipo de representación se vuelve menos intuitivo cuando manejamos arreglos de más de dos dimensiones, pero estos son casos raros.

¿Podrías inicializar un arreglo multidimencional en la misma forma en que inicializabas uno de una dimensión? La respuesta es Si, veamos como. Modifique el proyecto ejemplo que se usó anteriormente para que se vea de la siguiente forma:

Sub Main ()
Dim balance(,) As Decimal = {{100, 200, 300, 400, 250} , {100, 200, 300, 400, 250},{100, 200, 300, 400, 250},{100, 200, 300, 400, 250}}
Console.WriteLine(“El valor en el arreglo elemento 0,0 es {0}”, balance(0,0))
Console.WriteLine(“El valor en el arreglo elemento 0,1 es {0}”, balance(0,1))
Console.WriteLine(“El valor en el arreglo elemento 0,2 es {0}”, balance(0,2))
Console.WriteLine(“El valor en el arreglo elemento 0,3 es {0}”, balance(0,3))
Console.WriteLine(“El valor en el arreglo elemento 0,4 es {0}”, balance(0,4))

Dim b As Bolean
B= balance (0,0) <= 500
Console.WriteLine (“El valor b es {0}”, b)
Console.WriteLine(“Presiona para terminar el programa”)
Console.ReadLine()
End Sub


De forma similar al arreglo de una sola dimensión, puedes utilizar la notacion para declarar un arreglo de un numero de dimensión conocida pero de tamaño desconocido, y después usar la palabra New para construir un arreglo y asignarlo a la variable declarada. Por ejemplo:

Dim balance (,) As Decimal
balance = New Decimal (2,4) {}

Este ejemplo crea un arreglo Decimal de dos dimensiones de 3X5.

El uso de arreglos de dos dimensiones es algo común.

Bibliografía: Visual Basic .Net By Example
páginas (119-125)

+'s Manejo de Arreglos

Hacer un programa que de de alta artículos y le asigne un precio por cada uno. Simulará la venta de uno o varios artículos de un solo tipo de producto. Los productos, según el precio tendrán diferentes porcientos de descuento.

precios entre $10-$20 Tendrán el 20% de descuento
precios entre $30-$50 Tendrán el 10% de descuento
precios entre $60-$100 Tendrán el 5% de descuento
(Estos porcentajes son sujerencia, tomar de referencia los del pizarrón)

El programa Tendra dos MENUS.

Menú 1
A) Dar de alta un producto
B) Ventas

Menú 2

a) Alta
b) Busqueda
c) Mostrar todos los elementos


Al dar de alta un producto (menu 2) Se solicitara nombre del producto y el precio.


En la venta de un producto, el programa solicitará el nombre (o clave) del producto y posteriormente la cantidad de unidades a vender de cada producto.

El programa mostrará el total a pagar.

Nota: El procedimiento del calculo del descuento se deberá realizar en una subrutina o en una FUNCION. (es obligatorio hacer la funcion o subrutina).

Agenda (manejo de arreglos)

Hacer un programa que contega un menú.

1.- Dar de alta
2.- Mostrar
3.- Buscar
4.- Salir

¿Qué hace?
1.- El programa solicitará Nombre y Teléfono al dar de alta.
2.- Mostrará todo lo que se haya capturado.
3.- Buscará un nombre dentro de lo que se capturó y mostrara el nombre encontrado
y el telefono que el corresponde.
4.- Se Saldra del programa.

¿Como hacerlo?
Sugerencias:
a) Utilizar Select case
b) Utilizar un indice que se incremente cada ves que den de alta un elemento.

Nota: Hará una captura a la ves, capturas un nombre y un numero telefónico y se regresa al MENÚ. El programa se encarga de incrementar el índice.

Verificación y Rectificacion de Arreglos

Verificación durante la captura de la calificación:

for x = 0 to 6

do
Console.WriteLine ("Dame la calificación de la materia: ")
calif(x) = Console.ReadLine ()
Loop While calif(x) < 0 or calif(x) > 10

Next

calif() es un arreglo de 7 elementos, si durante la captura de la calificación el usuario incerta un numero menor a cero o mayor a diez, entonces el ciclo do while lo va a mantener ciclado hasta que no se cumpla esa condición. Será entonces que tendrá el usuario incertar valores entre cero y diez.

Ejemplo Visual de Arreglos

mat(0) = "Matématicas"
mat(1) = "Física"
mat(2) = "Algebra"
mat(3) = "Química"
mat(4) = "Electricidad"
mat(5) = "Programación"
mat(6) = "Comunicación"

calif (0) = 8
calif (1) = 10
calif (2) = 7
calif (3) = 9
calif (4) = 10
calif (5) = 10
calif (6) = 8

Esta Imagen, es un arreglo Visual de como se verian guardados los datos en un arreglo de 7 elementos.

Para hacer una búsqueda y mostrar su contenido tenemos el siguiente código:

Dim Busqueda As String
Console.WriteLine ("Materia que buscas: ")
Busqueda = Console.ReadLine ()
For x = 0 To 6
If StrComp (mat(x), Busqueda) = 0 Then
Console.WriteLine("Ya lo encontre en la posicion {0}", x)
Console.WriteLine("Materia: {0}", mat(x))
Console.WriteLine("calif: {0}", calif(x))
End If
Next


Como ya habiamos visto en clases pasadas en manejo de cadenas. Vimos la utilización de la función StrComp(cad1, cad2) del sistema, la cual compara dos cadenas. Si las dos son iguales, la función te regresa el valor de cero, si cad1 es mayor, regresa el valor de -1, y el otro caso, si es mayor cad2, entonces te regresa el valor de 1. Para nuestro ejemplo, el resultado tiene que ser igual a cero. Si en la comparación de las materias es igual a la que buscamos, entonces, nos mostrará el contenido del vector o arreglo en la posición del valor donde se encuentre x. De igual forma mosrtará la calificación que le correspode a la materia.

Ejercicio Agenda con Arreglos

21d e Febebro de 2006
Hacer un programa que simule una agenda.

El programa solicitará: Nombre, Dirección y Teléfono.

Al terminar de captar los n registros, el programa realizará una busqueda por nombre.
Si encuentra el nombre buscado desplegará toda la informacion de ese registro.

Tips: Usar un menu para la captura y la busqueda.

1.- Captura de datos
2.- Búsqueda
3.- Salir

Ejercicio con arreglos

20-Feb-2006
Hacer un programa que le solicite:

1. El nombre de un alumno
2. 8 Nombres de Materias
3. 8 Calificaciones de cada materia

Mostrar al final:

1.- El nombre del alumno
2.- El nombre de la materia y la calificacion
3.- El promedio del alumno

El programa devera:
Verificar que la calificacion no sea menor a 0 ni mayor a 10, de lo contrario debera solicitarla nuevamente.

Nota: Utilizar Ciclos For o Do While y Arreglos.

Arreglos

20-Feb-2006
Arreglos.
¿Qué veremos de los arreglos?
• Que son
• Como declararlo
• Como acceder a los elementos
• Como modificar el tamaño
• Como remover todos los elementos

Hemos visto como es una variable de un tipo de dato.
Que harías si te gustaría tener muchos valores de un mismo tipo guardados tan compactos como sea posible y tener el mismo nombre y algunos esquemas de índices que te permitan identificar cualquier valor? La respuesta es muy sencilla: tendrías un arreglo.

Por ejemplo consideremos que necesitas manejar cinco cuentas, darle nombre a cada una de las cuentas. Podrías declarar una variable por cada una de las cuentas que va a contener cada uno de los balances para esa cuenta, como en el siguiente ejemplo.

Dim balance1 As Decimal
Dim balance2 As Decimal
Dim balance3 As Decimal
Dim balance4 As Decimal
Dim balance5 As Decimal

O podrías usar un arreglo de cinco cuentas de balance- En este caso un arreglo de cinco valores Decimales. Un arreglo es un tipo de dato que puede contener mas de un valor de un tipo de dato dado. Estos valores son llamados elementos de un arreglo (elementos) y son del mismo tipo de datos (especificado en la declaración del arreglo). Puedes pensar en un arreglo como una lista de elementos, cada elemento en la lista es un elemento de un arreglo. Declararemos un arreglo de la siguiente manera:

Dim balance(4) As Decimal

Este enunciado va a hacer algo muy similar que en la declaración de 5 variables del tipo Decimal. Va a reservar memoria para cinco valores de tipo Decimal. La manera de acceder a estos valores es ligeramente diferente, como veremos a continuación. El número entre paréntesis después de la declaración de la variable del arreglo balance es conocido como el limite superior de un arreglo (array upper Bound), y representa el numero de valores en el arreglo, mas uno. La manera de acceder a cualquier valor en el arreglo que uses, es a traves de un índice. El índice (index) de un elemento de un arreglo es la posición actual de ese elemento en el arreglo. El primer elemento en el arreglo se encuentra en la posición 0. El siguiente se encuentra en la posición 1, y así los siguientes hasta la posición límite superior del arreglo -1, donde el tamaño del arreglo es el tamaño declarado en la declaración del arreglo. Echemos un vistazo en el siguiente ejemplo:

Dim balance(4) As Decimal
balance (0) = 100
balance(4) = 250

El primer enunciado declara un arreglo de Decimales que tiene cinco elementos (índice del 0 al 4). El siguiente enunciado es la asignación literal de un valor 100 al primer elemento del arreglo. El último enunciado le asigna el valor de 250 al último elemento del arreglo. Note la manera individual de acceder a un elemento del arreglo es indicándolo entre paréntesis al índice. balance(0) va a representar el primer elemento en el arreglo, mientras balance(4) va a representar el último elemento en el arreglo. Si tuvieras que acceder a un elemento que no esta en el arreglo –digamos elemento 7, como elemento 6, recibirías un excepción de ejecución (runtime exception) y el programa terminaría. Este tipo de excepción es conocida como excepción de acceso de un arreglo fuera de límite.

Los valores en cualquier índice dado en un arreglo pueden ser usados como una expresión, lo mismo que cualquier otra variable regular. En realidad son (desde cualquier punto de vista del compilador) solamente una variable regular, solamente la notación es diferente. Por ejemplo:

Dim balance(4) As Decimal
blance(0) = 100
Dim b As Bolean
B= balance(0) <=250

Este código va a crear un arreglo de cinco Decimales, le asignará un valor al primer elemento del arreglo a 100, y luego va a declarar una variable Boolean y se lo asignará al resultado de evaluar una expresión lógica. La expresión lógica compara el valor del elemento del arreglo en la posición 0 (al que se le asigno 100) al valor literal de 250. En una forma similar podrías utilizar elementos de un arreglo en cualquier tipo de expresión.

Hemos visto que las variables regulares pueden ser inicializadas cuando son declaradas. ¿Podremos hacer lo mismo con los arreglos? La respuesta es si y el ejemplo siguiente nos ilustra como hacerlo. Crea un proyecto de consola y nombralo EjemplodeArreglo. Después introduce el siguiente código.

Sub Main ()
Dim balance() As Decimal = {100, 200, 300, 400, 250}
Console.WriteLine(“El valor en el arreglo elemento 0 es {0}”, balance(0))
Console.WriteLine(“El valor en el arreglo elemento 1 es {0}”, balance(1))
Console.WriteLine(“El valor en el arreglo elemento 2 es {0}”, balance(2))
Console.WriteLine(“El valor en el arreglo elemento 3 es {0}”, balance(3))
Console.WriteLine(“El valor en el arreglo elemento 4 es {0}”, balance(4))

Dim b As Bolean
B= balance (0) <= 500
Console.WriteLine (“El valor b es {0}”, b)
Console.WriteLine(“Presiona para terminar el programa”)
Console.ReadLine()
End Sub


Note por favor la primer línea, la cual es la declaración y el enunciado de inicialización para el arreglo. La primer diferencia que ves es que no hay tamaño de arreglo especificado entre paréntesis (pero los paréntesis están presentes). Después, es facil ver el código de inicialización siguiéndole el signo de =. El arreglo es inicializado usando un set de valores literales del tipo apropiado, delimitado por llaves abiertas y cerradas. Las comas son necesarias para delimitar cualquier elemento del arreglo de otro. El compilador conoce exactamente cuantos elementos se encuentran en los valores de inicialización valores literales (estos son los valores entre { y } las llaves), no necesita de un tamaño para los arreglos que son inicializados como se muestra. Es en realidad un error de sintaxis proveer de un tamaño, y el IDE (Integrated Development Enviroment = Ambiente de Desarrollo Integrado) y el compilador lo administrara apropiadamente.

Es necesario algunas veces conocer cual es el tamaño del arreglo que vas a necesitar. Algunas veces es determinado en ejecución (runtime). Esto implica que necesitas la capacidad de declarar un arreglo vacio (o placeholder) y luego inicializarlo cuando sepas que tamaño del arreglo es. Esto es llamado inicialización dinámica de un arreglo. Nuestro ejemplo puede ser modificado para ilustrar como usar un arreglo.

Sub Main ()
Dim balance () As Decimal
Balance = New Decimal(4) {100, 200, 400, 250} Console.WriteLine(“El valor en el arreglo elemento 0 es {0}”, balance(0))
Console.WriteLine(“El valor en el arreglo elemento 1 es {0}”, balance(1))
Console.WriteLine(“El valor en el arreglo elemento 2 es {0}”, balance(2))
Console.WriteLine(“El valor en el arreglo elemento 3 es {0}”, balance(3))
Console.WriteLine(“El valor en el arreglo elemento 4 es {0}”, balance(4))
Dim b As Bolean
B= balance (0) <= 500
Console.WriteLine (“El valor b es {0}”, b)
Console.WriteLine(“Presiona para terminar el programa”)
Console.ReadLine()
End Sub

Como puedes ver las modificaciones son menores; se ha removido el código de inicialización de la línea de declaración del arreglo, y se le ha añadido una línea que le asigna un nuevo arreglo de cinco valores Decimales (especificados entre las llaves {}) a la variable del arreglo del balance. Si no conocieras los valores para el nuevo arreglo podrías usar algo como:

Balance = New Decimal (n) {}

Donde n es el limite superior del nuevo arreglo (y puede ser una variable), mientras que las llaves vacías son necesarias para indicar que es un arreglo que se esta construyendo. Note también la palabra New que es usado en la declaración de objetos y clases.

Bibliografía: Visual Basic .Net By Example
páginas (119-125)

Convertidor Unidad Métrica a Unidad Americana

(1) km -> millas
(2) mts -> pies

(3) cms -> pulgadas 1/2 1/4 1/8
mm -> pulgadas

Deberá Identificar de que unidad se trata (km, mts, cms ó mm) para poderla convertir a su respectiva unidad (millas, pies, pulgadas y fracciones).

Si yo introduzco 3kms, deberá de convertirlo y mostrar el siguiente resultado en pantalla: 1.864 millas
Si introducimos 45mts deberá convertirlos a: 147.638 pies
Si introducimos 85cms deberá convertirlos a: 33 1/2 pulgadas.

Nota: para la conversión a fracciones considerar solo : 1/2 1/4 y 1/8
El critero para identificar que fracción le corresponde es cual se aproxima más a 1
(85 / 2.54) = 33.4645
(0.4645) (2) = 0.929 <- el programa debe de elegir este.
(0.4645) (4) = 1.858
(0.4645) (8) = 3.716
opcionales:
(0.4645) (16) = 7.432
(0.4645) (32) = 14.864

Recomendaciones:
Utilizar una función para identificar de que unidad se trata.

Libro de referencia
Fundamentos De Programación Con Visual Basic Net

Comentarios

Si desean hacer comentarios en este Blog, mandenme sus correos electronicos.
De esta forma podran postear sus inquietudes, dudas, sugerencias o quejas.

Saludos.

Envien sus direcciones de correos a gallovdaniel@gmail.com

Cajero Automático

' 3 de Febrero de 2006


Module Module1

Sub Main()
'Este programa simulara el cambio dado por un cajero automatico.
'Las denominaciones serán las siguientes:
'$500 pesos
'$200 pesos
'$100 pesos
'$50 pesos
'$20 pesos
'$10 pesos
'$5 pesos
'$2 pesos
'$1 peso
'El programa nos lanzara los multiplos de cada denominacion.

Dim Retiro As Integer, Total As Integer
Dim m_500 As Double, m_200 As Double, m_100 As Double, m_50 As Double, m_20 As Double, m_10 As Double

'm_500, m_200 etc... son los multiplos de cada billete
Dim m_5 As Double, m_2 As Double, m_1 As Double
Dim Txt_Retiro As String

Console.WriteLine("¿Cuánto quieres retirar?")
Retiro = Console.ReadLine()
Total = Retiro
' En esta seccion preguntamos por la primer Denominacion
If Retiro >= 500 Then
m_500 = Retiro / 500
'Seccion de comentarios:
'Dividimos entre 500 para sacar los multiplos de 500
'Pero el resultado de m_500 puede tener fraccion por ser flotante.
'Entonces es necesario quitarle el punto y sus fracciones.
'En clase vimos como ejemplo que el usuario quisiera retirar $925.00 pesos
'Entonces los multiplos de 500 serian solo 1
'925/500 = 1.85
'Lo que queremos es que m_500 sea: 1 y no (1.85)
'Si Hubiesemos declarado m_500 como Entero (Integer) el programa redondea el resultado
'Es como si le hubieramos aplicado un m_500 Math.Round (Retiro/500)
'El valor de m_500 seria: 2 en lugar de 1.85
'Como no es lo que queremos entonces tenemos que convertir el valor de m_500 a
'Cadena para poderle eliminar las fracciones y su punto.
'Es lo que se realizara a continuacion con la funcion (Convierte)
m_500 = Convierte(m_500)
Retiro = Retiro - m_500 * 500
Txt_Retiro = "$500X" + m_500.ToString()
End If
'Hasta aqui ya identificamos si el total a retirar es mayor a 500
'Si sí lo es entonces sacamos los multiplos, la fraccion la enviamos
'una función para que nos regrese un valor entero (no fraccional).
'En la variable tipo cadena (Txt_Retiro) la inicializamos con el texto: "$500X"
'y le concatenamos m_500.ToString para que la variable contega lo siguiente:
' $500X1

'Volvemos a preguntar si el resto (despues de restarle los 500 ó multiplos de 500)
'es mayor a 200 (similar a los 500)
If Retiro >= 200 Then
m_200 = Retiro / 200
m_200 = Convierte(m_200)
Retiro = Retiro - m_200 * 200
Txt_Retiro = Txt_Retiro + " $200X" + m_200.ToString()
'Aqui estamos Acumulando y concatenando el valor de la cadena Txt_Retiro
'El valor Anterior + el valor nuevo
'el contenido hasta aquí de Txt_Retiro seria el siguiente:
'$500X1 $200X2
End If

'La lógica se repite para cada una de las Condiciones...
If Retiro >= 100 Then
m_100 = Retiro / 100
m_100 = Convierte(m_100)
Retiro = Retiro - m_100 * 100
Txt_Retiro = Txt_Retiro + " $100X" + m_100.ToString()
End If

If Retiro >= 50 Then
m_50 = Retiro / 50
m_50 = Convierte(m_50)
Retiro = Retiro - m_50 * 50
Txt_Retiro = Txt_Retiro + " $50X" + m_50.ToString()
End If

If Retiro >= 20 Then
m_20 = Retiro / 20
m_20 = Convierte(m_20)
Retiro = Retiro - m_20 * 20
Txt_Retiro = Txt_Retiro + " $20X" + m_20.ToString()
End If

If Retiro >= 10 Then
m_10 = Retiro / 10
m_10 = Convierte(m_10)
Retiro = Retiro - m_10 * 10
Txt_Retiro = Txt_Retiro + " $10X" + m_10.ToString()
End If

If Retiro >= 5 Then
m_5 = Retiro / 5
m_5 = Convierte(m_5)
Retiro = Retiro - m_5 * 5
Txt_Retiro = Txt_Retiro + " $5X" + m_5.ToString()
End If
If Retiro >= 2 Then
m_2 = Retiro / 2
m_2 = Convierte(m_2)
Retiro = Retiro - m_2 * 2
Txt_Retiro = Txt_Retiro + " $2X" + m_2.ToString()
End If
If Retiro >= 1 Then
m_1 = Retiro / 1
'm_1 = Convierte(m_1)
Retiro = Retiro - m_1 * 1
Txt_Retiro = Txt_Retiro + " $1X" + m_1.ToString()
End If

Console.WriteLine("Los multiplos son los siguientes:")
Console.WriteLine("(500)({0}) (200)({1}) (100)({2}) (50)({3}) (20)({4}) (10)({5}) (5)({6}) (2)({7}) (1)({8}) ", m_500, m_200, m_100, m_50, m_20, m_10, m_5, m_2, m_1)
Console.WriteLine(Txt_Retiro & " = " & Total.ToString())
Console.ReadLine()
End Sub

Function Convierte(ByVal puntoF As Double) As Double
Dim Cadena As String
Dim pos As Integer
Cadena = CStr(puntoF)
pos = InStr(Cadena, ".")
If pos > 0 Then
Cadena = Left(Cadena, pos - 1)
End If
Return CDbl(Cadena)
End Function
'Comentarios:
'Esta funcion recibe un valor Double y regresa un valor Double
' Cadena = CStr(puntoF)
'Convierte el valor flotante que se le envia a la funcion y la convierte a Cadena
'pos = InStr(Cadena, ".")
'pos almacena la posicion donde localice el punto dentro de la cadena
'Por ejemplo:
'Si nuestra cadena fuera la siguiente: Cadena = "Estamos en el mes de febrero"
'pos = InStr(Cadena, "febrero")
'pos seria igual a: 22
'la posicion donde localizó el inicio de la palabra febrero fue en 22
'Cadena = Left(Cadena, pos - 1)
'En esta linea de código cargamos a la variable Cadena de (izq a der) un determinado
'numero de caracteres, el resto de la cadena se pierde.
'Si al ejemplo de: Cadena = "Estamos en el mes de febrero"
'le aplicamos el siguiente código obtendriamos el siguiente resultado:
' "Estamos en el mes de "

'Al final de la funcion convertimos el valor de la cadena a Double y se lo regresamos
'en forma Double.

End Module

Tarea IV Calculo de un Recibo

30 de Enero 2006
Calculo recibo CFE
Hacer un programa que nos permita conocer el consumo Mensual y el total a pagar de un recibo de la CFE (Comisión Federal de Electricidad) del segundo semestre del año (Julio – Diciembre)
El cálculo se realizará tomando en cuenta las tarifas mensuales.

Hay que tomar en cuenta:
1.- Que cada mes tiene una tarifa distinta.
2.- Contiene un rango en el costo por Kwh.
3.- Al pasarse un rango, pasa a un segundo rango.

Ej. Si el mes a facturar es el mes de Abril y su consumo fue de 250KWh. Entonces, los primeros 74KWh se cobraran a $0.571 pesos; los siguientes 125KWh se cobraran a $0.685 Pesos y el resto menor o igual a 250 se cobraran a $1.997 pesos
El total a pagar será:
(74KWh)($0.571) + (51KWh)($0.685) + (125KWh)($1.997) =
$42.254 + $34.935 + $249.625 = $326.814

Consumo Total = 250KWh
250KWh -74KWh = 176 KWh
176KWh -125KWh = 51KWh

74KWh + 51KWh = 125KWh

Si el consumo fuera mayor a 250KWh entonces entraría al segundo rango donde es mayor a 250 y el costo por KWh es mayor.
(Dar Click en la imagen para verla mas grande)


Tabla Actual 2006:
Tabla 1F 2006 CFE
Buscar Tabla 1F

La practica hace al Maestro

La Practica hace al Maestro 27-ene-2006
Siempre que hacemos arte desvelamos al verdadero yo; ese yo que incluye las otras partes del verdadero ser y al que permitimos que hable. (Carbonetti, 2000:46)

La creatividad es tu forma especial de hacer las cosas, de entregarte. Los seres humanos pretendemos más que existir. Tenemos grandes capacidades de pensamiento e imaginación. Desgraciadamente, muchas veces las vamos perdiendo al desanimarnos cuando nos dicen: “eso no está bien”, “qué mal cantas”, “ese dibujo parece de un niño de cuatro años”, etc. No dejes que te suceda esto.

Si te gusta algo, hazlo por el placer de hacerlo. Si quieres triunfar en algún arte o deporte, práctica todos los días. Estudia. Prepárate. Sueña y busca cómo hacer lograr que eso sea realidad. Si quieres ser escritor, escribe. Si quieres ser pintor, pinta. Y así con todo lo que te propongas, pero no te quedes lamentándote en un rincón sobre lo que podrías ser y no eres. PRACTICA, porque la práctica hace al maestro. Nadie nace sabiendo.

Liga