COMPILACION DE EJERCICIOS DE ALGORITMOS³n orientada a Objetos en Java 2 4 ACTIVIDAD 2 Transcriba,...

ALGORITMOS Programación Orientada a Objetos en Java 2

PROGRAMA DE INGENIERIA DE SISTEMAS BARRANQUILLA

CONTENIDO

ARREGLOS UNIDIMENSIONALES........................................................................ 3 ARREGLOS BIDIMENSIONALES........................................................................... 5 MANEJO DE METODOS ........................................................................................ 8 RECURSIVIDAD Y CONSTRUCTORES .............................................................. 11 GUI SWING........................................................................................................... 15 ORDENAMIENTO Y BUSQUEDA......................................................................... 19 HERENCIA............................................................................................................ 25 ARCHIVOS............................................................................................................ 28 EXCEPCIONES .................................................................................................... 31 BIBLIOGRAFIA RECOMENDADA ........................................................................ 34

Programación orientada a Objetos en Java 2

3

PRACTICA Nº 1 ARREGLOS UNIDIMENSIONALES

JUSTIFICACION Las estructuras de datos lineales se encuentran dentro de las más utilizadas en el manejo de información temporal en muchas de las soluciones informáticas actuales. Ordenamiento, procesos en serie, volcados, son sólo algunas de sus múltiples aplicaciones. OBJETIVOS • Afianzar los conocimientos adquiridos en el manejo de arreglos unidimensionales en Java. • Profundizar el manejo de las propiedades y características de los arreglos.

DESCRIPCION GENERAL El estudiante deberá retomar los conocimientos adquiridos en el curso previo y profundizar en el manejo de los arreglos (vectores y matrices) para obtener dominio en el diseño e implementación de los mismos. MARCO TEORICO Las estructuras de datos fijas (Arreglos) permiten el manejo de múltiples datos de un mismo tipo bajo un mismo componente y con una gran facilidad de acceso. En Java, se cuentan con 2 tipos de estructuras, los vectores fijos y los vectores dinámicos, a través de la clase Vector. En este apartado, se manejan únicamente vectores fijos, aunque los conceptos aplican de igual manera a los generados dinámicamente. Referencia Texto Guía: Capítulo 11. Secciones 11.1 – 11.4 Págs. 348-355 Referencia Web: http://java.sun.com/docs/books/tutorial/java/data/arrays.htmlDESARROLLO DE LA PRACTICA ACTIVIDAD 1 Transcriba, compile y ejecute el siguiente ejercicio. /* Escritura invertida de un Vector */ import java.io.*; public class taller1_1 { public static void main(String[] args) throws IOException { /* Declaracion de Variables */ int i,n; int vec[]; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Digite Longitud del Vector"); n = ((new Double(tec.readLine())).intValue()); vec = new int[n]; /*Lectura del Vector */ for (i=0;i<n;i++) { System.out.println("Digite Elemento ["+i+"]"); vec[i]=((new Double(tec.readLine())).intValue()); } /*Escritura Inversa del Vector */ System.out.print("\n"); for (i=n-1;i>=0;i--) { System.out.print(vec[i]+" "); } System.out.println("\n Fin del Programa"); } }

http://java.sun.com/docs/books/tutorial/java/data/arrays.html


4

ACTIVIDAD 2 Transcriba, compile y ejecute el siguiente ejercicio. /* Determinación de Cadena Palíndrome */ import java.io.*; public class taller1_2 { public static void main(String[] args) throws IOException{ /* Declaracion de Variables */ int i,j,n; boolean sw=true; char vec[]; String cad; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Digite cadena a evaluar"); cad = tec.readLine(); n =cad.length(); vec = new char[n]; /*Lectura del Vector */ for (i=0;i<vec.length;i++) { vec[i]=cad.charAt(i); } /*Verificación Vector Palindrome */ i=0; j=vec.length-1; while((sw)&&(i<(vec.length/2))) { if (vec[i]!=vec[j]) { sw=false; } i++; j--; } /*Escritura del Vector */ System.out.print("\n El Vector "); for (i=0;i<vec.length;i++) { System.out.print(vec[i]); } if (sw) { System.out.println(" es Palindrome"); } else { System.out.println(" no es Palindrome"); } } } CONSIDERACIONES IMPORTANTES - Antes de poder realizar cualquier operación sobre un arreglo en Java, debe declararse e instanciarse su variable, pues todo arreglo en Java es un objeto. - Como objetos, los arreglos en Java presentan algunos datos, por ejemplo, el atributo length que indica el número de elementos (dimensión) del arreglo. - Todo arreglo en Java, presentan indices desde 0 hasta su longitud -1. Si se invoca una posición que no existe, se presenta una excepción del tipo ArrayIndexOutOfBounds en tiempo de ejecución. PREGUNTAS PREVIAS Se debe tener claro el uso de estructuras de datos lineales y sus diferentes operaciones, lectura y escritura. BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


5

PRACTICA Nº 2 ARREGLOS BIDIMENSIONALES

JUSTIFICACION Los arreglos multidimensionales permiten manipular eficazmente una gran cantidad de información en una solución computacional. Entre sus usos, se encuentran el ordenamiento, el mapeo y procesos de representación. De ellos, los más utilizados son los bidimensionales o tablas. OBJETIVOS • Afianzar los conocimientos adquiridos en el manejo de arreglos bidimensionales en Java. • Profundizar el manejo de las propiedades y características de los arreglos.

DESCRIPCION GENERAL El estudiante aprenderá a manejar arreglos bidimensionales, utilizando ciclos anidados con contador, verificando su funcionalidad y comparando su desempeño con los arreglos unidimensionales (Vectores). MARCO TEORICO Los arreglos bidimensionales se utilizan en casos donde 2 series de datos se intersectan en puntos comunes, tales como el plano cartesiano. En general, todo grupo de datos que se pueda representar por una tabla, puede modelarse con una matriz. Referencia Texto Guía: Capítulo 11. Secciones 11.5 Págs. 359-367 Referencia Web: http://java.sun.com/docs/books/tutorial/java/data/arrays.htmlDESARROLLO DE LA PRACTICA ACTIVIDAD 1 Transcriba, compile y ejecute el siguiente ejercicio. /*Mayor y Menor Elemento de una matriz con sus posiciones */ import java.io.*; public class taller2_1 { public static void main(String[] args) throws IOException{ int i,j,fila, columna, mayor, menor, filmayor, colmayor,filmenor,colmenor; int mat[][]; DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Digite Numero de Filas"); fila=(new Double(tec.readLine())).intValue(); System.out.println("Digite Numero de Columnas"); columna=(new Double(tec.readLine())).intValue(); mat = new int[fila][columna]; //Creacion de Matriz for(i=0;i<fila;i++) { for(j=0;j<columna;j++) { System.out.println("Digite Elemento ["+i+"]["+j+"]"); mat[i][j]=(new Double(tec.readLine())).intValue(); } } /*Busqueda Mayor y Menor */ mayor=menor=mat[0][0];filmayor=colmayor=filmenor=colmenor=0; for(i=0;i<fila;i++) { for(j=0;j<columna;j++) { if(mat[i][j]>mayor) { mayor=mat[i][j]; filmayor=i;colmayor=j;

http://java.sun.com/docs/books/tutorial/java/data/arrays.html


6

} if (mat[i][j]<menor) { menor=mat[i][j]; filmenor=i;colmenor=j; } } } /*Salida */ System.out.println("Contenido de la Matriz"); for(i=0;i<fila;i++) { for(j=0;j<columna;j++) { System.out.print(mat[i][j]+" "); } System.out.println(); } System.out.println("Mayor Elemento: "+mayor+" Posición: ["+filmayor+"]["+colmayor+"]"); System.out.println("Menor Elemento: "+menor+" Posición: ["+filmenor+"]["+colmenor+"]"); } } ACTIVIDAD 2 Transcriba, compile y ejecute el siguiente ejercicio. /*Punto de Silla en una matriz. Posición que es el menor valor de su fila y el mayor de la columna */ import java.io.*; public class taller2_2 { public static void main(String[] args) throws IOException{ /* Declaracion de Variables */ int i,j,fila, columna,silla, filapos=-1, colpos=-1; int mat[][]; boolean sw; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Digite Numero de Filas"); fila=(new Double(tec.readLine())).intValue(); System.out.println("Digite Numero de Columnas"); columna=(new Double(tec.readLine())).intValue(); mat = new int[fila][columna]; //Creacion de Matriz for(i=0;i<fila;i++) { for(j=0;j<columna;j++) { System.out.println("Digite Elemento ["+i+"]["+j+"]"); mat[i][j]=(new Double(tec.readLine())).intValue(); } } /*Busqueda Punto de Silla */ for(i=0;i<fila;i++) { silla=mat[i][0]; colpos=0; for(j=0;j<columna;j++) { if(mat[i][j]<silla) { silla=mat[i][j]; colpos=j; } } sw=true; for(j=0;(j<fila) && (sw);j++) { if (silla<mat[j][colpos]) { sw=false;


7

} } if (sw) { System.out.println("Punto de Silla: ["+i+"]["+colpos+"]: "+silla); } } } } ACTIVIDAD 3 Construya un programa que realice el siguiente recorrido en una matriz cuadrada.

CONSIDERACIONES IMPORTANTES - Los indices deben mantenerse en el rango válido para cada dimensión. Si alguna petición no se encuentra dentro del rango, se genera una excepción ArrayIndexOutOfBounds. PREGUNTAS PREVIAS El estudiante deberá conocer cuando diseñar una solución con arreglos bidimensionales. BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


8

PRACTICA Nº 3 MANEJO DE METODOS

JUSTIFICACION En la programación orientada a objetos, el diseño e implementación de métodos es obligatorio, en Java esta figura resalta como uno de los elementos en donde se aprecia claramente su polimorfismo. OBJETIVOS • Conocer el manejo de los métodos en Java2. • Profundizar el dominio de las estructuras de datos lineales (Arreglos).

DESCRIPCION GENERAL El estudiante deberá dominar el diseño e implementación de métodos para solucionar problemas nuevos y rehacer, bajo el nuevo paradigma, soluciones ya realizadas. MARCO TEORICO En Java los métodos se utilizan para definir los procesos de un objeto, y en general definen la interfaz que presenta el objeto hacia el exterior. Referencia Texto Guía: Capítulo 8. Secciones 8.1 – 8.8 Págs. 243-262 Referencia Web: http://java.sun.com/docs/books/tutorial/java/javaOO/methods.html DESARROLLO DE LA PRACTICA ACTIVIDAD 1 Transcriba, compile y ejecute el siguiente ejercicio. /* Factorial de un número usando métodos */ import java.io.*; import java.util.Date; public class taller3_1 { /* Metodo Main */ public static void main(String[] args) throws IOException{ /* Declaracion de Variables */ double rfact; long numero; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ bienvenido(); System.out.println("Digite el numero a calcular"); numero = (new Double(tec.readLine())).longValue(); rfact = factorial(numero); System.out.println("El factorial de "+numero+" es "+rfact); } /* Metodo Presentacion */ static void bienvenido() { Date fecha = new Date(); System.out.print("\n"); System.out.println("********************************"); System.out.println("* BIENVENIDO A FACTORIAL v1.0 *"); System.out.println("* "+fecha+" *"); System.out.println("********************************"); } /* Metodo Factorial */ static double factorial(long num) { double prod=1;

http://java.sun.com/docs/books/tutorial/java/javaOO/methods.html


9

long i; for (i=1;i<=num;i++) { prod*=i; } return prod; } } ACTIVIDAD 2 Transcriba, compile y ejecute el siguiente ejercicio. /*Cantidad de Numeros Primos en Vector o Matriz */ import java.io.*; public class taller3_2 { public static void main(String[] args) throws IOException{ /* Declaracion de Variables */ int vec[],mat[][],tipo,n,f,c; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Digite el tipo de estructura que desea: \n 1. Vector \n 2. Matriz"); tipo = (new Double(tec.readLine())).intValue(); switch(tipo) { case 1: System.out.println("Digite longitud del vector"); n=(new Double(tec.readLine())).intValue(); vec = new int[n]; lectura(vec); System.out.println("Número de primos en Vector: "+contprimos(vec)); break; case 2: System.out.println("Digite numero de filas de la matriz"); f=(new Double(tec.readLine())).intValue(); System.out.println("Digite numero de columnas de la matriz"); c=(new Double(tec.readLine())).intValue(); mat = new int[f][c]; lectura(mat); System.out.println("Número de primos en Matriz: "+contprimos(mat)); break; } } /*Metodo Lectura Vector*/ static int[] lectura(int v[]) throws IOException { DataInputStream lea = new DataInputStream(System.in); for (int i=0;i<v.length;i++) { System.out.println("Digite Elemento "+i+" del vector"); v[i]=(new Double(lea.readLine())).intValue(); } return v; } /*Metodo Lectura Matriz*/ static int[][] lectura(int m[][]) throws IOException { DataInputStream lea = new DataInputStream(System.in); for (int i=0;i<m.length;i++) { for (int j=0;j<m[0].length;j++) { System.out.println("Digite Elemento "+i+","+j+" de la matriz");


10

m[i][j]=(new Double(lea.readLine())).intValue(); } } return m; } /*Metodo ContPrimos Vector */ static int contprimos(int v[]) { int i,cont=0; for (i=0;i<v.length;i++) { if (primo(v[i])) { cont++; } } return cont; } /*Metodo ContPrimos Matriz */ static int contprimos(int m[][]) { int i,j,cont=0; for (i=0;i<m.length;i++) { for (j=0;j<m[0].length;j++) { if (primo(m[i][j])) { cont++; } } } return cont; } /*Metodo Indicador Primo */ static boolean primo(int num) { int cont=0,i; for (i=1;i<=num;i++) { if (num%i==0) { cont++; } } if (cont==2) { return true; } else { return false; } } } ACTIVIDAD 3 Desarrollar el algoritmo para el factorial de un número en forma recursiva. CONSIDERACIONES IMPORTANTES - Un método debe tener un objetivo específico concreto. Si llega a sobrecargarse, puede tornarse ineficiente y fácilmente reemplazar a un método principal. - Es deseable construir una clase con los métodos más utilizados en cierta área, por ejemplo en vectores, en matrices, en archivos, etc. Eso permitirá construir una biblioteca de clases personal a futuro. PREGUNTAS PREVIAS - El estudiante deberá tener claro el significado de cada uno de los componentes de la estructura de un método en Java, así como cuando usar e implementar uno de ellos. BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


11

PRACTICA Nº 4 RECURSIVIDAD Y CONSTRUCTORES

JUSTIFICACION La recursividad es una herramienta práctica para la solución de un determinado tipo de problemas, es importante además tener claridad en el diseño de métodos constructores para permitir la creación de objetos bien estructurados y consistentes. OBJETIVOS • Afianzar el manejo de los métodos en Java • Conocer el concepto de métodos constructores. • Conocer la recursividad en los métodos y su aplicación.

DESCRIPCION GENERAL El estudiante conocerá el concepto de recursividad, y realizará comparaciones entre soluciones con métodos recursivos y métodos no recursivos. Además adquirirá el concepto de método constructor, sus características y su utilización en el diseño de objetos. MARCO TEORICO Un método recursivo no es diferente en su estructura a un método no recursivo, su principal característica radica en dentro de su código, se invoca a sí mismo con nuevos argumentos. Esta serie de llamadas, genera una sobrecarga de trabajo y de memoria que en procesos muy grandes, no es aconsejable, por lo tanto siempre se recomienda realizar pruebas de casos exhaustivas para verificar el funcionamiento y la eficiencia del método en la práctica. Un método constructor (inicializador) se utiliza en Java para determinar o definir características o procesos iniciales cuando se instancia un objeto. Referencia Texto Guía: Cap. 8. Secc. 8.9 Págs. 263-265. Cap. 9. Secc. 9.4-9.4.5 Págs. 287-291 Referencia Web: http://java.sun.com/docs/books/tutorial/java/javaOO/constructors.html DESARROLLO DE LA PRACTICA ACTIVIDAD 1 /*Implementacion recursiva de Factorial y Serie Fibonacci */ import java.io.*; public class taller4_1 { public static void main(String[] args) throws IOException{ /* Declaracion de Variables */ int opc,numero; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ System.out.println("Metodos Recursivos"); System.out.println("1. Factorial de un numero"); System.out.println("2. Serie Fibonacci"); opc = (new Double(tec.readLine())).intValue(); switch(opc) { case 1: System.out.println("Digite el numero a calcular el factorial"); numero=(new Double(tec.readLine())).intValue(); System.out.println("El Factorial de "+numero+" es "+factorial(numero)); break; case 2: System.out.println("Digite la posicion a calcular la serie(mayor a 3)"); numero=(new Double(tec.readLine())).intValue(); System.out.println("El elemento "+numero+" de la serie es "+fibonacci(numero)); break;

http://java.sun.com/docs/books/tutorial/java/javaOO/constructors.html


12

} } /*Metodo Recursivo Factorial */ static long factorial(int num) { if (num==1) { return 1; } else { if (num==2) { return 2; } else { return (factorial(num-1)*num); } } } /*Metodo Recursivo Fibonacci */ static long fibonacci(int num) { if (num==1) { return 1; } else { if (num==2) { return 1; } else { return (fibonacci(num-1)+fibonacci(num-2)); } } } } ACTIVIDAD 2 /*Uso de Constructores y Metodos para crear objetos Cuenta*/ import java.io.*; public class banco { public static void main(String[] args) throws IOException{ /* Declaracion de Variables y Objetos*/ int opc,tiposal; double valor; cuenta cta1 = null; String nomcliente,numerocta; /*Declaracion Objeto DataInputStream */ DataInputStream tec = new DataInputStream(System.in); /*Codigo Programa */ do { System.out.println("Operaciones"); System.out.println("1. Crear Cuenta"); System.out.println("2. Consignacion"); System.out.println("3. Retiro"); System.out.println("4. Consulta de Saldo"); System.out.println("5. Transferencia"); System.out.println("6. Salir"); opc = (new Double(tec.readLine())).intValue(); switch(opc) { case 1: System.out.println("Digite Nombre Cliente");


13

nomcliente = tec.readLine(); System.out.println("Digite Numero Cuenta"); numerocta = tec.readLine(); System.out.println("Desea introducir saldo inicial? ((1=SI/0=NO)"); tiposal = (new Double(tec.readLine())).intValue(); if (tiposal==1) { System.out.println("Digite Saldo Inicial"); valor = (new Double(tec.readLine())).doubleValue(); //Creacion de Cuenta cta1 = new cuenta(numerocta, nomcliente,valor); } else { //Creacion de Cuenta Saldo 0 cta1 = new cuenta(numerocta,nomcliente); } break; case 2: System.out.println("Digite el valor a consignar"); valor = (new Double(tec.readLine())).doubleValue(); cuenta.consignar(cta1,valor); System.out.println("Consignacion Realizada"); break; case 4: System.out.println("Saldo Actual: "+cta1.versaldo()); break; } } while (opc!=6); } //Fin main } class cuenta { double saldo; String nrocuenta; String cliente; /*Constructores */ cuenta(String nrocta, String nomcl) { //Constructor Cuenta Saldo en 0 saldo=0; nrocuenta = new String(nrocta); cliente = new String(nomcl); } cuenta(String nrocta, String nomcl,double saldoini) { //Constructor Cuenta con Saldo Inicial saldo=saldoini; nrocuenta = new String(nrocta); cliente = new String(nomcl); } //Metodos Adicionales public static void consignar(cuenta cta, double valor) { cta.saldo+=valor; } public double versaldo() { return saldo; } } ACTIVIDAD 3 Desarrolle la funcionalidad de las opciones Retiro y Transferencia de la actividad 2.


14

CONSIDERACIONES IMPORTANTES - Tener en cuenta el caso base para los métodos recursivos y asegurarse que en algún momento llegue a cumplirse para evitar procesos infinitos. - Toda clase debería tener al menos un constructor para garantizar que sus datos de entrada permitan la generación de una instancia bien formada. PREGUNTAS PREVIAS - El estudiante deberá conocer la estructura y el uso de los métodos en Java.

BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


15

PRACTICA Nº 5 GUI SWING

JUSTIFICACION Las aplicaciones modernas exigen una interfaz con el usuario agradable, atractiva y eficiente, por lo que el estudiante debe manejar los conceptos básicos de diseño de GUI para realizar soluciones acordes a las necesidades del mercado actual. OBJETIVOS • Conocer el API Swing de Java. • Identificar los métodos para el manejo de ventanas, etiquetas, cajas de texto y botones. DESCRIPCION GENERAL El estudiante conocerá la creación y utilización de objetos básicos para generar una GUI bajo el API Swing de Java. MARCO TEORICO - Referencia del Lenguaje para cada Componente Swing utilizado: Jframe http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JFrame.htmlJButton http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JButton.htmlJTextField http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JTextField.htmlJLabel http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JLabel.htmlDESARROLLO DE LA PRACTICA ACTIVIDAD 1 /* Suma de Dos Numeros usando GUI*/ import javax.swing.*; import java.awt.*; import java.awt.event.*; class taller5_1 extends JFrame implements ActionListener{ /* Controles de la Interfaz Grafica */ JLabel lbltot,lblnum1,lblnum2; JTextField txtnum1,txtnum2,txtresult; JButton btaceptar; /* Contructor de la clase * Define toda la GUI de la clase */ taller5_1() { //Crear controles lblnum1 = new JLabel("Numero 1:"); txtnum1 = new JTextField(5); lblnum2 = new JLabel("Numero 2:"); txtnum2 = new JTextField(5); lbltot = new JLabel("Total: "); txtresult = new JTextField(); txtresult.setEnabled(false); btaceptar = new JButton("Sumar"); //Adicionar controles a traves de un JPanel JPanel pane = new JPanel(); //Crea un Borde alrededor de los componentes de la ventana pane.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); //Define el Layout para la ventana. pane.setLayout(new GridLayout(4,2,0,10)); pane.add(lblnum1); pane.add(txtnum1); pane.add(lblnum2); pane.add(txtnum2);

http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JFrame.html

http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JButton.html

http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JTextField.html

http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JLabel.html


16

pane.add(lbltot); pane.add(txtresult); pane.add(new JLabel()); pane.add(btaceptar); //Prepara el boton comando btaceptar.setMnemonic('S'); btaceptar.setActionCommand("sumar"); btaceptar.addActionListener(this); //Define el Panel getContentPane().add(pane); } /*Metodo main que invoca a la ventana definida por el constructor *creando una instancia de la clase */ public static void main(String[] args) { /*Construye un objeto taller5_1 */ taller5_1 vent = new taller5_1(); //Define titulo vent.setTitle("Suma de Dos Números"); //Configura Boton Cerrar vent.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Muestra la ventana */ vent.pack(); vent.show(); } /*Metodo que define el código de los controles de la ventana*/ public void actionPerformed(ActionEvent e) { if (e.getActionCommand().equals("sumar")) { double n1,n2; n1 = (new Double(txtnum1.getText())).doubleValue(); n2 = (new Double(txtnum2.getText())).doubleValue(); txtresult.setText((new Double(n1+n2)).toString()); } } } ACTIVIDAD 2 /* Suma de Dos Vectores con GUI*/ import javax.swing.*; import java.awt.*; import java.awt.event.*; class taller5_2 extends JFrame implements ActionListener { //Objetos Graficos JLabel lbldim,lblvecsuma; JTextField txtdimension; JTextField txtsalida; JButton btaceptar; //Datos int dim,vec1[],vec2[],suma[]; /*Constructor Lectura Dimension */ taller5_2() { lbldim = new JLabel("Ingrese dimension del vector: "); txtdimension = new JTextField(2); btaceptar = new JButton("Sumar Vectores"); txtsalida = new JTextField(10); lblvecsuma = new JLabel("Vector Suma:"); JPanel pane = new JPanel(); pane.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));


17

pane.setLayout(new GridLayout(2,3,0,10)); pane.add(lbldim); pane.add(txtdimension); pane.add(btaceptar); pane.add(lblvecsuma); pane.add(txtsalida); lblvecsuma.setVisible(false); txtsalida.setVisible(false); //Prepara botones comando btaceptar.setMnemonic('C'); btaceptar.setActionCommand("ldim"); btaceptar.addActionListener(this); //Define el Panel getContentPane().add(pane); } /*Metodo main que invoca a la ventana definida por el constructor *creando una instancia de la clase */ public static void main(String[] args) { /*Lee dimension */ taller5_2 vent = new taller5_2(); //Define titulo vent.setTitle("Suma de Vectores"); //Configura Boton Cerrar vent.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Muestra la ventana */ vent.pack(); vent.show(); } /*Metodo que define el código de los controles de la ventana*/ public void actionPerformed(ActionEvent e) { leernumero Dialogo = new leernumero(this); //Oculta Controles de Resultado lblvecsuma.setVisible(false); txtsalida.setVisible(false); this.validate(); if (e.getActionCommand().equals("ldim")) { /*Creacion Vectores*/ dim = (new Double(txtdimension.getText())).intValue(); vec1 = new int[dim]; vec2 = new int[dim]; suma = new int[dim]; /*Lectura Vectores*/ Dialogo.defineTitulo("Vector 1"); for (int i=0;i<dim;i++) { vec1[i]= Dialogo.nentero("Digite elemento Nº"+i); } Dialogo.defineTitulo("Vector 2"); for (int i=0;i<dim;i++) { vec2[i]= Dialogo.nentero("Digite elemento Nº"+i); } /* Suma Vectores */ txtsalida.setText(""); for (int i=0;i<dim;i++) { suma[i]= vec1[i]+vec2[i]; txtsalida.setText(txtsalida.getText() + " " +suma[i]); } txtsalida.setVisible(true); lblvecsuma.setVisible(true); this.validate();


18

} } } /*Clase Auxiliar para Leer Datos */ class leernumero { /*Datos de la Clase */ String titulo; JFrame ventppal; /* Constructor de la Clase */ public leernumero(JFrame vent) { titulo = "Lectura Numero"; ventppal = vent; } /* Metodo para leer numero double */ public double nreal(String mensaje) { double valor; Double obj; Object cad; cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.doubleValue(); return valor; } /* Metodo para leer numero int */ public int nentero(String mensaje) { int valor; Double obj; Object cad; cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.intValue(); return valor; } /*Metodo para definir titulo de la ventana*/ public void defineTitulo(String cad) { titulo = cad; } } ACTIVIDAD 3 Implemente la suma de matrices en base a la Actividad 2. CONSIDERACIONES IMPORTANTES - El diseño de la GUI debe ser previo a la codificación de la solución, de igual forma que los métodos se diseñan en pseudocódigo, la GUI de la aplicación también debe diseñarse para tener un modelo claro de lo que se desea construir. PREGUNTAS PREVIAS El estudiante deberá conocer la referencia del lenguaje para los objetos Jframe, JButton, JLabel, JTextField que hacen parte de la API Swing en Java. BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


19

PRACTICA Nº 6 ORDENAMIENTO Y BUSQUEDA

JUSTIFICACION La gran mayoría de aplicaciones actuales presentan algoritmos integrados de ordenamiento y búsqueda de datos, es importante que el estudiante conozca cuales son los diferentes algoritmos que se manejan, sus ventajas, desventajas y aprender a valorarlos para utilizarlos adecuadamente. OBJETIVOS • Afianzar los conocimientos en el API Swing de Java. • Conocer la implementación de algoritmos de ordenamiento y de búsqueda. DESCRIPCION GENERAL El estudiante conocerá y se familizará con los algoritmos clásicos de ordenamiento y búsqueda en arreglos unidimensionales (Vectores). MARCO TEORICO En general los algoritmos de ordenamiento se pueden dividir en dos grandes grupos de acuerdo a su complejidad: Cuadráticos y Logarítmicos. Los cuadráticos se usan preferentemente en arreglos pequeños y los logarítmicos en arreglos extensos. En cuanto a las búsquedas, se encuentra la secuencial, utilizada en arreglos no ordenados y la binaria, utilizada en arreglos ordenados. Referencia Texto Guía: Cap. 11. Secc. 11.7-11.8 Págs. 374-376. Referencia Web: http://es.wikipedia.org/wiki/Algoritmos_de_ordenamientoDESARROLLO DE LA PRACTICA ACTIVIDAD 1 /*Ordenamiento con Intercambio Directo (Burbuja) Ascendente */ import javax.swing.*; import java.awt.*; import java.awt.event.*; public class taller6_1 extends JFrame implements ActionListener{ //Objetos Graficos JLabel lbldim,lblvecorg,lblvecord; JTextField txtdimension; JTextField txtvecorg, txtvecord; JButton btaceptar; //Datos int dim,vecorg[]; public taller6_1() { /*Creacion de Controles*/ lbldim = new JLabel("Dimension Vector: "); txtdimension = new JTextField(2); btaceptar = new JButton("Ordenar Vector"); txtvecorg = new JTextField(10); txtvecord = new JTextField(10); lblvecorg = new JLabel("Vector Original:"); lblvecord = new JLabel("Vector Ordenado:"); JPanel pane = new JPanel(); /*Adicion de Controles*/ /*Panel Principal */ pane.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); pane.setLayout(new GridLayout(4,2,0,10)); pane.add(lbldim); pane.add(txtdimension); pane.add(lblvecorg); pane.add(txtvecorg); pane.add(lblvecord); pane.add(txtvecord); pane.add(new Label("")); pane.add(btaceptar);

http://es.wikipedia.org/wiki/Algoritmos_de_ordenamiento


20

//Prepara botones comando btaceptar.setMnemonic('O'); btaceptar.setActionCommand("ldim"); btaceptar.addActionListener(this); //Define al botón aceptar como predeterminado this.getRootPane().setDefaultButton(btaceptar); //Define el Panel getContentPane().add(pane); } public static void main(String[] args) { taller6_1 vent = new taller6_1(); //Define titulo vent.setTitle("Ordenamiento Intercambio"); //Configura Boton Cerrar vent.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Muestra la ventana */ vent.pack(); vent.show(); } public void actionPerformed(ActionEvent e) { leernumero Dialogo = new leernumero(this); txtvecord.setText(""); txtvecorg.setText(""); if (e.getActionCommand().equals("ldim")) { /*Creacion Vector*/ dim = (new Double(txtdimension.getText())).intValue(); vecorg = new int[dim]; /*Lectura Vector*/ Dialogo.defineTitulo("Vector a Ordenar"); for (int i=0;i<dim;i++) { vecorg[i]= Dialogo.nentero("Digite elemento Nº"+i); txtvecorg.setText(txtvecorg.getText() + " " +vecorg[i]); } /*Ordena vector */ burbuja(vecorg); /*Escritura Vector Ordenado */ for (int i=0;i<dim;i++) { txtvecord.setText(txtvecord.getText() + " " +vecorg[i]); } } } void burbuja(int vec[]) { int I,J,AUX; int N=vec.length; for (I=1; I<N;I++) { for (J=N-1;J>=I;J--) { if(vec[J-1]>vec[J]) { AUX=vec[J-1]; vec[J-1]=vec[J]; vec[J]=AUX; } } } } /*Clase Auxiliar para Leer Datos */ class leernumero {


21

/*Datos de la Clase */ String titulo; JFrame ventppal; /* Constructor de la Clase */ public leernumero(JFrame vent) { titulo = "Lectura Numero"; ventppal = vent; } /* Metodo para leer numero double */ public double nreal(String mensaje) { double valor; Double obj; Object cad; cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.doubleValue(); return valor; } /* Metodo para leer numero int */ public int nentero(String mensaje) { int valor; Double obj; Object cad; cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.intValue(); return valor; } /*Metodo para definir titulo de la ventana*/ public void defineTitulo(String cad) { titulo = cad; } } } ACTIVIDAD 2 /*Busqueda Secuencial en un Vector*/ import javax.swing.JTextField; import javax.swing.JLabel; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; import javax.swing.JOptionPane; import javax.swing.BorderFactory; import java.awt.*; import java.awt.event.*; public class taller6_2 extends JFrame implements ActionListener{ //Objetos Graficos JLabel lbldim,lblvecorg,lblposicion; JTextField txtdimension; JTextField txtvecorg, txtposicion;


22

JButton btaceptar,btbuscar; //Datos int dim,vecorg[]; public taller6_2() { /*Creacion de Controles*/ lbldim = new JLabel("Dimension Vector: "); txtdimension = new JTextField(2); btaceptar = new JButton("Leer Vector"); txtvecorg = new JTextField(10); txtposicion = new JTextField(10); lblvecorg = new JLabel("Vector Busqueda:"); lblposicion = new JLabel("Elemento Buscado:"); btbuscar = new JButton("Buscar Elemento"); JPanel pane = new JPanel(); /*Adicion de Controles*/ /*Panel Principal */ pane.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); pane.setLayout(new GridLayout(3,3,0,10)); pane.add(lbldim); pane.add(txtdimension); pane.add(btaceptar); pane.add(lblposicion); pane.add(txtposicion); pane.add(btbuscar); pane.add(lblvecorg); pane.add(txtvecorg); //Prepara botones comando btaceptar.setMnemonic('L'); btaceptar.setActionCommand("ldim"); btaceptar.addActionListener(this); btbuscar.setMnemonic('B'); btbuscar.setActionCommand("busq"); btbuscar.addActionListener(this); //Define al botón aceptar como predeterminado this.getRootPane().setDefaultButton(btaceptar); //Define el Panel getContentPane().add(pane); lblposicion.setVisible(false); txtposicion.setVisible(false); lblvecorg.setVisible(false); txtvecorg.setVisible(false); btbuscar.setVisible(false); txtvecorg.setEditable(false); } public static void main(String[] args) { taller6_2 vent = new taller6_2(); vent.setTitle("Busqueda Secuencial"); vent.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); vent.pack(); vent.show(); } public void actionPerformed(ActionEvent e) { int posbus,elementobus; leernumero Dialogo = new leernumero(this); if (e.getActionCommand().equals("ldim")) { /*Creacion Vector*/ dim = (new Double(txtdimension.getText())).intValue(); vecorg = new int[dim]; /*Lectura Vector*/ Dialogo.defineTitulo("Vector"); txtvecorg.setText("");


23

for (int i=0;i<dim;i++) { vecorg[i]= Dialogo.nentero("Digite elemento Nº"+i); txtvecorg.setText(txtvecorg.getText() + " " +vecorg[i]); } lblposicion.setVisible(true); txtposicion.setVisible(true); btbuscar.setVisible(true); lblvecorg.setVisible(false); txtvecorg.setVisible(false); } if (e.getActionCommand().equals("busq")) { /*Busqueda Elemento*/ elementobus = (new Double(txtposicion.getText())).intValue(); posbus=busquedasec(vecorg,elementobus); /*Respuesta Busqueda */ if (posbus==-1) { JOptionPane.showMessageDialog(this, "El elemento "+elementobus+" no se encuentra.", "Resultado Busqueda", JOptionPane.INFORMATION_MESSAGE); } else { JOptionPane.showMessageDialog(this, "El elemento "+elementobus+" se encuentra en la posicion "+posbus, "Resultado Busqueda", JOptionPane.INFORMATION_MESSAGE); } lblvecorg.setVisible(true); txtvecorg.setVisible(true); } } /*Metodo Busqueda Secuencial en Vector Enteros*/ int busquedasec(int vec[], int elemento) { for (int i=0;i<vec.length;i++) { if (elemento==vec[i]) { return i; } } return -1; } } /*Clase Auxiliar para Leer Datos */ class leernumero { /*Datos de la Clase */ String titulo; JFrame ventppal; /* Constructor de la Clase */ public leernumero(JFrame vent) { titulo = "Lectura Numero"; ventppal = vent; } /* Metodo para leer numero double */ public double nreal(String mensaje) { double valor; Double obj; Object cad;


24

cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.doubleValue(); return valor; } /* Metodo para leer numero int */ public int nentero(String mensaje) { int valor; Double obj; Object cad; cad = JOptionPane.showInputDialog(ventppal, mensaje, titulo, JOptionPane.DEFAULT_OPTION); obj = Double.valueOf(cad.toString()); valor = obj.intValue(); return valor; } /*Metodo para definir titulo de la ventana*/ public void defineTitulo(String cad) { titulo = cad; } } ACTIVIDAD 3 Implemente un programa que ordene un vector sea ascendente o descendemente a voluntad del usuario. Implemente un programa que ordene una matriz de enteros utilizando intercambio directo.

CONSIDERACIONES IMPORTANTES - Para determinar el mejor algoritmo de ordenamiento debe tenerse en cuenta la cantidad de datos a ordenar, para calcular la mejor opción. - Aunque existen ya algoritmos estables para el ordenamiento y la búsqueda, cada cierto tiempo surgen nuevas soluciones que se deben tener en cuenta para brindar mejor respuesta y beneficio a los usuarios. PREGUNTAS PREVIAS El estudiante deberá tener claros los conceptos de Arreglos Unidimensionales (Vectores). BIBLIOGRAFIA JOYANES AGUILAR LUIS. ZAHONERO MARTINEZ IGNACIO, “Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos”. McGraw Hill. 2002


25

PRACTICA Nº 7

HERENCIA JUSTIFICACION La herencia es uno de los pilares de la programación orientada a objetos, y ofrece grandes ventajas en el diseño e implementación de soluciones comparada con la programación estructurada. OBJETIVOS • Conocer la implementación del concepto de Herencia en Java. • Afianzar la utilización de clases, paquetes y los conceptos de clases base y derivadas. DESCRIPCION GENERAL El estudiante conocerá los conceptos de herencia, super clase, sub clase y como interactuan entre si para formar una jerarquía de clases que le permita dar solución a sus problemas algorítmicos. MARCO TEORICO La herencia es una herramienta que permite definir objetos generales y “especializarlos” hasta el nivel deseado con eficiencia y de manera organizada y consistente. Referencia Texto Guía: Cáp. 10. Secc. 10.1-10.6 Págs. 308-325. Referencia Web: http://java.sun.com/docs/books/tutorial/java/javaOO/subclasses.html DESARROLLO DE LA PRACTICA ACTIVIDAD 1 /* Implementacion Herencia Clase Automor - Clase Automovil */ public class taller7_1 { public static void main(String args[]) { /*Creacion Objeto Automotor */ automotor vehi_1; vehi_1 = new automotor("8V", 4300, "NX_V", 8000); /*Invoca metodo verinfo automotor */ System.out.println("Info Objeto Automotor"); vehi_1.verinfo(); /*Creacion Objeto Automovil */ automovil vehi_2; vehi_2 = new automovil(); vehi_2.cilindrada=5000; vehi_2.rpm =10000; //Invoca metodo cambiarModelo Clase Base Automotor vehi_2.cambiarModelo("Phantom 2004"); vehi_2.tipomotor = "12 en linea"; //Invoca metodo cambiarusoVehiculo Clase Automovil vehi_2.cambiarusoVehiculo("Privado"); vehi_2.numpasajeros=5; vehi_2.numpuertas =4; /*Invoca metodo verinfo Automovil */ System.out.println("Info Objeto Automovil"); vehi_2.verinfo(); } } /*Clase Automovil derivada de Automotor*/ class automovil extends automotor { /*Datos de la clase */ int numpuertas=0;

http://java.sun.com/docs/books/tutorial/java/javaOO/subclasses.html


26

int numpasajeros=0; String usovehiculo="Privado"; String equipamento="NOEQUIP"; /*Metodo cambiarusoVehiculo CLase Automovil */ public void cambiarusoVehiculo(String nuevusoveh) { usovehiculo = nuevusoveh; } /*Sobre carga Metodo VerInfo Para Automovil */ public void verinfo() { /*llama al metodo verinfo de la clase base */ super.verinfo(); /*Adiciona funcionalidad automovil */ System.out.println("Nº Puertas: "+numpuertas); System.out.println("Numero Pasajeros: "+numpasajeros); System.out.println("Uso Vehiculo: "+usovehiculo); System.out.println("Equipamiento: "+equipamento); } } /*Clase Automotor */ class automotor { /*Datos de la clase */ String tipomotor; int cilindrada; int rpm; String modelo; /*Metodo Constructor con todos los datos*/ public automotor(String tipmotor, int cilind, String model, int revpormin) { tipomotor = tipmotor; cilindrada = cilind; modelo = model; rpm = revpormin; } /*Metodo Constructor sin argumentos*/ public automotor() { tipomotor = new String("NODEF"); cilindrada = -1; modelo = new String("NODEF"); rpm = -1; } /*Metodo VerInfo Clase automotor*/ public void verinfo() { System.out.println("Modelo Vehiculo: "+modelo); System.out.println("Tipo motor: "+tipomotor); System.out.println("Cilindrada: "+cilindrada); System.out.println("Revoluciones por Minuto: "+rpm); } /*Metodo cambiarModelo Clase automotor*/ public void cambiarModelo(String nuevomod) { modelo = nuevomod; } } ACTIVIDAD 2 Implemente una clase Moto derivada de la clase Automóvil de la Actividad 1 con sus propios datos y métodos.


27

CONSIDERACIONES IMPORTANTES - Es muy importante realizar un correcto diseño previo de los objetos a implementar en la solución para evitar pérdida de tiempo y retrasos por la mala organización en el montaje de los algoritmos. PREGUNTAS PREVIAS - El estudiante deberá conocer los conceptos de herencia, clase, superclase, subclase y polimorfismo en Java.



28

PRACTICA Nº 8 ARCHIVOS

JUSTIFICACION Las estructuras de datos ofrecen grandes ventajas en cuanto al manejo de información y la velocidad de procesamiento, desafortunadamente no se almacenan en memoria secundaria por lo que si se desea manejar datos persistentes, se deben utilizar herramientas como los archivos. OBJETIVOS • Conocer los diferentes conceptos alrededor de los archivos planos y como utilizarlos. • Conocer e identificar los objetos y métodos en Java para implementar archivos. DESCRIPCION GENERAL El estudiante conocerá los conceptos claves para el manejo de archivos en Java, y los diferentes objetos y métodos utilizados para tal fin. Desarrollará aplicaciones sencillas que cuenten con la facilidad de almacenar sus datos persistentes permanentemente. MARCO TEORICO Los archivos permiten almacenar información, con cierta facilidad, en aplicaciones sencillas con datos no prioritarios. Aunque en la actualidad, la mayor parte del almacenamiento se realiza a través de bases de datos, en algunos casos es preferible la utilización de archivos planos, tales como archivos de configuración (.ini, .config), archivos de texto(.txt, .dat), archivos bitácora (.log, .boot), etc. Referencia Texto Guía: Cáp. 18. Secc. 18.1-18.6 Págs. 594-622. Referencia Web: http://java.sun.com/docs/books/tutorial/essential/io/datasinks.htmlDESARROLLO DE LA PRACTICA ACTIVIDAD 1 /* Ejemplo Archivos de Texto */ import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.*; public class taller8_1 extends JFrame { JLabel lblnombre; JTextField txtnombre; JButton butabrir, butguardar; JTextArea txtTexto; JScrollPane pan; FileInputStream aentrada; DataInputStream fentrada; FileOutputStream asalida; DataOutputStream fsalida; File arch; public taller8_1() { //Configuracion Ventana super("Taller 8_1"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); getContentPane().setLayout(null); setResizable(false); setSize(400,500); //GUI lblnombre = new JLabel("Archivo:"); txtnombre = new JTextField("salida"); txtnombre.selectAll(); butabrir = new JButton("Abrir"); butguardar = new JButton("Guardar"); txtTexto = new JTextArea(); pan = new JScrollPane(txtTexto, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); lblnombre.setBounds(5,3,50,30); txtnombre.setBounds(60,3, 150,30);

http://java.sun.com/docs/books/tutorial/essential/io/datasinks.html


29

butabrir.setBounds(220, 3, 80,30); butguardar.setBounds(310, 3, 80,30); pan.setBounds(1,40, 392, 422); getContentPane().add(lblnombre); getContentPane().add(txtnombre); getContentPane().add(butabrir); getContentPane().add(butguardar); getContentPane().add(pan); //Eventos butabrir.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) { if (txtnombre.getText().length()==0) { JOptionPane.showMessageDialog(null,"Nombre en Blanco"); } else { String nom = txtnombre.getText(); arch = new File(nom+".txt"); //Nombre del archivo try { //Flujo de Archivo de Entrada aentrada = new FileInputStream(arch); } catch (FileNotFoundException ea) { JOptionPane.showMessageDialog(null,"Archivo no Encontrado"); } //Flujo de Datos de Entrada fentrada = new DataInputStream(aentrada); //Proceso de Lectura en el archivo txtTexto.setText(null); try { txtTexto.setText(fentrada.readUTF()); JOptionPane.showMessageDialog(null,"Archivo Leido!"); } catch(IOException ea) { JOptionPane.showMessageDialog(null,"Error al Leer"); } //Cerrar Flujos try { fentrada.close(); aentrada.close(); } catch (IOException ea) { JOptionPane.showMessageDialog(null,"Error al cerrar archivo"); } } } }); butguardar.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) { if (txtnombre.getText().length()==0) { JOptionPane.showMessageDialog(null,"Nombre en Blanco"); } else { String nom = txtnombre.getText(); arch = new File(nom+".txt"); //Nombre del archivo try { //Flujo de Archivo de Salida asalida = new FileOutputStream(arch); } catch (FileNotFoundException ea) { JOptionPane.showMessageDialog(null,"Archivo no Encontrado"); } //Flujo de Datos de Salida


30

fsalida = new DataOutputStream(asalida); //Proceso de Escritura en el archivo if (txtTexto.getText()!=null) { try { fsalida.writeUTF(txtTexto.getText()); JOptionPane.showMessageDialog(null,"Archivo Creado!"); txtTexto.setText(null); } catch(IOException ea) { JOptionPane.showMessageDialog(null,"Error al Escribir"); } } //Cerrar Flujos try { fsalida.close(); asalida.close(); } catch (IOException ea) { JOptionPane.showMessageDialog(null,"Error al cerrar archivo"); } } } }); } public static void main(String args[]) { taller8_1 v = new taller8_1(); v.show(); } } CONSIDERACIONES IMPORTANTES - Tener en cuenta los nombres de los archivos a utilizar. - Considerar la estructura con la que se almacena la información, ya que al leer el archivo se debe manejar exactamente el mismo formato. (Registro). - Al finalizar el trabajo con los archivos, deben cerrarse siempre sus procesos (flujos), para evitar comportamientos no deseados o inconsistencia en la información. - Los archivos no deben ser utilizados para información confidencial, prioritaria o de valor elevado, pues no presentan medidas de seguridad adecuadas a este tipo de información. PREGUNTAS PREVIAS - El estudiante deberá tener claros los conceptos básicos del uso de archivos en aplicaciones sencillas.



31

PRACTICA Nº 9 EXCEPCIONES

JUSTIFICACION Todo lenguaje de programación moderno ofrece herramientas para la gestión de errores y es importante para todo programador que domine y sea hábil con las técnicas que permitirán que sus soluciones tengan mejor desempeño y eficiencia frente a sus usuarios. OBJETIVOS • Conocer los diferentes conceptos alrededor de la gestión de errores. • Conocer e identificar las excepciones y las sentencias relacionadas con ellas en Java. DESCRIPCION GENERAL El estudiante conocerá como maneja Java su gestión de errores y en que forma puede implementar rutinas para sus programas que le brinden mayor estabilidad y eficacia. MARCO TEORICO En Java, la gestión de errores es soportada por un conjunto de clases especiales denominadas Excepciones. Un programa puede “capturar” las excepciones que se presenten cuando se usa un método para definir el curso a seguir en caso de presentarse un problema en la ejecución y también se pueden “lanzar” nuevas excepciones para complementar el diseño de la gestión. Las sentencias try, catch, finally, throws y throw están relacionadas con las excepciones y cada una de ellas ofrece un herramienta específica para el diseño de soluciones bien estructuradas. Referencia Texto Guía: Cáp. 19. Secc. 19.1-19.6 Págs. 632-650. Referencia Web: http://java.sun.com/docs/books/tutorial/essential/exceptions/index.htmlDESARROLLO DE LA PRACTICA ACTIVIDAD 1 /* Manejo de Excepciones en Java */ import java.math.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; public class taller9_1 extends JFrame{ JLabel lblmensaje, lbla, lblb, lblc,lblraices; JTextField txta,txtb,txtc,txtr1,txtr2; JButton butcalcular,butsalir; public taller9_1() { super("Formula General"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setResizable(false); setSize(300,200); getContentPane().setLayout(null); //GUI lblmensaje = new JLabel("Ingrese los coeficientes"); lbla = new JLabel("A:"); lblb = new JLabel("B:"); lblc = new JLabel("C:"); txta = new JTextField(); txtb = new JTextField(); txtc = new JTextField(); txtr1 = new JTextField(); txtr2 = new JTextField(); butcalcular = new JButton("Calcular"); butsalir = new JButton("Salir"); lblraices = new JLabel("Raices"); txtr1.setEditable(false); txtr2.setEditable(false); lblmensaje.setBounds(5,5, 150, 30); lbla.setBounds(5, 40, 30,30); txta.setBounds(40, 40, 50,30); lblb.setBounds(100, 40, 30,30); txtb.setBounds(140, 40, 50,30); lblc.setBounds(200, 40, 30,30); txtc.setBounds(240, 40, 50,30); butcalcular.setBounds(50, 80, 100, 30); butsalir.setBounds(180,80, 100, 30);

http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html


32

lblraices.setBounds(5,120, 50, 30); txtr1.setBounds(50,120, 100, 30); txtr2.setBounds(180,120, 100, 30); getContentPane().add(lblmensaje); getContentPane().add(lbla); getContentPane().add(txta); getContentPane().add(lblb); getContentPane().add(txtb); getContentPane().add(lblc); getContentPane().add(txtc); getContentPane().add(butcalcular); getContentPane().add(butsalir); getContentPane().add(lblraices); getContentPane().add(txtr1); getContentPane().add(txtr2); //Eventos butsalir.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e){ dispose(); } }); butcalcular.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e){ double ca = new Double(txta.getText()).doubleValue(); double cb = new Double(txtb.getText()).doubleValue(); double cc = new Double(txtc.getText()).doubleValue(); Cuadratica eq = new Cuadratica(ca,cb,cc); try { eq.calcularRaiz(); txtr1.setText(String.valueOf(eq.verR1())); txtr2.setText(String.valueOf(eq.verR2())); JOptionPane.showMessageDialog(null,"Raices Calculadas!"); } catch(CoeficienteCeroException e1) { JOptionPane.showMessageDialog(null,"El coeficiente a es cero!"); } catch(RaicesComplejasException e1) { JOptionPane.showMessageDialog(null,"Raices Complejas!"); } } }); } public static void main(String args[]){ taller9_1 v = new taller9_1(); v.show(); } } /*Clase Ejemplo Excepciones */ class Cuadratica { double a,b,c,r1,r2; /** Builds a cuadratic equation (a^2X+bX+c=0)*/ public Cuadratica(double coef1,double coef2,double coef3) { a = coef1; b=coef2; c=coef3; } public void calcularRaiz() throws RaicesComplejasException, CoeficienteCeroException { double rad1 = Math.pow(b,2); double rad2 = 4*a*c; if(a==0){ throw new CoeficienteCeroException(); } if(rad1>=rad2) { r1 = (-b+Math.sqrt(rad1-rad2))/(2*a);


33

r2 = (-b-Math.sqrt(rad1-rad2))/(2*a); } else { throw new RaicesComplejasException(); } } public double verA() { return a; } public double verB() { return b; } public double verC() { return c; } public double verR1() { return r1; } public double verR2() { return r2; } public void colocarA(double coef) { a = coef; } public void colocarB(double coef) { b = coef; } public void colocarC(double coef) { c = coef; } } /*Clases Excepciones */ class RaicesComplejasException extends Exception { double rad1, rad2; public RaicesComplejasException() { super("La ecuación presenta raices complejas"); } public RaicesComplejasException(double r1,double r2){ super("La ecuación presenta raices complejas"); rad1 = r1; rad2 = r2; } public double verRad1(){ return rad1; } public double verRad2(){ return rad2; } } class CoeficienteCeroException extends Exception { public CoeficienteCeroException(){ super("La ecuación tiene primer coeficiente en cero"); } } CONSIDERACIONES IMPORTANTES - Las excepciones deben incluirse en el diseño de los objetos que utilice una solución específica. Usualmente permiten manejar de manera mas eficiente los diferentes errores que puedan presentarse en la ejecución del programa. - Los errores que se manejan con excepciones son los errores “interceptables” y de software, caídas de hardware no pueden ser detectados a través de estas herramientas. - Cuando se manejen diferentes excepciones, es mejor utilizar una jerarquía de ellas y hay que tener en cuenta que al capturarlas se debe hacer de la excepción mas específica a la más general. PREGUNTAS PREVIAS - El estudiante deberá tener claro la funcionalidad de la clase Exception y las sentencias try, match, throw, throws y finally en Java.



34

BIBLIOGRAFIA RECOMENDADA

CORREA URIBE, GUILLERMO. Desarrollo de algoritmos y sus aplicaciones en Basic, Pascal y C. Mc Graw Hill. 1992 JOYANES AGUILAR, Luis. Fundamentos de Programación. Algoritmos y Estructura de Datos. Mc Graw Hill. 1996. JOYANES AGUILAR, Luis. ZAHONERO MARTINEZ, Ignacio. Programación en Java 2 Algoritmos, Estructuras de Datos y Programación orientada a Objetos. Mc Graw Hill. 2002. NAUGHTON PATRICK, SCHILDT HERBERT. Java Manual de Referencia. Mc Graw Hill. 1997 WANG PAUL S. Java con programación orientada a objetos y aplicaciones en la WWW. Thomson. 2000

COMPILACION DE EJERCICIOS DE ALGORITMOS³n orientada a Objetos en Java 2 4 ACTIVIDAD 2 Transcriba,...

Documents

Transcript of COMPILACION DE EJERCICIOS DE ALGORITMOS³n orientada a Objetos en Java 2 4 ACTIVIDAD 2 Transcriba,...