es es es es it es en zh es pt es de es es en en ja ar ar es es nl es es es es es es es es es nl es es en en es en es es es es es es es es nl es en cs es en cs kn fa es kn es en en en en ro kn fa es es es es es es nl es es pt en it pt en en es pt es es es es es es nl es es zh en en es es es es es es nl es es es es es es nl es es es es es es nl es es es es es es nl es es es en es es es es es es nl es es es es es es es nl es es es es es es es nl es es es es es es es nl es es es es en es en kn es te fr kn es es es es pt nl es en es pt es en es en gl tr es kn es es es es es es es nl es es es es es es es es nl es es es es es ru en es es tr en es tr es kn es es es es es es nl es es es es es es es es es nl es es es es es es es es es es es es es es es nl es es es es es es es es es es es es nl es es es es es es es es es es es nl es es es es es es es es es nl es es es es es es en en es en en it de zh kn fr es en it pt en en uk it es uk es es es es es es nl es es en en es kn es kn ru es fr en en es kn kn es es es es es es nl es es es es es es es es es es es es nl es es es es es es es nl es en en es en fr en fr es es es es es es es nl es es es es es es es es nl es es es es es es es es es es es pt es es kn es es es es es en es es es es es es es es es es es en cs es es es cs es es es es es es es es cs es es es es es es es es fr es es es es it es es es es es es es es es es es es es es es es pt es es es es es es es es es es es es es es es it es es de es es es es it es pl es es cs es es it pl es es es es es es es es es es es es es es es es es es
La clase StreamTokenizer de java.io aporta posibilidades más avanzadas que StringTokenizer. pero también es más compleja. Directamente separa en tokens lo que entra por un InputStream o Reader.
Se recuerda que la manera de convertir un String del tipo "3.141592654" en el valor don ble correspondiente es crear un objeto Double a partir de él y luego extraer su valor double: double pi = (Double.valueOf("3.141592654")).doubleValue();
El uso de estas clases facilita el acceso desde teclado, resultando un código más fácil de escribir y de leer. Además tiene la ventaja de que se puede generalizar a la lecmra de archivos.
Publicado por Unknown en 7:07 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
viernes, 30 de mayo de 2014
Método práctico para leer desde teclado - I
Para facilitar la lectura de teclado se puede conseguir que se lea una línea entera con una sola orden si se utiliza un objeto BnfferedReader. El método String readLineQ perteneciente a BufferReader lee todos los caracteres hasta encontrar un V o V y los devuelve como un String (sin incluir V ni V). Este método también puede lanzar java.io.IOException.
System.in es un objeto de la clase InputStream. BnfferedReader pide un Reader en el constructor. El puente de unión necesario lo dará InputStreamReader. que acepta un InputStream como argumento del constructor y es una clase derivada de Reader. Por lo tanto si se desea leer una línea completa desde la entrada estándar habrá que utilizar el siguiente código:
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
Así ya se ha leído una línea del teclado. El thread que ejecute este código estará parado en esta línea hasta que el usuario termine la línea (pulse return). Es más sencillo y práctico que la posibilidad anterior. ¿Y qué hacer con una línea entera?
La clase java.útil.StringTokenizer da la posibilidad de separar una cadena de caracteres en las "palabras" (tokens) que la forman (por defecto, conjuntos de caracteres separados por un espacio, V. V, o por V). Cuando sea preciso se pueden convertir "palabras" en números
Publicado por Unknown en 7:03 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
jueves, 29 de mayo de 2014
Para leer desde teclado se puede utilizar el método System.in.read() de la clase InputStream. Este método lee un carácter por cada llamada. Su valor de retomo es un int. Si se espera cualquier otro tipo hay que hacer una conversión explícita mediante un cast.
Este método puede lanzar la excepción java.io.IOException y siempre habrá que ocuparse de ella, por ejemplo en la forma:
Para leer datos más largos que un simple carácter es necesario emplear un bucle wltile o for y unir los caracteres. Por ejemplo, para leer una línea completa se podría utilizar un bucle wltile guardando los caracteres leídos en un String o en un StringBuffer (más rápido que String):
Una vez que se lee una línea, ésta puede contener números de coma flotante, etc. Sin embargo, hay una manera más fácil de conseguir lo mismo: utilizar adecuadamente la librería java.io.
Publicado por Unknown en 7:00 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
miércoles, 28 de mayo de 2014
Salida de texto y variables por pantalla
Para imprimir en la pantalla se utilizan los métodos System.out.print() y System.out.println(). Son los primeros métodos que aprende cualquier programador. Sus características fundamentales son:
1. Pueden imprimir valores escritos directamente en el código o cualquier tipo de variable primitiva de Java.
String hola = new String("Hola");
2. Se pueden imprimir varias variables en una llamada al método correspondiente utilizando el operador + de concatenación, que equivale a convertir a String todas las variables que no lo sean y concatenar las cadenas de caracteres (el primer argumento debe ser un String).
System.out.println("Hola, Mundo! " + numeroPI);
Se debe recordar que los objetos System.out y System.err son de la clase PrintStream y aunque imprimen las variables de un modo legible. no permiten dar a la salida un formato a medida. El programador no puede especificar un formato distinto al disponible por defecto.
Publicado por Unknown en 6:56 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
martes, 27 de mayo de 2014
ENTRADA Y SALIDA ESTÁNDAR (TECLADO Y PANTALLA)
Existen tres métodos de System que permiten sustituir la entrada y salida estándar. Por ejemplo, se utiliza para hacer que el programa lea de un archivo y no del teclado.
El argumento de setln 0 no tiene que ser necesariamente del tipo InputStream. Es una referencia a la clase base, y por tanto puede apuntar a objetos de cualquiera de sus clases derivadas (como FttelnputStream). Asimismo, el constructor de PrintStream acepta un OutputStreain. luego se puede dirigir la salida estándar a cualquiera de las clases definidas para salida. Si se utilizan estas sentencias con un compilador de Java 1.1 se obtiene un mensaje de método obsoleto (deprecated) al crear un objeto PrintStream. Al señalar como obsoleto el constructor de esta clase se pretendía animar al uso de PrintWriter. pero existen casos en los cuales es imprescindible un elemento PrintStream. Afortunadamente. Java 1.2 ha reconsiderado esta decisión y de nuevo se puede utilizar sin problemas.
Publicado por Unknown en 6:46 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
lunes, 26 de mayo de 2014
La Tabla 9.3 explica las funciones de las clases que alteran el comportamiento de un stream ya definido.
domingo, 25 de mayo de 2014
Clases que iudicau el origen o destino de los datos
La Tabla 9.2 explica el uso de las clases que definen el lugar con que conecta el stream.
Publicado por Unknown en 6:39 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
sábado, 24 de mayo de 2014
Los nombres de las clases de java.io
Las clases de java.io siguen una nomenclaftira sistemática que permite deducir su función a partir de las palabras que componen el nombre, tal como se describe en la Tabla 9.1.
Publicado por Unknown en 6:35 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
viernes, 23 de mayo de 2014
CLASES DE JAVA PARA LECTURA Y ESCRITURA DE DATOS - II
En Java 1.1 aparecieron dos nuevas familias de clases, derivadas de Reader y Writer. que manejan caracteres en vez de bytes. Estas clases resultan más prácticas para las aplicaciones en las que se maneja texto. Las clases que heredan de Reader están incluidas en la Figura 9.3 y las que heredan de Writer en la Figura 9.4.
En las cuatro últimas figuras las clases con fondo gris definen de dónele o a dónde se están enviando los datos, es decir, el dispositivo con que conecta el stream. Las demás (fondo blanco) añaden características particulares a la forma de enviarlos. La intención es que se combinen para obtener el comportamiento deseado.
BufferedReader in = new BufferedReader(new FileReader("autoexec.bat"));
Con esta línea se lia creado un stream que permite leer del archivo autoexec.bat. Además, se ha creado a partir de él un objeto BnfferedReader (que aporta la característica de utilizar buffer6). Los caracteres que lleguen a través del FileReader pasarán a través del BnfferedReader. es decir utilizarán el buffer. A la hora de definir una comunicación con un dispositivo siempre se comenzará determinando el origen o destino de la comunicación (clases en gris) y luego se le aüadiran otras características (clases en blanco). Se recomienda utilizar siempre que sea posible las clases Reader y Writer. dejando las de Java 1.0 para cuando sean imprescindibles. Algunas tareas como la señalización y la compresión necesitan las clases InputStream y OutputStreain.
Publicado por Unknown en 6:25 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
jueves, 22 de mayo de 2014
CLASES DE JAVA PARA LECTURA Y ESCRITURA DE DATOS - I
El package java.io contiene las clases necesarias para la comunicación del programa con el exterior. Dentro de este package existen dos familias de jerarquías distintas para la entrada/salida de datos. La diferencia principal consiste en que una opera con bytes y la otra con caracteres (el carácter de Java está formado por dos bytes porque sigue el código Unicode).
En general, para el mismo fin hay dos clases que manejan bytes (una clase de entrada y otra de salida) y otras dos que manejan caracteres. Desde Java 1.0. la entrada y salida de datos del programa se podía hacer con clases derivadas de InpntStream (para lecmra) y OutputStreain (para escritura). Estas clases tienen los métodos básicos readQ y write() que manejan bytes y que 110 se suelen utilizar directamente. La Figura 9.1 muestra las clases que derivan de InpntStream y la Figura 9.2 las que derivan de OutputStreain.
Publicado por Unknown en 6:19 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
miércoles, 21 de mayo de 2014
ENTRADA/SALIDA DE DATOS EN JAVA 1.1
Los programas necesitan comunicarse con su entorno, tanto para recoger datos e información que deben procesar, como para devolver los resultados obtenidos. La manera de representar estas entradas y salidas en Java es a base de streams (flujos de datos). Un stream es una conexión entre el programa y la fuente o destino de los datos. La informa- ción se traslada en serie (un carácter a continuación de otro) a través de esta conexión. Esto da lugar a una forma general de representar muchos tipos de comunicaciones.
Por ejemplo, cuando se quiere imprimir algo en pantalla, se hace a través de un stream que conecta el monitor al programa. Se da a ese stream la orden de escribir algo y éste lo traslada a la pantalla. Este concepto es suficientemente general para representar la leetura escntura de archivos, la comunicación a través de Internet o la lectura de la información de un sensor a través del puerto en serie.
Publicado por Unknown en 6:14 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
sábado, 17 de mayo de 2014
HERENCIA DE CLASES Y TRATAMIENTO DE EXCEPCIONES
Si un método redefine otro método de una super-clase que utiliza throws, el método de la clase derivada no tiene obligatoriamente que poder lanzar todas las mismas excepciones de la clase base. Es posible en el método de la subclase lanzar las mismas excepciones o menos, pero no se pueden lanzar más excepciones. No puede tampoco lanzar nuevas excepciones ni excepciones de una clase más general.
Se trata de una restricción muy útil ya que como consecuencia de ello el código que funciona con la clase base podrá trabajar automáticamente con referencias de clases derivadas, incluyendo el tratamiento de excepciones, concepto fundamental en la Programación Orientada a Objetos (polimorfismo).
Publicado por Unknown en 6:12 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
viernes, 16 de mayo de 2014
El programador puede crear sus propias excepciones solo con heredar de la clase Exception o de una de sus clases derivadas. Lo lógico es heredar de la clase de la jerarquía de Java que mejor se adapte al tipo de excepción. Las clases Exception suelen tener dos constructores:
1. Un constructor sin argumentos.
2. Un constructor que recibe un String como argumento.
El este String se suele definir un mensaje que explica el tipo de excepción generada. Conviene que este constructor llame al constructor de la clase de la que deriva super(String). Al ser clases como cualquier otra se podrían incluir variables y métodos nuevos. Por ejemplo:
class MiExcepcion extends Exception {
public MiExcepcion{) {          // Constructor por defecto
public MiExcepcion(String s) {  // Constructor con mensaje
Publicado por Unknown en 6:09 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
jueves, 15 de mayo de 2014
El bloque finally {...} debe ir detrás de todos los bloques catch considerados. Si se incluye (ya que es opcional) sus sentencias se ejecutan siempre, sea cual sea el tipo de excepción que se produzca, o incluso si no se produce ninguna. El bloque finally se ejecuta incluso si dentro de los bloques try/catch hay una sentencia continué, break o return. La forana general de una sección donde se controlan las excepciones es por lo tanto:
// Código "vigilado" que puede lanzar una excepción de tipo A, B o C
} catch (A al) {
// Se ocupa de la excepción A
} catch (B bl) {
// Se ocupa de la excepción 3
} catch (C el) {
// Se ocupa de la excepción C
// Sentencias que se ejecutarán en cualquier caso
El bloque finally es necesario en los casos en que se necesite recuperar o devolver a su situación original algunos elementos. No se trata de liberar la memoria reservada con new ya que de ello se ocupará automáticamente el garbage collector.
Como ejemplo se podría pensar en un bloque try dentro del cual se abre un fichero para lectura y escritura de datos y se desea cerrar el fichero abierto. El fichero abierto se debe cerrar tanto si produce una excepción como si no se produce, ya que dejar un fichero abierto puede provocar problemas posteriores. Para conseguir esto se deberá incluir las sentencias correspondientes a cerrar el fichero dentro del bloque finally.
Publicado por Unknown en 9:31 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
miércoles, 14 de mayo de 2014
Existen algunos casos en los cuales el código de un método puede generar una Exception y no se desea incluir en dicho método la gestión del error. Java permite que este método pase o relance (throws) la Exception al método desde el que ha sido llamado, sin incluir en el método los bucles try/catch correspondientes. Esto se consigue mediante la adición de throws más el nombre de la Exception concreta después de la lista de argumentos del método. A su vez el método superior deberá incluir los bloques try/catch o volver a pasar la Exception. De esta forma se puede ir pasando la Exception de un método a otro hasta llegar al último método del programa, el método mainQ. El ejemplo anterior (metodol) realizaba la gestión de las excepciones dentro del propio método. Ahora se presenta un nuevo ejemplo (metodol) que relanza las excepciones al siguiente método:
void método2() throws IOException, MyException { // Código que puede lanzar las excepciones IOException y MyException } // Fin del método2
Según lo anterior, si un método llama a otros métodos que pueden lanzar excepciones (por ejemplo de un package de Java), tiene 2 posibilidades: 1. Capturar las posibles excepciones y gestionarlas. 2. Desentenderse de las excepciones y remitirlas hacia otro método anterior en el stack para éste se encargue de gestionarlas. Si no hace ninguna de las dos cosas anteriores el compilador da un error, salvo que se trate de una RuntirneException.
Publicado por Unknown en 6:00 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
martes, 13 de mayo de 2014
Bloques try y catch
En el caso de las excepciones que no pertenecen a las RuntimeExceptiow y que por lo tanto Java obliga a tenerlas en cuenta habrá que utilizar los bloques try. catch y flnatty.
El código dentro del bloque try está "vigilado": Si se produce una situación anormal y se lanza por lo tanto una excepción el control salta o sale del bloque try y pasa al bloque catch. que se hace cargo de la situación y decide lo que hay que hacer. Se pueden incluir tantos bloques catch como sean necesarios, cada uno de los cuales tratará un tipo de excepción.
Las excepciones se pueden capturar individualmente o en grupo, por medio de una superclase de la que deriven todas ellas. El bloque finally es opcional. Si se incluye sus sentencias se ejecutan siempre, sea cual sea la excepción que se produzca o si no se produce ninguna.
El bloque finally se ejecuta aunque en el bloque try haya un return.
En el siguiente ejemplo se presenta un método que debe "controlar" una IOException relacionada con la lectura ficheros y una MyException propia:
// Código que puede lanzar las excepciones IOException y MyException
} catch (IOException el) {//Se ocupa de IOException simplemente dando aviso
} catch (MyException e2) {
// Se ocupa de MyException dando un aviso y finalizando la función
} finally { // Sentencias que se ejecutarán en cualquier caso
} // Fin del metodol
Publicado por Unknown en 8:58 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
lunes, 12 de mayo de 2014
Como ya se ha visto, ciertos métodos de los packages de Java y algunos métodos creados por cualquier programador producen ("lanzan") excepciones. Si el usuario llama a estos métodos sin tenerlo en cuenta se produce un error de compilación con un mensaje del tipo: "... Exception java.io.IOException must be caugth or it must be declared in the throws clatise of this method\ El programa no compilará mientras el usuario no haga una de estas dos cosas:
1. Gestionar la excepción con una construcción del tipo try {...} catch {...},
2. Re-lanzar la excepción hacia un método anterior en el stack. declarando que su método también lanza dicha excepción, utilizando para ello la construcción throws en el header del método.
El compilador obliga a capturar las llamadas excepciones explícitas. pero no protesta si se captura y luego no se hace nada con ella. En general, es conveniente por lo menos imprimir un mensaje indicando qué tipo de excepción se ha producido.
Publicado por Unknown en 8:51 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
domingo, 11 de mayo de 2014
Cuando en un método se produce una situación anómala es necesario lanzar una excepción. El proceso de lanzamiento de una excepción es el siguiente:
1. Se crea un objeto Exception de la clase adecuada.
2. Se lanza la excepción con la sentencia throw seguida del objeto Exception creado.
// Código que lanza la excepción MyException una vez detectado el error MyException me = new MyException("MyException message"); throw me;
Esta excepción deberá ser capturada (catch) y gestionada en el propio método o en algún otro lugar del programa (en otro método anterior en la pila o stack de llamadas), según se explica en el Apartado 8.3.
Al lanzar una excepción el método termina de inmediato, sin devolver ningún valor. Solamente en el caso de que el método incluya los bloques try/catch/finally se ejecutará el bloque catch que la captura o el bloque finally (si existe).
Todo método en el que se puede producir uno o más tipos de excepciones (y que no utiliza directamente los bloques try/catch/finally para tratarlos) debe declararlas en el encabezamiento de la función por medio de la palabra throws. Si un método puede lanzar varias excepciones, se ponen detrás de throws separadas por comas, como por ejemplo: public void leerFichero(String fich) throws EOFException, FileNotFoundException {...} Se puede poner únicamente una superclase de excepciones para indicar que se pueden lanzar excepciones de cualquiera de sus clases derivadas.
El caso anterior sería equivalente a: public void leerFichero(String fich) throws IOException {...}
Las excepciones pueden ser lanzadas dilectamente por leerFichero() o por alguno de los métodos llamados por leerFicherof). ya que las clases EOFException y FileNotFoundException derivan de IOException.
Se recuerda que no hace falta avisar de que se pueden lanzar objetos de la clases Error o RuntimeException (excepciones implícitas).
Publicado por Unknown en 8:26 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
sábado, 10 de mayo de 2014
EXCEPCIONES ESTÁNDAR DE JAVA - II
El caso de RuntimeException es un poco especial. El propio Java durante la ejecución de un programa chequea y lanza automáticamente las excepciones que derivan de RuntimeException. El programador no necesita establecer los bloques tryícatch para controlar este tipo de excepciones. Representan dos casos de errores de programación:
1. Un error que normalmente no suele ser chequeado por el programador, como por ejemplo recibir una referencia nuil en un método.
2. Un error que el programador debería haber chequeado al escribir el código, como sobrepasar el tamaño asignado de mi array (genera un ArraylndexOutOfBoundsException automáticamente).
En realidad sería posible comprobar estos tipos de errores, pero el código se complicaría excesivamente si se necesitara chequear continuamente todo tipo de errores (que las referencias son distintas de nuil, que todos los argumentos de los métodos son correctos, y un largo etcétera). Las clases derivadas de Exception pueden pertenecer a distintos packages de Java. Algunas perenecen a java.lang (Throwable. Exception. RuntimeException, ...); otras a java.io (EOFException. FileNotFoundException. ...) o a otros packages. Por heredar de Throwable todos los tipos de excepciones pueden usar los métodos siguientes:
1. String getMessage() Extrae el mensaje asociado con la excepción.
2. String toString() Devuelve un String que describe la excepción.
3. voidprintStackTrace() Indica el método donde se lanzó la excepción.
Publicado por Unknown en 8:22 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
viernes, 9 de mayo de 2014
EXCEPCIONES ESTÁNDAR DE JAVA - I
Los errores se representan mediante dos tipos de clases derivadas de la clase Throwable: Error y Exception. La siguiente figura muestra parcialmente la jerarquía de clases relacionada con Throwable\
La clase Error está relacionada con errores de compilación, del sistema o de la JVM. De ordinario estos errores son irrecuperables y no dependen del programador ni debe preocuparse de capturarlos y tratarlos. La clase Exception tiene más interés. Dentro de ella se puede distinguir:
1. RuntimeExceptíon: Son excepciones muy frecuentes, de ordinario relacionadas con errores de programación. Se pueden llamar excepciones implícitas.
2. Las demás clases derivadas de Exception son excepciones explícitas. Jara obliga a tenerlas en cuenta y chequear si se producen. El caso de RuntimeException es un poco especial. El propio Java durante la ejecución de un programa chequea y lanza automáticamente las excepciones que derivan de RuntimeException. El programador no necesita establecer los bloques try;catch para controlar este tipo de excepciones. Representan dos casos de errores de programación:
1. Un error que normalmente no suele ser chequeado por el programador, como por ejemplo recibir una referencia nuil en un método.
2. Un error que el programador debería haber chequeado al escribir el código, como sobrepasar el tamaño asignado de mi array (genera un ArraylndexOutOfBoundsException automáticamente).
Publicado por Unknown en 10:39 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
jueves, 8 de mayo de 2014
A diferencia de otros lenguajes de programación orientados a objetos como C/C++, Java incorpora en el propio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente solo los errores de sintaxis son detectados durante este periodo. El resto de problemas surgen durante la ejecución de los programas. En el lenguaje Java. una Exception es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la ejecución del programa. En este caso conviene terminar ordenadamente y dar un mensaje explicando el tipo de error que se ha producido. Otras, como por ejemplo no encontrar mi fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error (indicando una nueva localización del fichero no encontrado). Un buen programa debe gestionar correctamente todas o la mayor parte de los errores que se pueden producir. Hay dos "estilos*' de hacer esto:
1. A la "antigua usanza": los métodos devuelven un código de error. Este código se chequea en el entorno que ha llamado al método con una serie de if elseif.... gestionando de fonna diferente el resultado conecto o cada uno de los posibles errores. Este sistema resulta muy complicado cuando hay varios niveles de llamadas a los métodos.
2. Con soporte en el propio lenguaje: En este caso el propio lenguaje proporciona construcciones especiales para gestionar los errores o Exceptions. Suele ser lo habitual en lenguajes modernos, como C++. Visual Basic y Java.
En los siguientes apartados se examina cómo se trabaja con los bloques y expresiones try, catch. throw. throws y finally. cuándo se deben lanzar excepciones, cuándo se deben capturar y cómo se crean las clases propias de tipo Exception.
Publicado por Unknown en 10:35 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
miércoles, 7 de mayo de 2014
APPLETS QUE TAMBIÉN SON APLICACIONES
Es muy interesante desarrollar aplicaciones que pueden funcionar también como applets y viceversa. En concreto, para hacer que un applet pueda ejecutarse como aplicación pueden seguirse las siguientes instrucciones:
1. Se añade un método mainf) a la clase MiApplet (que deriva de Applet)
2. El método main() debe crear un objeto de la clase MiApplet e introducirlo en un Frame.
3. El método main() debe también ocuparse de hacer lo ()ue haría el browser, es decir, llamar a los métodos init() y start() de la clase MiApplet.
4. Se puede añadir también una static inner class ()ue derive de WindowAdapter y ()ue gestione el evento de cerrar la ventana de la aplicación definiendo el método ivindowClosingO. Este método llama al método System.exit(O). Según como sea el applet. el método windowClosing() previamente deberá también llamar a los métodos MiApplet.stop() y MiApplet.destroy(). cosa ()ue para las applets se encarga de hacer el browser. En este caso conviene ()ue el objeto de MiApplet creado por main() sea static. en lugar de una variable local.
A continuación se presenta un ejejinplo:
public class MiApplet extends Applet {
public void init() {...}
// clase para cerrar la aplicación
static class WL extends WindowsAdapter {
public void windowClosing(WindowEvent e) {
} // fin de WindowAdapter
public static void main(String[] args) {
static MiApplet unApplet = new MiApplet();
Frame unFrame = new Frame("MiApplet");
} // fin de la clase MiApplet
Publicado por Unknown en 10:33 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
martes, 6 de mayo de 2014
UTILIZACIÓN DE THREADS EN APPLETS - II
Un ejemplo de tarea ()ue se realiza una sola vez es la carga de imágenes *.gif o *.jpeg. ()ue ya se realiza automáticamente en un thread especial. Sin embargo, los sonidos no se cargan en threads especiales de fonna automática; los debe crear el programador para cargarlos en "background*'. Este es un caso típico de programa producer- consumer: el thread es el producer y el applet el consumer. Las threads deben estar sincronizadas, para lo que se utilizan los métodos waitQ y notifyAllf).
A continuación se presenta un ejemplo de thread con tarea repetitiva:
public void start() {
if (repetitiveThread == nuil) {
repetitiveThread = new Thread(this); // se crea un nuevo thread
repetitiveThread.start(); // se arranca el thread creado: start() llama a run()
public void stop() {
repetitiveThread — nuil; // para parar la ejecución del thread
public void run() {
while (Thread.currentThread() == repetitiveThread) {
... // realizar la tarea repetitiva.
El método runf) se detendrá en cuanto se ejecute el método stop(). porque la referencia al thread está a nuil.
Publicado por Unknown en 10:27 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
lunes, 5 de mayo de 2014
UTILIZACIÓN DE THREADS EN APPLETS - I
Un applet puede ejecutarse con varias threads. y en muchas ocasiones será necesario o conveniente hacerlo así. Hay que tener en cuenta que un applet se ejecuta siempre en un browser (o en la aplicación appletviewer).
Así. las threads en las que se ejecutan los métodos mayores -init(). startQ. stop() y destroyQ- dependen del browser o del entorno de ejecución. Los métodos gráficos -paintQ. updateQ y repaint()- se ejecutan siempre desde una thread especial del AWT. Algunos browsers dedican un thread para cada applet en una misma página: otros crean mi grupo de threads para cada applet (para poderlas matar al mismo tiempo, por ejemplo).
En cuelquier caso se garantiza que todas las threads creadas por los métodos mayores pertenecen al mismo grupo. Se deben introducir threads en applets siempre que haya tareas que consuman mucho tiempo (cargar una imagen o un sonido, hacer una conexión a Internet, ...). Si estas tareas pesadas se ponen en el método init() bloquean cualquier actividad del applet o incluso de la página HTML hasta que se completan. Las tareas pesadas pueden ser de dos tipos:
• Las que solo se hacen una vez.
• Las que se repiten muchas veces.
Un ejemplo de tarea ()ue se repite muchas veces puede ser una animación. En este caso, la tarea repetitiva se pone dentro de un bucle while o do...while. dentro del thread. El thread se debería crear dentro del método start() del applet y destruirse en stop(). De este modo, cuando el applet no está visible se dejan de consumir recursos.
Al crear el thread en el método start() se pasa una referencia al applet con la palabra this. ()ue se refiere al applet. El applet deberá implementar la interfaz Runnable. y por tanto debe definir el método run(). ()ue es el centro del Thread (ver Apartado 6.1.2. en la página 126).
Publicado por Unknown en 10:19 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
domingo, 4 de mayo de 2014
OBTENCIÓN DE LAS PROPIEDADES DEL SISTEMA
Un applet puede obtener información del sistema o del entorno en el que se ejecuta. Solo algunas propiedades del sistema son accesibles.
Para acceder a las propiedades del sistema se utiliza un método static de la clase System: String salida = System. getProperty("file.separator"); Los nombres y significados de las propiedades del sistema accesibles son las siguientes:
Publicado por Unknown en 10:17 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
sábado, 3 de mayo de 2014
Las applets admiten los formatos JPEG y GIF para representar imágenes a partir de ficheros localizados en el servidor. Estas imágenes se pueden cargar con el método getlmagef) de la clase Applet. que puede tener las formas siguientes:
public Image getlmage(URL url)
public Image getlmage(URL url, String name)
Estos métodos devuelven el control inmediatamente. Las imágenes de cargan cuando se da la orden de dibujar las imágenes en la pantalla. El dibujo se realiza entonces de fonna incremental. a medida que el contenido va llegando. Para dibujar imágenes se utiliza el método drawlmageQ de la clase Graphics. que tiene las formas siguientes:
public abstract boolean drawImage(Image img, int x, int y.
Color bgcolor, ImageObserver observer)
public abstract boolean drawImage(Image img, int x, int y, int width, int height,
Color bgcolor, ImageObserver observer)
El primero de ellos dibuja la imagen con su tamaño natural, mientras que el segundo realiza un cambio en la escala de la imagen. Los métodos drawlmagef) van dibujando la parte de la imagen que ha llegado, con su tamaño, a partir de las coordenadas (x. y) indicadas, utilizando bgcolor para los pixels transparentes. Estos métodos devuelven el control inmediatamente, aunque la imagen no esté del todo cargada. En este caso devuelve false.
En cuanto se carga una parte adicional de la imagen, el proceso que realiza el dibujo avisa al ImageObsen'er especificado. ItnageObsen'er es una interfaz implementada por Applet que permite seguir el proceso de carga de una imagen.
Publicado por Unknown en 10:11 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
viernes, 2 de mayo de 2014
La clase Applet y la interfaz AudioClips permiten utilizar sonidos en applets. La Tabla 7.1 muestra
algunos métodos interesantes al respecto. Respecto a la carga de sonidos, por lo general es mejor cargar los sonidos en un thread distinto (creado en el método init()) que en el propio método init(). que tardaría en devolver el control y permitir al usuario empezar a interaccionar con el applet.
Si el sonido no ha terminado de cargarse (en la thread especial para ello) y el usuario interacciona con el applet para ejecutarlo, el applet puede darle un aviso de que no se ha terminado de cargar.
Publicado por Unknown en 10:08 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
jueves, 1 de mayo de 2014
COMUNICACIÓN DEL APPLET CON EL BROWSER - II
Para mostrar documentos HTML en una ventana del browser se pueden utilizar los métodos siguientes: Para mostrar documentos HTML en una ventana del browser se pueden utilizar los métodos siguientes:
• showDocumentfURL miUrl, [String target]). que muestra un documento HTML en el frawe del browser indicado por target (ñame. _top. _parent. Jblartk. _self).
• showDocumentfURL miUrl). que muestra un documento HTML en la ventana actual del browser. Un applet puede conseguir información de otras applets que están corriendo en la misma página del browser. enviarles mensajes y ejecutar sus métodos. El mensaje se envía invocando los métodos del otro applet con los argumentos apropiados. Algunos browsers exigen, para que las applets se puedan comunicar, que las applets provengan del mismo browser o incluso del mismo directorio (que tengan el mismo codebase). Por ejemplo, para obtener información de otras applets se pueden utilizar los métodos:
• getApplet (String ñame), que devuelve el applet llamada ñame (o nuil si no la encuentra). El nombre del applet se pone con el atributo opcional ÑAME o con el parámetro ÑAME.
• get Applets Q. que devuelve una enumeración con todas las applets de la página. Para poder utilizar todos los métodos de un applet que se está ejecutando en la misma página HTML (y no solo los métodos comunes heredados de Applet). debe hacerse un cast del objeto de la clase Applet que se obtiene como valor de retomo de getApplet() a la clase concreta del applet.
Para que pueda haber respuesta (es decir, comunicación en los dos sentidos), el primer applet que envía un mensaje debe enviar una referencia a sí misma por medio del argumento this.
Publicado por Unknown en 10:02 No hay comentarios:
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
Entradas más recientes Entradas antiguas Inicio
Suscribirse a: Entradas (Atom)
Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una unidad la variable a la que se aplica, mien...
Los Wrappers (envoltorios) son clases diseñadas para ser un complemento de los tipos primitivos. En efecto, los tipos primitivos son los ún...
Redefinición de métodos heredados
Una clase puede redefinir (volver a definir) cualquiera de los métodos heredados de su super-clase que 110 sean final. El nuevo método sust...
La localización mas adecuada para una nueva unidad productiva debe orientarse hacia los mismos objetivos que el tamaño óptimo, es decir haci...
Maps y SortedMaps - Part 1
Un Map es una estructura de datos agrupados en parejas clave/valor. Pueden ser considerados como una tabla de dos columnas. La clave debe ...
Técnicas para Recopilación de Antecedentes
Para obtener antecedentes como las que acabamos de mencionar se han desarrollado técnicas de distinto grado de complejidad. Estas técnicas...
Clases TextArea y TextField
Ambas componentes heredan de la clase TextComponent y muestran texto seleccionable y editable. La diferencia principal es que TextField sól...
LECTURA DE UN ARCHIVO EN UN SERVIDOR DE INTERNET
Teniendo la dilección de Internet de un archivo, la librería de Java permite leer este archivo utilizando 1111 stream. Es una aplicación mu...
Insertar un manejador de evento a la etiqueta A (enlace) que hay en la página
Ahora que ya sabemos cómo y cuando debemos ejecutar las acciones de jQuery que alteren la funcionalidad, contenidos o aspecto de la página,...
Recordemos cómo será la creación de una base de datos con SQL:
1) En primer lugar, tendremos que dar nombre a la base de datos, con la sentencia CREATE DATABASE, si la hay, o con CREATE SCHEMA. 2) A con...
Método práctico para leer desde teclado - II
Método práctico para leer desde teclado - I
Salida de texto y variables por pantalla
ENTRADA Y SALIDA ESTÁNDAR (TECLADO Y PANTALLA)
Clases que añaden características
Clases que iudicau el origen o destino de los datos
Los nombres de las clases de java.io
CLASES DE JAVA PARA LECTURA Y ESCRITURA DE DATOS - II
CLASES DE JAVA PARA LECTURA Y ESCRITURA DE DATOS - I
ENTRADA/SALIDA DE DATOS EN JAVA 1.1
HERENCIA DE CLASES Y TRATAMIENTO DE EXCEPCIONES
Bloques try y catch
EXCEPCIONES ESTÁNDAR DE JAVA - II
EXCEPCIONES ESTÁNDAR DE JAVA - I
APPLETS QUE TAMBIÉN SON APLICACIONES
UTILIZACIÓN DE THREADS EN APPLETS - II
UTILIZACIÓN DE THREADS EN APPLETS - I
OBTENCIÓN DE LAS PROPIEDADES DEL SISTEMA
COMUNICACIÓN DEL APPLET CON EL BROWSER - II
Acerca de Este Blog
Mi lista de blogs
NOTICIAS DE TECNOLOGIA Y TELECOMUNICACIONES
Honor Las ventajas de comprar un smartphone con servicio técnico y garantía en Bolivia - HONOR se apega a los estándares de calidad más exigentes de la industria global. Además, brinda un sistema de asistencia personalizado para entregar la ...
Rata de bombeo y eficiencia - Calculo de eficiencia de las bombas - Bomba Triplex - Volumen del cilindro = π.r².L Pi, conversión de radio a diámetro, unidades de conversión y el numero de cámaras son todas calculadas por la siguientes e...
LO QUE SE DE BLOGS
Video CONFIGURA TU ROUTER TP-LINK WR940N COMO REPETIDOR SIN CABLES 100% Inhalambrico -
Telefonos Moviles y Aplicaciones
Video Desayuno de Samsung para los Periodistas, los Galaxy S20 -
Lentes inteligentes que cambian su graduación - Cuando se alcanza cierta edad, la vista comienza a fallar. Muchas personas también sufren problemas de visión de nacimiento, o por una lesión. Si ves mal d...