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.html
DESARROLLO 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");
}
}
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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.html
DESARROLLO 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;
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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");
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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");
 Programación orientada a Objetos en Java 2 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.
 Programación orientada a Objetos en Java 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
 Programación orientada a Objetos en Java 2 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.html
JButton http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JButton.html
JTextField http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JTextField.html
JLabel http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JLabel.html
DESARROLLO 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);
 Programación orientada a Objetos en Java 2 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));
 Programación orientada a Objetos en Java 2 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();
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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_ordenamiento
DESARROLLO 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);
 Programación orientada a Objetos en Java 2 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 {
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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("");
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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;
 Programación orientada a Objetos en Java 2 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.
 Programación orientada a Objetos en Java 2 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.

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
 Programación orientada a Objetos en Java 2 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.html
DESARROLLO 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);
 Programación orientada a Objetos en Java 2 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
 Programación orientada a Objetos en Java 2 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.

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
 Programación orientada a Objetos en Java 2 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.html
DESARROLLO 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);
 Programación orientada a Objetos en Java 2 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);
 Programación orientada a Objetos en Java 2 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.

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
 Programación orientada a Objetos en Java 2 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