Manual Tecnicas de Programación Orientado a Objetos - A - Java - V0510

  9

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

¾ Modulo A 9

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

9 Semana 2: Ordenamiento de datos y Búsqueda de Datos…….……………….28 9 Semana 3: Programación Orientada a Objetos …………………………………38 9 Semana 4: Manejo de la Clase String ……………………………………………65 9 Semana 5: Manejo de Archivos ………………………………………………………….....74 9 Semana 6: Clases Primitivas ………………………………………………………………….92 9 Semana 7: Métodos propios …………………………………………………………………109 9 Semana 8: Ejercicios de Aplicación………………………………………………………115 9 Semana 9: Manejo de Capas en una aplicación en escritorio……………………121

¾ Bibliografía: ……………………………………………………………………………………………

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 u 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, de la misma forma el manejo del lenguaje de programación orientada a objetos. La implementación y uso de Capas dentro de la aplicación en escritorio permitirán que el alumno aplique la programación Orientada a objetos. Todas estas herramientas darán un soporte solido al alumno para aprender a programar en cualquier lenguaje de programación Orientada a Objetos(JAVA, .NET, Visual C,etc). Este material en su primera edición, servirá para ayudar a nuestros estudiantes SISESINOS a tener una formación solida para resolver problemas.

Técnica de Programación Orientada a Objetos    

3 

 

eglos Arre

Conttenidos -

Concepto de d Arreglos :Declaración, asignación e inicialización de memo oria a un arre eglo Acceso Secuencial y Aleatorio. A Agrregar Datos de d Arreglo. Arreglos co on uso de Esstructuras Co ondicionales:: Uso de Con ntadores y A Acumuladores s. Uso del JList (defaultLisstModel) d matrices: Acceso a elementos de una matriz: Asignación d de Datos: Definición de Operacione es con Matrizz (setEleme Uso de el JTable e(DefatultTab bleModel), entAt(), g getSelectedR Row(), getSelected dColum(), ch hangeSelection(), addRo ow(),etc).

_____ ___________ ___________ ___________ ___________ ___________ ___________ ___________ _____

ARRE EGLOS LINEAL LES Un arreglo a es una u colecció ón de datos del mismo tipo, que se s almacena an en posic ciones conse ecutivas de memoria y reciben un n nombre común. Para a referirse a un determ minado eleme ento de un arreglo a se deberá utiliza ar el nombre e del arreglo acompañad do de un índ dice el cual especifica e la posición relativa en que se encuentrra el elementto.

¾ Los arrreglos pue eden ser: 9

Unidimen nsionales (ve ectores).

9

Bidimenssionales (mattrices, tablass).

9

Multidime ensionales (ttres dimensio ones o más)..

Técniica de Prograamación Orieentada a Objjetos   

4 

 

9 Declarar de un arreglo: : nombre_variable [Tamaño]

9

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] Carácter nombres [8]

9 Asignación de datos hacia a un arreglo:

nombre_variable[índice] =

9

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  2  0   152

Arreglo Talla  0 

Arreglo  Nombres  0   null 

3   0 

1 

168.52

1  2  Angie  null  

4  5   0  115

7  0  

2 

8   0 

9  10   0  652 

3 

85.62

102.6  0 

3 

5  null  

4  William null  

Técnica de Programación Orientada a Objetos    

6   0 

4 

5 

170.5  0 

6 

7  8  Verónica null   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.

9 Acceso al contenido de un arreglo: Para poder acceder al contenido: a. Mostrar: 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] Mostar(Variable) o Mostar(nombre_Arrgelo[indice) Ejemplo: X=nombre[1] Mostrar(X)

el resultado será Angie

_________________________________________________________ Mostrar(nombre[8])

el resultado será Sebastián

b. Lectura: 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=0 hasta 10-1) leer(Arreglo[x]) mostrar(Arreglo[x) fin_desde

Técnica de Programación Orientada a Objetos    

6 

 

9 Los pasos para la utilizar de un vector son 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 mostrar(“Total de Aprobados: “+ca) mostrar(“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 están son del área “Sistemas”,” Contabilidad”, y cuantos sueldos superan al sueldo mínimo y cuántos de ellos 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] ) mostrar (Sueldo[i] , Area[i] ) si(Area[i]=”Sistema”) cs=cs+1 fin_si si(Area[i]=”Contabilidad”) cc=cc+1 fin_si si(Sueldo[i]>650) 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    

59 

 

} 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    

60 

 

}

™ 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    

61 

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    

62 

 

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    

63 

 

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    

64 

 

 

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

Técnica de Programación Orientada a Objetos    

65 

 

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    

66 

 

¾ 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()); 9

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): z z z z z z z z

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    

67 

 

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    

68 

 

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    

69 

 

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

Técnica de Programación Orientada a Objetos    

70 

 

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

9 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();

9 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());   9 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 Técnica de Programación Orientada a Objetos    

71 

  argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para 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’);

9 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    

72 

  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    

73 

 

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. Cada archivo es referenciado por su identificador (su nombre).

Técnica de Programación Orientada a Objetos    

74 

 

¾ 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. 9

Tipos De Archivos

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

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.

9

Según sus elementos.

Archivo de Entrada: Una colección de datos localizados en un dispositivo de entrada. 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.

Técnica de Programación Orientada a Objetos    

75 

 

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

9

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

Técnica de Programación Orientada a Objetos    

76 

  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 }

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.

Técnica de Programación Orientada a Objetos    

77 

 

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

Técnica de Programación Orientada a Objetos    

78 

 

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

Técnica de Programación Orientada a Objetos    

79 

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

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    

80 

 

z

z

z

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 z El constructor que vamos a utilizar para crear un BufferedReader es: BufferedReader fileIn = new BufferedReader(new FileReader(fileName); z Ya que tenemos el objeto tipo BufferedReader podemos utilizar varios métodos para leer, él más común es: fileIn.readLine(); z 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. z z

z z

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(); 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.

Técnica de Programación Orientada a Objetos    

81 

 

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 z z

z

z

z

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    

82 

 

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    

83 

  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));

Técnica de Programación Orientada a Objetos    

84 

 

String texto=""; while(true){ texto = entrada.readLine(); /* tam=texto.length(); for(int g=0;g