Boletin prßcicas 1-a-4

Enunciados de prácticas
PRIMERA TANDA
(prácticas 1 a 4)
Informática Para la ingeniería
Escuela de Ingenieros Industriales

Enunciados de prácticas. Informática Para la ingeniería
Escuela de Ingenieros Industriales. Universidad de Vigo i
Tabla de contenidos
1. PRÁCTICA 1. CREAR UN NUEVO PROYECTO ...........................................................................3
1.1 OBJETIVOS ....................................................................................................................................3
1.2 DURACIÓN.....................................................................................................................................3
1.3 INTRODUCCIÓN..............................................................................................................................3
1.3.1 Conocer el entorno de programación Visual Basic 2010.....................................................3
1.3.2 Proyectos en Visual Basic (VB)............................................................................................4
1.3.3 Escribir programas, compilar y ejecutar..............................................................................8
1.3.4 Creación y eliminación de módulos......................................................................................9
1.3.5 Lectura y escritura de datos ...............................................................................................11
1.3.5.1 Ejemplo................................................................................................................................................. 11
1.3.6 Variables y constantes........................................................................................................12
1.3.6.1 Ejemplo................................................................................................................................................. 12
1.3.6.2 Ejemplo................................................................................................................................................. 12
1.3.7 Constantes ..........................................................................................................................13
1.3.7.1 Ejemplo................................................................................................................................................. 13
1.3.8 Tipos de datos.....................................................................................................................14
1.3.8.1 Ejemplo................................................................................................................................................. 15
1.3.8.2 Ejemplo................................................................................................................................................. 15
1.3.9 Resumen de Instrucciones...................................................................................................15
1.4 PROBLEMAS.................................................................................................................................16
1.4.1 Problema 1 .........................................................................................................................16
1.4.2 Problema 2 .........................................................................................................................16
1.4.3 Problema 3 .........................................................................................................................16
1.5 PROBLEMAS COMPLEMENTARIOS ................................................................................................17
1.5.1 Problema 1 .........................................................................................................................17
2. PRÁCTICA 2. INTERFACES GRÁFICAS I....................................................................................18
2.1 OBJETIVOS ..................................................................................................................................18
2.2 DURACIÓN...................................................................................................................................18
2.3 INTRODUCCIÓN............................................................................................................................18
2.3.1 Formularios y controles. Características comunes............................................................18
2.3.1.1 Eventos ................................................................................................................................................. 20
2.3.1.2 Métodos ................................................................................................................................................ 21
2.3.2 Formularios........................................................................................................................21
2.3.2.1 Propiedades más importantes de los formularios............................................................................... 21
2.3.2.2 Algunos de los eventos más importantes de los formularios ............................................................ 22
2.3.3 Controles básicos ...............................................................................................................22
2.3.3.1 Propiedades más importantes de los controles................................................................................... 23
2.3.3.2 Algunos de los eventos más importantes de los controles................................................................. 23
2.4 EJEMPLO......................................................................................................................................24
2.4.1 Código del ejemplo.............................................................................................................27
2.5 PROBLEMA OBLIGATORIO ............................................................................................................28
2.6 PROBLEMA COMPLEMENTARIO....................................................................................................29
3. PRÁCTICA 3. INSTRUCCIONES CONDICIONALES..................................................................30
3.1 OBJETIVO ....................................................................................................................................30
3.2 DURACIÓN...................................................................................................................................30
3.3 PROBLEMAS.................................................................................................................................30
3.3.1 Problema ............................................................................................................................30
3.3.2 Problema ............................................................................................................................30
3.3.3 Problema (utilizar IF).........................................................................................................30

Escuela de Ingenieros Industriales. Universidad de Vigo ii
3.3.4 Problema (utilizar SELECT) ..............................................................................................31
3.3.5 Problema ............................................................................................................................31
3.3.6 Problema ............................................................................................................................31
4. PRÁCTICA 4. INSTRUCCIONES REPETITIVAS .........................................................................32
4.1 OBJETIVO ....................................................................................................................................32
4.2 DURACIÓN...................................................................................................................................32
4.3 PROBLEMAS.................................................................................................................................32
4.3.1 Problema ............................................................................................................................32
4.3.2 Problema ............................................................................................................................32
4.3.3 Problema ............................................................................................................................32
4.3.4 Problema ............................................................................................................................32
4.3.5 Problema ............................................................................................................................33
4.3.6 Problema ............................................................................................................................33
4.3.7 Problema ............................................................................................................................33
4.3.8 Problema ............................................................................................................................33
4.3.9 Problema ............................................................................................................................34
4.3.10 Problema ............................................................................................................................34
4.3.11 Problema ............................................................................................................................34
4.3.12 Problema ............................................................................................................................35

Escuela de Ingenieros Industriales. Universidad de Vigo 3
1. Práctica 1. Crear un nuevo proyecto
1.1 Objetivos
1. Conocer el entorno de programación Visual Basic 2010
2. Crear y guardar proyectos
3. Características de los proyectos
4. Ejecución de un proyecto
5. Creación de una interfaz gráfica sencilla
6. Manipulación de módulos
7. Declaración de variables y constantes
1.2 Duración
2 horas
1.3 Introducción
Para el desarrollo de aplicaciones informáticas se requiere un lenguaje. En el
mercado existen una gran variedad. La selección de uno de ellos depende de varios
factores desde el económico hasta los requisitos que el sistema debe de cumplir. Uno
de estos lenguajes es Visual Basic.
Visual Basic maneja el término proyecto para referirse a todos los elementos
requeridos para la construcción de una aplicación. El proyecto Visual es por tanto el
contenedor de múltiples objetos. Pueden existir distintos tipos de proyectos, tales
como aplicaciones de consola, aplicaciones Windows, aplicaciones web, etc.
Para familiarizar a los alumnos con las características principales del lenguaje
Visual se utilizarán tanto aplicaciones de consola con interfaz gráfica (GUI Graphical
User Interface).
1.3.1 Conocer el entorno de programación Visual Basic 2010
El contexto puede variar en función de las configuraciones que tenga el usuario.
A continuación se muestra la pantalla con las configuraciones por defecto del
programa, y con una aplicación de consola activa.

Los elementos básicos son:
1. Nombre del proyecto abierto y la versión de Visual Basic.
2. Barra de menús se listan todos los menús de la aplicación.
3. Barra de botones de acceso rápido.
4. Pestañas con todos los elementos abiertos del proyecto.
5. Lista de errores que aparece en el momento de la compilación y ejecución
del proyecto.
6. Barra de estado que indica el estado de la aplicación, así como información
relativa a la posición del cursor.
7. Explorador de soluciones donde se listan todos los elementos que
componen al proyecto.
8. Ventana de propiedades donde se muestran las propiedades del elemento
seleccionado.
1.3.2 Proyectos en Visual Basic (VB)
Los proyectos contienen elementos que en su conjunto conforman la solución
computacional al problema planteado. Lo primero que debe hacerse en VB. Es crear

un nuevo proyecto al que se le van añadiendo los elementos necesarios. Para crear un
nuevo proyecto en VB es necesario hacer lo siguiente:
Desde la página principal seleccionar Nuevo Proyecto (New Proyect).
Inmediatamente se abre una ventana donde seleccionaremos el tipo de aplicación:
Aplicación de Consola (Console Applications), y pondremos el nombre del nuevo
proyecto. Se recomienda usar nombres que indiquen la naturaleza del mismo. En éste
caso el nombre será CExample1.

Podemos ver la ventana correspondiente al único modulo del proyecto que se
crea por defecto y que recibe el nombre de Module1.vb. En el Explorador de
Soluciones (Solution Explorer) aparece el nombre del proyecto como entrada de
mayor nivel, así como los ficheros que lo conforman. Por defecto, también aparece
una entrada denominada MyProject, la cual representa las características de
configuración del mismo.
El nombre de Module1.vb puede cambiarse por otro que sea más significativo.
Para hacerlo basta con seleccionarlo de la ventana Solution Explorer, presionar el
botón derecho y en el menú emergente pulsar sobre la opción Cambiar Nombre
(Rename). El nuevo nombre puede ser Example1.
Para establecer y consultar las características de configuración de los proyectos
tenemos dos alternativas:
1. Seleccionar en la ventana del Solution Explorer la opción de mayor rango,
Solution Explorer, sobre ésta pulsar botón derecho y pulsar sobre Abrir
(Open).
2. Ir al menú Proyecto (Project) y seleccionar Propiedades (Properties).
La ventana que se abre permite establecer las opciones de configuración básica
del proyecto y está formada de varias carpetas: Application, Compile, Debug, etc.
En la carpeta Application se comprobarán las siguientes opciones:
1. Assembly name: Especifica el nombre de fichero de salida que contiene el
ensamblado. Directamente relacionada con la propiedad Output Name.

2. Root namespace: Determina el contexto de los ficheros de todo el proyecto.
Si algún fichero está fuera de este contexto para referirse a él se especifica
como contexto.nombreElemento. Para todos los elementos dentro del
contexto basta con nombrarlos directamente nombreElemento.
3. Application type: Indica el tipo de aplicación para nuestro caso debe estar
marcada ConsoleApplication.
4. Startup object: Punto de entrada para la ejecución del proyecto. En este
caso vamos a utilizar el único modulo creado y que hemos llamado
Example1.
Es recomendable que coincidan en nombre las dos primeras opciones. En este
ejemplo, en ambos apartados debería aparecer el nombre del proyecto CExample1.
Aunque aún no se ha escrito código es una buena práctica el guardar el trabajo
realizado para evitar posibles pérdidas. Para almacenar el proyecto que acabamos de
crear, se selecciona el fichero File y la opción Save All:
1. Name: nombre del proyecto

2. Location: lugar donde será almacenado el proyecto. Por defecto la
ubicación es C:usuario DocumentsVisual Studio 2010Projects
3. Create directory for solution: al marcar esta opción se crea un directorio en
el que se almacenan los ficheros propios del proyecto. Y se activa la opción
SoluctionName.
4. SolutionName: nombre del directorio donde se almacenan los ficheros.
Por simplicidad ambas opciones Name y SolutionName deben coincidir. En
ambas pondremos CExample1.
En el directorio indicado se crean varios ficheros para almacenar desde el
código necesario hasta las características de configuración
Ficheros a destacar:
1. Application.MyApp, Application.designer.vb y AssemblyInfo.vb. Ficheros en
formato XML que contienen las propiedades del proyecto. Se almacenan en
UbicaciónNombreProyectoMyProject. Las propiedades deben
establecerse a través de la ventaja de propiedades del proyecto y los
ficheros no se deben de editar manualmente.
2. Resources.resx Permite definir recursos que se puede utilizar en el
ensamblado, pueden ser string, iconos, imágenes, audio. Se definen en la
pestaña Resources.
3. Resources.designer.vb. Maneja la referencia al objeto .NET llamado
ResourceManager, que se encarga de administrar los recursos en el código.
1.3.3 Escribir programas, compilar y ejecutar
Los programas se escriben en los módulos que contiene el proyecto (en las
aplicaciones gráficas también pueden escribirse en los formularios y controles). Para
abrir un módulo y editarlo basta con hacer doble click sobre el nombre del mismo en la
ventana del solution explorer. Para el ejemplo abriremos el modulo que hemos
llamado Example1.vb. Y escribiremos el siguiente código:

Module Example
Sub Main()
' Muestra Hello World
Console.WriteLine("Hello World !")
Console.ReadLine()
End Sub
End Module
Para probar el funcionamiento del código basta con pulsar F5 o el botón de
inicio de depuración en la barra de botones de acceso rápido. En caso de que exista
algún error o aviso (warning) se abrirá una ventana con la lista de los mismos. Si la
sintaxis del programa es correcta el programa se ejecuta. El resultado es:
Para detener la ejecución del programa basta con presionar el botón Detener
depuración, o bien ir al menú Depurar y pulsar Detener depuración.
1.3.4 Creación y eliminación de módulos
Un proyecto VB puede tener uno o más módulos. Cada módulo puede
entenderse, por ahora como un bloque de instrucciones. Por defecto cada nuevo
proyecto se crea con un módulo nombrado de manera automática como Module1.vb.
Cada nuevo módulo que se añade al proyecto se nombra por defecto como
Module2.vb, Module3.vb, etc. Los nombres de los módulos se modifican para reflejar
la tarea que realizan. El nombre del módulo es su identificador y no puede haber dos
iguales.
Para agregar un nuevo módulo a un proyecto:
1. Ir al menú Proyecto y seleccionar Agregar elemento. En la pantalla
emergente seleccionar la opción de Módulo y pulsar el botón Agregar. En el
Explorardor de soluciones se lista el nuevo módulo.

2. Otra manera de agregar el módulo es seleccionar directamente en el
Explorador de soluciones el proyecto y pulsar el botón derecho del ratón. Se
despliega un menú emergente, donde se selecciona Agregar y Módulo. El
nuevo módulo aparece en el Explorador de soluciones.
El código que por defecto aparece en el nuevo módulo es el siguiente:
Module Module1
End Module
Donde:
Module: palabra reservada que indica el comienzo del módulo.
Module1: nombre del módulo que se convierte el identificador del mismo, y
porque el que será conocido en todo el proyecto. No puede haber dos módulos con el
mismo nombre. El nombre coincide con el que se despliega en el Explorador de
soluciones. En la carpeta del proyecto también aparece un nuevo fichero con el mismo
nombre. Module1.vb. La extensión .vb indica que se trata de código fuente Visual
Basic.
End Module: final del bloque de instrucciones o módulo.
Todas las instrucciones se ponen entre las palabras reservadas Module y End
Module. Dentro de los módulos se encuentran las funciones y los procedimientos.
Para cambiar el nombre a un módulo basta con hacer doble clic sobre él o
pulsar el botón derecho del ratón y escoger la opción Cambiar nombre.
Para eliminar un Módulo se selecciona el módulo y se presiona la tecla Supr, o
se presiona el botón derecho del ratón sobre el módulo y se marca la opción Eliminar.

Para continuar con la práctica vamos a crear un nuevo módulo al que
llamaremos Example1. Este módulo mostrará en consola. “Hola soy un nuevo
módulo”.
1. Cree un nuevo módulo y llámelo Example1.
2. El nuevo módulo debe tener el siguiente código:
Module Example1
Sub Main()
Console.WriteLine("Hola soy un nuevo módulo")
Console.ReadLine()
End Sub
End Module
3. Abra la ventana de propiedades del proyecto y establezca el nuevo
módulo como objeto de inicio.
4. Ejecute el proyecto y observé los resultados.
1.3.5 Lectura y escritura de datos
La instrucción que se utiliza para mostrar los datos es:
MsgBox(“Mensaje que se muestra”)
El texto que se muestra en pantalla (por medio de una ventana emergente)
puede ser una de cadena de caracteres, números, etc.
La instrucción que se emplea para leer datos:
variable = InputBox(“Mensaje para solicitar datos”)
variable: variable a la que se le asigna el valor leído por consola.
Los datos que el usuario escribe en el cuadro de texto de la ventana emergente,
se guardan en la variable.
En el mismo proyecto crea un nuevo módulo y copia el código del ejemplo.
Ejecuta el programa y ve los resultados en pantalla.
1.3.5.1 Ejemplo
Module Example3

Sub Main()
Dim nombre As String
Dim edad As Integer
nombre = InputBox("¿Nombre?")
edad = InputBox("¿Edad?")
MsgBox("Tu nombre es " & nombre & ".")
MsgBox ("Tienes " & edad & " años.")
End Sub
End Module
El símbolo & se utiliza para concatenar cadenas de caracteres.
1.3.6 Variables y constantes
Las variables son contenedores de datos que durante la ejecución del programa
almacenan información que puede cambiar tantas veces como sea necesario. Un
ejemplo de variable se muestra en el ejemplo anterior con: nombre y edad. Son dos
variables que contendrán dos datos introducidos por teclado para mostrarlos más
adelante. Antes de utilizar una variable es necesario declararla. Para declarar:
[Dim] nombreVariable [As] TipoDeDato
Donde:
Dim: palabra reservada para la declaración.
nombreVariable: identificador de la variable que debe ser único dentro de la
rutina o procedimiento donde se declare.
As: Palabra reservada del lenguaje
TipoDeDato: Indica la información que contendrá la variable y las operaciones
que se pueden hacer sobre ella.
1.3.6.1 Ejemplo
Dim nombre As String 'Se crea la variable nombre de tipo String
Dim edad As Integer 'Se crea la variable edad de tipo entero.
Inicializar una variable se refiere a darle un valor desde su creación o
inmediatamente después. Para ello se utiliza el operador asignación:
1.3.6.2 Ejemplo
Dim nombre As String = "Luisito Penas"

'Se crea e inicializa la variable nombre de tipo String
Dim edad As Integer = 20
'Se crea e inicializa la variable edad de tipo entero.
1.3.7 Constantes
Las constantes son similares a las variables, pero al contrario que éstas su
información no debe de modificarse durante la ejecución de un programa. Son de solo
lectura y se declaran e inicializan en la misma línea. Las constantes pueden ir a nivel de
clases, módulos o procedimientos. Declaración constante:
[Public|Private] Const nombreConstante As TipoDeDato = valor
Donde:
[Public|Private] Modificador de acceso. Si la constante se declara a nivel de
procedimiento éste puede omitirse.
Const: Palabra reservada para constante.
nombreConstante: Identificador de la constante.
TipoDeDato: Tipo de información que contendrá la constante.
1.3.7.1 Ejemplo
Module Example5
Sub Main()
Const pi As Double = 3.1415
Dim radio As Single = 20
Dim circumferencia As Double = radio * 2 * pi
Dim area As Double = radio ^ 2 * pi
MsgBox("Circumferencia del círculo : " & circumferencia)
MsgBox ("Área del círculo : " & area)
End Sub
End Module

1.3.8 Tipos de datos
tipo Tamaño (bytes) valores
Boolean En función de la plataforma
de implementación
True o False
Byte 1 byte 0 a 255 (sin signo)
Char (carácter individual) 2 bytes 0 a 65535 (sin signo)
Date 8 bytes 0:00:00 (medianoche) del 1 de enero de
0001 a 11:59:59 p.m. del 31 de diciembre
de 9999.
Decimal 16 bytes 0 a +/-
79.228.162.514.264.337.593.543.950.335
(+/-7,9... E+28) † sin separador decimal; 0
a +/-7,9228162514264337593543950335
con 28 posiciones a la derecha del
decimal;
Double (punto flotante de
precisión doble)
8 bytes -1,79769313486231570E+308 a -
4,94065645841246544E-324 † para los
valores negativos;
4,94065645841246544E-324 a
1,79769313486231570E+308 † para los
valores positivos
Integer 4 bytes -2.147.483.648 a 2.147.483.647 (con
signo)
Long (entero largo) 8 bytes -9.223.372.036.854.775.808 a
9.223.372.036.854.775.807 (9,2...E+18 †)
(con signo)
Object 4 bytes en plataforma de 32
bits 8 bytes en plataforma
de 64 bits
Cualquier tipo puede almacenarse en una
variable de tipo Object
SByte 1 byte -128 a 127 (con signo)
Short (entero corto) 2 bytes -32.768 a 32.767 (con signo)
Single (punto flotante de
precisión sencilla)
4 bytes -3,4028235E+38 a -1,401298E-45 † para
los valores negativos;
1,401298E-45 a 3,4028235E+38 † para
los valores positivos
String (longitud variable) En función de la plataforma
de implementación
0 a 2.000 millones de caracteres Unicode
aprox.
UInteger 4 bytes 0 a 4.294.967.295 (sin signo)
ULong 8 bytes 0 a 18.446.744.073.709.551.615
(1,8...E+19 †) (sin signo)
UShort 2 bytes 0 a 65.535 (sin signo)
Más detalle en:
http://msdn.microsoft.com/es-es/library/47zceaw7%28v=VS.100%29.aspx

1.3.8.1 Ejemplo
Solicitar al usuario tres números enteros (byte), sumarlos y mostrar el resultado
por pantalla. Modificarlo y utilizar el tipo Integer.
Module Example6
Sub Main()
Dim num1 As Byte, num2 As Byte, num3 As Byte, suma As Byte
num1 = InputBox("Dame un número")
num2 = InputBox ("Dame un número")
suma = num1 + num2 + num3
MsgBox(num1 & " + " & num2 & " + " & num3 & " = " & suma)
End Sub
End Module
Nota: Investigar que implica el OverflowException.
1.3.8.2 Ejemplo
Pedir al usuario dos números enteros (short) y realice la división. Modificar el
programa para utilizar números flotantes.
Module Example7
Sub Main()
Dim num1 As Short, num2 As Short
Dim div As Short
num1 = InputBox("Dame un número")
div = num1 / num2
MsgBox (num1 & " / " & num2 & " = " & div)
End Sub
End Module
Nota: Compare los resultados de los dos programas.
1.3.9 Resumen de Instrucciones
Instrucción Funcionamiento
Module Son contenedores de código. Se definen como:
Module nombreModulo
Código
End Module
El nombreModulo se convierte en el identificador del mismo, y es el nombre
porque el que será conocido en todo el proyecto, por tanto no puede haber dos
módulos con el mismo nombre. El nombre no puede contener espacios ni ser una
palabra reservada del lenguaje. Cada módulo debe de ir aparejado con la
instrucción End Module que indica el cierre del módulo.
Sub Es un procedimiento que contiene un algoritmo computacional creado para
realizar una tarea concreta, como escribir el mensaje “¡Hello World!”. Los
procedimientos se definen como:

Sub nombreProcedimiento
Código
End Sub
El nombreProcedimiento es el identificador del procedimiento, y debe ser único.
Puede haber uno o más procedimientos dentro de un módulo. La ejecución del
módulo se inicia con el procedimiento llamado Main y no puede haber dos
procedimientos Main en el mismo módulo.
End Sub Marca el final del procedimiento
End Module Marca el final del módulo
Console.WriteLine() Escribe en la salida estándar la cadena de caracteres contenida entre paréntesis.
Console.ReadLine () Lee una línea desde la consola, la línea puede contener cero o más caracteres. Se
determina el final de la línea por el carácter fin de línea. Éste se crea cuando el
usuario final presiona la tecla Enter.
‘ o REM Comentarios, información sobre el código que no afecta la compilación ni la
ejecución de un programa. Por defecto se despliegan en verde.
& Concatenar strings.
1.4 Problemas
1.4.1 Problema 1
Crear un nuevo módulo al que llamaremos Problema1. Este módulo mostrará
en consola. “Mi primer programa”.
Completa el programa pidiendo el grado en el que está matriculado el usuario,
y la duración en la que prevé terminar.
Crea una constante con la duración del grado.
Calcula y muestra por pantalla la diferencia entre ambas.
1.4.2 Problema 2
Calcula el área de superficie corporal. Utilizando la fórmula:
La altura se da en centímetros y el peso en kilogramos.
1.4.3 Problema 3
Repetir los dos problemas anteriores usando una interfaz gráfica sencilla

1.5 Problemas complementarios
1.5.1 Problema 1
Solicita al usuario la temperatura en grados centígrados y muestra se
equivalente en grados Fahrenheit. (C= F - 32 / 1.8). Realizar el problema con y sin
interfaz gráfica.

2. Práctica 2. Interfaces gráficas I
2.1 Objetivos
Familiarizarse con los principios básicos de las interfaces gráficas
2.2 Duración
2 horas
2.3 Introducción
Entorno de programación de ventanas de VB:
2.3.1 Formularios y controles. Características comunes.
Un formulario representa la ventana que se utiliza en las aplicaciones con
interfaz gráfica para interactuar con el usuario.
Una aplicación (o proyecto) puede estar formada por varios formularios,
aunque un único formulario puede ser suficiente para las aplicaciones más sencillas.
Un control, por otra parte, es todo elemento situado dentro de un formulario
que permite al usuario de la aplicación interactuar con la misma para introducir datos
o recuperar información.

Algunos de los tipos de controles de Visual Basic: botones, cajas de diálogo,
cajas de selección desplegable, menús, etc.
A los formularios y controles de Visual Basic les denominamos objetos.
Cada objeto de Visual Basic tiene un nombre (propiedad Name), por medio del
cual es posible hacer referencia a dicho objeto a la hora de programar. Haciendo una
analogía con las estructuras (structure): un objeto sería una estructura y las
propiedades del objeto los campos de la estructura.
Al crear un formulario o un control, VB le proporciona un nombre, constituido
por el nombre del tipo de control y un número que se autoincrementa al introducir
más controles del mismo tipo (ejemplo: nombres de 3 controles tipo “Button”:
Button1, Button2, Button3).
No usar nombres por defecto. La propiedad Name se debe cambiar cuando se
agrega un nuevo objeto a un proyecto.
Los formularios y los controles tienen un conjunto de propiedades que definen
su aspecto gráfico y su forma de responder a las acciones del usuario.
Cada propiedad tiene un nombre que viene ya definido por Visual Basic.
En tiempo de diseño, se puede acceder a las propiedades de un objeto por
medio de la ventana de propiedades.
En tiempo de ejecución, se accede por programa a una propiedad de un objeto
por medio del nombre del objeto al que pertenece, seguido de un “.” y el nombre de la
propiedad.

2.3.1.1 Eventos
Las acciones del usuario sobre un formulario y sus controles se denominan
eventos. Son eventos típicos el pulsar un botón, hacer doble-clic sobre un icono, el
pulsar una tecla, cerrar una ventana, etc.
Cada vez que se produce un evento, Visual Basic ejecuta una determinada
función o procedimiento, que se llama con un nombre que se forma a partir del
nombre del objeto, separado con el carácter “_” y el nombre del evento
correspondiente.

2.3.1.2 Métodos
Los métodos son funciones o procedimientos pre-programados en el lenguaje
que están asociadas a los formularios y los controles.
Se accede a los métodos de cada objeto por medio de su nombre
correspondiente. Para ejecutar un método de un objeto, se escribe el nombre del
objeto, el carácter “.” y el nombre del método junto con los parámetros (si éstos son
necesarios).
2.3.2 Formularios
2.3.2.1 Propiedades más importantes de los formularios
1. Name: Permite identificar al formulario. Se introduce en tiempo de diseño y
no se puede variar durante la ejecución del programa. Por defecto: Form1
(Form2 y sucesivos, si hay más de un formulario).
2. Text: Es el texto que se muestra en la barra de título cada vez que aparece
en pantalla el formulario. El programa no accede a los formularios por el
título, sino por el nombre. Puede cambiarse en tiempo de ejecución.

3. Enabled: Propiedad lógica. Si su valor es True, el formulario está activado y
se puede interactuar con él. Si es False, se desactiva el formulario,
impidiendo de esta forma que se pueda trabajar con él en tiempo de
ejecución.
4. Font: Especifica el tipo y el tamaño de la letra que se usará en el formulario.
5. WindowState: Establece el estado en el que aparecerá el formulario cuando
se activa y presenta en pantalla. Admite tres opciones:
5.1. Normal: Posición y tamaño que tenía en tiempo de diseño.
5.2. Minimized: Aparece minimizado, representado por su icono.
5.3. Maximized: Aparece maximizado, ocupando toda la pantalla.
2.3.2.2 Algunos de los eventos más importantes de los formularios
1. Click: Clic de ratón sobre el formulario.
2. DoubleClick: Doble-Clic de ratón sobre el formulario.
3. KeyPress: Pulsar una tecla.
4. Shown: Mostrar el formulario (lo carga si es necesario).
5. MouseDown: Pulsar una tecla del ratón sobre él.
2.3.3 Controles básicos

2.3.3.1 Propiedades más importantes de los controles
1. Name: Define al objeto durante la ejecución del programa. Se introduce en
tiempo de diseño. No se puede variar durante la ejecución.
2. Text: Es el texto que aparecerá en el control (En el caso de un formulario es
el título, en el caso de un botón el texto del mismo, etc.)..
3. Enabled: Propiedad lógica que habilita o deshabilita un control. Cuando está
deshabilitado (Enabled = False), el control no tiene efecto, y su apariencia
varía, presentando un tono pálido
4. Font: Es el tipo de letra que se emplea para visualizar texto (Text).
5. Size: Especifica el tamaño del control:
5.1. Height: Altura del control.
5.2. Width: Anchura del control.
6. Location: Especifica la posición del control:
6.1. X: Indica la posición de la parte izquierda del control con respecto
izquierda de la ventana.
6.2. Y: Indica la coordenada de la parte superior del control con respecto a
la parte superior de la ventana.
7. Visible: Especifica si el control es visible o no.
8. Si es True, el control se ve, si es False, el control no se ve.
9. Aunque el control esté “invisible”, sigue “existiendo” en el formulario y se
puede acceder a sus propiedades, métodos, etc.
2.3.3.2 Algunos de los eventos más importantes de los controles
1. Click: Hacer clic con el ratón sobre el control.
2. DoubleClick: Lo mismo que el anterior, pero con doble-clic.
3. DragDrop: Arrastrar y/o soltar sobre el control.
4. DragOver: Arrastrar por encima del control.
5. GotFocus: Obtener el foco sobre el control.

6. KeyDown: Se produce cuando está pulsa una tecla teniendo el control el
foco.
7. KeyPress: Se produce, después de KeyDown, cuando está pulsa una
tecla teniendo el control el foco.
8. KeyUp: Se produce cuando se suelta una tecla teniendo el control el
foco.
9. LostFocus: Perder el foco en el control.
10. MouseDown: Pulsar una tecla del ratón sobre el control.
11. MouseMove: Mover el ratón (Detecta la posición del ratón sobre el
control).
12. MouseUp: Soltar una tecla del ratón sobre el control.
2.4 Ejemplo

2.4.1 Código del ejemplo
Nombre de los controles del ejemplo:
1. entradatexto
2. listadetextos
3. listadesplegabledetextos
4. acciones
5. controlbotonborrar
6. controlbotonintroducir
7. controlbotondesactivar
8. activarlistadetextos
9. activarlistadesplegabledetextos

2.5 Problema obligatorio
Se trata de realizar una aplicación en Visual Basic que permita hacer las
operaciones matemáticas básicas. El aspecto de la interface tiene que ser el siguiente:

Las funcionalidades son las siguientes:
1. Cuando se selecciona la operación sumar los títulos en azul indicarán
sumando 1 y sumando 2.
2. Cuando se selecciona la operación restar los títulos en azul indicarán
minuendo y sustraendo.
3. Cuando se selecciona la operación multiplicar los títulos en azul indicarán
factor 1 y factor 2.
4. Cuando se selecciona la operación dividir los títulos en azul indicará
dividendo y divisor.
5. Al seleccionar cualquiera de las operaciones el texto rojo se borrará.
6. Al pulsar el botón obtener resultado, si algunos de los operandos no son
numéricos, la aplicación sacará un mensaje advirtiéndolo.
7. Al pulsar el botón obtener resultados si los operandos son numérico se
mostrará en el texto en rojo la operación y su resultado
2.6 Problema complementario
Poner un Check Box que, en caso de estar activado, borre las casillas de los
operandos al seleccionar una operación.
Poner un Check Box que, en caso de estar activado, ponga el resultado de la
operación como operando 1 de modo que se pueda ir acumulando sucesivas
operaciones.

3. Práctica 3. Instrucciones condicionales
3.1 Objetivo
Familiarizar al alumno con las Instrucciones condicionales (IF y SELECT) y la
gestión de las mismas por parte del ordenador.
3.2 Duración
2 horas
3.3 Problemas
3.3.1 Problema
Modificar el ejemplo 1.3.8.1 para que en el caso de que la suma sea negativa
saque el mensaje: "Suma negativa" y en caso contrario "Suma positiva"
3.3.2 Problema
Modificar el ejemplo 1.3.8.2 para que en el caso de que se vaya a dividir por 0
se informe al usuario y se le dé una nueva oportunidad de introducir el divisor. Si este
sigue siendo 0 no se calculará la división y se informará al usuario.
3.3.3 Problema (utilizar IF)
Escribir un programa que determine la calificación final de un examen. Para ello
se parte de las notas de teoría y de práctica, de acuerdo con el criterio especificado en
la tabla. La nota total la componen el 40% de la nota de teoría y el 60% de la de
prácticas. El programa visualizará la calificación final correspondiente.
0 < Teoría < 3 3 Teoría < 4,5 4,5 Teoría 10
0 < total < 5 Suspenso Suspenso Suspenso
5 total 10 Suspenso Dudoso Aprobado
En el caso de que la nota implique aprobado, informar mediante un mensaje
cuál ha sido la calificación (APROBADO, NOTABLE O SOBRESALIENTE)

3.3.4 Problema (utilizar SELECT)
Realizar el problema anterior utilizando SELECT.
3.3.5 Problema
Preguntar por un valor de temperatura en grados centígrados al usuario y, en
función de su valor, mostrar el mensaje que corresponda:
“Baja”: temperatura < 0
“Media”: temperatura [0, 40)
“Alta”: temperatura [40, 50)
“Muy alta”: temperatura >= 50
3.3.6 Problema
Preguntar por un número de mes [1, 12] al usuario y mostrar el nombre de
dicho mes. Si el usuario introduce un valor no válido, se le mostrará un mensaje de
error.

4. Práctica 4. Instrucciones repetitivas
4.1 Objetivo
Familiarizar al alumno con las estructuras de control y la gestión de las mismas
por parte del ordenador.
4.2 Duración
5 horas
4.3 Problemas
Realizar los programas en Visual Basic que se indican a continuación, usando la
estructura For … Next.
4.3.1 Problema
Escribir un programa en Visual Basic que realice el siguiente cálculo:
4.3.2 Problema
Escribir un programa que permita obtener la suma de los 200 primeros
números impares.
4.3.3 Problema
Escribir un programa que permita calcular el producto de los 15 primeros
números naturales.
4.3.4 Problema

El programa debe solicitar al usuario los valores de z y de v, una vez dados
dichos valores, el programa deberá hacer los cálculos independientemente de que z
sea mayor que v o viceversa.
4.3.5 Problema
El programa debe solicitar al usuario los valores de z y de v, una vez dados
dichos valores, el programa deberá hacer los cálculos independientemente de que z
sea mayor que v o viceversa.
4.3.6 Problema
Solicitar al usuario un valor entero N y mostrar la suma todos sus divisores
excepto el uno y él mismo. Por ejemplo, si N=36, la suma de todos sus divisores es 54
(2+3+4+6+9+12+18). NOTA: para ver si un entero es divisible por otro entero, debe
usarse el operador Mod.
4.3.7 Problema
Solicitar al usuario un valor entero N y mostrar al usuario si dicho número es
primo o no mediante un mensaje por pantalla. En caso de no ser primo se mostrará
también en pantalla todos sus divisores.
4.3.8 Problema
Calcular la integral del siguiente polinomio en el intervalo [4,9] por el método
de las sumas sucesivas:

Dividir el intervalo en N (constante) intervalos iguales. Cada uno de esos
intervalos junto con el valor del polinomio en el centro de cada uno, define un
rectángulo. La integral aproximada será la suma de las áreas de dichos rectángulos.
(Tomar como constante N=100).
Realizar los programas en Visual Basic que se indican a continuación, usando las
estructuras Do … While o Do … Until.
4.3.9 Problema
Calcular
Hasta que el último elemento de la serie que se sume sea inferior a una
constante K de valor 0,000000001.
4.3.10 Problema
Calcular
Hasta que el último elemento de la serie que se sume sea inferior a una
constante K de valor 0,00001.
4.3.11 Problema
Crear un programa en Visual Basic que calcule la media de una serie de datos
reales que se irán introduciendo por teclado. El programa solicitará al usuario que
introduzca un dato y a continuación le pregunta si desea introducir más, si la respuesta
es afirmativa continuará solicitando datos, cuando se le indique que no se quieren
introducir más datos, nos visualizará la media de los datos introducidos.

4.3.12 Problema
En este problema se programará un juego en el que el usuario debe adivinar un
número generado aleatoriamente, con una cantidad de intentos limitada. Para ello se
escribirá un programa en Visual Basic que haga lo siguiente:
1. Generar un entero aleatorio entre 1 y LIMITE (constante con valor 100).
2. Invitar de forma repetida al usuario a adivinar el número aleatorio.
3. Tras cada intento, mostrar al usuario un mensaje que indique si el valor
buscado es mayor, menor o igual al intentado.
4. El programa finalizará cuando se adivine el número o se llegue al número
máximo de intentos (constante MAX_INTENTOS de valor 10).
5. Tras finalizar el programa, se mostrará un mensaje con el número de intentos
utilizados, así como la suma de todos los números introducidos por el usuario.
6. Usando la sentencia SELECT sacar el mensaje correspondiente en función del
porcentaje de intentos utilizados, independientemente del valor de la constante
MAX_INTENTOS. La correspondencia entre mensajes y porcentajes será la siguiente:
“Muy bien” < 25%
“Bien” (25%, 50%]
“Regular” (50%, 75%]
“Mal” >75% o no acertado
El programa debe funcionar aunque se cambien los valores de MAX_INTENTOS
y LIMITE.
NOTA: La función Rnd() devuelve un valor aleatorio real en el intervalo (0, 1]. La
función Int devuelve la parte entera argumento. Por tanto, para generar un valor
entero aleatorio entre a y b (ambos incluidos), se debe usar la expresión
a+Int(Rnd()*(b-a+1)

Boletin prßcicas 1-a-4

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (10)

Similar a Boletin prßcicas 1-a-4

Similar a Boletin prßcicas 1-a-4 (20)

Último

Último (20)

Boletin prßcicas 1-a-4