Datos Que Maneja Java

Almacenamiento de datos en variables.

El trabajo con datos es parte fundamental de cualquier programa, las variables y sus tipos se encargan de almacenar esa informacin y la memoria que es necesaria para gestionarlas. La manera mas habitual de declarar una variable siempre contiene dos elementos, el tipo de la variable y su nombre y terminando la declaracin con punto y coma. Pero tambin se puede declarar en una misma instruccin mas de una variable del mismo tipo siempre separadas por una coma, al igual que se puede inicializar una variable en el momento de declararla. Inicializar una variable consiste en almacenar un determinado valor en el espacio de memoria reservado para ella. int midato; tipoVariable nombre; int midato1 = 3, midato2 = 6,midato3 = 5;

Los diferentes tipos de variables.

Las variables en Java deben tener un tipo de dato asociado. El tipo de dato de esa variable indicara los valores que la variable puede contener y las operaciones que se pueden realizar con ella. Podemos diferenciar los datos en Java en dos categoras de datos principales: los tipos primitivos y los tipos referenciados. Los tipos primitivos contienen un slo valor e incluyen los tipos como los enteros, coma flotante, los caracteres, de tipo booleano etc... Los tipos referenciados se llaman as porque el valor de una variable de referencia es una referencia (un puntero) hacia el valor real. En Java tenemos los arrays, las clases y los interfaces como tipos de datos referenciados.

Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor, estos
representan un nmero y no pueden representar elementos fraccionarios. Esto puede ser un buen ejemplo de declaracin de tipos de datos enteros: public class enteros { public static void main(String[] arg) { byte midato1 = 1; short midato2 = 100; int midato3 = 10000; long midato4 = 100000000; System.out .println("midato = " + midato1); .... } }

Nmeros en coma flotante: Estos son float y double y pueden almacenar nmeros
en coma flotante y con signo, esto quiere decir que nos permiten representar nmeros decimales. Todos los literales de coma flotante son del tipo double salvo que se especifique lo contrario,

por eso si se intenta asignar un literal en coma flotante a una variable de tipo float el compilador nos dar un error (tipos incompatibles): public class tipoDecinales { public static void main(String[] arg) { float valor; valor = 2.6; System.out .println("Valor del dato= " + valor); //esto dara un error. } } Esto se solucionara indicando que el valor 2.6 es de tipo float con una f al final 2.6f

El tipo Caracter: Estos son de tipo char, que almacena la representacin de los

caracteres (letras o nmeros), un carcter esta almacenado en 16 bits, y siguen un estndar que es el Unicoide. Los caracteres en Java se pueden especificar de forma normal o con secuencias de escape, utilizando la barra invertida "\" seguida de una letra:( \r) o utilizando la barra invertida con una "u" seguida de un numero hexadecimal (\u0000d), en este caso hemos especificado la secuencia de escape \r y su cdigo unicoide correspondiente del retorno de carro. public class tipoCaracter { public static void main(String[] arg) { char valor, valor1, valor2; valor = 'a'; // el literal de tipo carcter tiene que estar encerrado entre comillas simples. valor1 = 65; } } Ejemplo de secuencias de escape: \'...................... comillas simples. \"......................comillas dobles. \\......................barra invertida. \b......................espacio en blanco. \ddd..................carcter octal. \f.......................avance. \n......................nueva lnea. \r.......................retorno de carro. \t.......................tabulador. \uxxxx..............carcter Unicoide

El tipo booleano: Este solo guarda dos valores: verdadero (true) o falso(false), y no
como ocurre en otros lenguajes que toman los valores 0 y 1. Generalmente su utilizacin es muy frecuente para determinar el flujo de los programas: public class tipoBoolean { public static void main(String[] arg) { boolean valor1, valor2 ; valor = true; valor1 = false; if (valor1){ System.out .println("valor1 = verdadero");

} else { System.out .println("valor1 = falso"); } } }

Tabla tipos de datos:

Tipos de datos Byte Short Int Long Float double Char boolean Rango de valores 8-bit complemento a 2 Descripcin Entero de un Byte Nmeros enteros 16-bit complemento a 2 Entero corto 32-bit complemento a 2 Entero 64-bit complemento a 2 Entero largo Nmeros reales 32-bit IEEE 754 64-bit IEEE 754 16-bit Caracter true o false Coma flotante de precisin simple Coma flotante de precisin doble otros tipos Un slo carcter Un valor booleano (verdadero o falso)

Los Arrays (Matrices)

Java dispone de un tipo de dato de posiciones secuenciales y que cuenta de unas comprobaciones exhaustivas para su correcta manipulacin como puede ser la comprobacin de no sobrepasar los limites permitidos en la definicin del array. Los arrays permiten guardar grupos de datos similares, puesto que Java trata los arrays como un tipo de objeto y por lo tanto este se tendra que instanciar con el operador new. Para crear un array tenemos que especificar una variable que se utilizara como ndice para acceder al array y el tipo de datos que este contendr. Antes de poder utilizar un array hay que declararlo, como Java trata este tipo como un objeto, el array en este caso no reserva memoria para contener los datos, sino que solamente localiza memoria para almacenar una referencia al array, por ejemplo cuando se pasa una matriz a un metodo, slo se pasa la referencia y no todos los elementos de la matriz. En este ejemplo he creado un array unidimensional del tipo int que nos permite almacenar diez enteros, pero tambien pueden ser bidimensionales... int miDato[] = new int[5]; Podriamos inicializar el array de la siguiente manera: int miDato[] ={5,9,4,2,7}; String misdatos[] = new String[4]; int misdatos[][] = new int[20][10]; Y para acceder al tercer elemento utilizariamos los indices en este caso seria la posicion elemento -1, pues Java considera el indice del primer elemento como 0. misDatos[] = {"uno","dos","tres","cuatro"); misDatos[1] = "dos" misDatos[0] = "uno" .... Resaltar que todos los objetos array disponen de un metodo publico "lenght()" que se utiliza para determinar su tamao. int array[][] = new int[5][2]; array.length; //= 5 array[0].length; //= 2

Ver ejemplo matrices.java

Tipos de datos string (las cadenas)

En realidad una variable de tipo string, ms que un tpo propio de Java es una clase tratada con todo rigor como un objeto ms de Java. En Java el contenido de las cadenas no se pueden modificar aun que se vuelva a definir la variable String, si en un programa se necesita modificar el contenido de una cadena lo ms correcto seria utilizar la clase StringBuffer, la cual posee muchos metodos para este cometido como append() etc.. En este ejemplo definimos una cadena: String miCadena = "Esto es una cadena"; No podemos modificar su contenido pero si podemos hacer que miCadena se refiera a otra cadena nueva: miCadena = miCadena + "otra cadena"; En este ejemplo muestra el hecho de que una cadena no puede ser modificada, y sin embargo una variable de referencia puede modificarse para que apunte a una nueva cadena para que parezca que se ha modificado la cadena original: class miCadena{ String cadena1 = "PRIMERA CADENA"; String cadena2 = "SEGUNDA CADENA"; public static void main( String args[] ) { miCadena cad = new miCadena(); System.out.println( "Los valores originales de las cadenas son:" ); System.out.println( cad.cadena1 ); System.out.println( cad.cadena2 ); System.out.println( "Reemplaza cadena1 con otra cadena" ); cad.cadena1 = cad.cadena1 + " " + cad.cadena2; System.out.println( "Nuevo valor de cadena1:" ); System.out.println( cad.cadena1 ); } }

Nombres de Variables
Un programa se refiere al valor de una variable por su nombre. Por convencin, en Java, los nombres de las variables empiezan con una letra minscula (los nombres de las clases empiezan con una letra mayscula). Todas los nombres de variables de instancia o de clase deben estar constituidos por palabras con la primera letra de la primera palabra en minscula y la primera letra de las palabras internas en mayscula. Los nombres de variables deben ser cortos y significativos. La eleccin de un nombre de variable debe ser mnemotcnico, es decir, pensado para que un lector casual al verla comprenda su uso. Se deben evitar las variables de una sola letra, excepto en variables temporales de corto uso. Nombres comunes para este tipo de variables son: i, j, k, m y n para enteros; c, d, y e para caracteres. char c; Double myMedida; int j,k;

Manejo de Errores Usando Excepciones Java

Qu es un Excepcin y Por Qu Debo Tener Cuidado?

El trmino excepcin es un forma corta da la frase "suceso excepcional" y puede definirse de la siguiente forma.

Definicin: Una excepcin es un evento que ocurre durante la ejecucin del programa que interrumpe el flujo normal de las sentencias.

Muchas clases de errores pueden utilizar excepciones -- desde serios problemas de hardware, como la avera de un disco duro, a los simples errores de programacin, como tratar de acceder a un elemento de un array fuera de sus lmites. Cuando dicho error ocurre dentro de un mtodo Java, el mtodo crea un objeto 'exception' y lo maneja fuera, en el sistema de ejecucin. Este objeto contiene informacin sobre la excepcin, incluyendo su tipo y el estado del programa cuando ocurri el error. El sistema de ejecucin es el responsable de buscar algn cdigo para manejar el error. En terminologa java, crear una objeto exception y manejarlo por el sistema de ejecucin se llama lanzar una excepcin. Despus de que un mtodo lance una excepcin, el sistema de ejecucin entra en accin para buscar el manejador de la excepcin. El conjunto de "algunos" mtodos posibles para manejar la excepcin es el conjunto de mtodos de la pila de llamadas del mtodo donde ocurri el error. El sistema de ejecucin busca hacia atrs en la pila de llamadas, empezando por el mtodo en el que ocurri el error, hasta que encuentra un mtodo que contiene el "manejador de excepcin" adecuado. Un manejador de excepcin es considerado adecuado si el tipo de la excepcin lanzada es el mismo que el de la excepcin manejada por el manejador. As la excepcin sube sobre la pila de llamadas hasta que encuentra el manejador apropiado y una de las llamadas a mtodos maneja la excepcin, se dice que el manejador de excepcin elegido captura la excepcin. Si el sistema de ejecucin busca exhaustivamente por todos los mtodos de la pila de llamadas sin encontrar el manejador de excepcin adecuado, el sistema de ejecucin finaliza (y consecuentemente y el programa Java tambin). Mediante el uso de excepciones para manejar errores, los programas Java tienen las siguientes ventajas frente a las tcnicas de manejo de errores tradicionales.

Ventaja 1: Separar el Manejo de Errores del Cdigo "Normal" Ventaja 2: Propagar los Errores sobre la Pila de Llamadas Ventaja 3: Agrupar los Tipos de Errores y la Diferenciacin de stos

En la programacin tradicional, la deteccin, el informe y el manejo de errores se convierte en un cdigo muy liado. Por ejemplo, supongamos que tenemos una funcin que lee un fichero completo dentro de la memeoria. En pseudo-cdigo, la funcin se podra parecer a esto.

Ventaja 1: Separar el Manejo de Errores del Cdigo "Normal"

leerFichero { abrir el fichero; determinar su tamao; asignar suficiente memoria; leer el fichero a la memoria; cerrar el fichero; }

A primera vista esta funcin parece bastante sencilla, pero ignora todos aquello errores potenciales. Qu sucede si no se puede abrir el fichero? Qu sucede si no se puede determinar la longitud del fichero? Qu sucede si no hay suficiente memoria libre? Qu sucede si la lectura falla? Qu sucede si no se puede cerrar el fichero?

Para responder a estas cuestiones dentro de la funcin, tendramos que aadir mucho cdigo para la deteccin y el manejo de errores. El aspecto final de la funcin se parecera esto.

codigodeError leerFichero { inicializar codigodeError = 0; abrir el fichero; if (ficheroAbierto) { determinar la longitud del fichero; if (obtenerLongitudDelFichero) { asignar suficiente memoria; if (obtenerSuficienteMemoria) { leer el fichero a memoria; if (falloDeLectura) { codigodeError = -1; } } else { codigodeError = -2; } } else { codigodeError = -3; } cerrar el fichero; if (ficheroNoCerrado && codigodeError == 0) { codigodeError = -4; } else { codigodeError = codigodeError and -4; } } else { codigodeError = -5; } return codigodeError; }

Con la deteccin de errores, las 7 lneas originales (en negrita) se han covertido en 29 lneas de cdigo-- a aumentado casi un 400 %. Lo peor, existe tanta deteccin y manejo de errores y de retorno que en las 7 lneas originales y el cdigo est totalmente atestado. Y an peor, el flujo lgico del cdigo tambin se pierde, haciendo dficil poder decir si el cdigo hace lo correcto (si se cierra el fichero realmente si falla la asignacin de memoria?) e incluso es dficil asegurar que el cdigo continue haciendo las cosas correctas cuando se modifique la funcin tres meses despus de haberla escrito. Muchos programadores "resuelven" este problema ignordolo-- se informa de los errores cuando el programa no funciona. Java proporciona una solucin elegante al problema del tratamiento de errores: las excepciones. Las excepciones le permiten escribir el flujo principal de su cdigo y tratar los casos excepcionales en otro lugar. Si la funcin leerFcihero utilizara excepciones en lugar de las tcnicas de manejo de errores tradicionales se podra parecer a esto.

leerFichero { try { abrir el fichero; determinar su tamao; asignar suficiente memoria; leer el fichero a la memoria; cerrar el fichero; } catch (falloAbrirFichero) { hacerAlgo; } catch (falloDeterminacionTamao) { hacerAlgo; } catch (falloAsignaciondeMemoria) { hacerAlgo; } catch (falloLectura) { hacerAlgo; } catch (falloCerrarFichero) { hacerAlgo;

} }
Observa que las excepciones no evitan el esfuerzo de hacer el trabajo de detectar, informar y manejar errores. Lo que proporcionan las excepciones es la posibilidad de separar los detalles oscuros de qu hacer cuando ocurre algo fuera de la normal. Adems, el factor de aumento de codigo de este es programa es de un 250% -comparado con el 400% del ejemplo anterior.

Una segunda ventaja de las exepciones es la posibilidad del propagar el error encontrado sobre la pila de llamadas a mtodos. Supongamos que el mtodo leerFichero es el cuarto mtodo en una serie de llamadas a mtodos anidadas realizadas por un programa principal: metodo1 llama a metodo2, que llama a metodo3, que finalmente llama a leerFichero.

Ventaja 2: Propagar los Errores sobre la Pila de Llamadas

metodo1 { call metodo2; } metodo2 { call metodo3; } metodo3 { call leerFichero; }

Supongamos tambin que metodo1 es el nico mtodo interesado en el error que ocurre dentro de leerFichero. Tradicionalmente las tcnicas de notificacin del error forzaran ametodo2 y metodo3 a propagar el cdigo de error devuelto por leerFichero sobre la pila de llamadas hasta que el cdigo de error llegue finalmente a metodo1 -- el nico mtodo que est interesado en l.

metodo1 { codigodeErrorType error; error = call metodo2; if (error) procesodelError; else proceder; } codigodeErrorType metodo2 { codigodeErrorType error; error = call metodo3; if (error) return error; else proceder; } codigodeErrorType metodo3 { codigodeErrorType error; error = call leerFichero; if (error) return error; else proceder; }

Como se aprendi anteriormente, el sistema de ejecucin Java busca hacia atrs en la pila de llamadas para encontrar cualquier mtodo que est interesado en manejar una excepcin particular. Un mtodo Java puede "esquivar" cualquier excepcin lanzada dentro de l, por lo tanto permite a los mtodos que estn por encima de l en la pila de llamadas poder capturarlo. Slo los mtodos interesados en el error deben preocuparse de detectarlo.

metodo1 { try { call metodo2;

} catch (excepcion) { procesodelError; } } metodo2 throws excepcion { call metodo3; } metodo3 throws excepcion { call leerFichero; }

Sin embargo, como se puede ver desde este pseudo-cdigo, requiere cierto esfuerzo por parte de los mtodos centrales. Cualquier excepcin chequeada que pueda ser lanzada dentro de un mtodo forma parte del interface de programacin pblico del mtodo y debe ser especificado en la clausula throws del mtodo. As el mtodo informa a su llamador sobre las excepciones que puede lanzar, para que el llamador pueda decidir concienzuda e inteligentemente qu hacer con esa excepcin. Observa de nuevo la diferencia del factor de aumento de cdigo y el factor de ofuscacin entre las dos tcnicas de manejo de errores. El cdigo que utiliza excepciones es ms compacto y ms fcil de entender.

Frecuentemente las excepciones se dividen en categorias o grupos. Por ejemplo, podramos imaginar un grupo de excepciones, cada una de las cuales representara un tipo de error especfico que pudiera ocurrir durante la manipulacin de un array: el ndice est fuera del rango del tamao del array, el elemento que se quiere insertar en el array no es del tipo correcto, o el elemento que se est buscando no est en el array. Adems, podemos imaginar que algunos mtodos querran manejar todas las excepciones de esa categoria (todas las excepciones de array), y otros mtodos podra manejar slo algunas excepciones especficas (como la excepcin de ndice no vlido). Como todas las excepciones lanzadas dentro de los programas Java son objetos de primera clase, agrupar o categorizar las excepciones es una salida natural de las clases y las superclases. Las excepciones Java deben ser ejemplares de la clase Throwable, o de cualquier descendiente de sta. Como de las otras clases Java, se pueden crear subclases de la clase Throwable y subclases de estas subclases. Cada clase 'hoja' (una clase sin subclases) representa un tipo especfico de excepcin y cada clase 'nodo' (una clase con una o ms subclases) representa un grupo de excepciones relacionadas. InvalidIndexException, ElementTypeException, y NoSuchElementException son todas clases hojas. Cada una representa un tipo especfico de error que puede ocurrir cuando se manipula un array. Un mtodo puede capturar una excepcin basada en su tipo especfico (su clase inmediata o interface). Por ejemplo, una manejador de excepcin que slo controle la excepcin de ndice no vlido, tiene una sentencia catch como esta.

Ventaja 3: Agrupar Errores y Diferenciacin

catch (InvalidIndexException e) { . . . }

ArrayException es una clase nodo y representa cualquier error que pueda ocurrir durante la manipulacin de un objeto array, incluyendo aquellos errores representados especficamente por una de sus subclases. Un mtodo puede capturar una excepcin basada en este grupo o tipo general especificando cualquiera de las superclases de la excepcin en la sentencia catch. Por ejemplo, para capturar todas las excepciones de array, sin importar sus tipos especficos, un manejador de excepcin especificara un argumento ArrayException.

catch (ArrayException e) { . . . }

Este manejador podra capturar todas las excepciones de array, incluyendo InvalidIndexException, ElementTypeException, y NoSuchElementException. Se puede descubrir el tipo de excepcin preciso que ha ocurrido comprobando el parmtero del manejador e. Incluso podramos seleccionar un manejador de excepciones que controlara cualquier excepcin con este manejador.

catch (Exception e) { . . .

Los manejadores de excepciones que son demasiado generales, como el mostrado aqu, pueden hacer que el cdigo sea propenso a errores mediante la captura y manejo de excepciones que no se hubieran anticipado y por lo tanto no son manejadas correctamente dentro de manejador. Como regla no se recomienda escribir manejadores de excepciones generales. Como has visto, se pueden crear grupos de excepciones y manejarlas de una forma general, o se puede especificar un tipo de excepcin especfico para diferenciar excepciones y manejarlas de un modo exacto.

Escuela Industrial Superior

Materia: DOCENTE:

Inf-246

Lic. Adrian Quisbert

Estudiante:
Mendoza Gutirrez Juan Carlos

Manejo de Datos en Java

Manejo de Errores Usando Excepciones Java

19-Agosto-2011