PARA APLICAR PROGRAMAS DE JAVA

http://luanunp.blogspot.com/2008/10/solucion-ejecutable-jar-con-jcreator.html

PERMUTACIONES

Factorial de un número natural
Es el producto de los “n” factores consecutivos desde “n” hasta 1. El factorial de un número se denota por n!.


1! = 1
Variaciones
Se llama variaciones ordinarias de m elementos tomados de n en n (m ≥ n) a los distintos grupos formados por n elementos de forma que:
No entran todos los elementos.
Sí importa el orden.
No se repiten los elementos.

También podemos calcular las variaciones mediante factoriales:

Las variaciones se denotan por
Variaciones con repetición
Se llama variaciones con repetición de m elementos tomados de n en n a los distintos grupos formados por n elementos de manera que:
No entran todos los elementos si m > n. Sí pueden entrar todos los elementos si m ≤ n
Sí importa el orden.
Sí se repiten los elementos.

Permutaciones
Sí entran todos los elementos.
Sí importa el orden.
No se repiten los elementos.

Combinaciones
Se llama combinaciones de m elementos tomados de n en n (m ≥ n) a todas las agrupaciones posibles que pueden hacerse con los m elementos de forma que:
No entran todos los elementos.
No importa el orden.
No se repiten los elementos.

También podemos calcular las combinaciones mediante factoriales:

Binomio de Newton
La fórmula que nos permite hallar las potencias de un binomio se conoce como binomio de Newton.

PAGINA DE HTML-KIT.PARA DISEÑAR PAG. WEB

http://www.comocreartuweb.com/html-kit-tutorial/tutorial-html-kit-introducion.html

PAGINA DE BASE DE DATOS Y ARCHIVOS:
http://ict.udlap.mx/people/carlos/is341/bases01.html

1. Introducción
1.1 Aplicación de bases de datos

1.1.1 Antecedentes

La información ha llegado a ser el eje que mueve a la mayoría de las organizaciones hoy día
La cantidad de información que se maneja actualmente es en extremo enorme.
Se tiene la necesidad de tenerla perfectamente organizada de manera que pueda ser accesada fácilmente y por otro lado se debe tener disponible todo el tiempo (sistemas 24x7)
La solución: las personas de computación han desarrollado conceptos, técnicas y sistemas bajo un tópico conocido como "bases de datos" (databases)

1.1.2 Definición

Surgen entonces los primeros conceptos:

Dato: es la representación física de un aspecto de la realidad
Base de datos: conjunto de datos, que pueden estar organizados y/o interrelacionados de alguna manera con un propósito particular

DBMS*: Sistema Manejador de Bases de Datos (DataBase Manager/Management System) es una colección e datos interrelacionados y un conjunto de programas para accesarlos. En otras palabras un sistema para crear, manipular y aprovechar bases de datos.*Algunos lo llaman SGBD (Sistema Gestionador de Bases de Datos)

1.1.3 Escenarios de bases de datos

Podemos afirmar que las bases de datos están en todas partes, cualquier problema que podamos pensar podemos asociar una base de datos

Bancos: cuentas, transacciones, fondos de ahorro, SAR
Aerolíneas: reservaciones, pasajes, suministros, personal de vuelos
Escuelas: cursos, calificaciones, horarios
Negocios: compras, proveedores, ventas, clientes, devoluciones
Fábricas: flujo de procesos, almacenes, envíos
Recursos Humanos: empleados, puestos, salarios, impuestos, prestaciones
Curiosamente el uso de las bases de datos puede llegar a ser tan transparente que para algunos pareciera que no existen como en las transacciones de web o el cajero del banco (ATM).

1.2 Sistemas de bases de datos vs sistemas de archivos(Databases vs File Systems)

El camino hacia las bases de datos ha sido largo y en el trayecto se han desarrollado un gran número de técnicas que forman los cimientos de las bd y de otras tecnologías.
Dentro de estas técnicas tenemos:
Archivos, Sistemas de Archivos, Acceso y manipulación de archivos, Indices
Pero...
por qué no es suficiente utilizar las herramientas anteriores y es necesario emplear un DBMS ?no es lo mismo ?cuál es la diferencia ?
No es lo mismo, un sistemas de archivos aún cuando pensemos que contiene lógicamente archivos y que se cuenta con índices para accesar los registros en ellos, carece de mucha funcionalidad que se emplea en la mayoría de las aplicaciones, aunque como se mencionó anteriormente, un DBMS emplea sistemas de archivos e índices para la manipulación de datos.
La funcionalidad adicional que provee un DBMS surge en base de algunos inconvenientes al emplear sistemas de archivos únicamente:
Redundancia de datos e inconsistencias (Redundancy and Inconsistency): formatos, duplicidad de información (alto costo de almacenamiento y acceso) e incongruencia entre datos o copias de datos a lo largo del sistema.
Dificultad de acceso (Access): en un sistema de archivos no se pueden obtener aquellos datos que no estén implantados en un programa, se carece de niveles de abstracción.
Aislamiento de datos (Isolation): debido al factor tiempo y los requerimientos que van surgiendo se puede llegar a tener un problema al intentar separar un conjunto de datos porque ya se tiene un enredo en los archivos y se podría dar el caso en que dos usuarios estén manipulando la misma información pero de distinta manera.

Integridad (Integrity): si queremos asociar dos datos, por ejemplo un alumno con una materia que esté cursando, debemos asegurarnos que ambas entidades existan, de lo contrario el alumno parecerá cursando un curso fantasma y viceversa. Para ello se emplean "restricciones de consistencia" (consistency constraints)

Atomicidad (Atomicity): el problema clásico de transacciones bancarias, u ocurre toda la transacción o no ocurre nada pero no puede quedarse a medias.

Acceso concurrente (Concurrent-access): garantizar un buen tiempo de respuesta, que todos los usuarios puedan accesar y/o modificar la información; esto no es fácil porque también hay que considerar que aunque los datos son los mismos, las aplicaciones no necesariamente lo son.

Seguridad (Security): no toda la información debe estar disponible a todos los usuarios, algunos usuarios solo tendrán permisos de lectura, esto es relativamente sencillo de resolver aplicando "roles" pero el problema aumenta cuando en luegar de pensar en terminos de usuarios pensamos en terminos de aplicaciones ya que el número de roles y sus combinaciones aumenta y mantener las restricciones de seguridad se torna complicado.
Podemos entonces extender la definición de DBMS como un sistema robusto que es capaz de emplear algoritmos de almacenamiento y recuperación de información para poder implementar un modelo de datos de manera física garantizando que todas las transacciones que se realizan con respecto a dichos datos sean "ácidas" (Atomicity, Consistency, Isolation, Durability).

1.3 Vistas de datos
Una de las ventajas de emplear una base de datos es que los datos se pueden ver a distintos niveles de abstracción, separando por ejemplo detalles de almacenamiento y mantenimiento.
Niveles de abstracción:

Nivel Físico: el más bajo y define cómo los datos son almacenados
Nivel Lógico: define qué datos hay almacenados y cómo se relacionan
Nivel de visión: más alto nivel, define vistas de "partes" de la base de datos, esto para restringir el acceso a determinados datos o bien para simplificar la interacción

1.4 Modelos de datos

1.4.1 Definición
Un modelo de datos es una colección de herramientas conceptuales para describir datos, sus relaciones, semántica y restricciones de consistencia
Exiten 3 niveles de modelado:
Conceptual
Modelo Entidad-Relación
Lógico
Modelo Relacional
Físico
Implementación en el DBMS

LAS FASES DEL PROCESO DE PROGRAMACIÓN
A fin de poder asegurar que un sistema cumpla con el sistema requerido por el cliente, no basta simplemente con un levantamiento y diseño funcional, especificación de los casos de uso y descripción de procesos. Es imprescindible el la comunicación con el Equipo de Desarrollo. Es decir, con la participación del programador.
Para DocIRS, un programador debe participar del análisis de los problemas delineados por el ingeniero de procesos en términos de los requerimientos detallados. Desde ahí va diseñando la estrategia a seguir en la estructura del programa. Codifica las instrucciones implementando algoritmos en el lenguaje de programación adecuado. Verifica la lógica del programa preparando rutinas de prueba. Revisa, depura y corrige los programas. Evalúa y modifica los programas existentes para tomar en cuenta los cambios producidos en los requerimientos del sistema. Finalmente prepara el documento base de la ayuda de usuarios.
Nótese que un programador debe comprender y expresarse a través de un lenguaje de alta programación. Este conocimiento puede ser por oficio práctico, intuición o por estudio formales . Los lenguajes de programación utilizan formalización matemática, tanto en su estructura como en su simbología. Sus convenciones y usos se realizan especialmente utilizando leyes algebraicas, tales como la Lógica de Bool, particularmente Algebra de Proposiciones, Teoría de Conjuntos, Funciones (algebra y sus propiedades), Series Numéricas, Recursividad, etc. y por tanto un programador trabaja fundamentado en conceptos matemáticos.
Cualquier consideración del proceso de programación mismo debe comenzar aislando cada una de sus fases componentes. Se identifica las siguientes cinco fases:
1. Análisis del problema2. Desarrollo de la solución3. Construcción de la solución en forma de programa4. Prueba5. Mantenimiento

El análisis del problema se refiere a la etapa del proceso en la que el programador toma conocimiento del problema antes de proceder a desarrollar una solución. Es un proceso de “introducción”, de naturaleza cognoscitiva y muy difícil de describir. Son demasiados los programadores que recorren esta etapa muy rápidamente, lo que hace que entiendan mal o malinterpreten las especificaciones. Algunos programadores prefieren devolver las especificaciones del problema al diseñador, para reducir la posibilidad de malentendido. Los errores que se cometen en esta etapa son con mucha frecuencia difíciles de detectar y consumen mucho tiempo cuando se les trata de remediar en las etapas posteriores.
La segunda etapa, el desarrollo de la solución, es eminentemente creativa. Aquí se debe hacer hincapié en la formulación del algoritmo antes que en su codificación en un lenguaje de programación en particular. Aunque algunos podrían argumentar que la habilidad para resolver problemas es algo innato y que es difícil educar o mejorar la creatividad, existe suficiente evidencia en el sentido de que algunos enfoques sistemáticos tienen mucho valor.
También es una alternativa recurrir a desarrollos anteriores hechos para otras soluciones (la librería propia) y desde allí comenzar el proceso de creación. Siempre y cuando el problema central haya sido resuelto realmente, puesto que si no es así esta situación acarreará problemas en las fases posteriores. Otro punto de suma importancia en esta etapa, es el definir la arquitectura del modelo de datos, las relaciones lógicas básicas y las pautas a seguir en las transacciones con la base(s) de datos que tendrá la aplicación. (Asumimos que en esta etapa, ya debe estar delineado el conjunto de clases de funciones que tendrá el sistema, y que posteriormente se transformarán en las entidades u objetos).
La tercera etapa identificada es la construcción de la solución desarrollada en forma de un programa real (o código). Considerando que la solución ha sido bien definida, este proceso es casi directo, pues es un proceso mental inmediato de las fases anteriores. Mediante rutinas, funciones, script, procedimientos y reglas del lenguaje de programación, se va ensamblando la aplicación de acuerdo con los estándares de estilo y de estructura.
La cuarta fase se refiere a la revisión y corrección del programa sea en de Ambiente de Desarrollo o Prueba. Es inevitable realizar pruebas mientras va construyendo las componentes de la aplicación. Todo programador experto prueba no sólo mentalmente cada instrucción cuando la está escribiendo, sino que va ejecutando las rutinas de cualquier módulo o sección de su programa antes de proceder a pasar a Ambiente de Prueba, donde probarán los que establecieron el diseño funcional del sistema. La prueba de las aplicaciones nunca es sencilla; Es natural que las pruebas muestran la presencia de errores y nunca se puede demostrar la ausencia de ellos. Una prueba con éxito sólo significa que no se detectaron errores bajo las circunstancias especiales de dicha prueba; esto no significa nada frente a otras circunstancias. Aunque se sabe, que el programado repite múltiples veces sus formas de prueba de lo que construye y siempre dejará espacios que encontrará un tercero.
En teoría, la (única manera en que las pruebas pueden demostrar que un programa es correcto es que se examinen todos los casos posibles (lo cual se conoce como una prueba exhaustiva), situación que es imposible técnicamente, incluso para los programas más simples.
Significa esto que las pruebas son inútiles? Definitivamente, no. El programador puede hacer mucho por reducir el número de casos a probar a partir del número requerido por una prueba exhaustiva. Tomando con mucho cuidado y seleccionando apropiadamente el diseño de los casos de prueba, puede reducirse el número de ellos, haciendo posible una prueba razonable con un número relativamente pequeño de casos.
La prueba de un programa es una tarea tan creativa como su mismo desarrollo, por lo que debe considerarse con la misma diligencia y entusiasmo. Algunos principios de las pruebas son claros: trátese de iniciar las pruebas de un programa con una mentalidad de saboteador, casi disfrutando la tarea de buscar un error. Hay que sospechar de todo. Los casos de prueba deberían diseñarse a partir de las especificaciones originales, en lugar del programa mismo; si se efectúan a partir del programa, algunos aspectos del problema que han sido pasados por alto durante su construcción también lo serán cuando se le pruebe. Para reducir las posibilidades de que esto ocurra en las compañías profesionales de programación, los encargados suelen insistir en que sean personas diferentes a los programadores originales quienes tengan a su cargo la prueba de los programas. Los usuarios de los programas disponen, con frecuencia, de sus propios datos de prueba desarrollados, independientemente, para usarlos cuando el programa esté a su disposición. Téngase en cuenta que la contraparte del cliente evalúa muy mal al equipo de desarrollo o proveedor cuyas aplicaciones no son capaces de pasar las pruebas de los usuarios. Por eso de cualquier forma que se haga, una prueba completa antes de pasar a la revisión del cliente es una parte esencial de los proyecto de programación.
La quinta etapa del proceso de programación, el mantenimiento del programa. Sin embargo, su importancia en el trabajo real nunca debe despreciarse. En general, el costo de mantenimiento de un programa de uso generalizado es del orden del 40% o más del costo de su desarrollo”. Al contrario de lo que sucede con el mantenimiento de hardware, el mantenimiento de los programas no se refiere a la reparación o cambio de partes deterioradas, sino a las modificaciones que deben hacerse a los defectos del diseño, lo cual puede incluir el desarrollo de funciones adicionales para reunir nuevas necesidades. El tiempo de los desarrolladores para producir nuevos programas se ve siempre afectado por el tiempo que deben dedicar al mantenimiento de los programas viejos. La inevitabilidad del mantenimiento debe reconocerse y, en consecuencia, deben realizarse las acciones que sean necesarias para reducir el tiempo que ello implica.

Programa en java

class CCalcular
{
public static void main(String[] args)
{
float dato1 , dato2 , dato3 , dato4 , resultado;
float result;
dato1 = 2;
dato2 = 4;
dato3 = 8;
dato4 = 5;
//Suma
resultado = dato1 + dato2 + dato3 + dato4;
System.out.println (dato1 + "+" + dato2 + "+" + dato3 + "+" + dato4 + "=" + resultado);
//Media
result = resultado / 2;
System.out.println (resultado + "/" + 2 + "=" + result );
}
}

Programa en java

class CEcuacion
{
// realizar una ecuacion.
public static void main(String[] args)
{
float valora, valorb, valorc;
float resultado;
valora = 1;
valorb = 5;
valorc = 2;
resultado = 0;
resultado=(valorb * valorb - 4*(valora*valorc))/(2*valora);
System.out.println(resultado);
}
}

Programa en java

class CMundoJava
{
/* Este programa mostrara la palabra bienvenido al mundo de java.
* Tambien mostrara la frace " prodras dar resultado a muchos problemas "
*/
public static void main (String[] args)
{
System.out.println (" Bienvenido al mundo de java");
System.out.println (" Podras dar resultado a muchos problemas");
}
}

1) A) las clases son declaraciones de un objeto, lo que significa, que una clase es la definición de un objeto. Cuando programamos un objeto y definimos sus características realmente se programa una clase.

B) las subclases son un grupo intermedio entre clase y orden que se crea por la necesidad de agrupar en conjuntos naturales los numerosos órdenes de una clase.

C) La instancia es una modelo básica de comunicación con la administración pública que, con ligeras variantes, un administrado o interesado puede utilizar para reclamar, solicitar, denunciar o como substituto de algún impreso.

2) Java es un lenguaje de programación con el que podemos realizar cualquier tipo de programa.
Características de java:Las características mas frecuentes de java nos ayudaran haber para que tipo de problemas esta pensado este programa:

Ø Es simple: es un lenguaje sencillo de aprender con sintaxis parecidas a las de c++ pero mas simplificado.

Ø Es orientada al objeto: java implementa la tecnología básica de c++ con algunas mejoras y elimina algunas cosas para mantener el objetivo de la simplicidad del lenguaje.

Ø Es distribuido: java se ha construido con extensas capacidades de interconexión TCP/Inexisten librerías de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales.
Ø Es robusto: java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución.
Ø Es portable: mas allá de la portabilidad básica por ser de arquitectura independiente, java implementa otros estándares de portabilidad para facilitar el desarrollo.
Ø Es interpretado: el intérprete java puede ejecutar directamente el código objeto. Enlazar un programa, normalmente, consume menos recursos que compilarlo, por lo que los desarrolladores con java pasaran mas tiempo desarrollando y menos esperando por el ordenador.
Ø Es multithreaded: consiste en un mejor rendimiento interactivo y un mejor comportamiento en tiempo real.
Ø Es dinámica: java se beneficia todo lo posible de la tecnología orientada a objeto.

Evaluacion

Evaluativo.

1) Defina Clases, Subclases, instancias.
2) ¿Qué es Java y cuáles son sus características más notorias?
3) Desarrolle un algoritmo que permita determinar si un número dado es par, impar o cero.
4) Desarrolle un algoritmo que permita determinar de una serie de números cuántos son par, impar o cero.
5) Desarrolle un algoritmo que lea un número , y si es negativo que lo imprima.
6) Desarrolle un algoritmo que lea una serie de números , imprima el número si es negativo y el positivo del mismo.
7) Desarrolle un algoritmo que le permita leer el nombre , la edad , el sexo y el estado civil de cualquier persona e imprima el nombre de la persona si es un hombre casado y mayor de 40 años o una mujer soltera menor de 50 años.
8) Desarrolle un algoritmo que le permita leer las notas de las materias que ha cursado un estudiante hasta el momento, saque su promedio e imprima su nombre, número de carnet y el promedio.
9) Desarrolle un algoritmo para leer el nombre de un empleado, el salario básico por hora y el número de horas trabajadas durante una semana. Calcule el salario neto, teniendo en cuenta que si el número de horas trabajadas durante la semana es mayor de 48 horas, esas horas demás se consideran horas extras y tienen un recargo del 35%. Imprima el nombre del empleado y su salario neto.
10) Desarrolle un algoritmo que le permita determinar dadas tres cajas cada una con 15 números , en cuál caja está un número dado.
11) Desarrolle un algoritmo que le permita determinar el número medio de tres números. El número medio es aquel que no es el mayor ni el menor.
12) Analiza el siguiente programa en java, define cada partes del mismo, e identifica clase e instancia.
class CAritmetica
{
/*
* Operaciones aritméticas
*/
public static void main (String[] args)
{
int dato1, dato2, resultado;

dato1 = 20;
dato2 = 10;

// Suma
resultado = dato1 + dato2;
System.out.println(dato1 + " + " + dato2 + " = " + resultado);

// Resta
resultado = dato1 - dato2;
System.out.println(dato1 + " - " + dato2 + " = " + resultado);

// Producto
resultado = dato1 * dato2;
System.out.println(dato1 + " * " + dato2 + " = " + resultado);

// Cociente
resultado = dato1 / dato2;
System.out.println(dato1 + " / " + dato2 + " = " + resultado);
}
}

La Clase Systemstrong>
Hay ocasiones en que se necesita acceder a recursos del sistema , como son los dispositivos de entrada/salida, el reloj del sistema, etc. Java dispone de la clase System, que proporciona acceso a estos recursos, independientemente de la plataforma. Es decir, que si se ejecuta un programa en una plataforma diferente a la que se ha desarrollado, no es necesaria ninguna modificación para tener en cuenta las peculiaridades de la nueva plataforma.

La clase System es miembro del paquete java.lang y en ella se definen los dispositivos estándar de entrada/salida

static PrintStream err;
static InputStream in;
static PrintStream out;
y dispone de varios métodos, algunos de los cuales ya se han utilizado en secciones anteriores, sin saber muy bien lo que se estaba haciendo, cosa que se intentará remediar ahora.

static void arraycopy( Object,int,Object,int,int )
static long currentTimeMillis()
static void exit( int )
static void gc()
static Properties getProperties()
static String getPropertie( String )
static String getPropertie( String,String )
static SecurityManager getSecurityManager()
static native int identityHashCode( Object )
static void load( String )
static void loadLibrary( String )
static void runFinalization()
static void runFinalizersOnExit( boolean )
static void setErr( PrintStream )
static void setIn( InputStream )
static void setOut( PrintStream )
static void setProperties( Properties )
static void setSecurityManager( SecurityManager )
No se puede instanciar ningún objeto de la clase System, porque es una clase final y todos sus contenidos son privados; por ellos es por lo que no hay una lista de constructores en la enumeración de métodos. Es decir, la clase System siempre está ahí disponible para que se pueda invocar cualquiera de sus métodos utilizando la sintaxis de punto (.) ya conocida

System.out.println( "Hola Java" );

Entrada/Salida estándar

En otra sección del Tutorial se trata a fondo este tema de la entrada y salida, aquí solamente interesa su relación con la clase System. Los dispositivos de entrada/salida probablemente sean uno de los aspectos más utilizado de esta clase.

La clase System proporciona automáticamente cuando comienza la ejecución de un programa, un stream para leer del dispositivo estándar de entrada (normalmente, el teclado), un stream para presentar información en el dispositivo estándar de salida (normalmente, la pantalla) y otro stream donde presentar mensajes de error, que es el dispositivo estándar de error (normalmente, la pantalla).

Los tres streams de entrada/salida están controlados por esta clase y se referencian como:

System.in entrada estándar
System.out salida estándar
System.err salida de error estándar

Las variables internas de la clase System out y err son de tipo PrintStream, es decir, que tienen acceso a los métodos de la clase PrintStream. La clase PrintStream proporciona tres métodos para poder visualizar información: print(), println() y write().

Los dos primeros ya se han utilizado en el Tutorial ampliamente, con lo que no resultan extrañas sentencias como:

System.out.print( … );
System.out.println( … );
System.out.write( … );
Los métodos print() y println() son semejante, la única diferencia es que println() coloca automáticamente un carácter nueva línea en el stream, tras la lista de argumentos que se le pase.

El método write() se utiliza para escribir bytes en el stream, es decir, para escribir datos que no pueden interpretarse como texto, como pueden ser los datos que componen un gráfico.

Los métodos print() y println() aceptan un argumento de cualquiera de los siguientes tipos: Object, String, char[], int, long, float, double o boolean. En cada caso, el sistema convierte el dato a un conjunto de caracteres que transfiere al dispositivo estándar de salida. Si se invoca al método println() sin argumentos, simplemente se inserta un carácter nueva línea en el stream.

Además, hay versiones sobrecargadas de estos métodos para visualizar adecuadamente objetos de varias clases estándar. Por ejemplo, las siguientes sentencias:

Thread obj = new Thread;
System.out.println( obj );
Producirían la siguiente salida en pantalla:

Thread[Thread-4,5,main]
Cuando se utilizan print() y println() sobre un objeto, la salida dependerá de ese objeto; por ejemplo, si se imprime un objeto String, visualizaremos el contenido de la cadena y si se imprime un objeto Thread obtenemos una salida en formato:

claseThread[nombre,prioridad,grupo]
como en el ejemplo anterior.

Propiedades del Sistema

Ya se ha indicado al tratar la clase Properties que las Propiedades son pares de clave/valor que los programas Java pueden utilizar para establecer y mantener diversos atributos o parámetros, que estarían disponibles en todas sus invocaciones.

El sistema Java también mantiene un conjunto de Propiedades del Sistema que contienen información acerca del entorno en que se está ejecutando como: el usuario actual, la versión actual del ejecutable de Java, etc. Estas Propiedades se fijan cuando arranca el Sistema.

En la fecha de hoy, invierno del 97, los applets pueden acceder a algunas de las Propiedades del sistema, pero no a todas. Además, los applets no pueden escribir las Propiedades del sistema. Supongo que en adelante esto cambiará.

La clase System dispone de varios métodos para leer y escribir las Propiedades del sistema. A estas Propiedades se puede acceder a través de la clave o se puede leer el conjunto completo de Propiedades.

Los dos métodos que proporciona la clase System para leer las propiedades del sistema son getProperty() y getProperties(). De la primera hay dos versiones sobrecargadas. La primera de ellas es:

static String getProperty( String key );
Solamente tiene un argumento y devuelve un objeto de tipo String. Si no es capaz de encontrar la propiedad indicada en la clave, devolverá una referencia nula. La segunda versión sobrecargada de getProperty()

static String getProperty( String clave,String def );
necesita dos argumentos. El primero es la propiedad clave que se quiere consultar y el segundo argumento es el valor por defecto que devolverá el método si la propiedad clave no se encuentra entre las propiedades, o si esa propiedad clave sí se encuentra pero no tiene asignado ningún valor.

El tercer método para acceder a las Propiedades del sistema es getProperties(), que devuelve un objeto Properties conteniendo el conjunto completo de pares clave/valor del sistema. Una vez obtenido este objeto, se puede usar cualquiera de sus métodos para obtener la información que se necesite.

Las Propiedades del sistema también se pueden modificar a través del método setProperties() de esta clase System. Este método coge un objeto Properties que haya sido inicializado con el adecuado conjunto de pares clave/valor que se desee y reemplaza el conjunto completo de Propiedades del sistema por los nuevos valores representados por el objeto.

En general, hay que tener cuidado de no sobreescribir las Propiedades del sistema. El método setProperties() cambia las Propiedades del sistema solamente para la ejecución actual en que se está utilizando. El sistema Java reinicializa las Propiedades cada vez que se arranca, luego los cambios realizados por este método no son persistentes. Si se quiere que lo sean, hay que salvarlos en un fichero antes de concluir la aplicación y cargarlos de nuevo al arrancar. La clase Properties proporciona métodos para realizar ambas tareas.

Finalización

Todos los objetos en Java son instanciados dinámicamente, en tiempo de ejecución, en la pila. Cuando ya no exista variable alguna que referencie al objeto, éste será marcado para su reciclado.

El reciclador de memoria, o cualquier nombre que quiera dársele, se ejecuta asíncronamente en segundo plano, recogiendo los objetos que ya no estén referenciados y haciendo que la memoria que ocupaban quede libre y sea devuelta al sistema para su reutilización.

El método finalize() de un objeto siempre se ejecuta antes de que la memoria ocupada por ese objeto sea liberada. Este método se puede sobreescribir para las clases que se desee, de forma que se ejecuten un conjunto de setencias determinado antes de liberar la memoria.

Se puede forzar una ejecución del reciclador de memoria invocando al método gc(). Además, se puede forzar a que el sistema ejecute la finalización de los objetos utilizando la llamada al método runFinalization(), que invocará a todos los métodos finalize() de los objetos que estén marcados para ser reciclados.

Copia de arrays

Para copiar eficientemente datos desde un array a otro se puede utilizar el método arraycopy(). Este método requiere cinco argumentos, de forma que se indiquen los arrays de origen y destino y el número de elementos que se van a copiar.

static void arraycopy( Object src,int src_position,Object dst,
int dst_position,int length );
El array destino debe estar localizado en memoria antes de llamarlo y debe ser lo suficientemente largo para contener los datos que se le van a pasar.

Salida del Sistema

Se puede abandonar el intérprete Java llamando al método exit() y pasándole un int como código de salida. Sin embargo, la invocación de este método está sujeta a restricciones de seguridad, Así, dependiendo del navegador sobre el que se esté ejecutando un applet, una llamada a exit() desde dentro del applet puede originar una excepción de seguridad, SecurityException.

Seguridad

El controlador de seguridad es un objeto que asegura una cierta política de seguridad a la aplicación Java. Se puede fijar el controlador de seguridad para las aplicaciones utilizando el método setSecurityManager() y se puede recuperar el que esté actualmente definido utilizando el método getSecurityManager().

El controlador de seguridad para una aplicación solamente se puede fijar una vez. Normalmente, un navegador fija su controlador de seguridad al arrancar, con lo cual, en acciones posteriores los applets no pueden fijarlo de nuevo, o se originará una excepción de seguridad si el applet lo intenta.

Recursos dependientes del Sistema

Deberíamos ser capaces de satisfacer todas nuestras necesidades de programación utilizando la interfaz independiente de plataforma que proporciona la clase System. Pero también es posible saltarse este interfaz y acceder directamente a los recursos del sistema en que se esté ejecutando el programa Java.

El sistema Java proporciona un objeto Runtime que representa el entorno en que se está corriendo, y que se puede utilizar para acceder directamente a los recursos de la plataforma.

Al hacer esto, probablemente se esté perdiendo parte de la portabilidad que caracteriza a Java, pero se está ganando velocidad de ejecución, o la obtención de información propia del sistema en que se está ejecutando la aplicación.

Colecciones
Java tiene matrices para almacenar grupos de datos de tipo similar, que son muy útiles para modelos simples de acceso a datos. Sin embargo, las Colecciones o enumeraciones ofrecen una manera más completa y orientada a objetos para almacenar conjuntos de datos de tipo similar. Las Colecciones tienen su propia asignación de memoria y posibilidad de una nueva asignación para ampliarlas. Tienen interfaces de método para su iteración y recorrido. Se pueden indexar mediante algo más complejo y útil que los simples enteros. Hasta el JDK 1.1, las Colecciones parecían estar incorporadas a Java por necesidad de aportar alguna herramienta para el almacenamiento de datos. Pero en el JDK 1.2, se han revisado completamente las Colecciones y ahora el programador dispone de toda la potencia de estas nuevas estructuras de datos, a las cuales se ha hecho referencia en secciones anteriores, a las cuales debe remitirse el lector, aquí solamente se citarán por estar incluidas dentro de las clases base de Java, y muy por encima.

Enumeraciones

Enumeration es un interfaz simple que permite enumerar todos los elementos de cualquier conjunto de objetos. Especifica dos métodos:

Bboolean hasMoreElements()
Object nextElement()
El primer método devuelve true cuando todavía quedan más elementos que extraer y false cuando se han enumerado todos los elementos del conjunto. El segundo método, devuelve una referencia a objeto genérica, cuyo tipo hay que convertir al tipo de clase de la cual el objeto es una instancia.

En el programa de ejemplo, java816.java, se utiliza una clase llamada Coleccion para implementar una enumeración de objetos de tipo Integer, y la clase principal que crea una instancia de Coleccion, itera sobre sus valores e imprime cada uno de ellos. Coleccion no contiene realmente ningún dato; simplemente devuelve la secuencia de enteros que ha construido.

Vector

Un Vector es una matriz ampliable de referencia a objeto. Internamente, un Vector implementa una estrategia de crecimiento para minimizar la reasignación y el espacio desperdiciado. Los objetos se pueden almacenar al final de un Vector utilizando el método addElement() o en un índice dado mediante el método insertElement(). Se puede almacenar una matriz de objetos en un Vector utilizando el método copyInto(). Una vez se ha almacenado un conjunto de objetos en un Vector, se puede utilizar para buscar un elemento en concreto utilizando los métodos contains(), indexOf() o lastIndexOf(). También se puede extraer un objeto de una posición específica de un Vector utilizando los métodos elementAt(), firstElement() y lastElement().

Un Stack, pila, es una subclase de Vector que implementa una pila simple del tipo FIFO (primero en entrar, primero en salir. Además de los métodos estándar de la clase padre, Stack implementa el método push(), que coloca objetos en la parte superior de la pila y el método pop() que retira y devuelve el objeto superior de la pila. También dispone del método peek() para obtener el objeto superior de la pila, pro no retirarlo. El método empty() devolverá true si no hay nada en la pila. El método search() comprobará si existe un objeto en la pila y devolverá el número de llamadas al método pop() que se necesitarán realizar para que dicho objeto se quede en la parte superior de la pila, o –1 si el objeto pasado como parámetro no se encuentra.

Diccionario

Un Dictionary es una clase abstracta que representa un depósito para almacenar claves/valores. Una clave es un nombre que se utiliza para recuperar un valor más adelante. Dada una clave y un valor, se puede almacenar el valor en un Dictionary con el método put( clave,valor ). Después se puede utilizar get( clave ) para recuperar el valor. Se pueden devolver las claves y valores como una Enumeration utilizando los métodos keys() y elements(). El método size() devuelve el número de parejas clave/valor almacenadas en un diccionario y el método isEmpty() devuelve true cuando no queda ninguna pareja. Se puede utilizar el método remove( clave ) para eliminar una pareja clave/valor.

Una Hashtable, tabla hash, es una implementación concreta de un Dictionary. Se puede utilizar una instancia de Hashtable para almacenar objetos arbitrarios que están indexados por cualquier otro objeto arbitrario. La utilización más habitual de una Hashtable es utilizar un String como clave para almacenar objetos como valores. El ejemplo java818.java, crea una tabla hash para almacenar información acerca del Tutorial.

import java.util.Dictionary;
import java.util.Hashtable;

class java818 {
public static void main( String args[] ) {
Hashtable ht = new Hashtable();

ht.put( "titulo","Tutorial de Java" );
ht.put( "autor","Agustin Froufe" );
ht.put( "email","froufe@arrakis.es" );
ht.put( "patria","Spain" );
ht.put( "edad",new Integer( 31 ) );
show( ht );
}

static void show( Dictionary d ) {
System.out.println( "Titulo: " + d.get( "titulo" ) );
System.out.println( "Autor: " + d.get( "autor" ) );
System.out.println( "E-mail: " + d.get( "email" ) );
System.out.println( "Pais: " + d.get( "patria" ) );
System.out.println( "Edad: " + d.get( "edad" ) );
}
}
La salida del programa, muestra cómo el método show(), que toma un Dictionary abstracto como parámetro, es capaz de recuperar todos los valores que se han almacenado en el método main().

C:\> java java818
Titulo: Tutorial de Java
Autor: Agustin Froufe
E-mail: froufe@arrakis.es
Pais: Spain
Edad: 31

EXEPCION DE JAVA:

Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución.
Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores. Si hay un error, la aplicación no debería morirse y generar un core (o un crash en caso del DOS). Se debería lanzar (throw) una excepción que a su vez debería capturar (catch) y resolver la situación de error, o poder ser tratada finalmente (finally) por un gestor por defecto u omisión. Java sigue el mismo modelo de excepciones que se utiliza en C++. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones.
En este Tutorial de Java no se pretende entrar en detalle en las ventajas que representa la utilización de excepciones, para ello debe el lector recurrir al Java Tutorial de Sun, en donde hay una completa discusión acerca de este aspecto de Java.
La gestión de excepciones en Java proporciona un mecanismo excepcionalmente poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución. Las excepciones son formas muy limpias de manejar errores y problemas inesperados en la lógica del programa, y no deberían considerarse como un mecanismo general de ramificaciones o un tipo de sentencias de salto. Los lugares más indicados para utilizar excepciones son aquellos en los que se usan valores como 0 o 1, en C/C++, para indicar algún fallo funcional. Por ejemplo:#include
int fd;
fd = open( "leeme.txt" );
if( fd == -1 && errno == EEXIT )
fd = open( "defecto.txt" );
}
En este programa C, si falla la primera sentencia open() por cualquiera de las 19 razones distintas de EEXIT por las que puede fallar, entonces el programa se continuaría ejecutando y moriría por alguna razón misteriosa más adelante, dejando atrás un problema de depuración complicado y frustrante.
La versión Java del código anterior, tal como se muestra a continuación: FilterReader fr;
try {
Fr = new FilterReader( "leeme.txt" );
} catch( FileNotFoundException e ) {
fr = new FilterReader( "defecto.txt" );
}
proporciona una oportunidad para capturar una excepción más genérica y tratar la situación con elegancia o, en el peor de los casos, imprimiría el estado de la pila de memoria.
Por ello, que la utilización adecuada de las excepciones proporcionará un refinamiento profesional al código que cualquier usuario futuro de las aplicaciones que salgan de la mano del programador que las utilice agradecerá con toda seguridad.
Manejo de excepciones
A continuación se muestra cómo se utilizan las excepciones, reconvirtiendo en primer lugar el applet de saludo a partir de la versión iterativa de HolaIte.java:import java.awt.*;
import java.applet.Applet;
public class HolaIte extends Applet {
private int i = 0;
private String Saludos[] = {
"Hola Mundo!",
"HOLA Mundo!",
"HOLA MUNDO!!"
};
public void paint( Graphics g ) {
g.drawString( Saludos[i],25,25 );
i++;
}
}
Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella.
Vamos a reescribir el método paint() de esa versión iterativa del saludo:public void paint( Graphics g ) {
try {
g.drawString( Saludos[i],25,25 );
} catch( ArrayIndexOutOfBoundsException e ) {
g.drawString( "Saludos desbordado",25,25 );
} catch( Exception e ) {
// Cualquier otra excepción
System.out.println( e.toString() );
} finally {
System.out.println( "Esto se imprime siempre!" );
}
i++;
}
La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola, con i=4 sería:C:\>java HolaIte
Saludos desbordado
¡Esto se imprime siempre!

Cuando se produce una condición excepcional en el transcurso de la ejecución de un programa, se debería generar, o lanzar, una excepción. Esta excepción es un objeto derivado directa, o indirectamente, de la clase Throwable. Tanto el intérprete Java como muchos métodos de las múltiples clases de Java pueden lanzar excepciones y errores.
La clase Throwable tiene dos subclases: Error y Exception. Un Error indica que se ha producido un fallo no recuperable, del que no se puede recuperar la ejecución normal del programa, por lo tanto, en este caso no hay nada que hacer. Los errores, normalmente, hacen que el intérprete Java presente un mensaje en el dispositivo estándar de salida y concluya la ejecución del programa. El único caso en que esto no es así, es cuando se produce la muerte de un thread, en cuyo caso se genera el error ThreadDead, que lo que hace es concluir la ejecución de ese hilo, pero ni presenta mensajes en pantalla ni afecto a otros hilos que se estén ejecutando.
Una Exception indicará una condición anormal que puede ser subsanada para evitar la terminación de la ejecución del programa. Hay nueve subclases de la clase Exception ya predefinidas, y cada una de ellas, a su vez, tiene numerosas subclases.
Para que un método en Java, pueda lanzar excepciones, hay que indicarlo expresamente.void MetodoAsesino() throws NullPointerException,CaidaException
Se pueden definir excepciones propias, no hay por qué limitarse a las nueve predefinidas y a sus subclases; bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción.
También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida.
Las excepciones, pues, pueden originarse de dos modos: el programa hace algo ilegal (caso normal), o el programa explícitamente genera una excepción ejecutando la sentencia throw (caso menos normal). La sentencia throw tiene la siguiente forma: throw ObtejoExcepction;
El objeto ObjetoException es un objeto de una clase que extiende la clase Exception.
Origina una excepción de división por cero:class java901 {
public static void main( String[] a ) {
int i=0, j=0, k;
k = i/j; // Origina un error de division-by-zero
}
}
Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por pantalla:% javac java901.java
% java java901
java.lang.ArithmeticException: / by zero
at java901.main(java901.java:25)
Las excepciones predefinidas, como ArithmeticException, se conocen como excepciones runtime. Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones irrecuperables. Esto contrasta con las excepciones que se generan explícitamente, a petición del programador, que suelen ser mucho menos severas y en la mayoría de los casos no resulta complicado recuperarse de ellas. Por ejemplo, si un fichero no puede abrirse, se puede preguntar al usuario que indique otro fichero; o si una estructura de datos se encuentra completa, siempre se podrá sobreescribir algún elemento que ya no se necesite.

Todas las excepciones deben llevar un mensaje asociado a ellas al que se puede acceder utilizando el método getMessage(), que presentará un mensaj describiendo el error o la excepción que se ha producido.

Si se desea, se pueden invocar otros métodos de la clase Throwable que presentan un traceado de la pila en donde se ha producido la excepción, o también se pueden invocar para convertir el objeto Exception en una cadena, que siempre es más intelegible y agradable a la vista.

Los nombres de las excepciones indican la condición de error que representan. Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar:

ArithmeticException
Las excepciones aritméticas son típicamente el resultado de división por 0:int i = 12 / 0;
NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser definido:class Hola extends Applet {
Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.y = (Prueba)x; // donde x no es de tipo Prueba
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al cambiar el tamaño de un array.
OutOfMemoryException
¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema.
NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException <
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array.
UnsatisfiedLinkException
Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método a.kk()class A {
native void kk();
}
y se llama a a.kk(), cuando debería llamar a A.kk().
InternalException
Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse.
El compilador Java obliga al programador a proporcionar el código de manejo o control de algunas de las excepciones predefinidas por el lenguaje. Por ejemplo, el siguiente programa java902.java, no compilará porque no se captura la excepción InterruptedException que puede lanzar el método sleep().import java.lang.Thread;
class java902 {
public static void main( String args[] ) {
java902 obj = new java902();
obj.miMetodo();
}

void miMetodo() {
// Aqui se produce el error de compilacion, porque no se esta
// declarando la excepcion que genera este metodo
Thread.currentThread().sleep( 1000 ); // currentThread() genera
// una excepcion
}
}
Este es un programa muy simple, que al intentar compilar, producirá el siguiente error de compilación que se visualizará en la pantalla tal como se reproduce a continuación:% javac java902.java
java902.java:41: Exception java.lang.InterruptedException must be caught,
or it must be declared in the throws clause of this method.
Thread.currentThread().sleep( 1000 ); // currentThread() genera
^
Como no se ha previsto la captura de la excepción, el programa no compila. El error identifica la llamada al método sleep() como origen del problema. Así que, la siguiente versión del programa, soluciona el problema generado por esta llamada.import java.lang.Thread;
class java903 {
public static void main( String args[] ) {
// Se instancia un objeto
java903 obj = new java903();
// Se crea la secuencia try/catch que llamara al metodo que
// lanza la excepcion
try {
// Llamada al metodo que genera la excepcion
obj.miMetodo();
}catch(InterruptedException e){} // Procesa la excepcion
}

// Este es el metodo que va a lanzar la excepcion
void miMetodo() throws InterruptedException {
Thread.currentThread().sleep( 1000 ); // currentThread() genera
// una excepcion
}
}
Lo único que se ha hecho es indicar al compilador que el método miMetodo() puede lanzar excepciones de tipo InterruptedException. Con ello conseguimos propagar las excepción que genera el método sleep() al nivel siguiente de la jerarquía de clases. Es decir, en realidad no se resuelve el problema sino que se está pasando a otro método para que lo resuelva él.

En el método main() se proporciona la estructura que resuelve el problema de compilación, aunque no haga nada, por el momento. Esta estructura consta de un bloque try y un bloque catch, que se puede interpretar como que intentará ejecutar el código del bloque try y si hubiese una nueva excepción del tipo que indica el bloque catch, se ejecutaría el código de este bloque, si ejecutar nada del try.

La transferencia de control al bloque catch no es una llamada a un método, es una transferencia incondicional, es decir, no hay un retorno de un bloque catch.
Crear Excepciones Propias
También el programador puede lanzar sus propias excepciones, extendiendo la clase System.exception. Por ejemplo, considérese un programa cliente/servidor. El código cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el servidor. Si el servidor no responde, el servidor lanzaría la excepción de time-out:class ServerTimeOutException extends Exception {}
public void conectame( String nombreServidor ) throws Exception {
int exito;
int puerto = 80;
exito = open( nombreServidor,puerto );
if( exito == -1 )
throw ServerTimeOutException;
}
Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try:public void encuentraServidor() {
...
try {
conectame( servidorDefecto );
catch( ServerTimeOutException e ) {
g.drawString(
"Time-out del Servidor, intentando alternativa",5,5 );
conectame( servidorAlterno );
}
...
}
Cualquier método que lance una excepción también debe capturarla, o declararla como parte del interfaz del método. Cabe preguntarse entonces, el porqué de lanzar una excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones no simplifican el trabajo del control de errores. Tienen la ventaja de que se puede tener muy localizado el control de errores y no hay que controlar millones de valores de retorno, pero no van más allá.

Y todavía se puede plantear una pregunta más, al respecto de cuándo crear excepciones propias y no utilizar las múltiples que ya proporciona Java. Como guía, se pueden plantear las siguientes cuestiones, y si la respuesta es afirmativa, lo más adecuado será implementar una clase Exception nueva y, en caso contrario, utilizar una del sistema.

¿Se necesita un tipo de excepción no representado en las que proporciona el entorno de desarrollo Java?
¿Ayudaría a los usuarios si pudiesen diferenciar las excepciones propias de las que lanzan las clases de otros desarrolladores?
¿Si se lanzan las excepciones propias, los usuarios tendrán acceso a esas excepciones?
¿El package propio debe ser independiente y auto-contenido?

CAPTURA DE EXEPCIONES

Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque try/catch o try/finally.int valor;
try {
for( x=0,valor = 100; x < name="Cap9_3_1">try
Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos "intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally.
La sintaxis general del bloque try consiste en la palabra clave try y una o más sentencias entre llaves.try {
// Sentencias Java
}
Puede haber más de una sentencia que genere excepciones, en cuyo caso habría que proporcionar un bloque try para cada una de ellas. Algunas sentencias, en especial aquellas que invocan a otros métodos, pueden lanzar, potencialmente, muchos tipos diferentes de excepciones, por lo que un bloque try consistente en una sola sentencia requeriría varios controladores de excepciones.
También se puede dar el caso contrario, en que todas las sentencias, o varias de ellas, que puedan lanzar excepciones se encuentren en un único bloque try, con lo que habría que asociar múltiples controladores a ese bloque. Aquí la experiencia del programador es la que cuenta y es el propio programador el que debe decidir qué opción tomar en cada caso.
Los controladores de excepciones deben colocarse inmediatamente después del bloque try. Si se produce una excepción dentro del bloque try, esa excepción será manejada por el controlador que esté asociado con el bloque try.

catch
Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos "controlo cualquier excepción que coincida con mi argumento". No hay código alguno entre un bloque try y un bloque catch, ni entre bloques catch. La sintaxis general de la sentencia catch en Java es la siguiente:catch( UnTipoTrhowable nombreVariable ) {
// sentencias Java
}

El argumento de la sentencia declara el tipo de excepción que el controlador, el bloque catch, va a manejar.
En este bloque tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta: catch( Excepcion e ) { ...
Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario.
Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes. Por ejemplo:class Limites extends Exception {}
class demasiadoCalor extends Limites {}
class demasiadoFrio extends Limites {}
class demasiadoRapido extends Limites {}
class demasiadoCansado extends Limites {}
.
.
.
try {
if( temp > 40 )
throw( new demasiadoCalor() );
if( dormir < name="Cap9_3_3">finally
Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejar grabado si se producen excepciones y si el programa se ha recuperado de ellas o no.

Este bloque finally puede ser útil cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que se haga en el bloque try.

A la hora de tratar una excepción, se plantea el problema de qué acciones se van a tomar. En la mayoría de los casos, bastará con presentar una indicación de error al usuario y un mensaje avisándolo de que se ha producido un error y que decida si quiere o no continuar con la ejecución del programa.
Por ejemplo, se podría disponer de un diálogo como el que se presenta en el código siguiente:public class DialogoError extends Dialog {
DialogoError( Frame padre ) {
super( padre,true );
setLayout( new BorderLayout() );
// Presentamos un panel con continuar o salir
Panel p = new Panel();
p.add( new Button( "¿Continuar?" ) );
p.add( new Button( "Salir" ) );
add( "Center",new Label(
"Se ha producido un error. ¿Continuar?" ) )
add( "South",p );
}
public boolean action( Event evt,Object obj ) {
if( "Salir".equals( obj ) ) {
dispose();
System.exit( 1 );
}
return( false );
}
}
Y la invocación, desde algún lugar en que se suponga que se generarán errores, podría ser como sigue:try {
// Código peligroso
}
catch( AlgunaExcepcion e ) {
VentanaError = new DialogoError( this );
VentanaError.show();
}
Lo cierto es que hay autores que indican la inutilidad del bloque finally, mientras que desde el Java Tutorial de Sun se justifica plenamente su existencia. El lector deberá revisar todo el material que esté a su alcance y crearse su propia opinión al respecto.
En el programa java904.java, se intenta demostrar el poder del bloque finally. En él, un controlador de excepciones intenta terminar la ejecución del programa ejecutando una sentencia return. Antes de que la sentencia se ejecute, el control se pasa al bloque finally y se ejecutan todas las sentencias de este bloque. Luego el programa termina. Es decir, quedaría demostrado que el bloque finally no tiene la última palabra palabra.
El programa redefine el método getMessage() de la clase Throwable, porque este método devuelve null si no es adecuadamente redefinido por la nueva clase excepción.
throw
La sentencia throw se utiliza para lanzar explícitamente una excepción. En primer lugar se debe obtener un descriptor de un objeto Throwable, bien mediante un parámetro en una cláusula catch o, se puede crear utilizando el operador new. La forma general de la sentencia throw es:throw ObjetoThrowable;
El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y nunca se llega a la sentencia siguiente. Se inspecciona el bloque try que la engloba más cercano, para ver si tiene la cláusula catch cuyo tipo coincide con el del objeto o instancia Thorwable. Si se encuentra, el control se transfiere a ese sentencia. Si no, se inspecciona el siguiente bloque try que la engloba, y así sucesivamente, hasta que el gestor de excepciones más externo detiene el programa y saca por pantalla el trazado de lo que hay en la pila hasta que se alcanzó la sentencia throw. En el programa siguiente, java905.java, se demuestra como se hace el lanzamiento de una nueva instancia de una excepción, y también cómo dentro del gestor se vuelve a lanzar la misma excepción al gestor más externo.class java905 {
static void demoproc() {
try {
throw new NullPointerException( "demo" );
} catch( NullPointerException e ) {
System.out.println( "Capturada la excepcion en demoproc" );
throw e;
}
}
public static void main( String args[] ) {
try {
demoproc();
} catch( NullPointerException e ) {
System.out.println( "Capturada de nuevo: " + e );
}
}
}
Este ejemplo dispone de dos oportunidades para tratar el mismo error. Primero, main() establece un contexto de excepción y después se llama al método demoproc(), que establece otro contexto de gestión de excepciones y lanza inmediatamente una nueva instancia de la excepción. Esta excepción se captura en la línea siguiente. La salida que se obtiene tras la ejecución de esta aplicación es la que se reproduce:% java java905
Capturada la excepcion en demoproc
Capturada de nuevo: java.lang.NullPointerException: demo
throws
Si un método es capaz de provocar una excepción que no maneja él mismo, debería especificar este comportamiento, para que todos los métodos que lo llamen puedan colocar protecciones frente a esa excepción. La palabra clave throws se utiliza para identificar la lista posible de excepciones que un método puede lanzar. Para la mayoría de las subclase de la clase Exception, el compilador Java obliga a declarar qué tipos podrá lanzar un método. Si el tipo de excepción es Error o RuntimeException, o cualquiera de sus subclases, no se aplica esta regla, dado que no se espera que se produzcan como resultado del funcionamiento normal del programa. Si un método lanza explícitamente una instancia de Exception o de sus subclases, a excepción de la excepción de runtime, se debe declarar su tipo con la sentencia throws. La declaración del método sigue ahora la sintaxis siguiente:type NombreMetodo( argumentos ) throws excepciones { }
En el ejemplo siguiente, java906.java, el programa intenta lanzar una excepción sin tener código para capturarla, y tampoco utiliza throws para declarar que se lanza esta excepción. Por tanto, el código no será posible compilarlo.class java906 {
static void demoproc() {
System.out.println( "Capturada la excepcion en demoproc" );
throw new IllegalAccessException( "demo" );
}
}
public static void main( String args[] ) {
demoproc();
}
El error de compilación que se produce es lo suficientemente explícito:% javac java906.java
java906.java:30: Exception java.lang.IllegalAccessException must be caught, or
it must be declared in the throws clause of this method.
throw new IllegalAccessException( "demo" );
^
Para hacer que este código compile, se convierte en el ejemplo siguiente, java907.java, en donde se declara que el método puede lanzar una excepción de acceso ilegal, con lo que el problema asciende un nivel más en la jerarquía de llamadas. Ahora main() llama a demoproc(), que se ha declarado que lanza una IllegalAccessException, por lo tanto colocamos un bloque try que pueda capturar esa excepción.class java907 {
static void demoproc() throws IllegalAccessException {
System.out.println( "Dentro de demoproc" );
throw new IllegalAccessException( "demo" );
}
public static void main( String args[] ) {
try {
demoproc();
} catch( IllegalAccessException e ) {
System.out.println( "Capturada de nuevo: " + e );
}
}
}

La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque y sigue el flujo de control por el bloque finally (si lo hay) y concluye el control de la excepción.

Si ninguna de las cláusulas catch coincide con la excepción que se ha producido, entonces se ejecutará el código de la cláusula finally (en caso de que la haya). Lo que ocurre en este caso, es exactamente lo mismo que si la sentencia que lanza la excepción no se encontrase encerrada en el bloque try.

El flujo de control abandona este método y retorna prematuramente al método que lo llamó. Si la llamada estaba dentro del ámbito de una sentencia try, entonces se vuelve a intentar el control de la excepción, y así continuamente.

Cuando una excepción no es tratada en la rutina en donde se produce, lo que sucede es lo siguiente. El sistema Java busca un bloque try..catch más allá de la llamada, pero dentro del método que lo trajo aquí. Si la excepción se propaga de todas formas hasta lo alto de la pila de llamadas sin encontrar un controlador específico para la excepción, entonces la ejecución se detendrá dando un mensaje. Es decir, podemos suponer que Java nos está proporcionando un bloque catch por defecto, que imprime un mensaje de error, indica las últimas entradas en la pila de llamadas y sale.

No hay ninguna sobrecarga en el sistema por incorporar sentencias try al código. La sobrecarga se produce cuando se genera la excepción.

Se ha indicado ya que un método debe capturar las excepciones que genera, o en todo caso, declararlas como parte de su llamada, indicando a todo el mundo que es capaz de generar excepciones. Esto debe ser así para que cualquiera que escriba una llamada a ese método esté avisado de que le puede llegar una excepción, en lugar del valor de retorno normal. Esto permite al programador que llama a ese método, elegir entre controlar la excepción o propagarla hacia arriba en la pila de llamadas. La siguiente línea de código muestra la forma general en que un método declara excepciones que se pueden propagar fuera de él, tal como se ha visto a la hora de tratar la sentencia throws:tipo_de_retorno( parametros ) throws e1,e2,e3 { }
Los nombres e1,e2,... deben ser nombres de excepciones, es decir, cualquier tipo que sea asignable al tipo predefinido Throwable. Observar que, como en la llamada al método se especifica el tipo de retorno, se está especificando el tipo de excepción que puede generar (en lugar de un objeto Exception).

He aquí un ejemplo, tomado del sistema Java de entrada/salida:byte readByte() throws IOException;
short readShort() throws IOException;
char readChar() throws IOException;
void writeByte( int v ) throws IOException;
void writeShort( int v ) throws IOException;
void writeChar( int v ) throws IOException;

Lo más interesante aquí es que la rutina que lee un char, puede devolver un char; no el entero que se requiere en C. C necesita que se devuelva un int, para poder pasar cualquier valor a un char, y además un valor extra (-1) para indicar que se ha alcanzado el final del fichero. Algunas de las rutinas Java lanzan una excepción cuando se alcanza el fin del fichero.

Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se puede cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a través de un método. Normalmente, el texto del mensaje proporcionará información para resolver el problema o sugerirá una acción alternativa. Por ejemplo:class SinGasolina extends Exception {
SinGasolina( String s ) { // constructor
super( s );
}
....
// Cuando se use, aparecerá algo como esto
try {
if( j < 1 )
throw new SinGasolina( "Usando deposito de reserva" );
} catch( SinGasolina e ) {
System.out.println( o.getMessage() );
}
Esto, en tiempo de ejecución originaría la siguiente salida por pantalla:> Usando deposito de reserva
Otro método que es heredado de la superclase Throwable es printStackTrace(). Invocando a este método sobre una excepción se volcará a pantalla todas las llamadas hasta el momento en donde se generó la excepción (no donde se maneje la excepción). Por ejemplo:// Capturando una excepción en un método
class testcap {
static int slice0[] = { 0,1,2,3,4 };
public static void main( String a[] ) {
try {
uno();
} catch( Exception e ) {
System.out.println( "Captura de la excepcion en main()" );
e.printStackTrace();
}
}
static void uno() {
try {
slice0[-1] = 4;
} catch( NullPointerException e ) {
System.out.println( "Captura una excepcion diferente" );
}
}
}
Cuando se ejecute ese código, en pantalla observaremos la siguiente salida:> Captura de la excepcion en main()
> java.lang.ArrayIndexOutOfBoundsException: -1
at testcap.uno(test5p.java:19)
at testcap.main(test5p.java:9)
Con todo el manejo de excepciones podemos concluir que se proporciona un método más seguro para el control de errores, además de representar una excelente herramienta para organizar en sitios concretos todo el manejo de los errores y, además, que se pueden proporcionar mensajes de error más decentes al usuario indicando qué es lo que ha fallado y por qué, e incluso podemos, a veces, recuperar al programa automáticamente de los errores.

La degradación que se produce en la ejecución de programas con manejo de excepciones está ampliamente compensada por las ventajas que representa en cuanto a seguridad de funcionamiento de esos mismos programas.

tipos de datos

a.) Tipos de datos enteros:
Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long.

Literales enteros
Son básicos en la programación en Java y presentan tres formatos:
Decimal: Los literales decimales aparecen como números ordinarios sin ninguna notación especial.
Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X inicial, notación similar a la utilizada en C y C++.
Octal: Los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en decimal, como 0xC en hexadecimal, y como 014 en octal.

b.) Tipo de datos boolean:
Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y false. Representan valores bi-estado, provenientes del denominado álgebra de Boole.

Literales Booleanos
Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de falso se representaba por un 0 numérico, y verdadero cualquier número que no fuese el 0.
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean:
boolean reciboPagado = false; // ¡¿Aun no nos han pagado?!.

c .) Tipo de datos carácter:
Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres Unicode se compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin signo de 16 bits.
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.

Literales carácter
Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro de un par de comillas simples. De forma similar que en C/C++. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter.

Tipos de variables

Las variables, también llamadas caracteres cuantitativos, son aquellas cuyas variaciones son susceptibles de ser medidas cuantitativamente, es decir, que pueden expresar numéricamente la magnitud de dichas variaciones. Por intuición y por experiencia sabemos que pueden distinguirse dos tipos de variables; las continuas y las discretas .

Las variables continuas se caracterizan por el hecho de que para todo para de valores siempre se puede encontrar en valor intermedio, (el peso, la estatura, el tiempo empleado para realizar un trabajo, etc.)

Una variable es continua, cuando puede tomar infinitos valores intermedios dentro de dos valores consecutivos. Por ejemplo, la estatura, el peso, la temperatura.

Las variables discretas serán aquellas que pueden tomar solo un número limitado de valores separados y no continuos; son aquellas que solo toman un determinado números de valores, porque entre dos valores consecutivos no pueden tomar ningún otro.

Multi Thead: soporta de modo nativo los threat o hilos, sin necesidad del uso de librerías especificas (como es el caso del c++). Esto le permite además que cada hilo de una duplicación java pueda correr en una CPU distinta, si la duplicación se ejecuta en una maquina que posee varias CPU. las aplicaciones c++ no son capaces de distribuir de modo transparente para el programador la carga entre varias CPU.
actividad:
averiguar para que sirben los siguientes comandos, funciones e interpretes que pertenecen al paquete java:
a) javac
b) java
c) apple viewer.
d) javadoc

Tipos de datos:
Investiga sobre los distintos tipos de datos y variables:
enteros, reales, carácter y buliano.
Variables.

Desarrollo

1-b)Java; es un lenguaje de programación orientado a objetos.A diferencia de los lenguajes de programación convencionales, que generalmente están diseñados para ser compilados a código nativo, Java es compilado en un bytecode que es ejecutado (usando normalmente un compilador JIT), por una máquina virtual Java.

El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos mucho más simple y elimina herramientas de bajo nivel como punteros.Java está sólo lejanamente emparentado con JavaScript, aunque tengan nombres similares y compartan una sintaxis al estilo de C algo parecida.

1-d)Javadoc; es una herramienta que viene integrada con el JDK. Es un ejecutable, como "javac" (el compilador) y también se especifican las clases que se quieren "compilar". Lo diferente con javadoc es que no genera código ejecutable (bytecode en el caso de Java), sino documentos html.
Personalmente veo a javadoc como otra gran bondad de ese lenguaje sobrehumano que es Java. Aligera una de las tareas que supongo que la mayoría de los programadores considera un estorbo: La documentación.

¿Cómo funciona javadoc? Es muy sencillo. A medida que se codifica una clase se colocan comentarios delimitados por "/**" y "*/" para indicar inicio y fin del comentario respectivamente. En medio puede ir cualquier cantidad de texto con los caracteres que se desee. Dichos comentarios se colocan justo sobre la declaración de atributos y métodos públicos. Los comentarios colocados sobre métodos y atributos privados son ignorados por defecto, porque de todas formas dado el principio de abstracción del paradigma de programación orientada a objetos no tiene sentido saber para qué sirven si no son accesibles.
El ejecutable javadoc parsea los archivos de las clases y organiza los documentos html. En caso de haber herencia, incluye también los comentarios de los métodos y atributos heredados. También dispone de etiquetas y palabras especiales para ayudar a especificar mejor ciertas cosas como los parámetros de un método.

Rendimiento Medio

en la actualidad la velocidad del procesado de código java es semejante a la de c++, hay siertas pruebas estándares de comparaciòn (bench mark), en la cuales java gana a c++ y viceversa. esto es asi gracias al uso de compiladores yust in time, los cuales traducen los bete codec de java en código para una determinada CPU que no presisa de la maquina virtual para ser ejecutado, y guardan el resultado de dicha combercion, voviendolo a llamar en caso de volverlos a necesitar, lo que se evita en este caso la sobre caso de trabajo asociada ala interpretacion de bitcodec

Arquitectura Natural

El código generado por el compilador Java es independiente de la arquitectura: podría
ejecutarse en un entorno UNIX, Mac o Windows.
El motivo de esto es que el que realmente
ejecuta el código generado por el compilador no es el procesador del ordenador directamente,
sino que este se ejecuta mediante una máquina virtual.

Java
Estructura y gestión de datos
En la actualidad existen diversos tipos de lenguajes que han sido creados para una determinada función, están especialmente diseñados para facilitar la programación de distintos tipos de problemas, garantizando la seguridad de las aplicaciones para obtener una mayor facilidad de programación y conseguir un mayor aprovechamiento de los recursos del ordenador.
Cuando un programador elige un lenguaje debe pensar en sus necesidades y la facilidad de la programación.
Como nuevos estudiantes de java debemos preguntarnos para que fue pensado este programa.

Que es java?
Java es un lenguaje de programación con el que podemos realizar cualquier tipo de programa. En la actualidad es un lenguaje muy extendido y cada vez cobra más importancia tanto en el ámbito de Internet como en la informática en general. Está desarrollado por la compañía Sun Microsystems con gran dedicación y siempre enfocado a cubrir las necesidades tecnológicas más punteras.

¿Para que se creo java?
La tecnología Java se creó como una herramienta de programación para ser usada en un proyecto de set-top-box (cuya traducción literal al español es aparato que se coloca encima del televisor, es el nombre con el que se conoce el dispositivo encargado de la recepción y opcionalmente decodificación de señal de televisión analógica o digital (DTV), para luego ser mostrada en un dispositivo de televisión) en una pequeña operación denominada the Green Project en Sun Microsystems en el año 1991


Características de java
Las características mas generales de java nos ayudaran haber para que tipo de problemas esta pensado este lenguaje:
Simple: es un lenguaje sencillo de aprender de sintaxis parecida ala de c++ pero mas simplificado. Cabe aclarar que los creadores de java partieron de la sintaxis de c++, tratando de eliminar las partes complicadas y las fuentes de error del lenguaje.
Orientado a objeto: posiblemente sea el lenguaje mas orientado a objeto de los existentes; en java todo a excepción de los tipos fundamentales de variables (int, char, long, etc.) es un objeto.
Distribuido: java esta muy orientado al trabajo en red soportando protocolos como tcp/IP, udp, http y ftp. El uso de estos protocolos es bastante sencillo comparándolo con otros lenguajes que los soportan
HTTP define la sintaxis y la semántica que utilizan los elementos software de la arquitectura Web (clientes, servidores, proxies) para comunicarse. Es un protocolo orientado a transacciones y sigue el esquema petición-respuesta entre un cliente y un servidor.

Robusto
El compilador java detecta muchos errores que otros compiladores solo detectarían en tiempo de ejecución o incluso nunca.
If(a=b) then, el compilador java no nos dejaría compilar este código.
Seguro: es un lenguaje muy seguro en cuanto al desarrollo de sus aplicaciones, especialmente en los apple. Esto son programas diseñados para ser ejecutados en una página Web. El programa java garantiza que ningún apple puede escribir o leer desde nuestro disco, o mandar información del usuario que accede ala pagina a través de la red (como por ejemplo la dirección de correo electrónico. En general no permite realizar cualquier acción que pudiera dañar la maquina o violar la intimidad del que visita la pagina Web.
portable: en java no hay aspectos dependientes de la inplementacion, java sigen los mismos estandares en cuanto a tamaño y almacenamiento de datos, esto no ocurre asi en c++ por ejemplo. en este un entero puede tener un tamaño de 16, 32, o mas bits siendo la unica limitacion que un entero sea mayor que un yort o menor que un long int. c++ vajo sistema operativo iunit almacena los datos en formatos littleendia mientras que vajo windon lo ase en formato big endia. java lo ase siempre en little endian para evitar comfucion.
nota: Big y Little Endian se refiere al formato en el cual un dato con múltiples bytes se ordena para escribirse en la memoria de una computadora.
En el formato Big Endian el extremo más grande de cualquier dato aparece en primer lugar. El segundo formato Little Endian se almacena al contrario, es decir al inicio se pone el dato más pequeño.
Conocer estos formatos nos ayudan a interpretar archivos correctamente, ya que el uso entre formatos Big-endian y Little endian depende de la arquitectura del procesador. Un ejemplo más concreto de esto es Intel(Little Endian) y Apple clásico (Big Endian).

Es PORTABLE :
Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa otros estándares de portabilidad para facilitar el desarrollo. Los enteros son siempre enteros y además, enteros de 32 bits en complemento a 2. Además, Java construye sus interfaces de usuario a través de un sistema abstracto de ventanas de forma que las ventanas puedan ser implantadas en entornos Unix, Pc o Mac.

Es INTERPRETADO :
El intérprete Java (sistema run-time) puede ejecutar directamente el código objeto. Enlazar (linkar) un programa, normalmente, consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por el ordenador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, que todavía no hay compiladores específicos de Java para las diversas plataformas, Java es más lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional.

Se dice que Java es de 10 a 30 veces más lento que C, y que tampoco existen en Java proyectos de gran envergadura como en otros lenguajes. La verdad es que ya hay comparaciones ventajosas entre Java y el resto de los lenguajes de programación, y una ingente cantidad de folletos electrónicos que supuran fanatismo en favor y en contra de los distintos lenguajes contendientes con Java. Lo que se suele dejar de lado en todo esto, es que primero habría que decidir hasta que punto Java, un lenguaje en pleno desarrollo y todavía sin definición definitiva, está maduro como lenguaje de programación para ser comparado con otros; como por ejemplo con Smalltalk, que lleva más de 20 años en cancha.

Es MULTITHREADED :
Al ser multithreaded (multihilvanado, en mala traducción), Java permite muchas actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente pequeños procesos o piezas independientes de un gran proceso. Al estar los threads contruidos en el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++.
El beneficio de ser miltithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded) tanto en facilidad de desarrollo como en rendimiento.

Cualquiera que haya utilizado la tecnología de navegación concurrente, sabe lo frustrante que puede ser esperar por una gran imagen que se está trayendo. En Java, las imágenes se pueden ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador.

Es DINAMICO :
Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API anterior).

Programacion Orientada a Objetos

Introducción

La programación orientada a objetos expresa un programa como un conjunto de objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener y reutilizar.

De esta forma, un objeto contiene toda la información que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de interacción llamados métodos que favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos.

Los métodos y atributos están estrechamente relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos para poder tratar los atributos con los que cuenta. El programador debe pensar indistintamente en ambos conceptos, sin separar ni darle mayor importancia a ninguno de ellos, hacerlo podría producir el hábito erróneo de crear clases contenedoras de información por un lado y clases con métodos que manejen a las primeras por el otro. De esta manera se estaría realizando una programación estructurada camuflada en un lenguaje de programación orientado a objetos.

Origen

Los conceptos de la programación orientada a objetos tienen origen en Simula 67, un lenguaje diseñado para hacer simulaciones, creado en el Centro de Cómputo Noruego en Oslo. Al parecer, en este centro, trabajaban en simulaciones de naves, y fueron confundidos por la explosión combinatoria de cómo las diversas cualidades de diversas naves podían afectar unas a las otras. La idea ocurrió para agrupar los diversos tipos de naves en diversas clases de objetos, siendo responsable cada clase de objetos de definir sus propios datos y comportamiento. Fueron refinados más tarde para ser un sistema completamente dinámico en el cual los objetos se podrían crear y modificar "en marcha" en lugar de tener un sistema basado en programas estáticos.

La programación orientada a objetos tomó posición como el estilo de programación dominante a mediados de los años ochenta, en gran parte debido a la influencia de C++, una extensión del lenguaje de programación C.

Las características de orientación a objetos fueron agregadas a muchos lenguajes existentes durante ese tiempo, incluyendo Ada, BASIC, Lisp, Pascal, entre otros. La adición de estas características a los lenguajes que no fueron diseñados inicialmente para ellas condujo a menudo a problemas de compatibilidad y a la capacidad de mantenimiento del código. Los lenguajes orientados a objetos "puros", por otra parte, carecían de las características de las cuales muchos programadores habían venido a depender. Para saltar este obstáculo, se hicieron muchas tentativas para crear nuevos lenguajes basados en métodos orientados a objetos, pero permitiendo algunas características imperativas de maneras "seguras". El Eiffel de Bertrand Meyer fue un temprano y moderadamente acertado lenguaje con esos objetivos pero ahora ha sido esencialmente reemplazado por Java, en gran parte debido a la aparición de Internet, y a la implementación de la máquina virtual de Java en la mayoría de navegadores. PHP en su versión 5 se ha ido modificando y soporta una orientación completa a objetos, cumpliendo todas las características propias de la orientación a objetos.

Conceptos fundamentales

La programación orientada a objetos es una nueva forma de programar que trata de encontrar una solución a estos problemas. Entre ellos destacan los siguientes:

Clase: definiciones de las propiedades y comportamiento de un tipo de objeto concreto. La instanciación es la lectura de estas definiciones y la creación de un objeto a partir de ellas, (de c a d),Es la facilidad mediante la cual la clase D ha definido en ella cada uno de los atributos y operaciones de C, como si esos atributos y operaciones hubiesen sido definidos por la misma D.

Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos). Se corresponde con los objetos reales del mundo que nos rodea, o a objetos internos del sistema (del programa). Es una instancia a una clase.

Método: algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se desencadena tras la recepción de un "mensaje". Desde el punto de vista del comportamiento, es lo que el objeto puede hacer. Un método puede producir un cambio en las propiedades del objeto, o la generación de un "evento" con un nuevo mensaje para otro objeto del sistema.

Evento: un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento, a la reacción que puede desencadenar un objeto, es decir la acción que genera.

Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de sus métodos con ciertos parámetros asociados al evento que lo generó.

Atributo: contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como sus características predeterminadas, y cuyo valor puede ser alterado por la ejecución de algún método.

Estado interno: es una variable que se declara privada, que puede ser únicamente accedida y alterada por un método del objeto, y que se utiliza para indicar distintas situaciones posibles para el objeto (o clase de objetos). No es visible al programador que maneja una instancia de la clase.
Componentes de un objeto:atributos, identidad, relaciones y métodos.

Representación de un objeto: un objeto se representa por medio de una tabla o entidad que esté compuesta por sus atributos y funciones correspondientes.

Características de la POO

Hay un cierto desacuerdo sobre exactamente qué características de un método de programación o lenguaje le definen como "orientado a objetos", pero hay un consenso general en que las características siguientes son las más importantes (para más información, seguir los enlaces respectivos):

Abstracción: Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción.

Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema. Algunos autores confunden este concepto con el principio de ocultación, principalmente porque se suelen emplear conjuntamente.

Principio de ocultación: Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su.

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando "tiempo de compilación") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.

Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes.