• Author / Uploaded
• Pither Honrrado Levano Benites

• Categories
• Estructura de datos de matriz
• Matriz (Matemáticas)
• Algoritmos
• Java (lenguaje de programación)
• Programación de computadoras

Citation preview

Técnicas de Programación Orientada a Objetos



Presentación…………………………………………………………………………………………..3

 Modulo A 

Semana 1: Arreglos Lineales y Matrices …………………………………………………...4

 Semana 2: Ordenamiento de datos y Búsqueda de Datos…….……………….28  Semana 3: Programación Orientada a Objetos …………………………………40  Semana 4: Manejo de la Clase String ……………………………………………72  Semana 5: Manejo de Archivos ………………………………………………………….....81  Semana 6: Clases Primitivas ………………………………………………………………….99  Semana 7: Métodos propios …………………………………………………………………116  Semana 8: Ejercicios de Aplicación…………………………………………………….…127  Semana 9: Manejo de Capas en una aplicación en escritorio……………………133

 Modulo B  Semana 1: Introducción a la Plataforma .NET…………………………………136  Semana 2: Uso de Estructuras de Control…….……………………………….194  Semana 3: Introduccion a la Estructura de Datos(Arreglos)………………….233  Semana 4: Procedimientos y Funciones……………………………………...…239  Semana 5: Funciones de Sistema y Formatos …………………………………..…284  Semana 6: Programacion Orientados a Objetos…………………………………….308  Semana 7: Manejo de Colecciones………………………………………………………350  Semana 8: Manejo de Archivos……………………………………………………………392  Semana 9: Manejo de Streams de Datos y Archivos………………………………412

 Bibliografía: ……………………………………………………………………………………………421

Técnica de Programación Orientada a Objetos

2

PRESENTACIÓN Esta guía didáctica es un material de ayuda institucional, perteneciente a las especialidades de computación, Ingeniería de Software e Ingeniería de Redes y Comunicaciones tiene por finalidad proporcionar los conocimientos de la programación orientada a Objetos a los estudiantes del segundo ciclo de estudios. La Organización SISE, líder en la enseñanza tecnológica a nivel superior, promueve la elaboración de materiales educativos, en concordancia a las exigencias de las tecnologías de estos tiempos, que permiten la creación de nuevas herramientas de aprendizaje con el objetivo de facilitar el acceso de los estudiantes a la educación en el marco del desarrollo tecnológico de la informática de las telecomunicaciones. Esta guía se divide en 2 módulos y cada una de ellas en 9 semanas. Permite conocer las herramientas indispensables para la elaboración de aplicaciones con el uso de la técnica O.O. Se inicia con el uso de técnica en manejo de datos en memoria y en el manejo de capas donde estas técnicas básicas se necesitan para dar solución a una determinada proposición o problema. En este proceso el alumno aprenderá instrucciones que le permitirán evaluar expresiones para luego procesar un conjunto de sentencias. También aprenderá el manejo de una aplicación a nivel de contenedores. La implementación y uso de Capas dentro de la aplicación en escritorio permitirán que el alumno aplique la técnica Orientada a objetos. Todas estas herramientas darán un soporte solido al alumno para aprender a programar en cualquier lenguaje Orientada a Objetos(JAVA, .NET, Visual C,etc). Este material en su primera edición, servirá para ayudar a nuestros estudiantes SISESINOS.

Técnica de Programación Orientada a Objetos

3

Arreglos

Contenidos -

Concepto de Arreglos :Declaración, asignación e inicialización de memoria a un arreglo Acceso Secuencial y Aleatorio. Agregar Datos. Arreglos con uso de Estructuras Condicionales: Uso de Contadores y Acumuladores. Uso del JList (defaultListModel) Definición de matrices: Acceso a elementos de una matriz: Asignación de Datos: Matrices: Definicion,Asignacion, Ingreso. Uso del JTable(DefatultTableModel), (setElementAt(), getSelectedRow(), getSelectedColum(), changeSelection(), addRow(),etc).

____________________________________________________________________________

ARREGLOS LINEALES Un arreglo es una colección de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre común. Para referirse a un determinado elemento de un arreglo se deberá utilizar el nombre del arreglo acompañado de un índice el cual especifica la posición relativa en que se encuentra el elemento.

 Los arreglos pueden ser: 

Unidimensionales (vectores).



Bidimensionales (matrices, tablas).



Multidimensionales (tres dimensiones o más).

 Declaración de un arreglo: : nombre_variable [Tamaño]

Técnica de Programación Orientada a Objetos

4



Con esto diremos que se está definiendo un atributo de tipo arreglo y estamos determinando el tipo de dato y el tamaño de registros.

Ejemplos: entero: Numeros[10] decimal: talla [5] caracter nombres [8]

 Asignación de datos hacia a un arreglo:

nombre_variable[índice] =



Esta instrucción asigna el valor asociado de la expresión a la posición índice del arreglo nombre_variable. El índice debe ser una expresión del tipo entero en el rango [0, longitud-1].

Ejemplos: Estableciendo Datos a los Arreglos Numero[2]=152

talla[4]=170.5

nombre[6]=”Verónica”

Numero[5]=115

talla[0]=168.52

nombre[3]=”William”

Numero[10]=652

talla[2]=102.62

nombre[1]=”Angie”

Numero[0]=52

talla[1]=85.62

nombre[8]=”Sebastian”

Los datos establecidos en Memoria serian así: Arreglo Numero Índice 0 Valores 52

Índice Valores

Índice Valores

1 0

2 152

Arreglo Talla 0

Arreglo Nombres 0 null

3 0

5 115

1

168.52

1 Angie

4 0

2 null

7 0

2

8 0

9 0

3

85.62

102.6 0

3

5 null

4 William null

Técnica de Programación Orientada a Objetos

6 0

10 652

4

5

170.5 0

6

7 Verónica null

8 Sebastián

5

Nota: las posiciones que no se le asignaron datos quedarían vacios (0) en el caso de ser numero y null en el caso de carácter.

 Acceso al contenido de un arreglo: Para poder acceder al contenido: a. escribir: Obtener el dato de acuerdo al índice establecido, para ello se deberá mostrar dicho dato, lo cual se podrá utilizar una variable o mostrarlo directamente.Aquí también vale la aclaración de que el índice debe estar dentro del rango de definición del arreglo.

Variable=nombre_Arreglo[índice] escribir (Variable) o escribir (nombre_Arrgelo[indice) Ejemplo: X=nombre[1] escribir(X)

el resultado será Angie

_________________________________________________________ escribir (nombre[8])

el resultado será Sebastián

b. Leer: se podrá ingresar datos al arreglo en forma contigua de acuerdo al índice. Es por ello que se usara a una estructura iterativa que puede ser Mientras(while), Desde (do) o Repetir(do..while). Leer(Arreglo[indice]) Nota Para que esta lectura se repita hasta el total de tamaño del arreglo se deberá de usar a una estructura Iterativa.

Un Ejemplo con él Desde desde(x=1 hasta 10) leer(Arreglo[x]) escribir(Arreglo[x]) fin_desde

Técnica de Programación Orientada a Objetos

6

 Los pasos para la utilizar un vector: 1. Declarar el vector: Consiste en establecer el nombre, el tamaño y el tipo de los datos que se van a almacenar en el arreglo ejemplo:  Hay que diferenciar dos términos: tamaño del vector (T): es el número máximo de elementos que puede contener el vector. Numero de elementos(N): que indica cuantos elementos hay almacenados en el arreglo en determinado momento. Nota N=10.5) ca=ca+1 sino cd=cd+1 fin_si fin_desde escribir(“Total de Aprobados: “,ca) escribir(“Total de Desaprobados: “,cd)

Técnica de Programación Orientada a Objetos

9

6. Crear un Arreglo que ingrese 15 Áreas y sus respectitos Sueldos y mostrar cuantos son del área de “Sistemas”,”Contabilidad”, Cuantos superan al sueldo mínimo Cuántos ganan entre 1000 y 2500. Constante N=15 entero:Sueldo[N] Carácter:Area[N] desde(i = 0 hasta N-1) leer(Sueldo[i] , Area[i] ) escribir (Sueldo[i] , Area[i] ) si(Area[i]=”Sistema”)entonces cs=cs+1 fin_si si(Area[i]=”Contabilidad”) entonces cc=cc+1 fin_si si(Sueldo[i]>650) entonces csum=csum+1 fin_si si(Sueldo[i]>=1000 y Sueldo[i]1500) d=0.10*sueldo; return(d); } public double pago(int sueldo,double dsct){ return(sueldo-dsct); } }

//Campos encapsulado public class ClassEncapsular { int c,cs,suel; double np,des; public int getC() { return c; } public void setC(int c) { this.c = c; } public int getCs() { return cs; } public void setCs(int cs) { this.cs = cs; } public int getSuel() { return suel; } public void setSuel(int suel) { this.suel = suel; } public double getNp() { return np; } public void setNp(double np) { this.np = np; } public double getDes() { return des;

Técnica de Programación Orientada a Objetos

66

} public void setDes(double des) { this.des = des; } }

// Frame: public class FrmVentana extends JFrame { Class1 x = new Class1(); ***** public FrmVentana() { try { jbInit(); } catch (Exception e) { e.printStackTrace(); } } private void jbInit() throws Exception { ******* ****** ****** } private void btnCalcular_actionPerformed(ActionEvent e) { x.setC(Integer.parseInt(txtch.getText())); x.setCs(Integer.parseInt(txtcst.getText())); x.setSuel(x.pago(x.getC(),x.getCs())); x.setDes(x.pago(x.getSuel())); x.setNp(x.pago(x.getSuel(),x.getDes())); lblSueldo.setText(""+x.getSuel()); lblDesc.setText(""+x.getDes()); lblnp.setText(""+x.getNp()); } private void btnLlamar_actionPerformed(ActionEvent e) { FrmResultados j=new FrmResultados(); j.setVisible(true); j.lblr.setText(""+x.getNp()); } }

// Clase Main public class Class1 extends ClassMetodos{ public static void main(String[] args) { FrmVentana ven=new FrmVentana(); ven.setVisible(true); }

Técnica de Programación Orientada a Objetos

67

}

 Caso 04 Crear una sobrecarga de métodos donde permita hallar el precio, total, igv y el neto. Según el articulo saldrá el precio. El total será deacuerdo a la cantidad y precio y el neto será deacuero al total y a la selección del Igv.

// Clase encapsulada package pckLogico; public class ClassEncapsular { int precio,cantidad; double total,igv; String articulo; public int getPrecio() {

Técnica de Programación Orientada a Objetos

68

return precio; } public void setPrecio(int precio) { this.precio = precio; } public int getCantidad() { return cantidad; } public void setCantidad(int cantidad) { this.cantidad = cantidad; } public String getArticulo() { return articulo; } public void setArticulo(String articulo) { this.articulo = articulo; } public double getTotal() { return total; } public void setTotal(double total) { this.total = total; } public double getIgv() { return igv; } public void setIgv(double igv) { this.igv = igv; } }

// clase sobrecarga package pckLogico; public class ClassSobreCarga { public int Calcular(String articulo){ int pre = 0; if(articulo.equalsIgnoreCase("Monitor")) pre=259; if(articulo.equalsIgnoreCase("Teclado")) pre=15; if(articulo.equalsIgnoreCase("Memorias")) pre=175; if(articulo.equalsIgnoreCase("Case"))

Técnica de Programación Orientada a Objetos

69

pre=550; if(articulo.equalsIgnoreCase("Lectora")) pre=25; return(pre); } public double Calcular(int cantidad, int precio){ return(cantidad*precio); } public double calcular(double total){ return(total*0.19); } public double calcular(double total,double igv){ return(total+igv); } }

//Frame public class FrmDatos extends JFrame { ClassEncapsular atributo = new ClassEncapsular(); ClassSobreCarga metodos = new ClassSobreCarga(); String Titulos[]={"registro","articulo","precio","cantidad","total"}; String valores[][]={}; int c=1; ************* *************** private void jbInit() throws Exception { ********************* ********************* ********************* cboArticulo.addItem("Seleccionar"); cboArticulo.addItem("Monitor"); cboArticulo.addItem("Teclado"); cboArticulo.addItem("Memorias"); cboArticulo.addItem("Case"); cboArticulo.addItem("Lectora"); } private void cboArticulo_actionPerformed(ActionEvent e) { lblTotal.setText(""); txtCantidad.setText(""); atributo.setArticulo(cboArticulo.getSelectedItem().toString()); lblPrecio.setText(""+metodos.Calcular(atributo.getArticulo())); atributo.setPrecio(metodos.Calcular(atributo.getArticulo())); lblPrecio.setText(""+atributo.getPrecio()); } private void btnAgregar_actionPerformed(ActionEvent e) { atributo.setCantidad(Integer.parseInt(txtCantidad.getText())); atributo.setPrecio(atributo.getPrecio()); atributo.setTotal(metodos.Calcular(atributo.getCantidad(),atributo.getPrecio())); lblTotal.setText(""+atributo.getTotal());

Técnica de Programación Orientada a Objetos

70

if(chkIGV.isSelected()) atributo.setIgv(metodos.calcular(atributo.getTotal())); else atributo.setIgv(0); lblIGV.setText(""+atributo.getIgv()); lblneto.setText(""+metodos.calcular(atributo.getTotal(),atributo.getIgv())); Object valores[]={c,atributo.getArticulo(),atributo.getPrecio(),atributo.getCantidad(),atributo.getTotal()}; ModDatos.addRow(valores); ++c; }

private void btnLimpiar_actionPerformed(ActionEvent e) { txtCantidad.setText(""); cboArticulo.setSelectedIndex(0); lblIGV.setText(""); lblneto.setText(""); lblPrecio.setText(""); lblTotal.setText(""); } }

Técnica de Programación Orientada a Objetos

71

Contenidos -

Manejo de Paneles(JPanel) Clase GregorianCalendar Clase String: Uso de la Clase String String.valueOf(), length(), charAt(), toString(), substring(), indexOf(), lastIndexOf(), equalsIgnoreCase(), compareTo(), - Uso de la Clase String: concat(), replace(), toLowerCase(), toUperCase(). ____________________________________________________________________________

 PANEL Construir directamente programas o aplicaciones directamente en un FRAME, produce rápidamente un amontonamiento de controles o componentes en la propia forma. Es más conveniente usar componentes de agrupamiento visuales que faciliten la separación física y lógica de las diversas partes que componen un programa o aplicación. Estos controles de agrupamiento son conocidos como paneles, aunque en visual basic se conocen como frames (no confundirlos con frame de java). Java tiene los siguientes tipos de paneles, PANEL, SPLITPANE, SCROLLPANE, TABBEDPANE, TOOLBAR. Recordar además que los panels pueden y deben usar su propio layout para acomodar los componentes visuales que contendrá. En particular frame usando su layout acomoda sus paneles y panel usando su layout acomoda los componentes.

El panel es un área de Java Desktop System en la que se pueden ejecutar aplicaciones y realizar otras tareas. La clase Panel es el más simple de los Contenedores de Componentes gráficos. En realidad, se trataba de crear una clase no-abstracta (Container sí lo es) que sirviera de base a los applet y a otras pequeñas aplicaciones. La clase Panel consta de dos métodos propios: el constructor, cuyo fin es crear un nuevo Panel con un LayoutManager de tipo FlowLayout (el de defecto), y el método addNotify() que, sobrecargando la función del mismo nombre en la clase Container, llama al método createPanel() del Toolkit adecuado, creando así un PanelPeer. El AWT enviará así al Panel (y por tanto al applet) todos los eventos que sobre él ocurran. Esto que

Técnica de Programación Orientada a Objetos

72

puede parecer un poco rebuscado, obedece al esquema arquitectónico del AWT; se trata del bien conocido esquema de separación interface/implementación que establece por un lado una clase de interface y por otras distintas clases de implementación para cada una de las plataformas elegidas.

Técnica de Programación Orientada a Objetos

73

 GregorianCalendar Según la documentación del API de java, la clase Calendar es una clase abstracta base para convertir entre un objeto de tipo Date (java.util.Date) y un conjunto de campos enteros como YEAR (año), MONTH (mes), DAY (día), HOUR (hora), etc. Una subclase de Calendar representa una fecha de acuerdo a las reglas de un calendario específico. La plataforma provee una subclase concreta de Calendar: GregorianCalendar. Futuras subclases podrían representar varios tipos de calendarios lunares usados en diferentes lugares del mundo. La clase Calendar tiene mucho del comportamiento que esperaríamos de la clase java.util.Date, es decir, cuando obtenemos una instancia de la clase Calendar obtenemos un instante de tiempo específico con gran precisión similar a lo que obtenemos con la clase date. Sí es cierto, podemos decir aquí que los milisegundos juegan un papel fundamental en esta clase; pero el verdadero sentido de la clase Calendar no es obtener un instante de tiempo sino extraerle datos. Recordemos que la clase java.util.Date tiene métodos que permiten obtener el año, mes y día, pero estos métodos están obsoletos precisamente por que para eso existe Calendar y de hecho cuando usamos el método getYear() de la clase java.util.Date esta recurre a las funcionalidades que posee la clase Calendar.

Hay que mencionar también que obtener un instante de tiempo específico y diferente del actual es supremamente sencillo con esta clase, indicándole simplemente el día, mes y año con que se desea trabajar, o se puede especificar aún más dando hora, minuto y segundo deseado. Veamos: El método getInstance() de la clase nos devuelve una subclase de Calendar con el tiempo ajustado a la hora actual, y usamos el método set(args…) para forzarlo a tomar la fecha deseada: Calendar ahoraCal = Calendar.getInstance(); System.out.println(ahoraCal.getClass()); ahoraCal.set(2004,1,7); System.out.println(ahoraCal.getTime()); ahoraCal.set(2004,1,7,7,0,0); System.out.println(ahoraCal.getTime()); 

Extraer los datos La clase Calendar tiene un único método get para obtener todos sus datos para lo cual se ayuda de una serie de atributos constantes que permiten obtener o ajustar un atributo determinado de la fecha; los más importantes son (al lado los valores que representan):        

YEAR: Año. MONTH: Mes. DATE, DAY_OF_MONTH: Día del mes. DAY_OF_WEEK: Día de la semana entre 1 (MONDAY) y 7 (SATURDAY). HOUR: Hora antes o después del medio día (en intervalos de 12 horas). HOUR_OF_DAY: Lo hora absoluta del día (en intervalos de 24 horas). MINUTE: El minuto dentro de la hora. SECOND: El segundo dentro del minuto.

Están también los atributos que representan los meses, como: JANUARY, MARCH, JUNE, DECEMBER, etc. que van desde 0 (JANUARY) hasta 11 (DECEMBER).

Técnica de Programación Orientada a Objetos

74

También hay atributos que representan los días: SUNDAY, TUESDAY, SATURDAY, etc. estos empiezan con 1 (SUNDAY) y van hasta 7 (SATURDAY).

Hay más atributos pero con estos es suficiente para los objetivos de este artículo, si deseas conocerlos todos recurre a la documentación del lenguaje.

Para extraer algún atributo se usa el método get pasándole como parámetro alguna de las constantes que vimos anteriormente y el método devuelve siempre un dato de tipo int; así para obtener el año, mes, día y hora, usaríamos el siguiente código: System.out.println("ANYO: "+ahoraCal.get(Calendar.YEAR)); System.out.println("MES: "+ahoraCal.get(Calendar.MONTH)); System.out.println("DIA: "+ahoraCal.get(Calendar.DATE)); System.out.println("HORA: "+ahoraCal.get(Calendar.HOUR)); if (ahoraCal.get(Calendar.MONTH) == Calendar.JUNE){ System.out.println("ES JUNIO"); }else{ System.out.println("NO ES JUNIO"); } Si el objeto tiene la fecha equivalente a 5:30 p.m. del 22 de junio de 2004 se ve la siguiente salida: AÑO:2010 MES:Mayo DIA:02 HORA:5 ES JUNIO

Modificar Un Atributo Modificar un atributo de Calendar es tan sencillo como obtenerlo, solamente es necesario usar el método set(int atributo, int valor), en donde atributo es una de las constante mencionadas anteriormente y valor es la cantidad que se le quiere asignar. Por ejemplo: ahoraCal.set(Calendar.MONTH,Calendar.JANUARY) o ahoraCal.set(Calendar.YEAR, 1980) ajustarían la fecha almacenada en el objeto ahoraCal a enero o al año 1980 sin modificar ninguno de los otros atributos.

Aclaremos esto con un ejemplo. Mi cumpleaños es en octubre 27 :-), y deseo saber qué día lo celebraré en el 2010; para eso obtengo una instancia de Calendar (que siempre devuelve un objeto del tipo GregorianCalendar) y la ajusto hasta el 27 de octubre de 2010, luego obtengo el nombre del día, veamos: Calendar cumpleCal = Calendar.getInstance(); cumpleCal.set(2010,9,27); //La hora no me interesa y recuerda que los meses van de 0 a 11 int dia = cumpleCal.get(Calendar.DAY_OF_WEEK); System.out.println(dia); //Día 4 = WEDNESDAY = MIÉRCOLES La salida es: 4, lo que quiere decir que en el 2010 el 27 de octubre será un día miércoles (así que probablemente lo celebre el viernes 29 :-));

Técnica de Programación Orientada a Objetos

75

Clase GregorianCalendar y operaciones Realizar operaciones como sumar o restar días no es algo que dependa directamente de Calendar sino más bien de una subclase de esta que implemente algún tipo de calendario usado, pues no todos los calendarios tienen 12 meses ni años de 365 días como el que nosotros (en casi todo occidente) usamos.

Este calendario usado en occidente, llamado gregoriano fue adoptado por primera vez en 1582 por el imperio romano (o aproximadamente) y posteriormente se fue adoptando en muchos otros países, por ejemplo 1752 en Gran Bretaña y 1918 en Rusia. A grandes rasgos sabemos que el calendario gregoriano consta de años que son definidos por cada traslación (vuelta de la tierra alrededor del sol), cada año tiene doce meses de los cuales 7 tienen 31 días, 4 tienen 30 días y 1 tiene 28 días excepto en años bisiestos que tiene 29. Estos años bisiestos se implantaron para corregir el desfase que tenemos cada cuatro años (un año real dura 365 días y 6 horas aproximadamente), regla completa para los años bisiestos según el calendario gregoriano es la siguiente:

"Un año es bisiesto si es divisible por 4, a menos que sea divisible por 100 y no por 400".

Todo esto quizá suene un poco tonto, pero es absolutamente necesario tenerlo claro para entender el funcionamiento de la clase GregorianCalendar.

GregorianCalendar es una subclase de Calendar y es la implementación directa del calendario gregoriano (de hecho es la única implementación de un calendario en jdk1.4) tal y como lo conocemos hoy día. Es con esta clase con la que podemos sumar 2 ó 3 días a una fecha sin preocuparnos por desbordamientos o recalcular meses o años, pues ella lo hace automáticamente tomando en cuenta las reglas en los párrafos anteriores. De igual forma podemos obtener información como el día de la semana o la semana del año que fue una fecha determinada. Los métodos roll() y add() Anteriormente vimos los métodos set() y get() de la clase Calendar para obtener fechas y los datos de esas fechas, ahora veremos los métodos add() y roll() que nos permiten avanzar un tiempo exacto sobre los datos obtenidos anteriormente.

El método add(CONSTATE, valor) suma algebraicamente valor a una fecha; el valor a sumar asume el significado dado por CONSTANTE, que es una de las definidas para la clase y que se mencionaron en la sección anterior (MONTH, YEAR, SECOND, etc).

Por ejemplo agreguemos 3 días y 2 meses a la fecha actual: Calendar hoy = Calendar.getInstance(); hoy.add(Calendar.DATE, 3); hoy.add(Calendar.MONTH, 2); System.out.println(hoy.getTime()); Ahora restemos 5 años y 50 días (Prúebalo en tu PC): Calendar hoy = Calendar.getInstance();

Técnica de Programación Orientada a Objetos

76

hoy.add(Calendar.YEAR, -5); hoy.add(Calendar.DATE, -50); System.out.println(hoy.getTime());

Técnica de Programación Orientada a Objetos

77

 Clase String Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar. Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven valores String. Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están escritos desde otro lenguaje.

 MÉTODOS PRINCIPALES: Para poder aplicar estos métodos es necesario crear un objeto String. Además de estos métodos, la clase String cuenta con otros muchos.

 int length(): devuelve la longitud de la String, incluyendo espacios en blanco. La longitud siempre es una unidad mayor que el índice asociado al último carácter de la String. Ejemplo:

String s=”SISE tiene 27 años…..!”;

int longitud=str.length();

 int indexOf(String str, int indice): devuelve el índice en el que aparece por primera vez la String del primer argumento en la que se aplica el método, a partir del índice especificado en el segundo argumento. Recordar que una String está indexada. Si el índice a partir del que se inicia la búsqueda no existe o la String no aparece, devuelve -1. MUY USADO. Ejemplo:

String s=”Sebastian Aquino”; Cad=s.indexOf(“t”,s.length());

 int indexOf(char ch): devuelve el índice en el que aparece por primera vez el carácter que se le pasa al argumento. Si no se encuentra el carácter devuelve 1. Se observa que el nombre de este método es igual al anterior aunque su número de argumentos es distinto además de su tipo. A esto, en Java, se le llama sobrecarga de métodos: mismo nombre pero distinto nº de argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para Técnica de Programación Orientada a Objetos

78

comprobar que hay más con este mismo nombre. Este concepto se tratará más en profundidad en temas posteriores. String s=”Laboratorios SIse ”; Cad=s.indexOf(„S‟);

 String replace (char viejoChar, char nuevoChar): cambia el carácter asociado al primer argumento por el que se le pasa al segundo, de la String sobre la que se aplica el método generando una nueva. La String sobre la que se aplica el método no cambia, simplemente se crea otra nueva en base a la String sobre la que se aplica el método. Ejemplo:

String s1=”Angie”; Cad=s.replace(„e‟,‟E‟);

String toLowerCase(): devuelve una nueva String convirtiendo todos los caracteres de la String sobre la que se aplica el método, en minúsculas. String s=”SEBASTIAN”; JOptionPane.showMessageDialog(null,s.toLowerCase());

String toUpperCase(): devuelve una nueva String convirtiendo todos los caracteres de la String sobre la que se aplica el método, en mayúsculas. String s=”william”; JOptionPane.showMessageDialog(null,s.toUpperCase());

boolean equals(String str): investiga si dos String tienen los mismos caracteres y en el mismo orden. Si es así devuelve true y si no false. MUY USADO boolean equalsIgnoreCase(String str): investiga si dos String tienen los mismos caracteres y en el mismo orden sin tener en cuenta las mayúsculas. Si es así devuelve true y si no false. MUY USADO boolean startsWith(String str): devuelve true si la String sobre la que se aplica comienza por la del argumento; false si esto no ocurre. boolean startsWith(String str, int indice): devuelve true si la String sobre la que se aplica comienza por la del argumento a partir de un determinado índice asociado al segundo argumento; false si esto no ocurre.

Técnica de Programación Orientada a Objetos

79

boolean endsWith(String str): devuelve true si la String sobre la que se aplica acaba en la del argumento; false si esto no ocurre. String trim(): devuelve una String en base a la que se le pasa al argumento, pero sin espacios en blanco al principio ni al final. No elimina los espacios en blanco situados entre las palabras. Ejemplo:

String s=” Hola William ”; //primero visualicemos la longitud Int l=s.length(); JOptionPane.showMessageDialog(null,I) //quitemos el espacio en blanco Cad=s.trim(); //vuelve a mostrar la longitud Int l=s.length(); JOptionPane.showMessageDialog(null,I)

String substring(int indiceIni, int indiceFin): devuelve una String obtenida a partir del índice inicial incluido y del índice final excluido; es decir, se comporta como un intervalo semiabierto [indiceIni, indiceFin). Si el índice final sobrepasa la longitud de la String, lanza una IndexOutOfBoundsException. MUY USADO. Ejemplo:

String s=”Docentes de Programacion”; Cad=s.substring(4,9);

char charAt (int indice): devuelve el carácter asociado al índice que se le pasa como argumento de la String sobre la que se aplica el método. Si el índice no existe se lanza una StringIndexOutOfBoundsException que hereda de IndexOutOfBoundsException. MUY USADO.

Técnica de Programación Orientada a Objetos

80

Contenidos -

Clase String: Definición de Archivos Archivos de Textos: Lectura / Escritura. Aplicar la capa de Datos con Manejo de Archivos. Manejo de Excepciones y try … catch, Manejo de las clases BufferedReader, BufferedWriter, PrintWriter, FileReader, readLine, StringTokenizer, nextToken. - Apertura de Archivos, Grabar Datos a un archivo. ____________________________________________________________________________

Definición de ARCHIVOS. Los archivos también denominados ficheros (file); es una colección de información (datos relacionados entre sí), localizada o almacenada como una unidad en alguna parte de la computadora. Los archivos son el conjunto organizado de informaciones del mismo tipo, que pueden utilizarse en un mismo tratamiento; como soporte material de estas informaciones.



Introducción a los archivos.

Los archivos como colección de datos sirve para la entrada y salida a la computadora y son manejados con programas. Los archivos pueden ser contrastados con Arrays y registros; Lo que resulta dinámico y por esto en un registro se deben especificar los campos, él número de elementos de un arrays (o arreglo), el número de caracteres en una cadena; por esto se denotan como "Estructuras Estáticas". En los archivos no se requiere de un tamaño predeterminado; esto significa que se pueden hacer archivos de datos más grandes o pequeños, según se necesiten.

Técnica de Programación Orientada a Objetos

81

Cada archivo es referenciado por su identificador (su nombre).

 Características de los Archivos Independencia de las informaciones respecto de los programas La información almacenada es permanente Un archivo puede ser accedido por distintos programas en distintos momentos Gran capacidad de almacenamiento.

 Clasificación de los Archivos Los archivos se clasifican según su uso en tres grupos: Permanentes o Maestros: Estos contienen información que varia poco. En algunos casos es preciso actualizarlos periódicamente. De Movimientos Se cercan para actualizar los archivos maestros. Sus registros son de tres tipos: alta, bajas y modificaciones. De Maniobra o Trabajo. Tienen una vida limitada, normalmente menor que la duración de la ejecución de un programa. Su utilizan como auxiliares de los anteriores. 

Tipos De Archivos

Los elementos de un archivo pueden ser de cualquier tipo, simples o estructurados o según su función. 

Según su función.

Se define por: a.- Archivos Permanentes: Son aquellos cuyos registros sufren pocas o ninguna variación a lo largo del tiempo, se dividen en: Constantes: Están formados por registros que contienen campos fijos y campos de baja frecuencia de variación en el tiempo. De Situación: Son los que en cada momento contienen información actualizada. Históricos: Contienen información acumulada a lo largo del tiempo de archivos que han sufridos procesos de actualización o bien acumulan datos de variación periódica en el tiempo. b.- Archivos de Movimiento: Son aquellos que se utilizan conjuntamente con los maestros (constantes), y contienen algún campo común en sus registros con aquellos, para el procesamiento de las modificaciones experimentados por los mismos. c.- Archivo de Maniobra o Transitorio: Son los archivos creados auxiliares creados durante la ejecución del programa y borrados habitualmente al terminar el mismo.



Según sus elementos.

Archivo de Entrada: Una colección de datos localizados en un dispositivo de entrada.

Técnica de Programación Orientada a Objetos

82

Archivo de Salida: Una colección de información visualizada por la computadora. Constantes: están formados por registros que contienen campos fijos y campos de baja frecuencia de variación en el tiempo. De Situación: son los que en cada momento contienen información actualizada. Históricos: Contienen información acumulada a lo largo del tiempo de archivos que han sufrido procesos de actualización, o bien acumulan datos de variación periódica en el tiempo. 



Archivos de Movimiento o Transacciones: Son aquellos que se utilizan conjuntamente con los maestros (constantes), y contienen algún campo común en sus registros con aquellos, para el procesamiento de las modificaciones experimentados por los mismos. Archivos de Maniobra o Transitorios: Son los archivos auxiliares creados durante la ejecución del programa y borrados habitualmente al terminar el mismo.

 Acceso a los Archivos Se refiere al método utilizado para acceder a los registros de un archivo prescindiendo de su organización. Existen distintas formas de acceder a los datos: Secuenciales; los registros se leen desde el principio hasta el final del archivo, de tal forma que para leer un registro se leen todos los que preceden. Directo; cada registro puede leerse / escribirse de forma directa solo con expresar su dirección en el fichero por él numero relativo del registro o por transformaciones de la clave de registro en él numero relativo del registro a acceder. Por Índice; se accede indirectamente a los registros por su clave, mediante consulta secuenciales a una tabla que contiene la clave y la dirección relativa de cada registro, y posterior acceso directo al registro. Dinámico; es cuando se accede a los archivos en cualquier de los modos anteriormente citados. La elección del método está directamente relacionada con la estructura de los registros del archivo y del soporte utilizado.

 Tipos de accesos Acceso Secuencial. Exige el tratamiento de elemento, para esto es necesario una exploración secuencial comenzando desde el primer momento (Pascal permite este acceso) Secuenciales: archivo de texto que debe ser leído del principio hasta el final. Acceso Directo. Permite procesar o acceder a un elemento determinado y referencia directamente por su posición en el soporte de almacenamiento (Turbo Pascal permite este acceso. Aleatorios: Es un archivo con registros de un mismo largo. Un programa puede accesar directamente cualquier registro sin tener que leer los registros previos. Binarios: Es un archivo que lee byte por byte sin asumir ninguna estructura. Los archivos Binarios no son un nuevo tipo de archivo, pero si una nueva forma de manipular cualquier tipo de archivo. Las técnicas de archivo binarios permiten leer o cambiar cualquier byte de un archivo. Son herramientas extremadamente potentes, pero como toda herramienta potente debe manejarse con cuidado

 Operaciones generales que se realizan sobre un archivo. Técnica de Programación Orientada a Objetos

83

Las operaciones generales que se realizan son: Creación. Escritura de todos sus registros. Consulta. Lectura de todos sus registros. Actualización. Inserción supresión o modificación de algunos de sus registros Clasificación. Reubicación de los registros de tal forma que queden ordenados según determinados criterios. Borrado. Eliminando total del archivo, dejando libre el espacio del soporte que ocupaba.

Excepciones Excepcion es, o sencillamente problemas. En la programación siempre se producen errores, más o menos graves, pero que hay que gestionar y tratar correctamente. Por ello en java disponemos de un mecanismo consistente en el uso de bloques try/catch/finally . La técnica básica consiste en colocar las instrucciones que podrían provocar problemas dentro de un bloque try, y colocar a continuación uno o más bloques catch, de tal forma que si se provoca un error de un determinado tipo, lo que haremos será saltar al bloque catch capaz de gestionar ese tipo de error específico. El bloque catch contendrá el codigo necesario para gestionar ese tipo específico de error. Suponiendo que no se hubiesen provocado errores en el bloque try, nunca se ejecutarían los bloques catch. Veamos ahora la estructura del bloque try/catch/finally: try { //Código que puede provocar errores } catch(Tipo1 var1) { //Gestión del error var1, de tipo Tipo1 } [ ... catch(TipoN varN) { //Gestión del error varN, de tipo TipoN }] [ finally { //Código de finally }

Técnica de Programación Orientada a Objetos

84

Como podemos ver es obligatorio que exista la zona try, o zona de pruebas, donde pondremos las instrucciones problemáticas. Después vienen una o más zonas catch, cada una especializada en un tipo de error o excepción. Por último está la zona finally, encargada de tener un código que se ejecutará siempre, independientemente de si se produjeron o no errores. Se puede apreciar que cada catch se parece a una función en la cuál sólo recibimos un objeto de un determinado tipo, precisamente el tipo del error. Es decir sólo se llamará al catch cuyo argumento sea coincidente en tipo con el tipo del error generado

 Archivos de Texto Archivos necesarios: Los archivos nos permiten guardar nuestro trabajo para que no perdamos datos una vez que cerremos la aplicación. Existen dos tipos de archivos en Java, en este trial veremos los primeros. Los archivos de texto en Java se manejan mediante la clase BufferedReader y la clase PrintWriter. Estas dos clases nos permiten manejar los archivos de texto como podemos ver en la presentación a continuación: Archivos de Texto Además de los ejemplos y ejercicios de la presentación puedes basarte en el siguiente archivo para aprender a manejar archivos de texto:

¿Cómo guardar en archivos de texto? En la computadora, los archivos son un bitstream o "flujo de bits". Esto es para que se puedan construir fácilmente programas que puedan escribir a cualquier tipo de flujo, ya sean archivos, la pantalla, la impresora o una red. La clase que nos srive para imprimir bits a un bitstream es PrintWriter. En la imagen de la izquierda podemos ver que el constructor del PrintWriter recibe un FileWriter, esto se debe a que el PrintWriter sabe escribir a un flujo, pero no sabe a cuál, la clase FileWriter le permite escribir a un flujo de archivos. El constructor de FileWriter es muy importante, puede recibir uno o dos parámetros, el primer parámetro es el nombre del archivo o un objeto de la clase File que represente el archivo que queremos abrir, el segundo (que es opcional) es un boolean que indica si se debe sobreescribir el archivo o escribir al final.

Hay dos maneras de escribir a un archivo una vez que ya tenemos el PrintWriter, pero primeor tenemos que entender una cosa de esta clase. El PrintWriter es un buffer, como una caja en la que se guarda lo que se va a escribir al archivo y una vez que ya está todo listo se manda al archivo.

Técnica de Programación Orientada a Objetos

85

Para mandar un String a un archivo de texto podemos utilizar dos métodos, el primero es println() que recibe una línea de texto y la imprime en el archivo con un cambio de línea ("\n") al final, el segundo método que se utiliza frecuentemente es el método print que funciona básicamente de la misma manera, pero no pone un salto de línea al final y no imprime los datos al archivo sino únicamente los deja en el buffer, por lo que tenemos que utilizar el método flush() para que lo imprima al archivo. Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya que en caso contrario no estamos seguros de que todos los cambios se guarden en el archivo. Para poder cerrar el archivo utilizamos el método close() del PrintWriter.

Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya que en caso contrario no estamos seguros de que todos los cambios se guarden en el archivo. Para poder cerrar el archivo utilizamos el método close() del PrintWriter.

¿Cómo leer de archivos de texto? El bitstream que creamos al guardar un archivo podemos leerlo mediante la clase BufferedReader. Pero al igual que la clase PrintWriter esta clase no sabe qué tipo de archivo está leyendo por lo que hay que especificarle queobtenga el bitstream desde un archivo utilizando la clase FileReader. Para construir un FileReader lo único que tenemos que hacer es utilizar el constructor que recibe el nombre de archivo o un objeto de la clase File representando el archivo que queremos leer. Una vez que ya tenemos el FileReader debemos utilizarlo para construir un BufferedReader, de la manera que se ve a la izquierda. Una vez que tengamos el BufferedReader podemos utilizar varios métodos que nos permiten escribir a archivos de texto. El primero que vamos a ver es el método read(), que nos devuelve un int con el código Unicode del carácter leído, para poder convertir este código en un carácter debemos utilizar un cast a char. Para hacer un cast de un tipo de dato a otro tenemos que poner la variable que queremos que reciba el valor, un símbolo de igual, el tipo de dato al que queremos convertir y el valor que queremos convertir, como se ve en la imagen de la izquierda.

Técnica de Programación Orientada a Objetos

86

El otro método del BufferedReader que nos va a ser muy útil es el método readLine(), este método nos permite leer todo un archivo mucho más rápido y nos es muy útil cuando queremos obtener datos de un archivo de inicio ya que podemos leer una línea cada vez y utilizarla de la manera que nos convenga. Al igual que cuando utilizamos el PrintWriter debemos cerrar el archivo al terminarlo de utilizar utilizando el método close() del BufferedReader ya que aunque en este caso no se pierden datos, otros programas no van a poder utilizar el archivo hasta que lo cerremos. Por último vamos a darle un rápido vistazo a la clase File que nos es muy útil siempre que trabajamos con archivos. 

El constructor de File recibe un String con la ruta del archivo, una vez que creamos el objeto tipo File podemos utilizar los siguientes métodos:



f.canRead(): Devuelve un boolean verdadero en caso de que se pueda leer el archivo, falso en caso de que no se pueda leer. f.canWrite(): Devuelve un boolean verdadero en caso de que se pueda escribir el archivo, falso en caso de que no se pueda escribir. f.delete(): Intenta borrar el archivo, devuelve true si pudo hacerlo, false en caso de que no lo haya borrado. f.deleteOnExit(): Borra el archivo al terminar el programa, muy útil cuando necesitamos un lugar para guardar muchos datos y no queremos saturar la memoria porque nos permite crear un archivo temporal en el que se guarden los datos.

  

Técnica de Programación Orientada a Objetos

87







Para poder leer archivos de texto en Java debemos crear un objeto de tipo BufferedReader. BufferedReader es una clase que contiene métodos predefinidos para poder leer de una secuencia de bits. Para poder guardar archivos de texto en Java debemos crear un objeto de tipo PrintWriter. PrintWriter es una clase que contiene métodos predefinidos para meter datos a una secuencia de bits. Puedes hacer click en los nombres para ver el API que contiene muchos métodos útiles.

 BufferedReader  El constructor que vamos a utilizar para crear un BufferedReader es: BufferedReader fileIn = new BufferedReader(new FileReader(fileName);  Ya que tenemos el objeto tipo BufferedReader podemos utilizar varios métodos para leer, él más común es: fileIn.readLine();  Este método lee una línea y la devuelve o devuelve null si llegamos al final del archivo y no hay nada que leer.  



Es importante recordar cuando trabajamos con archivos que cada que leemos o escribimos a un archivo debemos hacerlo dentro de un try. Un try es un manejador de excepciones, cuando sucede un error en la ejecución de nuestro programa ejecuta ciertas instrucciones dependiendo del tipo de error que sucedió. Otro método muy importante es el método: fileIn.read();

Técnica de Programación Orientada a Objetos

88



Este método nos permite leer un solo carácter del flujo de datos. El método regresa un número (int) del 1 al 65535 si puede leer del archivo o regresa -1 si no.

try { BufferedReader fileIn = new BufferedReader( new FileReader(fileName)); int i = fileIn.read(); //Iniciamos una variable a la que //vamos a leer char c = (char) i; //Como lo que leimos es un int debemos // hacer un cast a char } catch (IOException ioe) { } catch (FileNotFoundException fnfe) { }

 PrintWriter  







El constructor que vamos a utilizar para crear un PrintWriter es: PrintWriter fileOut = new PrintWriter(new FileWriter(fileName); Ya que tenemos el objeto PrintWriter podemos utilizar varios métodos para escribir, los más comunes son: fileOut.print(String); fileOut.println(String); Estos dos métodos reciben un String y lo imprimen en el archivo, el segundo método le pone un carácter de fin de línea al final. Al igual que al leer debemos recordar utilizar un try. Cuando utilizamos el PrintWriter todo entra a un buffer y una vez que terminemos de escribir los datos debemos recordar utilizar el método flush() del PrintWriter para escribir todo al archivo. Al terminar de usar el archivo también debemos recordar que debemos cerrarlo mediante el método close() del PrintWriter.

String fileName = "Texto.txt"; PrintWriter fileOut = null; try { fileOut = new PrintWriter(new FileWriter(fileName)); String s = "Una linea de texto"; fileOut.println(s); fileOut.flush(); } catch (IOException ioe) { System.out("Error, disco protegido contra lectura"); } catch (FileNotFoundException fnfe) { System.out("Error, no se encuentra el archivo"); } finally { if (fileIn != null) { try { fileIn.close(); } catch (IOException ioe) { }

Técnica de Programación Orientada a Objetos

89

} }

Ejemplos:  Caso 01 package prjarchivos; import java.io.FileReader; import java.io.IOException; import javax.swing.JFrame; public class ArchivoApp2{ public static void main(String[] args) { FileReader entrada=null; StringBuffer str=new StringBuffer(); try { entrada=new FileReader("VERARCHI01.txt"); int c; while((c=entrada.read())!=-1){ str.append((char)c); } System.out.println(str); System.out.println("--------------------------------------"); } catch (IOException ex) { System.out.println("El archivo no existe"); } finally{ //cerrar los flujos de datos if(entrada!=null){ try{ entrada.close(); } catch(IOException ex){} } System.out.println("el bloque finally siempre se ejecuta"); } } }

 Caso 02 package prjrarchivos2; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import javax.swing.JOptionPane; import pckPrincipal.FrmLlamar;

Técnica de Programación Orientada a Objetos

90

public class Class1 extends FrmLlamar{ public Class1() { String nombre=" VERARCHI02.txt"; BufferedReader entrada; try { entrada = new BufferedReader(new FileReader(nombre)); String texto=""; while(true){ texto = entrada.readLine(); //JOptionPane.showMessageDialog(null,texto); if(texto==null) break; System.out.println(texto); this.txt.append(texto+"\n"); } entrada.close(); this.setVisible(true); }catch(FileNotFoundException f){ } catch (IOException e) { // TODO } } }

 Caso 03 package pckClase; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Vector; import javax.swing.JFrame; import javax.swing.JOptionPane; import pckAplica.FrmArchivo3; public class ClassAr3 { public String datos[]=new String[50]; public int i,pos,tam; public ClassAr3() { } public void llamar(){ String subStr=""; String nombre="ArchivoApp2.txt"; BufferedReader entrada; try { entrada = new BufferedReader(new FileReader(nombre)); String texto="";

Técnica de Programación Orientada a Objetos

91

while(true){ texto = entrada.readLine(); /* tam=texto.length(); for(int g=0;g 0 Then MessageBox.Show(msgbox_Pasar_Dato, msgbox_Title, MessageBoxButtons.OK, MessageBoxIcon.Information) End If End If

End Sub

Técnica de Programación Orientada a Objetos

215



Pasar todos los elementos del cuadro de lista 2 al cuadro de lista 1. Private Sub Button4_Click(..) 'Pasa todos los elementos del control ListBox2 al control ListBox1 While ListBox2.Items.Count > 0 ListBox2.SelectedIndex = ListBox2.Items.Count - 1 ListBox1.Items.Add(ListBox2.SelectedItem) ListBox2.Items.RemoveAt(ListBox2.SelectedIndex) End While



El botón Ordenar datos permitirá ordenar alfabéticamente los de ambos Label1.Text = ListBox1.Items.Count & elementos " elemento(s)" cuadros de lista. Label2.Text = ListBox2.Items.Count & " elemento(s)" Private Sub Button7_Click(ByVal ..) End Sub

ListBox2.Sorted = True ListBox2.Sorted = False

End Sub

Técnica de Programación Orientada a Objetos

216

 Construcción de Aplicaciones MDI Visual Basic permite crear aplicaciones empleando una interfaz de múltiples documentos (MDI: Multiple Document Interface), o dicho en términos de Visual Basic, múltiples formularios. En una aplicación MDI, se pueden abrir varias ventanas hijas. Cada una de estas ventanas hijas (formularios) son iguales entre sí. En una aplicación MDI puede haber varias ventanas hijas, pero solo una ventana padre por aplicación. El formulario padre actúa como contenedor de los formularios hijos. Muchos procesadores de textos bajo Windows son buenos ejemplos de aplicaciones MDI.

Formulario Padre

Formulario 1

Formulario Hijo 1 Formulario 3 Formulario Hijo 2

Ejemplo: MDI (Multiple Document Interface)

Formulario 2

Ejemplo: SDI (Simple Document Interface)

Para cargar formularios en un proyecto y poder interactuar entre ellos, tenemos diferentes opciones: 1.- Instanciamos un formulario y lo cargamos. Este es la forma tradicional de la orientación a objetos clásica y que es la usada en VB.NET 2002 y VB.NET 2003. También utilizada en VB 2005 por supuesto:

Private Sub Button1_Click(..) Handles Button1.Click Dim MiF As New Form2 MiF.Show() End Sub

2.- Utilizamos una instancia por defecto para cargar el formulario utilizando el nombre de espacio My (sólo para Visual Basic 2005):

Private Sub Button1_Click(..) Handles Button1.Click My.Forms.Form2.Show() End Sub

3.- Utilizamos una instancia por defecto para cargar el formulario de forma directa (sólo para Visual Basic 2005):

Técnica de Programación Orientada a Objetos

217

Private Sub Button1_Click(..) Handles Button1.Click Form2.Show() End Sub

En esta sesión, crearemos un formulario de acceso que permita abrir un formulario principal de tipo MDI, que a su vez contenga una barra de Menú (MenuStrip) desde donde llame a otros formularios hijos, y una barra de estado (StatusStrip) que permita mostrar cierta información.

Como agregar un formulario MDI al Proyecto? -

Crear un proyecto de Visual Basic de nombre SISTEMA, que se guarde en el Escritorio.

-

Creación del formulario de Acceso.

Objeto

Formulario

TextBox1

Propiedad

Valor

Name

frmAcceso

FormBorderStyle

FixedSingle

MaximizeBox

False

MinimizeBox

False

Text

ACCESO AL SISTEMA

Name

txtUsuario

Name

txtPassword

PasswordChar

*

Name

btnIngresar

Text

&Ingresar

Enabled

False

Name

btnCancelar

Text

&Cancelar

TextBox2

Button1

Button2

Técnica de Programación Orientada a Objetos

218



Para agregar otro formulario al proyecto, ir al Menú Proyecto > Agregar Windows Forms



Establecer las siguientes propiedades para el nuevo formulario. La propiedad IsMDIContainer definirla a True para que se comporte como un MDI o contenedor de formularios.

Objeto

Propiedad

Valor

Name

frmPrincipal

IsMDIContainer

True

Text

PANEL PRINCIPAL

WindowState

Maximized

Formulario

 Como insertar una Barra de Menú al formulario MDI?



El control MenuStrip permite insertar una barra de Menú que presenta opciones que permiten realizar diferentes tipos de acciones, como abrir formularios, cargar aplicaciones, salir del proyecto, etc.

Técnica de Programación Orientada a Objetos

219



Escribir las opciones siguientes:



Insertar un separador.



Añadir la opción de Salir con un ShortcutKey de Ctrl + F4



Completar las opciones del Menú.

Técnica de Programación Orientada a Objetos

220



Para insertar las imágenes junto a las opciones del menú, establecer en la propiedad Image el valor de

 Como insertar una Barra de Estado al formulario MDI?



El control StatusStrip permite insertar una barra de Estado que presenta paneles en los cuales se puede mostrar información como por ejemplo, un mensaje de confirmación, una acción a realizar, opciones activas del sistema como activación del teclado numérico o mayúsculas, etc.



Asumiendo que la resolución del monitor es un estándar de 1024x768, crearemos tres paneles de texto (StatusLabel) de ancho 150, 624 y 150. Para cada panel modificaremos algunas propiedades:

Técnica de Programación Orientada a Objetos

221

Objeto

ToolStatusStrip3

ToolStatusStrip2

Propiedad

Valor

BorderSides

Todo (All)

Autosize

False

BorderStyle

SunkenOuter

Size > Width

150

Text

0:0:0

Image

(Insertar Reloj al archivo de recursos)

ImageAlign

MiddleRight

BorderSides

Todo (All)

Autosize

False

BorderStyle

SunkenOuter

Size > Width

624

Text

ToolStatusStrip1

BorderSides

Todo (All)

Autosize

False

BorderStyle

SunkenOuter

Size > Width

150

Text

Usuario:

Image

(Insertar User al archivo de recursos)

ImageAlign

MiddleLeft

 Como insertar una Barra de Herramientas al formulario MDI?



El control ToolStrip permite insertar una barra de herramientas que muestra botones que permitan realizar las acciones más importantes, como carga de formularios o aplicaciones.

Técnica de Programación Orientada a Objetos

222



Modificar las propiedades del ToolStrip para que se muestre de la siguiente manera:

Objeto

(Button)

Propiedad DisplayStyle

Image

Image

(Insertar Calculadora del archivo de recursos)

ToolTipText

Calculadora

DisplayStyle

Image

Image

(Insertar Excel del archivo de recursos)

ToolTipText

MS Excel 2007

DisplayStyle

ImageAndText

Image

(Insertar Tabla del archivo de recursos)

Text

Tabla de Multiplicar

ToolStripButton1

(Button)

Valor

ToolStripButton2

(Separator) ToolStripSeparator1

(Button) ToolStripButton4

Técnica de Programación Orientada a Objetos

223



En el formulario frmAcceso, habilitar el botón btnIngresar solamente cuando el usuario haya ingresado el nombre de usuario y password. Private Sub txtUsuario_TextChanged(..)Handles txtUsuario.TextChanged, txtPassword.TextChanged

If Len(Trim(txtUsuario.Text)) > 0 And Len(Trim(txtPassword.Text)) > 0 Then btnIngresar.Enabled = True Else 

btnIngresar.Enabled = False Si el password ingresado es SISE (mayúsculas o minúsculas), ocultar frmAcceso mostrar frmPrincipal. End yIf Private Sub txtUsuario_TextChanged(..)Handles txtUsuario.TextChanged, txtPassword.TextChanged End Sub

If UCase(txtPassword.Text) = "SISE" Then Me.Hide() frmPrincipal.Show() End If Sub  End En el formulario frmPrincipal, la funcionalidad de las opciones de menú Calculadora y Excel 2007, permitirán ejecutar estas aplicaciones usando la instrucción Shell dentro de un Try..Catch para interceptar el error en caso de que el archivo no se encuentre en el equipo. Private Sub CalculadoraDeWindowsToolStripMenuItem_Click(..) Handles CalculadoraDeWindowsToolStripMenuItem.Click Try Dim n = Shell("C:\Windows\System32\calc.exe", AppWinStyle.NormalFocus) Catch ex As Exception MessageBox.Show("No se ha encontrado la aplicacion", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning) End Try End Sub

Técnica de Programación Orientada a Objetos

224



Defina las instrucciones para la opción MS Excel 2007.



Como este bloque de acciones es el mismo que debe ser ejecutado al pulsar el botón respectivo en el ToolStrip, entonces podríamos modificar el Handles. Private Sub CalculadoraDeWindowsToolStripMenuItem_Click(..) Handles CalculadoraDeWindowsToolStripMenuItem.Click, ToolStripButton1.Click Try Dim n = Shell("C:\Windows\System32\calc.exe", AppWinStyle.NormalFocus) Catch ex As Exception MessageBox.Show("No se ha encontrado la aplicacion", "Error", MessageBoxButtons.OK,

 Se pueden heredarMessageBoxIcon.Warning) las características de un formulario? End Try La herencia es una de las características resaltantes de la programación orientada a objetos, y cuando diseñamos un formulario con determinadas propiedades, podemos hacer que otros End Sub formularios hereden dichas propiedades, ahorrando bastante tiempo en el diseño de las interfaces. 

Agregar al proyecto anterior un formulario Windows,y establecer las siguientes propiedades:

Objeto

Formulario

Propiedad

Valor

Name

frmPlantilla

Backcolor

(Amarillo claro)

FormBorderStyle

FixedSingle

Font > Bold

True

MaximizedButton

False

MinimizeButton

False

Text

Técnica de Programación Orientada a Objetos

225



Ir al Menú Generar > Generar Sistema (este nombre depende del nombre del proyecto).



Agregar un formulario Windows, pero esta vez seleccionar Formulario Heredado, y establecer por nombre frmTabla.



Seleccionar el formulario que será usado para heredar las propiedades a los hijos.

Técnica de Programación Orientada a Objetos

226



El formulario resultante podrá ahora ser modificado y tener la siguiente apariencia.



Realizar el mismo procedimiento para el diseño del formulario frmArea.

 Como se llaman a los formularios hijos? En la página X (Construcción de Aplicaciones MDI), se detallan los métodos de carga, el primero permite abrir varias instancias del formulario hijo, mientras que los otros, permiten abrir solo una instancia. 

En el Menú Aplicaciones > Matemáticas > Área de un Rectángulo, de un doble clic para abrir la ventana de código y escribir.

Private Sub AreaDeUnRectanguloToolStripMenuItem_Click (..) Dim form As New frmArea form.MdiParent = Me form.Show()

Técnica de Programación Orientada a Objetos End Sub

227



En la opción Tabla de Multiplicar, del mismo menú, escribir este otro código, y notar las diferencias entre ambos.

Private Sub GeneracionDeTablasDeMultiplicarToolStripMenuItem_Click (..) frmTabla.MdiParent = Me frmTabla.Show()

End Sub 

En frmTabla, escribir el código que debe ser usado en el botón Generar para mostrar la tabla de multiplicar del 1 al 12 de un número entero cualquiera ingresado en la caja de texto (Consistencie que solamente ingresen números)



En frmArea, escribir el código que debe ser usado en el botón Operar para calcular el Área de un Rectángulo. Debe consistenciar que solamente ingresen valores numéricos en las cajas de texto de base y altura.

Ejercicios propuestos.

1- Ingrese por teclado en una caja de texto la hora en formato de 24 horas y en otra caja de texto la cantidad de minutos al hacer clic en un botón deberá salir la hora en formato de 12 horas por ejemplo si se ingresa 23 en una caja y en la otra 12 el resultado seria 11:12:PM

2- Ingrese la cantidad de minutos hablados por una persona y escoja el tipo de llamada (Local, Nacional, Internacional).Se visualizara el importe de la llamada sabiendo que por los 3 primeros minutos se paga S/ 1.00 y por cada minuto adicional se paga 0.50 en caso sea local si es nacional se incrementa el 25% y si es internacional se incrementa el 60% a los precios por minuto.

3- Ingresar el nombre de un trabajador, la cantidad de hijos y su sueldo, si este tiene hijos se le dará una bonificación de S./40.00 por hijo y si no tiene hijos se le dará el 25% de su sueldo se deberá mostrar la bonificación y el sueldo final.

4- Ingrese por teclado dos números y al escoger un signo de operación se deberá mostrar el resultado de la operación.

Técnica de Programación Orientada a Objetos

228

5- Ingrese un numero máximo de 2 cifras si el numero es de una cifra se deberá mostrar cuanto falta para convertirse en un numero de 2 cifras, y si es de 2 cifras se deberá mostrar cuanto falta para convertirse en un numero de 3 cifras.

6- Ingrese un número cualquiera y muestre la cantidad de cifras que tiene según sea el caso. Ejemplo: 203 = “Tiene 3 cifras”, 45678 = “Tiene 5 cifras” tome en cuenta que el numero máximo a ingresar es un millón.

7- Ingrese por teclado el nombre, año de nacimiento y sexo de una persona (M o F),se deberá mostrar uno de los siguientes mensajes. - Varón mayor de edad - Varón menor de edad - Dama mayor de edad - Dama menor de edad

8- Ingrese un número y visualícelo en romano.

9- Ingrese por teclado el día de nacimiento y el mes de nacimiento de una persona al hacer clic se deberá mostrar su signo zodiacal así como también deberá aparecer la imagen del signo Zodiacal en un control PictureBox.

10- Se deberá desarrollar un algoritmo en el cual se deberá ingresar el nombre de un alumno y se deberá escoger el turno en el que estudia (M , T y N) así como también el ciclo (I, II, III, IV, V, VI y SIDET) y la carrera (CI, Enfermería y Administración) se deberá calcular el pago de su pensión en base a los siguientes datos:

el precio por carrera es: CI = 320.00 Enfermería = 280.00 Administración = 270.00 Además que dependiendo del ciclo en el que están se pagara un recargo del precio de 10,20,30,40,50,60 y 70% (para SIDET). Así como también si es del turno “M” se deberá recargar 10% mas solo si esta en I, II, o III ciclo, si es del turno “T” se recarga el 15 % mas solo si esta en I, o II y por último si es del turno “N” se le hará un descuento del 15 % solo si esta en SIDET Al finalizar solo se debe mostrar el monto de la pensión.

Técnica de Programación Orientada a Objetos

229

11- Realizar el siguiente formulario:

12- Se deberá ingresar el largo y el ancho del terreno y conforme vayan digitándolo deberá salir el total (Largo * ancho)

13- Se deberá ingresar el precio por metro y al escoger una categoría el precio se incrementara en un 10, 20, y 30 % respectivamente según la categoría, además de salir el precio total que será el total de área * el precio y si se escogió en tipo de alquiler Contado se le hará un Descuento de 10% al precio total y si es crédito se le hará un recargo de 15 %.

14- Finalmente se deberá escoger si se pagara alumbrado, parques o serenazgo sacando los % correspondientes al precio total según indica el formulario el precio final deberá salir al hacer clic en el botan calcular.

15- Ingrese un numero y Genere las siguientes series: (el resultado se mostrara en un label o en un text) - 1,3,5,7,..... - -1,+3,-5,+7... - 1,3,2,5,3,7,4,9,5,11.... - 0,1,1,2,3,5,8,13...(Serie Fibonacci)

16- Genere 100 números aleatorios y diga cuantos primos mayores a 50 hay, perfectos menores a 10 hay, pares e impares.

Técnica de Programación Orientada a Objetos

230

17- Genere 100 números aleatorios y al finalizar diga cual es el mayor y el menor.

18- Ingrese un numero de cualquier cifra y mostrarlo en forma invertida

19- Ingrese un numero y conviértalo en base 2

20- Ingrese una cadena y muestre lo siguiente: - La cadena en forma invertida - Diga cuantas vocales tiene - Diga cuantos espacios en blancos hay

21- Ingrese una cadena y conviértalo en mayúscula y en minúsculas funciones ucase y lcase.

sin utilizar las

22- Genere 10 números aleatorios y si el numero es par se deberá incrementar el numero con la suma de su raíz cuadrada, si el numero es impar se deberá incrementar el numero con la suma del seno del numero. AL finalizar se debe mostrar la suma de todos los números.

23- Ingrese Una fecha y diga cuantos días faltan para acabar el año, cuantos días han pasado desde esa fecha hasta la fecha actual, que día cae esa fecha (Lunes, martes), y muestre la misma fecha en el siguiente formato: “Lunes 15 de Abril de 2003” (Por ejemplo)

24- Ingrese en una caja de texto una cadena y al finalizar diga cuantas palabras tiene dicha cadena y cual es la cantidad de caracteres que tiene la palabra con mayor longitud

25- Ingrese un usuario y un password y si se equivoca aplicación

tres veces debe salir de la

26- Realice el siguiente formulario: En este formulario se deberá escoger un color y un objeto (checks,text, options) y al hacer clic en fondo o en letra deberá cambiar al color que se escogió ya sea el fondo(backcolor o la letra(forecolor) Luego al hacer clic en cursiva( font.italic) o en negrita (font.bold) o subrayado (font.underline) se debera cambiar la apariencia de los controles que se escogio (Checks, text ,Options)

Técnica de Programación Orientada a Objetos

231

27- Realice el siguiente formulario:

28- Cuando se haga clic en Mostrar Resultado se debe mostrar la edad del trabajador, el tiempo de servicio y el código que se generara de la siguiente manera: el año de ingreso luego la letra “M” o “F” según su sexo , los 2 primeros caracteres de su apellido paterno, los 2 primeros caracteres de su apellido materno, el primer carácter de su nombre y un correlativo

29- Además al ingresar sus nombres al perder el enfoque se deberá cambiar el texto por mayúsculas y al entrar al enfoque de algún texto el color de fondo deberá cambiar y al salir del enfoque deberá regresar al color original que tuvo.

Técnica de Programación Orientada a Objetos

232

Contenido. 

Introducción a la Estructura de Datos o Conceptos o Operaciones: Asignación y obtención de valores. Recorrido por los elementos de un Arreglo.



Metodologías de trabajo usadas en la construcción de aplicaciones con Vectores y Matrices.

Los Arrays (término en inglés que se refiere a los Arreglos), en las versiones anteriores de Visual Basic eran tipos de datos de los llamados por valor, al igual que lo son los tipos Integer, Double, etcétera. Pero en Visual Basic .NET, los arrays realmente son tipos por referencia.

Las variables que hemos estado usando hasta ahora, eran de tipo escalar: sólo pueden contener un valor a la vez, pero resulta que en ocasiones nos podemos ver en la necesidad de querer tener en una misma variable, valores que de alguna forma están relacionados. Por ejemplo, si tenemos una colección de discos, nos podría interesar tener esa discografía incluida en una misma variable para poder acceder a cualquiera de esos discos sin necesidad de tener que crear una variable distinta para cada uno de los discos, ya que sería totalmente ineficiente si, por ejemplo, quisiéramos imprimir una relación de los mismos.

Realmente para el ejemplo, hay otros tipos de datos que serían más prácticos, pero cuando veamos esos otros tipos de datos, serás tú el que decida cual utilizar.

Una de las formas en las que podemos agrupar varios datos es mediante los arrays (o matrices). Usando un array, podemos acceder a cualquiera de los valores que tenemos

Técnica de Programación Orientada a Objetos

233

almacenado mediante un índice numérico. Por ejemplo, si tenemos la variable discografía y queremos acceder al tercer disco, podríamos hacerlo de la siguiente forma: discografía(3).

Sabiendo esto, podemos comprobar que sería fácil recorrer el contenido de los arrays mediante un bucle For.

¿Qué tipos de datos se pueden usar para crear arrays?

Los tipos de datos de las variables usadas como array, pueden ser de cualquier tipo, dependiendo de lo que queramos guardar. Por ejemplo, si queremos guardar los nombres de los discos que tenemos, podemos usar un array del tipo String, que lo que nos interesa es saber el porcentaje de goles por partido de nuestro equipo de fútbol favorito, el tipo de datos del array podía ser Integer. Incluso si queremos, también podemos crear un array de un tipo que nosotros hayamos definido o de cualquier clase que exista en el .NET Framework.

Declarar variables como arrays Para poder indicarle al VB que nuestra intención es crear un array podemos hacerlo de dos formas distintas, para este ejemplo crearemos un array de tipo Integer:

1. La clásica (la usada en versiones anteriores) Dim X() As Integer

2. La nueva forma introducida en .NET: Dim X As Integer()

De cualquiera de estas dos formas estaríamos creando un array de tipo Integer llamada X. Cuando declaramos una variable de esta forma, sólo le estamos indicando al VB que nuestra intención es que la variable a sea un array de tipo Integer, pero ese array no tiene reservado ningún espacio de memoria.

Asignar valores a un array Para asignar un valor a un elemento de un array, se hace de la misma forma que con las variables normales, pero indicando el índice (o posición) en el que guardará el valor.

Técnica de Programación Orientada a Objetos

234

X(0)

10 12

X(2) X(1)

8

X(3)

3

Por ejemplo, para almacenar el valor 3 en la posición 3 del array X, haríamos lo siguiente:

X(3) = 3

Acceder a un elemento de un array A = B*X(3)

De igual forma, si queremos utilizar ese elemento que está en la posición 3 para una operación, podemos hacerlo como con el resto de las variables, pero siempre usando el paréntesis y el número de elemento al que queremos acceder:

El índice para poder acceder al elemento del array puede ser cualquier expresión numérica, una variable o como hemos estado viendo en estos ejemplos, una constante. La única condición es que el resultado sea un número entero.

Los límites de los índices de un array Como ya he comentado antes, el índice inferior de un array, siempre es cero, esto es invariable, todos los arrays de .NET Framework empiezan a contar por cero.

Pero el índice superior puede ser el que nosotros queramos, aunque sin pasarnos, que la memoria disponible se puede agotar si pretendemos usar un valor exageradamente alto.

Técnica de Programación Orientada a Objetos

235

Saber el tamaño de un array Cuando tenemos un array declarado y asignado, podemos acceder a los elementos de ese array mediante un índice, esto ya lo hemos visto; pero si no queremos "pasarnos" cuando queramos acceder a esos elementos, nos será de utilidad saber cuántos elementos tiene el array, para ello podemos usar la propiedad Length, la cual devuelve el número total de elementos, por tanto, esos elementos estarán comprendidos entre 0 y Length - 1.

Esto es útil si queremos acceder mediante un bucle For, en el siguiente código se mostrarían todos los elementos del array a:

For i=0 to X.Length – 1 ‘ Leer X(i) Next

Inicializar un array al declararla Al igual que las variables normales se pueden declarar y al mismo tiempo asignarle un valor inicial, con los arrays también podemos hacerlo, pero de una forma diferente, ya que no es lo mismo asignar un valor que varios.

Aunque hay que tener presente que si inicializamos un array al declararla, no podemos indicar el número de elementos que tendrá, ya que el número de elementos estará supeditado a los valores asignados.

Para inicializar un array debemos declarar ese array sin indicar el número de elementos que contendrá, seguida de un signo igual y a continuación los valores encerrados en llaves.

Veamos un ejemplo:

Dim X() As Integer = {4, 2, 5, 9, 10}

Dim X() As Integer = {4, 2, 5, 9, 10} También podemos hacerlo de esta otra forma:

Técnica de Programación Orientada a Objetos

236

Usando cualquiera de estas dos formas mostradas, el número de elementos será 5, por tanto los índices irán desde 0 hasta 4.

Los arrays pueden ser de cualquier tipo En el caso de que sean datos de tipo String, los valores a asignar deberán estar entre comillas dobles o ser variables de tipo String. Por ejemplo:

Dim Cad As String() = {"Hola", "Mundo", "te", "saludo"} Cad(3)=”Mario” For i=0 to Cad.Length -1 ‘ Leer Cad(i) Next

Dim Cad As String() = {"Hola", "Mundo", "te", "saludo"} Dim i as Integer For Each i in Cad ‘ Leer Cad(i) Next

Usar un bucle For Each para recorrer los elementos de un array El tipo de bucle For Each es muy útil para recorrer los elementos de un array, además de ser una de las pocas, por no decir la única, formas de poder acceder a un elemento de un array sin indicar el índice.

Ámbito de Alcance de los Arrays Al igual que las variables, el array podrá ser declarado en un ámbito Local, Privado o Global, dependiendo de la complejidad de la aplicación o de los requerimientos, se tendrá que usar el ámbito adecuado.

Técnica de Programación Orientada a Objetos

237

Aplicación de ejemplo:

Diseñar un formulario (frmDistritos) que al iniciar muestre los distritos Ate, Barranco y Cercado de Lima, que sean leídos desde un arreglo de nombre Distritos y sea mostrado en un ListBox.



Declaramos el array Distritos con los elementos y una variable encargada de contabilizar la cantidad de elementos que serán agregados, luego añadirlos al listbox. Public Class frmDistritos Private distritos()as String={“Ate”,”Barranco”,”Cercado de Lima”} Private cont as Integer

Private Sub frmDistritos_Load(..) Dim i As Integer cant = distritos.Length For i = 0 To distritos.Length - 1 lstLista.Items.Add(distritos(i)) Next End Sub

Técnica de Programación Orientada a Objetos

238



Al agregar, se mostrará un cuadro de diálogo que permita agregar nuevos distritos al arreglo, y luego mostrarlos nuevamente en el cuadro de lista. Private Sub btnAgregar_Click(..) Dim cad As String = InputBox("Nombre del Distrito:", "Agregar") If cad.Trim.Length > 0 Then cant += 1 ReDim Preserve distritos(cant - 1) distritos(cant - 1) = cad lstLista.Items.Clear() For i As Integer = 0 To distritos.Length - 1 lstLista.Items.Add(distritos(i)) Next Else MessageBox.Show("Escriba un nombre valido", "Error", MessageBoxButtons.OK, MessageBoxIcon.Information) End If

End Sub

Técnica de Programación Orientada a Objetos

239



Al eliminar, se eliminara el elemento del arreglo y luego se mostrarán los elementos del arreglo.

Private Sub btnEliminar_Click(..) Dim item As Integer = lstLista.SelectedIndex For i As Integer = item To distritos.Length - 1 If i distritos.Length - 1 Then distritos(i) = distritos(i + 1) End If Next cant -= 1 ReDim Preserve distritos(cant - 1) „------- Mostrar los elementos en el Listbox lstLista.Items.Clear() For cont As Integer = 0 To distritos.Length - 1 lstLista.Items.Add(distritos(cont)) Next End Sub

Técnica de Programación Orientada a Objetos

240

Propiedades de los Arreglos Entre las más importantes tenemos:

1- Length.- Devuelve la cantidad de elementos que tiene un arreglo

Ejemplo : Dim v(4) as String v.length()  esto devolvería 5 , ya que el arreglo “v” tiene 5 elementos (0 al 4)

2- Sort.- Ordena un arreglo. Se utiliza la clase Array

Ejemplo Dim V(3) as Integer ={13,7,16} Array.Sort(V)  aquí la clase Array esta ordenado el Arreglo “V”

3- CopyTo.- Copia los datos de un arreglo a otro en una posición dada. Sintaxis: Arreglo1.CopyTo (Arreglo2, Posición)

Ejemplo Dim V1(3) as Integer ={13,7,16} Dim V2(3) as Integer V1.CopyTo(V2,0)  Aquí se esta copiando en el arreglo V2 a partir de la posición 0 los datos que hay en el arreglo V1

4- GetUpperBound (Indice_Dimension).- Esta función devuelve el índice mayor de un arreglo.

Dim V(3) as Integer

Si nos damos cuenta el arreglo declarado es un arreglo de una dimensión. Esta dimensión seria la dimensión 0 v.GetUpperBound(0) esto devolvería 3

Técnica de Programación Orientada a Objetos

241

Ahora si el arreglo tuviera2 dimensiones Dim M (2,3) as Integer, tendríamos la dimensión 0 (0 al 2) y la dimensión 1 (0 al 3)

M.GetUpperBound (0) esto devuelve 2 M.GetUpperBound (1) esto devuelve 3

5- GetLowerBound (Indice_Dimension).- Esta función devuelve el índice menor de un arreglo.

Casi siempre el índice menor será 0 al no ser que el arreglo empiece con otro índice.

Técnica de Programación Orientada a Objetos

242

Aplicaciones.

1- Llene un vector de 5 elementos con números aleatorios y muéstrelos en un listbox

Private Sub Button2_Click(..) Dim vec (4) As Integer „Se declara el vector Dim I As Int16 Dim N As Int16 „Hacemos un for desde 0 hasta el índice mayor del arreglo For I = 0 To Vec.GetUpperBound(0) „Generamos el numero aleatorio N = CInt (Rnd () * 100) „Guardamos el numero en el vector Vec (I) = N „Agregamos al Listbox el dato del vector Me.ListBox1.Items.Add(vec(I)) Next

End Sub

Técnica de Programación Orientada a Objetos

243

2- Ingrese un numero en una caja de texto, al hacer click en el botón “Agregar” se debe de agregar el numero a un arreglo dinámico además de mostrador en un listbox

„Aquí se declara el arreglo que es dinámico (nótese que no va nada entre los paréntesis) Private V () As Int16 „Este procedimiento se encarga de llenar el listbox con los datos que tiene el vector Sub Listar() Me.ListBox1.Items.Clear() Dim i As Int16 Me.ListBox1.Items.Clear() For i = 0 To V.GetUpperBound(0) Me.ListBox1.Items.Add(V(i)) Next End Sub Private Sub Form2_Load(..) „Aqui se el asigna un elemento al vector (el índice de ese elemento será 0) ni bien carga el „formulario ReDim Preserve V(0) End Sub Private Sub Button1_Click(..)

Técnica de Programación Dim posOrientada As Int16a Objetos „Capturamos el índice mayor del arreglo pos = V.GetUpperBound (0)

244

3- Llene un vector de 100 elementos con números aleatorios sin que estos se repitan y muéstrelos en un listbox

„Declaramos el vector Private Vec (99) As Integer „Ahora creamos una función llamada “BuscarItem”, esta función recibirá como parámetro un „numero y se buscara en todo el vector. „Si ese numero se encuentra la función devuelve “True” caso contrario “False” Function BuscarItem(ByVal N%) As Boolean Dim Estado As Boolean = False Dim I As Integer For I = 0 To Vec.GetUpperBound(0) If Vec(I) = N Then Estado = True Exit For End If Next BuscarItem = Estado End Function Private Sub Button1_Click(..) Dim N As Int16 Dim J As Int16 = 0 Me.ListBox1.Items.Clear() „Aquí se inicia el bucle para llenar los datos al vector Do While J 0

Fact=N*Fact(N – 1)

f(0) = 1

Else Fact=1 End Function

Fibonaci

n

0

f(n) = f(n-1) * f(n-2)

n>1

Function Fib( N as Integer) as Long

f(n) = 1

n1 Then Fib=Fib(N-1)+Fib(N-2) Else Fib=1 End If

Ejemplos a desarrollar: Factorial, Fibonnaci, Producto de dos números, suma empleando recursividad: (en Modulo.vb)

Técnica de Programación Orientada a Objetos

282

1. Implementar una función recursiva que devuelva el factorial de un número.

Public Function factorial(n As Integer) As Double If n = 0 Then factorial = 1 Else factorial = n * factorial(n - 1) End If End Function

2. Implementar una función recursiva que calcule la serie de Fibonacci.

Function fibo(n As Integer) As Long If n > 1 Then fibo = fibo(n - 2) + fibo(n - 1) Else fibo = 1

Ejercicios Propuestos 1. Definir una función recursiva que dado un número entero, devuelva la suma de sus cifras. Utilizarla para definir si un número es divisible por 3.

2. Definir una función recursiva que calcule w elevado a la k sucesivas. (k natural)

mediante multiplicaciones

3. Definir una función recursiva que devuelva la cantidad de dígitos de un número entero.

4. Definir una función recursiva que calcule z * y mediante sumas sucesivas.

5. Definir una función recursiva para cada uno de los siguientes problemas a) Calcular el promedio de los elementos del vector V de dimensión N. b) Buscar el mínimo elemento del vector V de dimensión N. c) Devolver la posición del máximo elemento del vector V de dimensión N.

Técnica de Programación Orientada a Objetos

283

Contenido. 

Funciones de Sistema o Cadena o Numericos o Fecha



Formatenado la salida

FUNCIONES DE SISTEMA  Funciones de cadenas Se denomina CADENA a una sucesión de caracteres. Una cadena puede tener uno o varios caracteres alfanuméricos. Una cadena es también una sucesión de números.

 Str(Expresión) Cuando los números se conviertan a cadenas, siempre se reservará un espacio inicial para el signo de Number. Si Number es positivo, la cadena devuelta contiene un espacio inicial; y el signo más se da por supuesto. Un número negativo incluirá el signo menos (-) y ningún espacio inicial.

Dim MyString As String MyString = Str(459) ' Retorna " 459" MyString = Str(-459.65) ' Retorna "-459.65"  Left (cadena, n) Extrae los n primeros caracteres de una cadena, comenzando por la izquierda.

 Right (cadena, n) Extrae lo n últimos caracteres de la cadena

Técnica de Programación Orientada a Objetos

284

Para utilizar las dos funciones anteriores que son propias de visual basic emplear Microsoft.VisualBasic.Funcion

Dim myString As String = "Curso de Visual Net" Dim subString As String subString = Microsoft.VisualBasic.Right(myString, 3) ' Retorna "Net" subString = Microsoft.VisualBasic.Left(myString, 5) ' Retorna "Curso"  Mid (cadena, m, n) Extrae n caracteres de la cadena, siendo el primer carácter extraído el que ocupa el lugar m.

Resultado = Mid (cadena, 3, 10) „Retorna “rso de Vis”

Segundo formato desde una posición hasta la posición final

Resultado=Mid(cadena,6) „Retorna “de visual net”

 LCase (cadena) Devuelve otra cadena igual, pero con todos los caracteres en minúsculas. (LCase = Lower Case)

Resultado = Lcase (cadena) „Retorna “curso de visual basic”

 UCase (cadena) Devuelve otra cadena igual, pero con todos loscaracteres en mayúsculas. (UCase = Upper Case)

Resultado = UCase (cadena) „Retorna “CURSO DE VISUAL BASIC”

Técnica de Programación Orientada a Objetos

285

 Len (cadena) Devuelve la longitud de la cadena

Resultado = Len (cadena) „Retorna “21”

 Space (n) Devuelve una cadena formada por n espacios.

Resultado = "A" + Space (6)+ "B" „Retorna “A

B”

 LTrim Elimina los posibles espacios que tenga una cadena por su izquierda.

 Rtrim Elimina los posibles espacios que tenga una cadena por su derecha.

 Trim Elimina los espacios que tenga una cadena, tanto por su izquierda como derecha. (No elimina los espacios centrales de la cadena).

por su

 InStr (cadena, cadena1) Busca la cadena1 dentro de cadena y devuelve el número de orden dentro de cadena donde se encuentra la primera letra de cadena1

Resultado = InStr (cadena, "sua") „Retorna “12”

 StrConv Convierte una cadena de caracteres en otra, según las instrucciones que le sigan. Puede sustituir a UCase o LCase si la instrucción es UpperCase o LowerCase respectivamente, o poner la primera letra de todas las palabras de la cadena en mayúsculas, si la instrucción es ProperCase.

Resultado = StrConv (cadena, UpperCase) „Retorna “CURSO DE VISUAL BASIC” Técnica de Programación Orientada a Objetos

286

Resultado = StrConv (cadena, LowerCase) „Retorna “curso de visual basic”

Resultado = StrConv (cadena, ProperCase) „Retorna “Curso De Visual Basic”



En este ejemplo se pone un texto todo en minúsculas.

Dim sText, sNewText As String sText = "Hello World" sNewText = StrConv(sText, VbStrConv.LowerCase) Debug.WriteLine (sNewText) ' Outputs "hello world".

 FUNCIONES CON NUMEROS Funcion Abs Int

Devuelve Valor absoluto de un numero real Parte entera de un real

Rnd

Un numero al azr entre 0 y 1

Exp

Exponecial de un numero real es decir e = 2.71828

El objeto Math. Funciones:  Math.round(n,d) Redondea, con ciertos numeros de decimals Math.Round(3.45, 1) 'Retorna 3.4 Math.Round(3.46, 1) 'Retorna 3.5

 Math.PI El valor de este campo es 3,14159265358979323846

 Math.acos Devuelve el ángulo cuyo coseno es el número especificado

Técnica de Programación Orientada a Objetos

287

 Math.ceiling Devuelve el número entero más pequeño mayor o igual que el número especificado.

Math.ceiling(3.1) 'Retorna 4  Math.Floor Devuelve el número entero más grande menor o igual que el número especificado

Math.Floor(3.1) 'Retorna 3  Math.sqrt(n) Devuelve la raíz cuadrada de un número especificado.

 Math.pow(n) Devuelve un número especificado elevado a la potencia especificada

Técnica de Programación Orientada a Objetos

288

Aplicaciones

1- Aplicación 1: Usando Funciones de Cadena

Private Sub BTNSPLIT_Click(..) Dim CAD As String Dim VEC() As String Dim I As Integer CAD = TXTCAD.Text.Trim ListBox1.Items.Clear() VEC = CAD.Split(" ".ToCharArray) For I = 0 To UBound(VEC) ListBox1.Items.Add(VEC(I)) Next End Sub

Private Sub FRMCADENA_Activated(..) TXTCAD.Text = "esto es una prueba" End Sub

Técnica de Programación Orientada a Objetos

289

Private Sub HandleCheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles rbn1.CheckedChanged, rbn2.CheckedChanged, rbn3.CheckedChanged, rbn4.CheckedChanged, rbn5.CheckedChanged, rbn6.CheckedChanged, rbn7.CheckedChanged DisplayText(CType(sender, RadioButton)) End Sub Private Sub DisplayText(ByVal rbtn As RadioButton) Dim cadr, texto As String texto = TXTCAD.Text.Trim If rbtn Is rbn1 Then cadr = texto.Insert(3, " ojo") ElseIf rbtn Is rbn2 Then cadr = texto.Replace("prueba", "practica") ElseIf rbtn Is rbn3 Then 'extraer apartir de la izquierda cadr = texto.Substring(0, 3) ElseIf rbtn Is rbn4 Then 'borrar los carect. desde la posicion 3 cinco caracteres cadr = texto.Remove(3, 5) ElseIf rbtn Is rbn5 Then 'extraer apartir de la derecha cadr = texto.Substring(texto.Length - 3, 3)

ElseIf rbtn Is rbn6 Then ' extraer apartir de una posicion cadr = texto.Substring(4, 5) ElseIf rbtn Is rbn7 Then ' extraer apartir de una posicion cadr = "posicion " & texto.IndexOf("t").ToString

End If lblres.Text = cadr End Sub

Técnica de Programación Orientada a Objetos

290

2- Aplicación 2: Empleando el Split Mostrando el formulario principal

En el Formulario 3. Private Sub Button1_Click(..) Dim x As New Form1() x.ShowDialog() End Sub

Private Sub Button2_Click(..) Dim x As New Form2() x.ShowDialog() End Sub

Técnica de Programación Orientada a Objetos

291

En el Formulario 1. Private Sub btnSplit_Click(..) Dim TempArray() As String Dim CurIndex As Integer lstOutput.Items.Clear() If txtInput.Text.Length > 0 And

_

txtSeparator.Text.Length > 0 Then

TempArray = txtInput.Text.Split(txtSeparator.Text)

For CurIndex = 0 To TempArray.GetUpperBound(0) lstOutput.Items.Add(TempArray(CurIndex)) Next

End If End Sub

Técnica de Programación Orientada a Objetos

292

En el Formulario 2. Private Sub btnJoin_Click(..) Dim TempArray() As String Dim RandomInteger As New System.Random() Dim CurIndex As Integer Dim NumElements As Integer = Convert.ToInt32(txtArraySize.Text)

'Generate random numbers, put in TempArray If NumElements > 0 Then ReDim TempArray(NumElements) For CurIndex = 0 To NumElements - 1 TempArray(CurIndex) = RandomInteger.Next(1000).ToString Next End If

'Join array elements into a comma-separated string txtOutput.Text = String.Join(",", TempArray)

End Sub

Técnica de Programación Orientada a Objetos

293

3- Aplicación 3: Conversión de un numero al sistema binario y hexadecimal

Private Sub

CmdBin_Click(….)

Dim cad as String Dim

N, r as String

n = Val(TxtNum.text) cad = "" Do While n 0 r = n Mod 2 n = n \ 2 cad = cad + Str(r) Loop LBR1 = StrReverse(cad) End Sub

Private Sub Cmdhexa_Click(….) Dim cad

As String

, N, R as integer

Dim n% n = Val(Text1) cad = "" Do While n 0

„Hacer mientras n sea diferente a cero

r = n Mod 16 n = n \ 16 If r > 9 Then cad = cad + Chr(55 + r) Else cad = cad + Str(r) End If Loop Lbr2 = StrReverse(cad) End Sub

Técnica de Programación Orientada a Objetos

294

4- Aplicación 4: Ingresando una frase por teclado invertir las palabras en su misma posición, luego visualizar la misma frase como una pirámide cuyo vértice es el centro de la frase. Private Sub CmdInvertir_Click( ..) Dim PA, P, K, M Dim

as Integer

Cad, palabra, scad

as String

cad = Trim(Text1.text) scad = ""

„la Frase ingresada

PA = 1

„ Cadena Vacia Para Formar la frase invertida „ es la posición inicial de la palabra

For M = 1 To Len(cad) „Se pregunta si el caracter es un espacio blanco o M es la ultima posicion If Mid(cad, M, 1) = " " If

Then

M = Len(cad) Then P =M

PALABRA = ""

Else P = M - 1

„para formar la palabra invertida

For k = PA To P PALABRA = Mid(cad, k, 1) + PALABRA Next scad = scad + " " + PALABRA End If PA = P + 1 Next Text2.text

= scad

„Muestra cada palabra de forma invertida

End Sub

Técnica de Programación Orientada a Objetos

295

Private Sub CmdPiramide_Click() List1.Items.Clear cad = Trim(Text1.text)

„ Almacena el valor de la Frase

List1.Width = Len(cad) * 100 centenas

„ El ancho queda definido por la frase en

P = Len(cad) \ 2 + 1

„ Obtiene la posición media de la frase

PL = Len(cad): a = 1: con = 1 CR = 1 CI = 1

„ Separamos en dos mitades la parte derecha un contador

CR

„ Un contador para la parte Izquierda

cad3 = Space(P) & Mid(cad, P, 1) espacios

„

Coloca en el Vertice la Primera letra con

List1.AddItem cad3 For I = 1 To P

If P - CI < 1 Then Exit For

„ si es un valor menor a uno sale del for

cad1 = Space(P - CI) & Mid(cad, P - CI, CI) cad2 = Mid(cad, P + 1, cr) cad4 = cad1 & Trim(cad3) & cad2 List1.AddItem cad4

„Cadena de la Izquierda „Cadena de La derecha „Unimos las tres Cadenas „Lo Colocamos en la lista

CI = CI + 1 cr = cr + 1 Next End Sub

Técnica de Programación Orientada a Objetos

296

 Funciones con fechas. Las fechas son cadenas especiales. Visual Basic sabe obtener y tratar la información relativa a la fecha y la hora. Dispone para ello de una declaración de variable: Date. Una variable declarada como date puede contener una fecha, una fecha y una hora o una hora solamente.

Dim MyDate As Date Dim MyMonth As Integer MyDate = #2/12/1969# ' Assign a date. MyMonth = Month(MyDate) ' MyMonth contains 2.  Now Devuelve la fecha y hora actual.

 WeekDay Devuelve el día de la semana (En número, 1=Domingo, 2=Lunes,...)

Dim MyDate As Date Dim MyWeekDay As Integer MyDate = #2/12/1969# ' asigna una fecha MyWeekDay = Weekday(MyDate) ' MyWeekDay contains 4  Day Obtiene el día, a partir de una fecha Dim MyDate As Date Dim MyDay As Integer MyDate = #2/12/1969# . MyDay = Microsoft.VisualBasic.Day(MyDate) ' MyDay contains 12.

 Month Obtiene el mes a partir de una fecha.

MyMonth = Month(MyDate) ' MyMonth contains 2.

 Year Obtiene el año a partir de una fecha. MyYear = Year(MyDate) ' MyYear contains 1969.

Técnica de Programación Orientada a Objetos

297

 Hour Obtiene la hora a partir de una hora

 Minute Obtiene el minuto a partir de una hora.

 Second Obtiene el segundo a partir de una hora.

 DateAdd Añade un intervalo de tiempo a una fecha

Interval Requerido. Valor de enumeración DateInterval o expresión String que representa el intervalo de tiempo que se desea agregar. Number Requerido. Double. Expresión de punto flotante que representa el número de intervalos que se desea agregar. Number puede ser un valor positivo (para obtener fechas u horas futuras) o negativo (para obtener fechas u horas pasadas). Puede contener una parte decimal cuando Interval especifica horas, minutos o segundos. Para otros valores de Interval, se omite cualquier parte decimal de Number. DateValue Requerido. Date. Expresión que representa la fecha y la hora a la que debe agregarse el intervalo. El propio DateValue no se modifica en el programa que realiza la llamada. Valores

El argumento Interval puede tener uno de los siguientes valores: Valor de enumeración

Cadena

Unidad de intervalo de tiempo agregada

DateInterval.Day

d

Día; truncado al valor integral

DateInterval.DayOfYear

y

Día; truncado al valor integral

DateInterval.Hour

h

Hora; redondeada al milisegundo más cercano

Técnica de Programación Orientada a Objetos

298

DateInterval.Minute

n

Minuto; redondeado al milisegundo más cercano

DateInterval.Month

m

Mes; truncado al valor integral

DateInterval.Quarter

q

Trimestre; truncado al valor integral

DateInterval.Second

s

Segundo; redondeado al milisegundo más cercano

DateInterval.Weekday

w

Día; truncado al valor integral

DateInterval.WeekOfYear

ww

Semana; truncada al valor integral

DateInterval.Year

yyyy

Año; truncado al valor integral

Dim NextTime As Date = Now

' Current date and time.

NextTime = NextTime.AddDays(3.4) ' Increment by 3 2/5 days.

 En este ejemplo se toma una fecha y mediante la función DateAdd, se muestra la fecha correspondiente un número especificado de meses en el futuro. Dim Msg, Number, StartDate As String 'Declare variables. Dim Months As Double Dim SecondDate As Date Dim IntervalType As DateInterval IntervalType = DateInterval.Month ' Especifica intervalos en meses. StartDate = InputBox("Ingrese fecha ") SecondDate = CDate(StartDate) Number = InputBox("Ingrsa el numero de meses a adicionar") Months = Val(Number) Msg = "New date: " & DateAdd(IntervalType, Months, SecondDate) MsgBox (Msg)

Técnica de Programación Orientada a Objetos

299

 DateDiff Obtiene el intervalo de tiempo entre dos fechas DateDiff(intervalo, fecha1, fecha2[, primerdíasemana[, primerasemanaaño]]) Intervalo

Descripción

yyyy

Año

Q

Trimestre

M

Mes

Y

Día del año

D

Día

W

Día de la semana

Ww

Semana

H

Hora

N

Minuto

S

Segundo

Este ejemplo utiliza la función DateDiff para mostrar el número de días entre una fecha dada y hoy. Dim DatTim1 As Date = #1/4/2004#

' primera fecha.

Dim DatTim2 As Date = #1/9/2004#

' segunda fecha.

Dim dias As Long = DateDiff("d", DatTim1, DatTim2) Dim meses As Long = DateDiff("m", DatTim1, DatTim2) MsgBox(dias)

 devuelve 5

Msgbox(meses)

 devuelve 0

Técnica de Programación Orientada a Objetos

300

 DatePart Devuelve una parte de una fecha (semana, trimestre, etc.)

El argumento Interval puede tener uno de los siguientes valores: Valor de enumeración

Cadena

Parte del valor de fecha u hora devuelta

DateInterval.Day

D

Día del mes (del 1 al 31)

DateInterval.DayOfYear

Y

Día del año (del 1 al 366)

DateInterval.Hour

H

Hora

DateInterval.Minute

N

Minuto

DateInterval.Month

M

Mes

DateInterval.Quarter

Q

Trimestre

DateInterval.Second

S

Segundo

DateInterval.Weekday

W

Día de la semana (del 1 al 7)

DateInterval.WeekOfYear

Ww Semana del año (de la 1 a la 53)

DateInterval.Year

yyyy Año

Este ejemplo obtiene una fecha y, utilizando la función DatePart, muestra el trimestre del año que ocurre. Dim FirstDate, Msg As String 'Declare variables. Dim SecondDate As Date FirstDate = InputBox("Enter a date:") SecondDate = CDate(FirstDate) Msg = "Quarter: " & DatePart(DateInterval.Quarter, SecondDate) MsgBox (Msg)

Técnica de Programación Orientada a Objetos

301

 Datetime. Representa un instante de tiempo, normalmente expresado en forma de fecha y hora del día. (es propio del framework)

Dim objdate as datetime Objdate.Metodo.- Lista de metodos Objdate.day dia del mes Similares a las funciones anteriores ,DayOfweek (dia de la semana),Month,Now,Hour,Minute,seconds, etc

 Función FORMAT Esta función permite presentar cadenas de numéricas o fechas de una determinada forma. Permite establecer el Formato de esa cadena.

FechadeHoy = Format (Now, “yyyy-mm-dd”)

La variable FechadeHoy tendrá el valor 1998-05-21, que se refiere al día 21 de mayo de 1998, según el formato recomendado por la norma ISO-8601 para la presentación de fechas. Si hubiésemos puesto la expresión FechadeHoy = Format (Now, “dd/mm/yy”) , la variable FechadeHoy contendría el valor 21/05/98 referido al día citado.

 firstdayofweek. Especifica el primer día de la semana. Puede tomar uno de estos valores o constantes : Constante VbSunday vbMonday vbTuesday vbWednesday vbThursday vbFriday vbSaturday

Valor 1 2 3 4 5 6 7

Técnica de Programación Orientada a Objetos

Descripcion Domingo (valor por defecto) Lunes Martes Miercoles Jueves Viernes Sabado

302

Observe que usamos la expresión Variable =Format (1234567,”Formato”) para todos los ejemplos de números.

Para poner los números separados por millares :

Variable = Format(1234567, "##,###,###") Variable = 1.234.567

 Ejemplos de funciones fecha:

Ingresando una fecha mostrar la edad exacta de cualquier presenta.

Public Class Form1 Private Sub BTnCalculo_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnCalculo.Click Dim FE, FA, FN As Date FA = Today : FE = CDate(TXTFE.Text) Dim DIAS, MES, AA, DA, DN As Integer AA = Year(FA) - Year(FE) FN = CDate(FE.Day & "/" & FE.Month & "/" & FA.Year) DA = FA.DayOfYear : DN = FN.DayOfYear If DN > DA Then AA = AA - 1 FE = FE.AddYears(AA) MES = DateDiff("M", FE, FA)

Técnica de Programación Orientada a Objetos

303

FE = FE.AddMonths(MES) If DN > DA Then DIAS = DateDiff("D", FA, FE) Else DIAS = DateDiff("D", FE, FA) End If LBFE.Text = AA LBDIA.Text = DIAS LBMES.Text = MES End Sub

End Class

Técnica de Programación Orientada a Objetos

304

 Aplicaciones empleando funciones Fechas 1.- Realizar un programa que permita generar los códigos de los empleados que serán almacenados en una lista, el código se genera en función del cargo y año de ingreso Según: el código esta compuesto de seis Caracteres. Apellidos = Laura Lee Cargo = Docente

fecha = 20/02/2001

Su código será : D01001

Consideración: el Campo apellido y nombre solo debe aceptar letras y espacios en Blanco, La fecha debe ser correcta.

Técnica de Programación Orientada a Objetos

305

2.- Aplicando Fechas.- Ingrese como datos Monto de la cuota, fecha de vencimiento y fecha de pago , calcular los días de mora , pago por mora y el pago total Los pago por Mora es de acuerdo a:

Menor a una semana

1% por cada dia

Entre 2 y 3 semanas

1.5% por dia

Mayor a 3 semanas

2% por dia

3.- Ingrese por teclado cierta cantidad de Bolas de billar , con el cual se desea formar una pirámide de base cuadrada, cada superficie esta formado por un numero cuadrado perfecto, calcular el numero de superficies que se forman y el numero de bolas que sobran Ejemplo para 20 Bolas serán 3 superficies y sobran 6 bolas.

4.- Alquiler de Maquinas

Técnica de Programación Orientada a Objetos

306

El pago hora es de acuerdo al usuario: Estudiante S/. 1.50

Publico S/2.00

Docente

S/1.0

4.- Realice una aplicación en donde se ingrese a cuadros de texto el Día(entre 1 y 31), Mes(entre 1 y 12) y Año de Nacimiento(4 dígitos) de una persona, luego al pulsar un clic sobre el botón “Calcular” mostrar su Edad y el signo Zodiacal (control Image) al que pertenece. NOTA: Validar que en los cuadros de texto sólo se debe ingresar dígitos.

Técnica de Programación Orientada a Objetos

307

Contenido.



Programación Orientada a Objetos en .NET o Entendiendo el modelo POO: Herencia, Polimorfismo, Encapsulamiento o Clases y Estructuras o Interfaces o Constructores y Destructores o Sobrecarga o Miembros de las Clases: Campos, Propiedades y Métodos. Ámbitos: Public, Private, Protected, Friend, Protected Friend.



Recursividad.

Programación Orientada a Objetos en .NET Visual Basic .NET tiene todas las características de la Programación Orientada a Objetos (POO), ya que el Marco .NET soporta los requerimientos para que todos los lenguajes que trabajen con él usen POO. Estas características son:

1. Encapsulación Cuando creamos un componente .NET este se encuentra encapsulado, ya que oculta la lógica de programación a los usuarios que lo utilizan, permitiendo manejar dicho objeto a través de sus miembros, tales como propiedades y métodos, realizando el desarrollo de aplicaciones más simple, al ocultar la complejidad del código (encapsular).

2. Herencia La herencia es la característica en la cual una clase llamada “Clase Base” pasa o hereda todas sus características a otra llamada “Clase Derivada”, permitiendo la total reusabilidad del código escrito en las aplicaciones. La herencia de clases es una nueva característica de Visual Basic .NET y no solo es a nivel de clases creadas en éste lenguaje sino a través de cualquier lenguaje del Marco .NET.

Técnica de Programación Orientada a Objetos

308

3. Polimorfismo Otra característica interesante de la POO es el polimorfismo, en el caso de Visual Basic .NET éste se puede crear cuando en una clase derivada se implementa de manera distinta un método heredado de la clase base. Es decir, podemos tener un mismo método con dos comportamientos distintos (códigos distintos) de acuerdo al tipo de objeto, que puede ser creado de la clase base o de la derivada.

Como vemos las nuevas características de la Programación Orientación a Objetos (POO) mezcladas con la facilidad de uso de la Programación Orientada a Componentes (POC) dan como resultado la creación de aplicaciones poderosas y con un bajo costo de mantenimiento.

Sin duda, la reusabilidad y encapsulación ofrecida por la tecnología COM basada en componentes se ve incrementada por la herencia de clases y el polimorfismo ofrecida por la tecnología .NET orientada a objetos; lográndose una verdadera integración entre aplicaciones.

Para finalizar esta introducción a los componentes .NET, la otra gran ventaja con respecto a COM es la distribución de componentes, que en este último era una pesadilla debido había que registrar componentes y lidiar con los problemas de compatibilidad de versiones; en cambio con .NET los componentes no se registran y su distribución es automática con solo copiar y pegar la aplicación.

 Elementos de una Clase (Miembros) Todos los componentes están formados por clases y estas a su vez se componen de elementos o miembros, los cuales trataremos en este capítulo. Para ilustrar mejor tenemos el siguiente gráfico.

Estructura de un Componente .NET Clase Base

Clase Derivada

Constantes

Constantes

Enumeraciones

Enumeraciones

Campos

Campos

Propiedades

Propiedades

Métodos

Métodos

Eventos

Eventos

Delegados

Delegados

Técnica de Programación Orientada a Objetos Constructores Destructores

Constructores Destructores

309

A diferencia de Visual Basic 6 en donde las clases podían tener solo propiedades, métodos, eventos y constantes enumeradas; en Visual Basic .NET las clases pueden tener campos, delegados, constructores y destructores. Además pueda ser que una clase herede de otra que este dentro del componente o en otro componente .NET.

 Clase Una clase es la plantilla para crear el objeto, es aquí donde se definen las partes del objeto: datos (propiedades, constantes, enumeraciones, campos) y procedimientos que operan sobre los datos (métodos).

La clase define un nuevo tipo de datos que resulta de la abstracción de algún elemento en la aplicación, por tanto, es necesario diseñar bien la aplicación antes de crear la clase, ya que esta solo implementa el diseño de objetos previamente realizado.

 Declaración de una Clase A diferencia de Visual Basic 6, donde el tipo de clase estaba dado por la propiedad “Instancing” de la clase, que podía ser privada (Private), dependiente (PublicNotCreateTable) o pública (SingleUse, GlabalSingleUse, MultiUse, o GlobalMultiUse); en VB .NET no existe propiedades para el módulo de clase, ya que las características de la clase dependen de la forma de su declaración.

Sintaxis:

[Tipo de Declaración] Class

End Class

Técnica de Programación Orientada a Objetos

310

Existen varias formas de declarar una clase, que detallamos a continuación en la siguiente tabla:

Declaración

Alcance o Ámbito

Public

Puede usarse en cualquier otra clase del componente o en las aplicaciones clientes.

Private

No puede usarse en otras clases del componente ni en las aplicaciones clientes.

Protected

Solo puede ser usada por las clases derivadas de éste, pero no por las aplicaciones clientes.

Friend

Solo puede ser usada por las otras clases del componente, pero no por las aplicaciones clientes.

Protected Friend

Es una combinación de ambas, es decir, la clase puede ser usada por otras clases del componente y por las clases derivadas.

Shadows

Indica que los miembros de la clase pueden ocultarse en la clase derivada, es decir que al heredar se ocultan ciertos miembros.

MustInherit

Determina que los miembros de la clase pueden heredarse a una clase derivada, pero no puede ser creada por aplicaciones clientes

NotInheritable

La clase no puede heredarse pero si instanciarse desde aplicaciones clientes.

Técnica de Programación Orientada a Objetos

311

 Ejemplo: Si queremos crear una aplicación de Planilla necesitamos diseñar un componente que manipule información del empleado, sus horas trabajadas, tardanzas, faltas, etc.

Para crear la clase Empleado, de tal manera que pueda heredarse y utilizarse tanto dentro del componente como en las aplicaciones clientes, definiríamos la clase en Visual Basic, tal como sigue:

Public Class Empleado

End Class

 Repaso: Constantes, Campos y Enumeraciones Constantes

Una constante es un dato que permanece fijo en toda la ejecución de la aplicación, a diferencia de la variable, cuyo valor va cambiándose en tiempo de ejecución.

Se utiliza para facilitar el mantenimiento del código, ya que si definimos un valor en una constante, si este cambia, con solo cambiar el valor de la constante, la aplicación trabajaría con el nuevo valor.

Sintaxis: [Public | Private] Const [As ]=

Ejemplo: Podemos crear un par de constantes que almacenen el valor de las tasas de los impuestos a la renta e impuesto extraordinario de solidaridad, para propósitos del cálculo de descuentos.

Private Const TasaIRenta As Single = 0.1 Private Const TasaIES As Single = 0.02

Técnica de Programación Orientada a Objetos

312

Nota: En Visual Basic .NET si no se define el tipo de dato de la constante se asume que es Object, ya no Variant como en Visual Basic 6, debido a que éste tipo de dato ya no existe.

 Campos

Un campo es una variable local para la clase, es decir, solo puede ser usada internamente por los miembros de la clase pero no por otras clases o por aplicaciones clientes.

El campo solo puede ser una variable privada o protegida que se use dentro de la clase para almacenar un valor usado por alguna propiedad o método, sin que éste pueda ser visto o instanciado por otras aplicaciones.

Sintaxis: [Private | Friend] [As ]

Ejemplo: Podemos crear un par de campos que almacenen el cálculo de los impuestos a la renta e impuesto extraordinario de solidaridad, para el total de descuentos.

Private IES As Single Private IRenta As Single

 Enumeraciones

Una enumeración es una estructura de datos personalizada que define un conjunto de valores enteros. Por defecto, el primer dato enumerado empieza en 0, el segundo en 1 y así sucesivamente, aunque esto puede cambiarse al momento de definir la enumeración.

Las enumeraciones son útiles para dar claridad al programa y evitar errores de asignación de variables, ya que si definimos una variable de tipo enumerada, el valor que se puede asignar está limitado por el rango de valores definido en la enumeración.

Técnica de Programación Orientada a Objetos

313

Sintaxis: [Public | Private | Protected | Friend] Enum [=] [=] [=]

End Enum

Ejemplo: Vamos a crear dos enumeraciones, la primera que describa los cargos de los empleados que se usará desde otras clases y aplicaciones, y la segunda que defina las áreas de la empresa para propósitos internos de trabajar con información del empleado.

Public Enum Cargos Auxiliar Técnico Ingeniero Secretaria Vendedor

End Enum

Private Enum Areas Gerencia = 100 Contabilidad = 200 Producción = 300 Sistemas = 400 Ventas = 500

End Enum

.

Técnica de Programación Orientada a Objetos

314

Para usar estas enumeraciones creadas, tan solo basta declarar una variable de estos tipos y asignarle un valor definido, por ejemplo, para el caso anterior sería como sigue:

Dim Cargo As Cargos Cargo = Cargos.Vendedor Dim Area As Areas Area = Areas.Ventas

 Propiedades

Una propiedad es una característica del objeto que tiene información sobre un cierto atributo de éste como por ejemplo su nombre, descripción, etc. Las propiedades son métodos que se trabajan como si fuesen campos, con la diferencia que el campo es interno solo para uso de la clase, en cambio las propiedades se usan fuera de la clase.

A diferencia de la versión anterior de Visual Basic que existían 3 estructuras para declarar una propiedad (Property Get, Let, y Set), ahora, en Visual Basic .NET solo existe una estructura llamada Property donde internamente se define si la propiedad es de lectura (Get) y/o escritura (Set), tal como se muestra debajo.

Sintaxis: [Tipo de Declaración] Property [As ] [[ReadOnly] Get

End Get] [[WriteOnly] Set (ByVal Value [As ])

End Set] End Property

Técnica de Programación Orientada a Objetos

315

Existen muchas formas de declarar una propiedad, que explicamos en la sgte tabla:

Declaración

Uso

Default

Indica que la propiedad es por defecto (no es necesario escribirla)

Public

Puede ser usada desde cualquier clase o aplicación.

Private

Solo puede ser accesada desde dentro de la clase.

Protected

Se usa desde dentro de la clase o desde una clase derivada.

Friend

Puede ser usada desde otras clases del componente pero no fuera.

Protected Friend

Tiene las características de la protegida y amiga, es decir, se usa dentro de la clase, desde una clase derivada o desde otra clase del mismo componente, pero no en aplicaciones clientes.

ReadOnly

Indica que el valor de la propiedad solo puede ser recuperado pero no escrito. Solo puede tener la cláusula Get y no Set.

WriteOnly

Indica que el valor de la propiedad solo puede ser escrito pero no devuelto. Solo puede tener la cláusula Set y no Get.

Overloads

Permite que la propiedad de la clase base sea sobrecargada, es decir definida varias veces en las clases derivadas pero con diferentes parámetros que la propiedad definida en la clase base.

Overrides

Permite sobrescribir la propiedad por otra propiedad con el mismo nombre en una clase derivada.

Overridable

Permite sobrescribir la propiedad por un método con el mismo nombre en una clase derivada.

Técnica de Programación Orientada a Objetos

316

NotOverridable

Indica que la propiedad no puede ser sobrescrita por nadie en ninguna clase derivada.

MustOverride

Indica que la propiedad no puede ser implementada en esta clase y puede ser implementada en una clase derivada.

Shadows

Se usa para ocultar una propiedad de tal manera que no pueda implementarse en una clase derivada.

Shared

Permite que la propiedad sea compartida y pueda llamarse sin necesidad de instanciar a la clase sino a través de su nombre.

Ejemplo: Para nuestra clase Empleado, podemos implementar las propiedades código, nombre y básico del empleado, de tal manera que se puedan leer y escribir en cualquier parte.

Private mvarCodigo As Integer Private mvarNombre As String Private mvarSueldo As Single

Public Property Codigo() As Integer Get Codigo = mvarCodigo End Get Set(ByVal Value As Integer) mvarCodigo = Value End Set

End Property

Public Property Nombre() As String Técnica de Programación Orientada a Objetos

317

Get Nombre = mvarNombre End Get Set(ByVal Value As String) mvarNombre = Value End Set

End Property

Public Property Sueldo() As Single Get Sueldo = mvarSueldo End Get Set(ByVal Value As Single) mvarSueldo = Value End Set

End Property

 Métodos Un método es un conjunto de instrucciones que modifica el estado de las propiedades; en términos de objetos, un método es un servicio o función del objeto, mientras que en términos de código un método es un procedimiento o función que realiza una tarea específica.

En Visual Basic .NET todos los miembros de una clase (propiedades, eventos, constructores, destructores, etc.) son en realidad métodos; claro, estos últimos son métodos especiales.

Un procedimiento o función en una clase es un método, y sus características son las mismas que cuando se encuentran en un módulo estándar, es decir, si es procedimiento la declaración es con Sub, y si es función la declaración es con Function, tal como se muestra en la sintaxis de abajo.

Técnica de Programación Orientada a Objetos

318

Sintaxis: [Tipo Declaración] [Sub | Function] ([Param]) [As ]

[Exit [Sub | Function]] End Property

En cuanto al tipo de declaración, es muy similar al de las propiedades, que describimos anteriormente en una tabla, es decir, puede declararse el método como Public, Private, Protected, Friend, Protected Friend y Shadows.

También hay que recordar que si el método es una función siempre se deberá devolver un valor, que se puede hacer de dos formas: de manera clásica asignando un valor al nombre de la función o de una nueva forma escribiendo la sentencia return y el valor.

Ejemplo: En nuestro ejemplo de Empleado, podemos implementar dos métodos públicos, uno que permita asignar valores a las propiedades creadas: código, nombre y sueldo del empleado y otro método que permita actualizar el sueldo.

Public Sub CrearEmpleado(ByVal vCodigo As Integer, _ ByVal vNombre As String, ByVal vSueldo As Single) mvarCodigo = vCodigo mvarNombre = vNombre mvarSueldo = vSueldo

End Sub

Public Sub ActualizarSueldo(ByVal vNuevoSueldo As Single) mvarSueldo = vNuevoSueldo

End Sub

Técnica de Programación Orientada a Objetos

319

 Eventos Un evento es un suceso que le ocurre al objeto y que le indica o notifica sobre un cambio en sus atributos o propiedades. Un evento es necesario para controlar el estado de las propiedades e informar a las aplicaciones del nuevo estado, para que estas realicen la acción correspondiente.

Es fácil entender eventos asociados a objetos visuales como los controles, por ejemplo en el objeto “Button” se tiene el evento “Click” que se desencadena al seleccionar el botón, el evento “MouseMove” que ocurre al pasar el mouse por el botón, y así hay muchos eventos asociados al objeto botón; pero, cuando trabajamos con clases, los eventos son más abstractos y un poco más difíciles de entender, ya que podía confundirse con los métodos.

Para aclarar el concepto de eventos definamos mentalmente una clase llamada “Cuenta” para un componente llamado “Banco”. Esta clase cuenta tiene propiedades como “NumeroCta”, “FechaApertura”, “TipoCta”, “NumeroTarjeta” y “Saldo”. Además tiene métodos como “Depósito”, “Retiro” y “Transferencia” que modifican el estado del saldo. Cuando hacemos un “Retiro” de nuestra cuenta donde el monto a retirar supera al “Saldo” se desencadena un evento llamado “SaldoInsuficiente” y también cuando durante el día hemos retirado más del monto permitido se desencadena el evento “LimiteRetiroDiario”.

Para crear un evento en la clase primero declare l evento con la sentencia “Event” y luego llámelo con “RaiseEvent”, tal como se muestra en la sintaxis.

Declaración Sintaxis: [Tipo Declaración] Event ([Parámetro(s)]) Declaración Llamada: RaiseEvent ([Parámetro(s)])

El tipo de declaración, es igual que la de los métodos, es decir, puede ser Public, Private, Protected, Friend, Protected Friend y Shadows.

Técnica de Programación Orientada a Objetos

320

Ejemplo: Crear dos eventos que nos informen cuando el sueldo es bajo o alto; para nuestra realidad un sueldo será bajo cuando es menor a 500 y alto cuando sea mayor a 3000.

Public Event SueldoBajo() Public Event SueldoAlto()

Private Sub ChequearSueldo() If mvarSueldo < 500 Then RaiseEvent SueldoBajo() ElseIf mvarSueldo > 3000 Then RaiseEvent SueldoAlto() End If End Sub

Para finalizar, deberíamos llamar a la rutina “ChequearSueldo” al final de “CrearEmpleado” y “ActualizarSueldo” que es donde se modifica el “Sueldo”.

Técnica de Programación Orientada a Objetos

321

 Constructores y Destructores  Constructores Un constructor es un método que se usa para inicializar características del objeto. Todas las clases de Visual Basic .NET tienen un constructor por defecto que es el método “New”, pero se pueden agregar varios constructores “New” diferenciándose por el número de parámetros.

Sintaxis: Public Sub New ()

End Sub Public Sub New ([ As ])

End Sub Public Sub New ([ As , As ])

End Sub Public Sub New ([ As , As ,…, As ])

End Sub

Nota: Es requisito indispensable escribir los métodos constructores al inicio de la clase, de lo contrario no funcionarían.

Técnica de Programación Orientada a Objetos

322

Ejemplo: Continuando con nuestro ejemplo de la clase “Empleado” podemos crear 4 constructores que permitan crear de cuatro maneras distintas un objeto de tipo empleado.

Public Sub New() End Sub

Public Sub New(ByVal vCodigo As Integer) mvarCodigo = vCodigo End Sub

Public Sub New(ByVal vCodigo As Integer, ByVal vNombre As String) mvarCodigo = vCodigo mvarNombre = vNombre End Sub

Public Sub New(ByVal vCodigo As Integer, ByVal vNombre As String, ByVal vSueldo As Single) mvarCodigo = vCodigo mvarNombre = vNombre mvarSueldo = vSueldo End Sub

Técnica de Programación Orientada a Objetos

323

 Destructores Un destructor es un método que se usa para limpiar características del objeto antes que sea destruido y liberado de la memoria. Por ejemplo, si tenemos una clase que accede a datos y que abre una conexión hacia una base de datos para crear un Dataset, entonces recitamos un destructor que permita cerrar el Dataset y la conexión antes de destruir el objeto que apunta a dicha clase.

El FrameWork .NET solo provee de destructores a Visual C#, en cambio, en Visual Basic :NET no existe un método especial para crear destructores; en vez de ello se crea un método cualquiera que realice la labor de iniciar variables, liberar recursos, etc.

Sintaxis: Public Sub ()

End Sub

Ejemplo: Para la clase “Empleado” podemos crear un destructor llamado “Finalizar” que permita liberar las variables usadas por las propiedades para almacenar sus valores.

Public Sub Finalizar() mvarCodigo = Nothing mvarNombre = Nothing mvarSueldo = Nothing

End Sub

Técnica de Programación Orientada a Objetos

324

 Creando una Librería de Clases Después de ver los elementos de una clase, es momento de crear Componentes .NET los cuales también son conocidos como “Librería de Clases”, para lo cual existen varias etapas que detallamos a continuación.

Eligiendo el Tipo de Aplicación

Del menú “File”, elegir “New” y luego “Project” o pulsar [Ctrl + N] En la opción “Project Types” elegir “Visual Basic Projects” y en la opción “Templates” elegir “Class Library”

Seleccionar la ubicación y escribir un nombre adecuado para el proyecto, generalmente, se acostumbra colocar el nombre de la Empresa, nosotros podemos llamar al componente “ACME” y luego “OK”. Inmediatamente aparecerá una clase llamada “Class1”, proceder a cambiar de nombre físico y lógico, por ejemplo ponerle como nombre “Empleado”.

Técnica de Programación Orientada a Objetos

325

 Añadiendo una Clase Por defecto toda librería trae una clase, pero si queremos crear mas clase realizamos lo siguiente:



Del menú “Project” elegimos la opción “Add Class”



Escribimos el nombre físico de la clase, este a su vez será por defecto el nombre lógico y damos clic en “Open”.

1. Por defecto aparecerá la siguiente estructura:

Public Class Cliente

End Class

Técnica de Programación Orientada a Objetos

326

2. Dependiendo del alcance que queramos que tenga el objeto se puede modificar el tipo de declaración “Public” a una de las vistas anteriormente, tales como: “Private”, “Protected”, “Friend”, “Shadows”, etc.

 Creando Propiedades, Métodos, Eventos La creación de propiedades, métodos y eventos se realiza dentro del módulo de clase tal como se mostró anteriormente. Por ejemplo para la clase “Empleado” podemos crear lo siguiente.

1. Añadiendo una propiedad:

Private mvarSueldo As Single

Public Property Sueldo() As Single Get Sueldo = mvarSueldo End Get Set(ByVal Value As Single) mvarSueldo = Value End Set

End Property

2. Añadiendo un método:

Public Sub ActualizarSueldo(ByVal vNuevoSueldo As Single) mvarSueldo = vNuevoSueldo

End Sub

3. Añadiendo eventos:

Public Event SueldoBajo() Public Event SueldoAlto()

4. Llamando eventos:

Técnica de Programación Orientada a Objetos

327

Sub ChequearSueldo() If mvarSueldo < 500 Then RaiseEvent SueldoBajo() ElseIf mvarSueldo > 3000 Then RaiseEvent SueldoAlto() End If

End Sub

Public Sub ActualizarSueldo(ByVal vNuevoSueldo As Single) mvarSueldo = vNuevoSueldo ChequearSueldo()

End Sub

También podemos definir en el módulo de clase constantes, campos y enumeraciones; además, podemos añadir constructores y destructores para la clase, tal como vimos en la sección anterior.

Técnica de Programación Orientada a Objetos

328

 Probando y Usando la Librería de Clases  Probar la Librería de Clases Para probar el funcionamiento de la Librería de Clases es necesario crear una aplicación que use los miembros de las clases de la librería. Esta aplicación la llamaremos el “Cliente” del componente y puede estar escrito en cualquier lenguaje del FrameWork .NET, es decir, si creamos una librería en Visual Basic .NET, la podemos probar o usar en una aplicación Visual Basic .NET, Visual C#, Visual C++, COBOL, Pascal, C++, etc.

Vamos a asumir que se desea crear una aplicación cliente en Visual Basic .NET que pruebe la librería de clases creada, para esto necesitamos realizar lo siguiente:

1. Del menú “File”, elegir “Add Project”, y luego seleccionar “New Project”. Elegir una plantilla de aplicación para Windows o Web en Visual Basic .NET 2. Elegir el directorio donde se creará la aplicación, escribir el nombre y “OK”. Aparecerá un nuevo proyecto en la solución, el cual se ejecuta por defecto.

3. Para indicar que el proyecto de la aplicación es el que se ejecuta dar clic derecho sobre el nombre del proyecto en la ventana del “Solution Explorer” y elegir “Set as StartUp Project”.

Técnica de Programación Orientada a Objetos

329

4. Para usar la librería desde la aplicación creada hacer una referencia a esta, desde el menú “Project” eligiendo “Add Reference...” 5. Elegir la ficha “Projects” de la ventana de añadir referencia y se mostrará la librería creada en la misma solución, tal como se muestra en la figura anterior. 6. Dar clic al botón “Select” y luego “OK”; inmediatamente, aparecerá en la carpeta “References” del proyecto en la ventana del “Solution Explorer”.

7. Declarar una variable objeto que apunte a una clase del componente o librería, para lo cual existen 3 formas que ilustraremos con la clase empleado:

1. Primera forma: Dim objEmpleado As ACME.Empleado objEmpleado = New ACME.Empleado()

2. Segunda forma: Dim objEmpleado As ACME.Empleado = New ACME.Empleado()

3. Tercera forma: Dim objEmpleado As New ACME.Empleado

8. Usar las propiedades y métodos del objeto, tal como se muestra en el ejemplo: objEmpleado.CrearEmpleado(123, "Luis Dueñas", 1000)

9. Si deseamos usar los eventos, entonces tendremos que declarar la variable en la sección de decalaraciones generales, de la siguiente forma:

Private WithEvents objEmpleado As New ACME.Empleado()

10. Para liberar la variable objeto realizar la siguiente asignación: objEmpleado = Nothing

Nota: La anterior sentencia en realidad no destruye la variable, sino que la desactiva, el encargado de destruir definitivamente al objeto es el “Garbage Collector”.

Técnica de Programación Orientada a Objetos

330

 Usar la Librería de Clases Anteriormente, habíamos visto como probar la librería junto con una aplicación en la misma solución, lo que permite realizar depuración paso a paso, pero cuando ya está probada la librería no es necesario tener el código fuente, sino tan solo el archivo DLL. Para usar la librería en cualquier aplicación solo hay que hacer una referencia y en la opción “Projects” hay que seleccionar el nombre de la DLL que se encuentra en la carpeta del proyecto. Después se realizan los mismos pasos que para probarla.

 Herencia de Clases La parte principal de la Programación Orientada a Objetos (POO) es la herencia de clases, es decir, la característica de definir una clase que sirva de base para otras clases derivadas, las clases derivadas tendrán los miembros de la clase base: propiedades, métodos, eventos, etc.

Los miembros heredados por la clase derivada pueden sobre escribirse e implementarse de otra forma, además la clase derivada puede tener sus propios miembros y servir de clase base para otras clases, lográndose la reutilización de objetos a través de la herencia.

Otra forma de herencia es a través del polimorfismo, que es una característica de la POO que consiste en definir una clase abstracta con propiedades y métodos que serán implementados de diferentes formas por otras clases, es decir, con un mismo nombre de propiedad o método se obtiene funcionalidad distinta de acuerdo al tipo de objeto.

En .NET solo existe herencia simple y no herencia múltiple, es decir, una clase derivada solo puede heredar de una clase base. Haciendo una analogía, si a la clase base le llamamos “padre” y a la clase derivada le llamamos “hijo” diríamos que la herencia simple consiste en que un “hijo” solo puede tener un solo “padre”, lo que parece algo natural y coherente.

Si deseamos simular herencia múltiple en Visual Basic .NET recurrimos a las interfaces, que permiten definir propiedades y métodos en una clase sin código, luego desde una clase se puede implementar varias interfaces, lográndose una herencia múltiple pero a nivel de definición y no de código, ya que la implementación será distinta en cada clase.

En general, la herencia de clases permite reutilizar código y facilitar el mantenimiento de las aplicaciones, ya que cuando se desea modificar características de un objeto solo hay que cambiar la clase adecuada.

Con .NET podemos implementar la herencia de cualquier clase pública de la librería de clases base, la cual tiene una gran cantidad de clases de diferentes tipos, tales como Windows, Data,

Técnica de Programación Orientada a Objetos

331

XML, ASP .NET, System, etc. Pero, también podemos implementar herencia de clases creadas por nosotros, sin importar el lenguaje en que fueron creadas.

 Implementando Herencia en una Clase Para crear una herencia de clases se usa la instrucción Inherits seguida de la clase base de donde se heredarán los miembros para la clase actual (clase derivada), tal como se muestra debajo.

Sintaxis: Inherits

Notas: Dos observaciones importantes que hay que tener en cuenta son: 1. La instrucción Inherits debe escribirse en la primera línea de la clase derivada. 2. Solo puede existir una instrucción Inherits, ya que solo existe herencia simple.

Ejemplo: Podemos crear una clase llamada “Vendedor” que herede de la clase “Empleado” que habíamos creado anteriormente, y crear dos propiedades, una llamada “Venta” y otra llamada “Comision”, tal como sigue:

Public Class Vendedor Inherits Empleado Private mvarVenta As Single Private mvarComision As Single

Property Venta() As Single Get Venta = mvarVenta End Get Set(ByVal Value As Single) mvarVenta = Value

Técnica de Programación Orientada a Objetos

332

End Set

End Property

Property Comision() As Single Get Comision = mvarComision End Get Set(ByVal Value As Single) mvarComision = Value End Set

End Property

End Class

Finalmente, la clase “Vendedor” tendrá   

5 propiedades: 3 heredadas: “Codigo”, “Nombre” y “Basico” y 2 propias: “Venta” y “Comision”. 2 métodos heredados: “CrearEmpleado” y “ActualizarBasico”. 2 eventos heredados: “BasicoBajo” y “BasicoAlto”.

Técnica de Programación Orientada a Objetos

333

 Sentencias para trabajar con Herencia Para trabajar con herencia de clases existen varias instrucciones que hay que conocer tanto a nivel de la clase como de sus miembros que definen las características de la herencia, las cuales explicamos a continuación.

Declaración de Clases Base Para declarar una clase base existen varias formas que fueron vistas en temas anteriores, ahora afianzaremos solo los tipos de declaraciones que posibilitan o limitan el uso de herencia de una clase base:

1. MustInherit Permite crear una clase que solo sirva como clase base, es decir, que sirva solo para implementar herencia en otras clases, pero no podrá crearse objetos de esta clase.

Sintaxis: MustInherit Class

End Class

2. NotInheritable Se usa para crear una clase que solo pueda crear objetos o aplicaciones clientes, pero que no pueda servir para heredarse en otra clase.

Sintaxis: NotInheritable Class

End Class

Técnica de Programación Orientada a Objetos

334

 SobreEscribiendo Propiedades y Métodos en Clases Derivadas Para declarar una propiedad o método en una clase derivada o clase que hereda de una clase base, hay que tener ciertas consideraciones de acuerdo al tipo de declaración, que se explican a continuación.

1. Overridable Permite crear una propiedad o método que puede ser sobre escrito en una clase derivada. Esta declaración se hace en la propiedad o método de la clase base.

2. Overrides Se usa para sobre escribir una propiedad o método que fue definido como “Overridable” en la clase base. Esta declaración se hace en la propiedad o método de la clase derivada. 3. NotOverridable Impide que una propiedad o método pueda ser sobre escrito en una clase derivada. La definición se realiza en la propiedad o método de la clase base. Por defecto, todas las propiedades o métodos públicos definidos en una clase base no pueden ser sobre escritos en la clase derivada. 4. MustOverride Permite crear una propiedad o método que será obligatorio sobre escribirlo en la clase derivada. Esta declaración se realiza en la propiedad o método de la clase base que ha sido definida como MustInherit.

 Palabras claves MyBase y MyClass Se puede usar las palabras clave MyBase y MyClass al trabajar con herencia, tal como se muestra a continuación:

1. MyBase Se usa para llamar a miembros de la clase base desde la clase derivada. Es decir en vez de usar el nombre de la clase seguido de la propiedad o método se usa la palabra clave MyBase seguida de la propiedad o método.

Este tipo de llamada es útil cuando se trabaja con métodos sobre escritos en una clase derivada y se necesita invocar al método de la clase base que será sobre escrito, tal como se muestra en el siguiente ejemplo.

Técnica de Programación Orientada a Objetos

335

Ejemplo: Suponiendo que el método “CrearEmpleado” de la clase “Empleado” haya sido creado como “Overridable”, y se desea sobre escribir en la clase “Vendedor” para calcular correctamente el sueldo del vendedor incluyendo las comisiones, entonces, tendriamos lo siguiente:

Public Class Vendedor Inherits Empleado

Public Overrides Sub CrearEmpleado(ByVal vCodigo As Integer, _ ByVal vNombre As String, ByVal vSueldo As Single) vSueldo = vSueldo + mvarVenta * mvarComision MyBase.CrearEmpleado(vCodigo,vNombre,vSueldo) End Sub

End Class

2. MyClass Se usa para llamar a métodos sobre escribibles desde la clase derivada, y diferenciarlos de los métodos heredados desde la clase base.

Técnica de Programación Orientada a Objetos

336

 Polimorfismo El polimorfismo consiste en la funcionalidad múltiple que puede tener un miembro de una clase para comportarse de diversas maneras de acuerdo al tipo de objeto que lo implemente.

Existen dos formas de implementar el polimorfismo en Visual Basic .NET:

1. Polimorfismo basado en Herencia Es una nueva forma de crear multiple funcionalidad para un método de una clase base que puede ser sobre escrito por otros métodos con el mismo nombre en las clases derivadas.

Ejemplo: Tomemos como caso el ejemplo anterior donde habíamos sobre escrito el método “CrearEmpleado” de la clase “Empleado” modificandose en la clase derivada “Vendedor” para incluir lo recibido por comisiones de ventas. Crearemos el método llamado “MostrarSueldo” que permita crear el empleado y mostrar cuanto gana, usando el polimorfismo dependeiendo si es vendedor o no.

Sub MostrarSueldo(ByVal vEmpleado As Empleado, _ ByVal vCodigo As Integer, ByVal vNombre As String, _ ByVal vSueldo As Single) vEmpleado.CrearEmpleado(vCodigo,vNombre,vSueldo) MsgBox(vNombre & " gana s/. " & vSueldo)

End Sub

Sub ProbarPolimorfismo() Dim objEmpleado As New Empleado Dim objVendedor As New Vendedor objEmpleado.CrearEmpleado(100, "Luis Dueñas", 1000) objVendedor.Venta=1000 objVendedor.Comision=0.10 objVendedor.CrearEmpleado(100, "Luis Dueñas", 1000)

End Sub Técnica de Programación Orientada a Objetos

337

En este ejemplo el resultado será para el primer caso el mensaje “Luis Dueñas gana 1000” y en el segundo caso el mensaje “Luis Dueñas gana 1100”.

2. Polimorfismo basado en Interfaces Este tipo de polimorfismo se usa también en Visual Basic 6 y consiste en crear una interface donde se definan nombres de propiedades y/o métodos, y luego se implementen con la sentencia “Implements” en varias clases, escribiendo diferentes códigos o implementaciones para las propiedades y métodos de cada clase.

Este último tipo de polimorfismo no se va a tratar, debido a que la manera natural de implementar polimorfismo es a través de la herencia de clases sobre escribiendo propiedades o métodos.

Las interfaces son un elemento bastante importante en .NET Framework, ya que de hecho se utiliza con bastante frecuencia, en esta lección veremos que son las interfaces y como utilizarlas en nuestros proyectos, también veremos que papel juegan en .NET y cómo aplicar algunas de las definidas en la biblioteca base.

Técnica de Programación Orientada a Objetos

338

 ¿Qué es una interfaz? Las interfaces son una forma especial de una clase, aunque la diferencia principal con las clases es que las interfaces no contienen código ejecutable, solo definen los miembros. Las interfaces se utilizan para indicar el "comportamiento" que tendrá una clase, o al menos qué miembros debe definir esa clase. Para definir una interfaz en Visual Basic 2005 tenemos que usar la instrucción Interface seguida del nombre de la interfaz y terminar la declaración con End Interface:

Public Interface IAnimal '... End Interface

Nota: Según las indicaciones de nomenclatura de .NET Framework, se recomienda que todas las interfaces empiecen con una I mayúscula seguida del nombre al que hacer referencia la interfaz.

¿Qué contiene una interfaz? Al principio de esta lección hemos comentado que las interfaces no contienen código, solo define los miembros que contiene. Esa definición la haremos como cualquier otra, con la diferencia de que no incluimos ningún código, solo la "firma" o el prototipo de cada uno de esos miembros.

En el siguiente código definimos una interfaz que contiene los cuatros tipos de miembros típicos de cualquier clase:

Public Interface IPrueba Sub Mostrar() Function Saludo(ByVal nombre As String) As String Property Nombre() As String Event DatosCambiados() End Interface

Técnica de Programación Orientada a Objetos

339

El primer miembro de esta interfaz, es un método de tipo Sub que no recibe parámetros. El siguiente método es una función que devuelve un valor de tipo String y recibe un parámetro también de tipo cadena.

A continuación definimos una propiedad que devuelve una cadena. Por último, definimos un evento.

Como podemos observar, lo único que tenemos que hacer es indicar el tipo de miembro y si recibe o no algún parámetro o argumento.

Dos cosas importantes sobre las interfaces: 1- No se pueden definir campos. 2- Los miembros de las interfaces siempre son públicos, tal como indicábamos en la tabla

 Una interfaz es un contrato Siempre que leemos sobre las interfaces, lo primero con lo que nos solemos encontrar es que una interfaz es un contrato. Veamos que nos quieren decir con esa frase. Tal como acabamos de ver, las interfaces solo definen los miembros, pero no el código a usar en cada uno de ellos, esto es así precisamente porque el papel que juegan las interfaces es el de solo indicar que es lo que una clase o estructura puede, o mejor dicho, debe implementar.

Si en una clase indicamos que queremos "implementar" una interfaz, esa clase debe definir cada uno de los miembros que la interfaz expone. De esta forma nos aseguramos de que si una clase implementa una interfaz, también implementa todos los miembros definidos en dicha interfaz. Cuando una clase implementa una interfaz está firmando un contrato con el que se compromete a definir todos los miembros que la clase define, de hecho el propio compilador nos obliga a hacerlo.

 Las interfaces y el polimorfismo Como comentamos anteriormente, el polimorfismo es una característica que nos permite acceder a los miembros de un objeto sin necesidad de tener un conocimiento exacto de ese objeto (o de la clase a partir del que se ha instanciado), lo único que tenemos que saber es que ese objeto tiene ciertos métodos (u otros miembros) a los que podemos acceder. También hemos comentado que las interfaces representan un contrato entre las clases que las implementan, por tanto las interfaces pueden ser, (de hecho lo son), un medio para poner en práctica esta característica de la programación orientada a objetos. Si una clase implementa una interfaz, esa clase tiene todos los miembros de la interfaz, por

Técnica de Programación Orientada a Objetos

340

tanto podemos acceder a esa clase, que en principio pude sernos desconocida, desde un objeto del mismo tipo que la interfaz.

 Usar una interfaz en una clase Para poder utilizar una interfaz en una clase, o dicho de otra forma: para "implementar" los miembros expuestos por una interfaz en una clase debemos hacerlo mediante la instrucción Implements seguida del nombre de la interfaz:

Public Class Prueba Implements IPrueba

Y como comentábamos, cualquier clase que implemente una interfaz debe definir cada uno de los miembros de esa interfaz, por eso es el propio Visual Basic el encargado de crear automáticamente los métodos y propiedades que la interfaz implementa, aunque solo inserta el "prototipo" de cada uno de esos miembros, dejando para nosotros el trabajo de escribir el código.

Usando la definición de la interfaz IPrueba que vimos antes, el código que añadirá VB será el siguiente:

Public Class Prueba Implements IPrueba

Public Event DatosCambiados() Implements IPrueba.DatosCambiados

Public Sub Mostrar() Implements IPrueba.Mostrar

End Sub

Public Property Nombre() As String Implements IPrueba.Nombre Get

End Get

Técnica de Programación Orientada a Objetos

341

Set(ByVal value As String)

End Set End Property

Public Function Saludo(ByVal nombre As String) As String _ Implements IPrueba.Saludo

End Function End Class

Como podemos apreciar, no solo ha añadido las definiciones de cada miembro de la interfaz, sino que también añade código extra a cada uno de esos miembros: la instrucción Implements seguida del nombre de la interfaz y el miembro al que se hará referencia.

La utilidad de que en cada uno de los miembros se indique expresamente el método al que se hace referencia, es que podemos usar nombres diferentes al indicado en la interfaz. Por ejemplo, si implementamos esta interfaz en una clase que solo utilizará la impresora, al método Mostrar lo podríamos llamar Imprimir que sería más adecuado, en ese caso simplemente cambiamos el nombre del método de la clase para que implemente el método Mostrar de la interfaz:

Public Sub Imprimir() Implements IPrueba.Mostrar

End Sub

De esta forma, aunque en la clase se llame de forma diferente, realmente hace referencia al método de la interfaz.



Acceder a los miembros implementados

Una vez que tenemos implementada una interfaz en nuestra clase, podemos acceder a esos miembros de forma directa, es decir, usando un objeto creado a partir de la clase:

Dim prueba1 As New Prueba

Técnica de Programación Orientada a Objetos

342

prueba1.Mostrar()

O bien de forma indirecta, por medio de una variable del mismo tipo que la interfaz:

Dim prueba1 As New Prueba Dim interfaz1 As IPrueba interfaz1 = prueba1 interfaz1.Mostrar()

 ¿Qué ha ocurre aquí? Como ya comentamos anteriormente, cuando asignamos variables por referencia, realmente lo que asignamos son referencias a los objetos creados en la memoria, por tanto la variable interfaz1 está haciendo referencia al mismo objeto que prueba1, aunque esa variable solo tendrá acceso a los miembros de la clase Prueba que conoce, es decir, los miembros definidos en IPrueba.

Si la clase define otros miembros que no están en la interfaz, la variable interfaz1 no podrá acceder a ellos.

 Saber si un objeto implementa una interfaz Si las interfaces sirven para acceder de forma anónima a los métodos de un objeto, es normal que en Visual Basic tengamos algún mecanismo para descubrir si un objeto implementa una interfaz.

Para realizar esta comprobación podemos usar en una expresión If/Then la instrucción TypeOf... Is, de forma que si la variable indicada después de TypeOf contiene el tipo especificado después de Is, la condición se cumple:

If TypeOf prueba1 Is IPrueba Then interfaz1 = prueba1

interfaz1.Mostrar() End If

Técnica de Programación Orientada a Objetos

343

De esta forma nos aseguramos de que el código se ejecutará solamente si la variable prueba1 contiene una definición de la interfaz IPrueba.

 Implementación de múltiples interfaces En Visual Basic 2005, una misma clase puede implementar más de una interfaz. Para indicar que implementamos más de una interfaz podemos hacerlo de dos formas:

1- Usando nuevamente la instrucción Implements seguida del nombre de la interfaz:

Public Class Prueba Implements IPrueba Implements IComparable

2- Indicando las otras interfaces en la misma instrucción Implements, pero separándolas con comas:

Public Class Prueba Implements IPrueba, IComparable

De cualquiera de las dos formas es válido implementar más de una interfaz, aunque en ambos casos siempre debemos definir los miembros de cada una de esas interfaces. Múltiple implementación de un mismo miembro

Como acabamos de comprobar, una misma clase puede implementar más de una interfaz, y esto nos puede causar una duda:

Técnica de Programación Orientada a Objetos

344

 ¿Qué ocurre si dos interfaces definen un método que es idéntico en ambas? En principio, no habría problemas, ya que el propio Visual Basic crearía dos métodos con nombres diferentes y a cada uno le asignaría la implementación de ese método definido en cada interfaz. Por ejemplo, si tenemos otra interfaz que define el método Mostrar y la implementamos en la clase Prueba, la declaración podría quedar de esta forma:

Public Interface IMostrar Sub Mostrar() End Interface

Public Sub Mostrar1() Implements IMostrar.Mostrar

End Sub

Aunque si ambos métodos hacen lo mismo, en este ejemplo mostrar algo, podríamos hacer que el mismo método de la clase sirva para implementar el de las dos interfaces: Public Sub Mostrar() Implements IPrueba.Mostrar, IMostrar.Mostrar

End Sub

Es decir, lo único que tendríamos que hacer es indicar la otra implementación separándola con una coma.

 ¿Dónde podemos implementar las interfaces? Para ir acabando este tema nos queda por saber, entre otras cosas, dónde podemos implementar las interfaces, es decir, en que tipos de datos podemos usar Implements. La implementación de interfaces la podemos hacer en las clases (Class), estructuras (Structure) y en otras interfaces (Interface). Debido a que una interfaz puede implementar otras interfaces, si en una clase implementamos una interfaz que a su vez implementa otras, esa clase tendrá definidas cada una de las interfaces, lo mismo ocurre con una clase que "se derive" de otra clase que implementa alguna interfaz, la nueva clase también incorporará esa interfaz.

Técnica de Programación Orientada a Objetos

345

Nota: Cuando una interfaz implementa otras interfaces, éstas no se pueden indicar mediante Implements, en lugar de usar esa instrucción debemos usar Inherits. Public Interface IPrueba2 Inherits IMostrar

Si en una clase implementamos una interfaz que a su vez implementa otras interfaces, esa clase tendrá definiciones de todos los miembros de todas las interfaces, por ejemplo, si tenemos la siguiente definición de la interfaz IPrueba2 que "implementa" la interfaz IMostrar:

Public Interface IPrueba2 Inherits IMostrar

Function Saludo(ByVal nombre As String) As String Property Nombre() As String Event DatosCambiados() End Interface

Y la clase Prueba2 implementa IPrueba2, la definición de los miembros quedaría de la siguiente forma:

Public Class Prueba2 Implements IPrueba2

Public Sub Mostrar() Implements IMostrar.Mostrar

End Sub

Public Event DatosCambiados() Implements IPrueba2.DatosCambiados

Public Property Nombre() As String Implements IPrueba2.Nombre Get

Técnica de Programación Orientada a Objetos

346

End Get Set(ByVal value As String)

End Set End Property

Public Function Saludo(ByVal nombre As String) As String _ Implements IPrueba2.Saludo

End Function End Class

En este código, el método Mostrar se indica mediante la interfaz IMostrar, pero también se puede hacer por medio de IPrueba2.Mostrar, ya que IPrueba2 también lo implementa (o hereda).

Si dejamos que Visual Basic cree los miembros, no tendremos problemas a la hora de definirlos. Pero si lo hacemos manualmente, aunque dentro del IDE de Visual Basic, éste nos ayuda indicándonos que interfaces implementamos y qué miembros son los que se adecuan a la declaración que estamos usando, tal como podemos comprobar en la figura 2.16:

Técnica de Programación Orientada a Objetos

347

 Un ejemplo práctico usando una interfaz de .NET Tal como comentamos al principio, el propio .NET está "plagado" de interfaces, cada una de ellas tiene un fin concreto, por ejemplo, si queremos definir una clase que pueda ser clasificada por el propio .NET, esa clase debe implementar la interfaz IComparable, ya que el método Sort, (de la clase que contiene los elementos del tipo definido por nosotros), que es el encargado de clasificar los elementos, hará una llamada al método IComparable.CompareTo de cada uno de los objetos que queremos clasificar, por tanto, si la clase no ha definido esa interfaz, no podremos clasificar los elementos que contenga.

En el siguiente código tenemos la definición de una clase llamada Empleado que implementa la interfaz IComparable y en el método CompareTo hace la comprobación de que objeto es mayor o menor, si el de la propia clase o el indicado en el parámetro de esa función:

Public Class Empleado Implements IComparable

Public Nombre As String

Public Sub New(ByVal nombre As String) Me.Nombre = nombre

End Sub

' Si el objeto es del tipo Empleado, comparamos los nombres. ' Si no es del tipo Empleado, devolvemos un cero ' que significa que los dos objetos son iguales. Public Function CompareTo(ByVal obj As Object) As Integer _ Implements System.IComparable.CompareTo If TypeOf obj Is Empleado Then Dim e1 As Empleado = CType(obj, Empleado)

Return String.Compare(Me.Nombre, e1.Nombre) Else Return 0

Técnica de Programación Orientada a Objetos

348

End If End Function End Class

En el método CompareTo hacemos una comprobación de que el objeto con el que debemos realizar la comparación es del tipo Empleado, en ese caso convertimos el objeto pasado en uno del tipo Empleado y comparamos los nombres.

Si el objeto que recibe el método no es del tipo Empleado, devolvemos un cero, para indicar que no haga ninguna clasificación, ya que ese valor indica que los dos objetos son iguales.

Esta comparación no es estrictamente necesaria, ya que si no indicamos el valor que debe devolver una función, devolverá un valor cero, al menos en este caso, ya que el tipo a devolver es un número entero.

Esta clase la podemos usar de esta forma: ' Una colección de datos del tipo Empleado. Dim empleados As New System.Collections.Generic.List(Of Empleado)

' Añadimos varios empleados a la colección. empleados.Add(New Empleado("Pepe")) empleados.Add(New Empleado("Bernardo")) empleados.Add(New Empleado("Juan")) empleados.Add(New Empleado("Ana"))

' Clasificamos los empleados de la colección. empleados.Sort()

' Mostramos los datos una vez clasificados. For Each e1 As Empleado In empleados Console.WriteLine(e1.Nombre) Next

Técnica de Programación Orientada a Objetos

349

Contenido. 

 

Manejo de Colecciones o Concepto de Colecciones. Tipos. o Agregar y remover ítems de una colección. o Recorrer los ítems de una colección. Colecciones Especializadas: ArrayList, HashTable Interfaces o IEnumerable e IEnumerator o ICloneable o IComparable

Las Colecciones En el tema sobre arrays hemos comprobado cómo a través de la clase Array, podemos manipular estos elementos del lenguaje con una mayor potencia y flexibilidad que en pasadas versiones del lenguaje. No obstante, en muchas ocasiones nos encontraremos con situaciones en las que sería muy de agradecer que los arrays dispusieran de algunas características adicionales, dependiendo del problema que tengamos que resolver en ese preciso momento. Por ejemplo, sería una gran idea poder manejar un array que creciera dinámicamente, sin tener que preocuparnos por aumentar o disminuir su tamaño; o también, disponer de un array a cuyos valores pudiéramos acceder, a través de identificadores claves, y no por el número de índice, que en algunas situaciones es más incómodo de manejar. Aun así no hay que preocuparse, ya que no va a necesitar escribir complicados algoritmos para implementar estas características en sus arrays. Todas las funcionalidades mencionadas, y algunas más, se encuentran disponibles en un tipo especial de array denominado colección (collection). Una colección es un objeto que internamente gestiona un array, pero que está preparado, dependiendo del tipo de colección, para manejar el array que contiene de una manera especial; podríamos definirlo como un array optimizado o especializado en ciertas tareas.

Técnica de Programación Orientada a Objetos

350

 El espacio de nombres System.Collections Este espacio de nombres del entorno de .NET Framework, es el encargado de agrupar el conjunto de clases e interfaces que nos permiten la creación de los distintos tipos de objetos collection. Por lo que si necesitamos un array con alguna característica especial, sólo hemos de instanciar un objeto de alguna de las clases de este espacio de nombres para disponer de un array con esa funcionalidad. Entre las clases más significativas de System.Collections, podemos destacar las siguientes. ArrayList. Proporciona una colección, cuyo array es redimensionado dinámicamente. Hashtable. Las colecciones de este tipo, contienen un array cuyos elementos se basan en una combinación de clave y valor, de manera que el acceso a los valores se facilita, al realizarse mediante la clave. SortedList. Consiste en una colección ordenada de claves y valores. Queue. Representa una lista de valores, en el que el primer valor que entra, es el primero que sale. Stack. Representa una lista de valores, en el que el último valor que entra, es el primero que sale.

Para hacer uso de colecciones en una aplicación VB.NET creada desde VS.NET, no es necesario importar este espacio de nombres, ya que como habrá observado el lector en ejemplos anteriores, el propio IDE incluye por defecto la importación del espacio System al proyecto.

 La clave se halla en los interfaces Las clases integrantes de System.Collections implementan en mayor o menor grado, un conjunto común de interfaces, que proporcionan la funcionalidad para el trabajo con arrays especializados o colecciones. Entre alguno de los interfaces de Collections, podemos mencionar los siguientes.

IEnumerable. Proporciona el soporte para recorrer colecciones de valores. ICollection. Proporciona las características para manipular el tamaño, gestionar enumeradores, etc., de listas de valores. IList. Referencia a una lista de valores que puede ordenarse. ICloneable. Permite la creación de copias exactas e independientes de objetos.

Todo ello significa, que además de las clases con las funcionalidades especiales de Collections, podemos crear nuestras propias clases, para aquellos casos en los que necesitemos disponer de un array con funcionalidades especiales, no contempladas por los arrays base, y que además tampoco exista como colección. La manera de crear nuestro propio tipo de colección sería heredando de una clase collection existente y/o la implementación de alguno de los interfaces de Collections.

Seguidamente realizaremos una descripción general y pruebas con algunas de las colecciones existentes en el entorno, remitiendo al lector a la documentación de la plataforma accesible desde Visual Studio .NET para los detalles más específicos.

Técnica de Programación Orientada a Objetos

351

 La clase ArrayList Los objetos de tipo colección creados con esta clase, implementan un array cuyo número de elementos puede modificarse dinámicamente.



Instanciación de objetos ArrayList

Podemos instanciar una colección ArrayList en alguno los modos mostrados en el Código fuente. Observe cómo en el último ejemplo de este fuente, el constructor de ArrayList recibe como parámetro una colección dinámica.

Sub Main() ' crear una lista sin elementos Dim alEstaciones As New ArrayList() ' crear una lista indicando el número de elementos ' pero sin darles valor Dim alDatos As New ArrayList(3) ' crear una lista utilizando una colección dinámica Dim alLetras As New ArrayList(New String() {"a", "b", "c"}) End Sub Una colección dinámica se crea de forma muy similar a un array, con la diferencia de que no es necesario usar una variable a la que asignar la colección, ya que en su lugar, se pasa como parámetro al constructor de ArrayList. El modo de creación de una colección dinámica consiste en utilizar la palabra clave New, seguida del tipo de dato de la colección, los paréntesis indicativos de array, y por último, encerrados entre llaves, los valores de la colección.

 Agregar valores a un ArrayList Una vez creado un ArrayList, podemos utilizar algunos de los métodos indicados a continuación para añadir valores a la colección. Add(Valor). Añade el valor representado por Valor. AddRange(Colección). Añade un conjunto de valores mediante un objeto del interfaz ICollection, es decir, una colección dinámica creada en tiempo de ejecución. Insert(Posición, Valor). Inserta el valor Valor en la posición Posición del array, desplazando el resto de valores una posición adelante. InsertRange(Posición, Colección). Inserta un conjunto de valores mediante una colección dinámica, a partir de una posición determinada dentro del array. SetRange(Posición, Colección). Sobrescribe elementos en un array con los valores de la colección Colección, comenzando en la posición Posición.

Técnica de Programación Orientada a Objetos

352

El código fuente siguiente muestra algunos ejemplos de asignación de nuevos valores a un ArrayList.

Sub Main() Dim alDatos As New ArrayList(10) alDatos.Add("a") alDatos.AddRange(New String() {"b", "c", "d"}) Console.WriteLine("ArrayList después de usar Add() y AddRange()") RecorrerAList(alDatos) alDatos.Insert(2, "hola") Console.WriteLine("ArrayList después de usar Insert()") RecorrerAList(alDatos) alDatos.InsertRange(1, New Integer() {55, 77, 88}) Console.WriteLine("ArrayList después de usar InsertRange()") RecorrerAList(alDatos) alDatos.SetRange(3, New String() {"zzz", "yyy"}) Console.WriteLine("ArrayList después de usar SetRange()") RecorrerAList(alDatos) Console.ReadLine() End Sub

Private Sub RecorrerAList(ByVal alValores As ArrayList) Dim oEnumerador As IEnumerator = alValores.GetEnumerator() While oEnumerador.MoveNext() Console.WriteLine("Valor: {0}", oEnumerador.Current) End While Console.WriteLine() End Sub

Técnica de Programación Orientada a Objetos

353

Los valores que espera recibir una colección son del tipo genérico Object, por lo que podemos insertar valores de diferentes tipos de dato. 

Recorrer y obtener valores de un ArrayList

Para recorrer un array podemos emplear la técnica habitual del bucle For...Next y la propiedad Count del objeto ArrayList, que devuelve el número de elementos que tiene el objeto; o bien podemos usar un objeto del interfaz IEnumerator, proporcionado por el método GetEnumerator(), mucho más simple de recorrer.

Sub Main() ' crear ArrayList y añadir valores

Dim alLetras As New ArrayList(6) alLetras.Add("a") alLetras.AddRange(New String() {"b", "c", "d"}) ' recorrer con un bucle For y usando la propiedad Count, ' tener en cuenta que al ser cero el primer índice del array, ' tenemos que restar uno a la propiedad Count

Console.WriteLine("Recorrer objeto ArrayList con bucle For") Dim iContador As Integer For iContador = 0 To (alLetras.Count - 1) Console.WriteLine("Elemento actual {0}, valor: {1}", _ iContador, alLetras(iContador)) Next Console.WriteLine() ' recorrer el array con un enumerador

Console.WriteLine("Recorrer objeto ArrayList con un enumerador") Dim oEnumerador As IEnumerator oEnumerador = alLetras.GetEnumerator() While oEnumerador.MoveNext() Console.WriteLine("Elemento de la lista: {0}", oEnumerador.Current()) End While Console.ReadLine() End Sub Técnica de Programación Orientada a Objetos

354

 Capacidad y valores en una colección ArrayList Cuando manipulamos un objeto ArrayList debemos distinguir entre los conceptos capacidad y valores asignados. La capacidad de un ArrayList hace referencia al número de elementos del array subyacente que contiene este objeto, mientras que los valores asignados se refieren a aquellos elementos del array a los que se ha asignado valor mediante métodos como Add( ) o AddRange( ). Podemos obtener esta información a través de las propiedades Capacity y Count del objeto colección.

Console.WriteLine("Valores asignados al array: {0}", alLetras.Count) Console.WriteLine("Capacidad del array: {0}", alLetras.Capacity)

La capacidad es un aspecto de la clase ArrayList que mejora el rendimiento a la hora de añadir o eliminar elementos del array. Analicemos esta característica con más detenimiento. En primer lugar, todo objeto ArrayList dispone de una propiedad oculta llamada _items, conteniendo el array que internamente gestiona los valores asignados. Esta es una propiedad que no puede manipular el programador, pero que puede visualizar a través del depurador, abriendo la ventana Locales y expandiendo el contenido de un objeto ArrayList.

Cuando creamos un objeto ArrayList con un tamaño como el del último ejemplo, la acción de añadir un valor a la colección no redimensiona su array subyacente, puesto que ya está creado con un tamaño determinado, sino que asigna un valor al siguiente elemento libre que no hubiera sido previamente asignado.

Técnica de Programación Orientada a Objetos

355

Este comportamiento del objeto tiene la ventaja de que mejora el rendimiento y optimiza recursos, puesto que cada vez que añadimos o eliminamos valores, el array _items no siempre tiene que ser redimensionado.

¿Qué sucede, sin embargo, cuando se han añadido valores y el array está completo?, pues que el objeto ArrayList detecta esta situación y en la siguiente ocasión en que se añade un nuevo valor, automáticamente redimensiona el array _items, duplicando el número de elementos inicial que contenía.

En el caso que muestra la anterior figura, después de añadir la letra m al objeto, la propiedad Capacity devolvería 12 y la propiedad Count devolvería 9.

Técnica de Programación Orientada a Objetos

356

Un detalle muy importante que debe tener en cuenta el lector, es que al crear un objeto ArrayList, si no especificamos el tamaño, la propiedad _items tiene una capacidad por defecto de 16 elementos.

 Obtención de subarrays a partir de un objeto ArrayList La clase ArrayList nos proporciona métodos tanto para obtener un fragmento o rango (subarray) de un objeto ArrayList, como para crear nuevos objetos mediante métodos shared o compartidos. Entre este tipo de métodos, se encuentran los siguientes.

GetRange(Posición, Elementos). Obtiene un subarray comenzando en el índice Posición, y tomando el número que indica Elementos. FixedSize(ArrayList). Método compartido que crea un array de tamaño fijo a partir de un objeto ArrayList pasado como parámetro. Sobre el nuevo array obtenido, podemos modificar los elementos existentes, pero no añadir nuevos. Repeat(Valor, Cantidad). Método compartido que crea un ArrayList de valores repetidos, tomando como valor a repetir el parámetro Valor, y creando tantos elementos como se especifica en el parámetro Cantidad. ToArray(). Copia los elementos del ArrayList en un objeto Array, al ser ambos arrays independientes, el objeto sobre el que se han copiado los elementos puede modificarse sin que afecte al ArrayList. ReadOnly( ). Método compartido que crea un objeto ArrayList de sólo lectura a partir de un array existente.

Sub Main() Dim alLetras As New ArrayList(10) alLetras.AddRange(New String() {"a", "b", "c", "d", "e", "f", "g"}) Console.WriteLine("Array alLetras") RecorrerAList(alLetras) ' obtener un subarray con un rango determinado Dim alRangoLetras As ArrayList alRangoLetras = alLetras.GetRange(4, 2) Console.WriteLine("Array alRangoLetras") RecorrerAList(alRangoLetras) ' obtener un subarray de tamaño fijo, ' se pueden modificar sus elementos, ' no se pueden añadir valores Dim alLetrasFijo As ArrayList = ArrayList.FixedSize(alLetras) Técnica de Programación Orientada a Objetos

357

'alLetrasFijo.Add("m")