1 c .

r e L a o r s a a r r r a a y y s s s a e n ó c n r i e m a o n s c ( o p n o r e l e j o e p m e p r l a o d , o r n c e r w e a r s e u g n u n i u d e o v o d e a l r r t a i y p o

CURSO DE JAVA
(Desarrollo de Software II)
Documentación Resumen por Alba Cristal Muñoz :)

CONTENIDO
I- TEORÍA
1. La API de JAVA 1.1. Definición 1.2. Estructura 1.3. Las Diez Librerias 1.4. Paquetes y sus Clases - java.lang - java.io - java.awt - java.util - java.math - java.text - java.beans - java.net - java.security - java.sql 2. Constructores 2.1. Definición 2.2. Formato 2.3. Ejemplos 3. Destructores 3.1. Definición 3.2. Garbage Collector 4. Estructuras de Control 4.1. Introducción 4.2. Sentencias condicionales: if-else y switch 4.2.1. Sentencia if-else 4.2.2. Sentencia switch 4.3. Sentencias de Iteración o Bucles: while, do-while y for 4.3.1. Bucle while 4.3.2. Bucle do-while 4.3.3. Bucle for 4.4. Sentencias de salto: break, continue y return 4.4.1. Sentencia break 4.4.2. Sentencia continue 4.4.3. Sentencia return

5. Sobrecarga de Métodos 5.1. Definición 5.2. Reglas para sobrecarga de métodos 5.3. Ejemplos de métodos sobrecargados 5.4. Invocación de métodos sobrecargados 5.5. Ejemplos 6. Excepciones 6.1. Concepto 6.1.1. Definición 6.1.2. ¿Qué es un Error? 6.1.3. Tratamiento de errores, funcionamiento de la pila de llamadas 6.2. Captura y Tratamiento de Errores 6.2.1. Try-catch 6.2.2. Try-catch-finally 6.2.3. Jerarquía y categorias de excepciones 6.2.4. Excepciones más frecuentes 6.2.5. Declarar, capturar, o propagar 6.2.6. Sentencia throw 6.2.7. Creación de excepciones de usuario 6.2.8. Ejemplos 7. Arreglos 7.1. Definición 7.2. Características 7.3. Declaración e Inicialización de Arreglos 7.5. Valores por Defecto 7.6. Ejemplos 8. Componentes Gráficos Básicos de JAVA 8.1. Qué es el AWT vs SWING 8.2. Componentes y Eventos 8.3. Layout Managers 8.3.1. FlowLayout 8.3.2. GridLayout 8.3.3. Border Layout 8.3.4. CardLayout 8.3.5. GridBagLayout

II- APLICACIÓN
1. Elementos Básicos 1.1. Comentarios 1.2. Palabras Reservadas 1.3. Identificadores 1.4. Tipos de Datos 1.5. Secuencia de Escape 1.6. Variables 1.7. Constantes 1.7.1. Literales 1.7.2. Simbólicas 1.8. Operadores 1.8.1. Operadores Aritméticos 1.8.2. Operadores Relacionales 1.8.3. Operadores Lógicos 1.8.4. Operadores de Asignación 1.8.5. Operadores Condicional '?' 1.9. Sentencias de Asignación 2. Estructura de un Programa 2.1. Sentencia 'import' 2.1 Clase 1.1.1. Atributos 1.1.2. Métodos 1.1.3. Objetos 2.3. Main 3. Entrada y Salida de Datos 3.1. Entrada y salida estándar (teclado y pantalla) 3.2. Métodos system.out.print() y system.out.println() 3.3. Método System.in.read() 3.4. Buffered Reader (lectura de cadenas) 3.5. JoptionPane 3.5.1. Entrada de datos con showInputDialog 3.5.2. Salida de datos con showInputDialog

III- REFERENCIAS BIBLIOGRÁFICAS

I- TEORÍA 1- LA API DE JAVA
1.1. Definición: El API de JAVA es una Interfaz de Programación de Aplicaciones, por sus siglas en inglés, provista por los creadores del lenguaje Java, y que da a los programadores los medios para desarrollar aplicaciones Java. Como el lenguaje Java es un 'Lenguaje Orientado a Objetos', la API de Java provee de un conjunto de clases utilitarias para efectuar toda clase de tareas necesarias dentro de un programa. La API Java está organizada en paquetes lógicos, donde cada paquete contiene un conjunto de clases relacionadas semánticamente. 1.2. Estructura 1.2.1. Paquetes: Un paquete en JAVA es un contenedor de clases que permite agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes.
package prueba; public class HolaMundo { public static void main (String [ ] args) { System.out.println

1.2.2. Interfaces: Las interfaces Java son expresiones puras de diseño. Se trata de auténticas conceptualizaciones no implementadas que sirven de guía para definir una determinado clase y lo que debe hacer, pero sin desarrollar un mecanismo de solución. Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel superior. Ejemplo: Las clases que quieran utilizar el interface VideoClip utilizarán la palabra implements y proporcionarán el código necesario para implementar los métodos que se han definido para el interface.
public interface VideoClip { // comienza la reproduccion del video void play(); // reproduce el clip en un bucle void bucle(); // detiene la reproduccion void stop(); class MiClase implements VideoClip { void play() { <código>} void bucle() { <código>} void stop() { <código>}

1.2.3. Clases: Las clases son lo más simple de Java. Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. Para crear una clase se utiliza la palabra reservada class y a continuación el nombre de la clase. La definición de la clase se pone entre las llaves de apertura y cierre.
Empleado Nombre Apellido Edad registrar() mostrar() public class Empleado { private String Nombre; private String Apellido; private Int Edad; public void registrar(){ } public void mostrar(){ } }

1.2.4. Excepciones: 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. Deberá lanzar (throw) una excepción que nosotros deberíamos capturar (catch) y resolver la situación de error. Existen varios tipos fundamentales de excepciones: • Error • Exception • RuntimeException

Ejemplo: El siguiente código de ejemplo origina una excepción de división por cero: Al compilar y ejecutar la aplicación Java, obtendremos la siguiente salida por pantalla:

class melon { > javac melon.java public static void main( String[] a ) { int i=0, j=0, k; > java melon k = i/j; // Origina un error de division-por-cero } java.lang.ArithmeticException: / } por cero at melon.main(melon.java:5)

1.3. Las Díez Librerias: La plataforma Java provee una librería de clases comunes útiles para ser usadas en su propia aplicación. Esta librería se conoce como "Interfaz de Programación de Aplicaciones" (API de Java). Sus paquetes representan las tareas más comúnmente asociadas con programación de propósito general. Las librerías se encuentran en 3 grupos que son: • Paquete de Utilidades. • Paquetes para el Desarrollo Gráfico. • Paquetes para el Desarrollo en la Red. 1.4. Paquetes y sus Clases - java.lang: contiene clases fundamentales e interfaces fuertemente relacionadas con el lenguaje y el sistema runtime. - java.io: las clases del paquete son principalmente streams; sin embargo, se incluye una clase para ficheros de acceso aleatorio. Las clases centrales del paquete son InputStream y OutputStream las cuales son clases abstractas. - java.awt: la Abstract Window Toolkit contiene herramientas para soportar operaciones básicas GUI (interfaz gráfica para el usuario). - java.util: contiene el marco colecciones, colección de clases heredadas, modelo de evento, fecha y tiempo de servicios, la internacionalización, y la utilidad de las clases diversas. - java.math: representa la librería matemática de Java. - java.text: proporciona clases e interfaces para el manejo del texto, fechas, números y mensajes de una manera independiente de las lenguas naturales. - java.beans: contiene clases relacionadas con el desarrollo componentes basados en la arquitectura JavaBeans. La mayoría de las clases en este paquete están destinados a ser utilizados por un editor. - java.net: java nació como lenguaje para la red y sólo sucesivamente se convirtió en un verdadero lenguaje de programación - java.security: proporciona las clases e interfaces para el marco de seguridad. Esto incluye las clases que implementan una fácil configuración, control de acceso de grano fino arquitectura de seguridad. - java.sql: se presenta como una colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo específico de base de datos.

- java.lang

public class StringBuffer { public static void main(String[] args) { StringBuffer name = new StringBuffer("Rolando"); name.append(", esta programando"); String nameStr1 = name.toString(); // Asigna una nueva cadena que contiene la secuencia de caracteres // Se encuentra el argumento de búfer de cadena String nameStr2 = new String(name); System.out.println("name:" + name)

} }

- java.io

import java.io.*; class Cifras { static int total=0; static int x=0; static int numCifras(int x){ while(x!=0){ x=x/10; total+=1; //incrementamos el contador } return total;

}

public static void main(String[]args) throws IOException{ BufferedReader leer = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Introduce un nu4mero:"); String linea = leer.readLine(); /*Convertirmos el string a un número. Podrías poner *un try y catch para comprobrar errores al convertirlo.Por *ejemplo si introducen un string*/ x= Integer.parseInt(linea); System.out.println("El numero de cifras es:"); //Imprimimos el número de líneas System.out.println(numCifras(x)); } }

- java.awt
import java.awt.*; public class PanelSolo { public static void main(String[] args) { Frame f = new Frame("Ejemplo"); Panel p0 = new Panel(); Panel p1 = new Panel(); Panel p2 = new Panel(); Panel p3 = new Panel(); Panel p4 = new Panel(); f.add(p0,"North"); f.add(p1,"West"); f.add(p2,"South"); f.add(p3,"Center"); f.add(p4,"East"); // Coloreo para distinguir los paneles. p0.setBackground(Color.blue); p3.setBackground(Color.white); p4.setBackground(Color.red); f.pack(); f.setVisible(true); } }

- java.util
import java.text.NumberFormat; import java.util.Locale; public class DecimalFormat1 { public static void main(String args[]) { // formato para el pais por defecto NumberFormat nf1 = NumberFormat.getInstance(); System.out.println(nf1.format(1234.56)); // formato para Alemania NumberFormat nf2 = NumberFormat.getInstance(Locale.GERMAN); System.out.println(nf2.format(1234.56)); } }

- java.text
import java.text.NumberFormat; import java.util.Locale; public class DecimalFormat1 { public static void main(String args[]) { // formato para el pais por defecto NumberFormat nf1 = NumberFormat.getInstance(); System.out.println(nf1.format(1234.56)); // formato para Alemania NumberFormat nf2 = NumberFormat.getInstance(Locale.GERMAN); System.out.println(nf2.format(1234.56)); } }

2- CONSTRUCTORES
2.1. Definición: El constructor de una clase es un método estándar para inicializar los objetos de esa clase Se invoca automáticamente cuando “new” crea un objeto de esa clase. Se caracteriza por: - El nombre del constructor tiene que se igual al de la clase. - Puede recibir cualquier número de argumentos de cualquier tipo, como cualquier otro método. - No devuelve ningún valor (en su declaración no se declara ni siquiera void). - Puede existir más de un constructor, e incluso no existir Si no se define ningún constructor de una clase, el compilador generará un constructor por defecto. El constructor por defecto no tiene argumentos y simplemente sitúa ceros en cada byte de las variables instancia de un objeto. Si se definen constructores para una clase, el constructor por defecto no se genera. 2.2. Formato: Para definir los constructores se emplea la siguiente sintaxis:
[visibilidad] nombreConstructor (listaParámetros) [throws listaExcepciones]

- Visibilidad: public (método accesible a través de una instancia del objeto), private (a través de una instancia no es accesible el método), protected (indica que a través de una instancia no es accesible el método), sin especificar (indica visibilidad de paquete, se puede acceder a través de una instancia, pero sólo de clases que se encuentren en el mismo paquete). - nombreConstructor: debe de coincidir con el nombre de la clase. - listaParámetros: lista de parámetros que tomará la función separados por comas. - listaExcepciones: nombre para todos esos posibles errores, la clausula opcional throws es empleada para indicar que, dentro del método, se pueden generar errores en su ejecución. El constructor posee un par de llaves, dentro de las cuales estará el código que se ejecutará al ser llamada la función. Dicho código estará formado por instrucciones válidas en el lenguaje, finalizadas generalmente por punto y coma.
class Dobby { int x, y; Dobby() { x=0; y=0; } // el constructor ... } Dobby a = new Dobby(); a.Print(); // 0 0

2.2. Ejemplos:
public class Constructor { int x; int y; int c; Constructor (int a, int b) // lleva el mismo nombre que la clase y esta recibiendo parámetros. { x=a; y=b; } int Evaluacion() { c=x+y; return (c); } public static void main(String[] args) { Constructor obj= new Constructor(5,4); // aquí se está creando el constructor y al mismo tiempo, se le están mandando parámetros. System.out.println("\n\t\t Ejemplo de un Constructor:\n"); System.out.print("\t La suma de dos valores:\n"); System.out.print("\t La suma de dos valores es..."+ obj.Evaluacion()); } }

Se pueden colocar varios constructores. Durante la creación de un objeto, se invoca aquel que calza con los argumentos dados:
class A { int x, y; A() { x=0; y= 0; } A(int ix, int iy) { x=ix; y=iy; } } class B { public static void main(String[] arg) { A a1= new A(); a1.Print(); // 0 0 A a2= new A(1,2); a2.Print(); // 1 2 } }

3- DESTRUCTORES
3.1. Definición: Un destructor es un método que se invoca automáticamente cuando el objeto se destruye. Java no posee destructores, porque tiene recolección de basuras. 3.2. Garbage Collector: Es un mecanismo implícito de gestión de memoria implementado en algunos lenguajes de programación de tipo interpretado o semi-interpretado. Cuando un lenguaje dispone de recolección de basura, el programador no tiene que invocar a una subrutina para liberar memoria. La reserva de memoria también es más o menos automática sin la intervención del programador. Por ejemplo:
• En los lenguajes orientados a objetos: se reserva memoria cada vez que el programador crea un objeto, pero éste no tiene que saber cuanta memoria se reserva ni cómo se hace esto.

En los lenguajes declarativos: cada vez que se construye una expresión se reserva memoria (de una manera inteligente), pero el programador no es consciente de ello.

Cuando se compila el programa, automáticamente se incluye en éste una sub-rutina correspondiente al recolector de basura. Esta subrutina también es invocada periódicamente sin la intervención del programador. El recolector de basura es informado de todas las reservas de memoria que se producen en el programa. Además, el compilador colabora para que sea posible llevar una cuenta de todas las referencias que existen a un determinado espacio de memoria reservado. Cuando se invoca el recolector de basura, recorre la lista de espacios reservados observando el contador de referencias de cada espacio. Si un contador ha llegado a cero significa que ese espacio de memoria ya no se usa y, por tanto, puede ser liberado.

4- ESTRUCTURAS DE CONTROL
4.1. Introducción Durante un programa existen acciones que se han de repetir un número determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificaría:
in.read(); in.read(); in.read();

Este código además de poco elegante sería inviable para una repetición de 3000 lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas acciones se realicen varias veces, mientras que una condición se cumpla, y en definitiva, tomar decisiones de qué hacer en función de las condiciones que se den en el programa en un momento dado de su ejecución.
int i=0; for ( i=0 ; i <= 3 ; i++ ) in.read();

Donde bastaría cambiar el 3 por cualquier otro número para que la lectura se repitiese ese número de veces. El lenguaje Java soporta las estructuras de control: SENTENCIA Toma de decisión Bucle Misceláneo CLAVE if-else / switch-case for / while / do-while break / continue / return

Aunque goto es una palabra reservada, actualmente el lenguaje Java no soporta la sentencia goto. Se puede utilizar las sentencias de bifurcación en su lugar. 4.2. Las sentencias condicionales: if-else y switch-case 4.2.1. La sentencia if-else: La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio. La sintaxis de la sentencia if-else es:
if ( condición ) Bloque de código a ejecutar si la condición es cierta else Bloque de código a ejecutar si la condición es falsa

La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía; para representar que en ese caso no se ha de ejecutar nada. Supongamos que un programa debe realizar diferentes acciones dependiendo de si el usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo. Nuestro programa puede realizar esto usando la sentencia if – else:
// La respuesta es Aceptar o Cancelar if (respuesta == Aceptar) { // código para realizar la acción Aceptar System.out.println( "Su peticion esta siendo atendida" ); } else { // código para realizar la acción Cancelar System.out.println( "Cancelando accion" ); }

Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else-if. Ejemplo: supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificacion: A para un valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:
int valor; char clasificacion; if (valor > 90) {clasificacion='A';} else if (valor > 80) {clasificacion='B';} else if (valor > 70) {clasificacion='C';} else {clasificacion='F';}

Este sistema de programación (else if) no es demasiado recomendable, y por ello el lenguaje Java incluye la sentencia switch, para dirigir el flujo de control de variables con múltiples valores. 4.2.2. La sentencia switch: Utilizando esta sentencia, podemos seleccionar entre varias sentencias según el valor de cierta expresión. Su forma general es:
switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break; }

La sentencia switch evalúa la expresiónMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la cláusula case cuyo valor corresponda con el de la expresiónMultivalor. Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch. Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break. Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado. Ejemplo: supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación:
int meses; switch ( meses ){ case 1: System.out.println( "Enero" ); break; case 2: System.out.println( "Febrero" ); break; case 3: System.out.println( "Marzo" ); break; //Demás meses // . . . case 12: System.out.println( "Diciembre" ); break; default: System.out.println( "Mes no valido" ); break; }

Por supuesto, se puede implementar esta estructura como una sentencia if else if:
int meses; if ( meses == 1 ) { System.out.println( "Enero" ); } else if ( meses == 2 ) { System.out.println( "Febrero" ); } // Y así para los demás meses

El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con más de tres o cuatro posibilidades.

4.3. Sentencias de iteración o bucles: for, do, while 4.3.1. Bucle while: El bucle while es el bucle básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición. La forma general del bucle while es la siguiente:
while ( expresiónBooleana ) { sentencias; };

Las sentencias se ejecutan mientras la expresiónBooleana tenga un valor de verdadero.
Ejemplo: Se utiliza para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100: int i = 1; while (i <= 100) { i = i * 2; }

4.3.2. Bucle do-while: El bucle do-while es similar al bucle while, pero en el bucle while la expresión se evalúa al principio del bucle y en el bucle do-while la evaluación se realiza al final. La forma general del bucle do-while es la siguiente:
do { sentencias; } while ( expresiónBooleana );

La sentencia do-while es el constructor de bucles menos utilizado en la programación, pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez. Ejemplo: cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter.
int c; do { c = System.in.read( ); // Sentencias para tratar el carácter c } while ( c != -1 ); // No se puede leer más (Fin fichero)

4.3.2. Bucle for: Mediante la sentencia for se resume un bucle do-while con una iniciación previa. Es muy común que en los bucles while y do-while se inicien las variables de control de número de pasadas por el bucle, de una vez antes de comenzar los bucles. Por eso el bucle for está tan extendido. La forma general de la sentencia for es la siguiente:
for ( iniciación ; terminación ; incremento ) sentencias;

- La iniciación es una sentencia que se ejecuta una vez antes de entrar en el bucle . - La terminación es una expresión que determina cuándo se debe terminar el bucle. Esta expresión se evalúa al final de cada iteración del bucle. Cuando la expresión se evalúa a falso, el bucle termina. - El incremento es una expresión que es invocada en cada iteración del bucle. En realidad puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable contador: for ( i = 0 ; i < 10 ; i++ ). Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre deben aparecer (aunque sea sin nada entre sí). Se debe utilizar el bucle for cuando se conozcan las restricciones del bucle (su instrucción de iniciación, criterio de terminación e instrucción de incremento). Ejemplo: los bucles for son utilizados comúnmente para iterar sobre los elementos de una matriz, o los caracteres de una cadena:
// cad es una cadena (String) for ( int i = 0; i < cad.length() ; i++){ // hacer algo con el elemento i-ésimo de cad }

4.4. Sentencias de salto: break, continue y return 4.3.1. Sentencia break: La sentencia break provoca que el flujo de control salte a la sentencia inmediatamente posterior al bloque en curso. El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la sentencia goto, que no es soportada por el lenguaje Java. Se puede etiquetar una sentencia poniendo una identificador Java válido seguido por dos puntos antes de la sentencia: nombreSentencia: sentenciaEtiquetada. La sentencia break se utiliza para salir de una sentencia etiquetada, llevando el flujo del programa al final de la sentencia de programa que indique:
break nombreSentencia2;

Ejemplo:
void gotoBreak() { System.out.println("Ejemplo de break como 'goto' "); a: for( int i=1; i<10; i++ ){ System.out.print(" i="+i); for( int j=1; j<10; j++ ){ if ( j==5 ) break a; //Sale de los dos bucles!!! System.out.print(" j="+j); } System.out.print("No llega aquí"); } }

Al interpretar break a, no solo se rompe la ejecución del bucle interior (el de j), sino que se salta al final del bucle i, obteniéndose: i=1 j=1 j=2 j=3. Nota: Se desaconseja esta forma de programación, basada en goto, y con saltos de flujo no controlados. 4.3.1. Sentencia continue: Del mismo modo que en un bucle se puede desear romper la iteración, también se puede desear continuar con el bucle, pero dejando pasar una determinada iteración. Se puede usar la sentencia continue dentro de los bucles para saltar a otra sentencia, aunque no puede ser llamada fuera de un bucle. Tras la invocación a una sentencia continue se transfiere el control a la condición de terminación del bucle, que vuelve a ser evaluada en ese momento, y el bucle continúa o no dependiendo del resultado de la evaluación. En los bucles for además en ese momento se ejecuta la cláusula de incremento (antes de la evaluación).
Ejemplo: el siguiente fragmento de código imprime los números del 0 al 9 no divisibles por 3:
for ( int i = 0 ; i < 10 ; i++ ) { if ( ( i % 3 ) == 0 ) continue; System.out.print( " " + i ); }

Del mismo modo que break, en las sentencias continue se puede indicar una etiqueta de bloque al que hace referencia. Con ello podemos referirnos a un bloque superior, si estamos en bucles anidados. Si dicha etiqueta no es indicada, se presupone que nos referimos al bucle en el que la sentencia continue aparece.
void gotoContinue( ) { f: for ( int i=1; i <5; i++ ) { for ( int j=1; j<5; j++ ) { if ( j>i ) { System.out.println(" "); continue f; } System.out.print( " " + (i*j) );

} } }

En este código la sentencia continue termina el bucle de j y continua el flujo en la siguiente iteración de i. Ese método imprimiría:
1 2 4 3 6 9 4 8 12 16

4.3.1. Sentencia return: Puede usar para salir del método en curso y retornar a la sentencia dentro de la cual se realizó la llamada. Para devolver un valor, simplemente se debe poner el valor (o una expresión que calcule el valor) a continuación de la palabra return. El valor devuelto por return debe coincidir con el tipo declarado como valor de retorno del método. Cuando un método se declara como void se debe usar la forma de return sin indicarle ningún valor. Esto se hace para no ejecutar todo el código.
int contador; boolean condicion; int devuelveContadorIncrementado(){ return ++contador; } void metodoReturn(){ //Sentencias if ( condicion == true ) return; //Más sentencias a ejecutar si condición no vale true }

5- SOBRECARGA DE MÉTODOS
5.1. Definición Java permite métodos sobrecargados (overloaded), es decir, métodos distintos que poseen el mismo nombre, y que se diferencian por el número y/o tipo de argumentos que poseen. 5.2. Reglas para sobrecarga de métodos
- Si los métodos van a tener el mismo nombre, deben tener diferentes parámetros, para que puedan ser distinguidos. - El valor de retorno no influye en la elección del método sobrecargado. En realidad, es imposible saber desde el propio método lo que se va a hacer con él. No es posible crear dos métodos sobrecargados que sólo difieran en el tipo de valor de retorno.

5.3. Ejemplos de métodos sobrecargados
class Ejemplo1 { ------------------------------// Métodos sobrecargados // Método de objeto c = c1.elMayor(c2); // Método de clase (Se trata de un método diferente, aunque tenga el mismo nombre, ya que tiene dos parámetros) c = Circulo.elMayor(c1, c2); } class Ejemplo2 { private int a, b, monedas; --------------------------------// Métodos constructores sobrecargados public Ejemplo2(int x, int y) { a = x; b = y; } public Ejemplo2() { monedas = 50; } // Los métodos tienen el mismo nombre, pero difieren en parámetros

5.4. Invocación de métodos sobrecargados A la hora de llamar a un método sobrecargado, Java sigue una serie de reglas para determinar el método concreto al que debe llamar: Si existe un método cuyos argumentos se ajustan exactamente al tipo de los argumentos de la llamada (argumentos actuales) entonces, se llama a ese método. Si no existe un método que se ajuste exactamente, se intenta promover los argumentos actuales al tipo inmediatamente superior (por ejemplo: char a int, int a long, float a double, etc.) y se llama al método correspondiente.

Si sólo existen métodos con argumentos de un tipo más restringido (por ejemplo, int en vez de long), el programador debe hacer un cast explícito en la llamada, responsabilizándose de esta manera, de lo que pueda ocurrir.

5.5. Ejemplos
public class Suma { public static void main (String arg[]) { System.out.println("¡Hola!"); Calculos c = new Calculos(); System.out.println("10 + 20 = " + c.suma() +"!!" System.out.println("30 + 10 = " + c.suma(30)); System.out.println("Fin"); } } class Calculos { int a = 10, b = 20; public int suma() { int x; x = a + b; return (x); } public int suma(int x) { return (x + 10); } }

public class Edad { public static void main(String arg[]) { Calculo_edad obj = new Calculo_edad(); System.out.println("Su nombre es: Juanito Trucupei"); System.out.println("Estamos en el año: 2010"); System.out.println("Usted nació en el año: 1992"); System.out.println("Su edad es:" +obj.calcular()); obj.calcular(18); }

} class Calculo_edad { int anio_a = 2010, anio_n = 1992; public int calcular() { int edad; edad = anio_a - anio_n; return edad; }

// No es posible crear dos métodos sobrecargados, que solo difieran en el valor de retorno. // Deben tener diferente cantidad o tipo de parámetros. public void calcular(int edad) { if (edad >= 18) { System.out.println("Usted es mayor de edad."); } else { System.out.print("Usted es menor de edad."); }

6- EXCEPCIONES
6.1. Concepto 6.1.1. Definición: Una excepción es la indicación de un problema que ocurre durante la ejecución de un programa. El nombre "excepción" viene del hecho de que, aunque puede ocurrir un problema, éste ocurre con poca frecuencia; si la regla es que una instrucción generalmente se ejecuta en forma correcta, entonces la excepción a la regla es cuando ocurre un problema. 6.1.2. ¿Qué es un Error?: Una excepción o un error 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. Si hay un error, la aplicación debe lanzar una excepción (throw) 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.

TIPOS DE ERRORES - Excepción: Se trata de un conjunto de excepciones que el programa del usuario debería capturar, es decir, resolver. - Error: Esta clase representa fallos, generalmente, no controlados que originan la parada del programa en ejecución. - Excepciones no capturadas: El propio interprete de java es el encargado de resolver el problema. - Excepciones capturadas: El programador debe encargarse de capturar y resolver el problema, si no lo hace el programa no compilará. 6.1.3. Tratamiento de errores, funcionamiento de la pila de llamadas: Pila de llamadas (en inglés call stack) es una estructura dinámica de datos LIFO, (una pila), que almacena la información sobre las subrutinas activas de un programa de computadora. La principal razón de su uso, es seguir el curso del punto al cual cada subrutina activa debe retornar el control cuando termine de ejecutar. El sistema de ejecución Java busca hacia atrás en la pila de llamadas para encontrar cualquier método que esté interesado en manejar una excepción particular. Un método Java puede "esquivar" cualquier excepción lanzada dentro de él, por lo tanto permite a los métodos que están por encima de él en la pila de llamadas poder capturarlo.

6.2. Captura y Tratamiento de Errores 6.2.1. Try-catch: La instrucción try-catch está compuesto por un bloque try que puede ir seguido por uno o más bloques catch. Los bloques catch especifican controladores para diferentes excepciones. Esta instrucción presenta una de las siguientes formas:
try try-block catch (exception-declaration-1) catch-block-1 catch (exception-declaration-2) catch-block-2 ... try try-block catch catch-block

La cláusula catch puede tomar un argumento de objeto derivado de la clase java.lang.Exception o una de sus subclases. Esto significa que puede capturar una excepción específica, como NumberFormatException, de este modo:
catch (NumberFormatException e) { // Exception handling statements. }

Es posible utilizar más de una cláusula catch específica en la misma instrucción try-catch. En este caso, el orden de las cláusulas catch es importante, ya que las cláusulas catch se examinan por orden. Capture las excepciones más específicas antes de las menos específicas, como se muestra en el código de ejemplo siguiente:
try { int x = Integer.parseInt(argv[0]); } catch (ArrayIndexOutOfBoundsException e) { System.out.println(e); } catch (NumberFormatException e) { System.out.println(e);} // The least specific catch (Exception e) { System.out.println(e);}

6.2.2. Try-catch-finally: Para los Bloques try/catch existe una variación que consiste en agregar una sección denominada finally, dicha estructura estaría compuesta de la siguiente manera:
try { // Código que pueda generar Errores ("Exception's") } catch(Tipo1 id1) { // Manejar "Exception's" para la Clase Tipo1 } catch(Tipo2 id2) { // Manejar "Exception's" para la Clase Tipo2 } catch(Tipo3 id3) { // Manejar "Exception's" para la Clase Tipo3 } finally { // Actividades que siempre ocurren }

La utilización de finally es empleada dentro de un Bloque try/catch para realizar tareas que deben ser ejecutadas independientemente del comportamiento de errores. Cuando se atrapa un error ("Exception") un programa queda inconcluso, es esta terminación abrupta la que puede causar que algún recurso/mecanismo permanezca asignado o mal utilizado; a través de una sección finally se garantiza que sea ejecutado un juego de instrucciones independientemente del tipo de error que pueda ocurrir; un uso muy común para una sección finally consiste en liberar conexiones hacia Bases de Datos que pudieran haber sido asignadas en la sección try. 6.2.3. Jerarquía y categorias de excepciones:

- En rojo: son las excepciones que es obligatorio controlar. - En azul: son las excepciones que no es obligatorio controlar. 6.2.4. Excepciones más frecuentes - ArithmeticException: Las excepciones aritméticas son típicamente el resultado de una división por 0: int i = 12 / 0;. - 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 intentar cambiar el tamaño de un array. 6.2.5. Sentencia throw: Todos los métodos Java utilizan la sentencia throw para lanzar una excepción. Esta sentencia requiere un sólo argumento, un objeto Throwable. En el sistema Java, los objetos lanzables son ejemplares de la clase Throwable definida en el paquete java.lang. - Ejemplo: throw algunObjetoThrowable;

Si se intenta lanzar un objeto que no es lanzable, el compilador rehusa la compilación del programa y muestra un mensaje de error similar a éste:
testing.java:10: Cannot throw class java.lang.Integer; it must be a subclass of class java.lang.Throwable. throw new Integer(4); ^

6.2.6. Creación de excepciones de usuario: También podemos lanzar nuestras propias excepciones, extendiendo la claseSystem.exception. Por ejemplo, consideremos 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 timeout:
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; }

6.2.8. Ejemplos:
import java.io.IOException; // ... public static void main(String[] args) { try { // Se ejecuta algo que puede producir una excepción } catch (IOException e) { // manejo de una excepción de entrada/salida } catch (Exception e) { // manejo de una excepción cualquiera } finally { // código a ejecutar haya o no excepción } }

7- ARREGLOS
7.1. Definición: Un arreglo es una colección de objetos numerados del mismo tipo, en donde cada variable o celda en el arreglo tiene un índice. Las celdas están numeradas del 0 al N-1, donde N es el número de celdas del arreglo es decir su capacidad. Java implementa los arreglos como objetos que pueden ser tratados como cualquier otro objeto. Para utilizar un arreglo en Java: 1. Declare una variable para que contenga el arreglo 2. Cree un nuevo arreglo de objeto y asígnelo a la variable de arreglo 3. Almacene información en ese arreglo 4. Realice operaciones de almacenamiento y recuperación con los elementos del arreglo 7.2. Características: - Los arrays se crean con el operador new seguido del tipo Y número de elementos. - Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo: vect.length). - Se accede a los elementos de un array con los corchetes [] y un índice que varía de length-1. - Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new. - Los elementos de un array se inicializan al valor por defecto del tipo correspondiente. - Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia. - Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método). 7.3. Declaración e Inicialización de Arreglos: Antes de poder utilizar un array, primero se debe declarar: int [] nombredearray;. La parte int[] de la declaración indica que nombredearray es un array de enteros. Existe otra forma de declarar arreglos y este depende de qué tipo de arreglo sea: UNIDIMENSIONALES tipo nombre_array[] = new tipo [nº] tipo nombre_array[] = {valores} BIDIMENSIONALES tipo nombre_array[][] = new tipo [nº] tipo nombre_array[][] = {valores}

Para inicializar un arreglo estan las maneras mostradas anteriormente: - int[] arreglo = new int[4] - int[] arreglo={100,200,300,400} Al momento de inicializar un arreglo de la manera: int[] arreglo = new int[4, cada posición del arreglo será inicializada con el valor por defecto del tipo de variable.

7.4. Valores por Defecto TIPO DE DATO byte short int long float double char boolean object 0 0 0 0 0.0 0.0 /u0000 false null VALOR

7.5. Ejemplos
class ArregloNombres { String[] nombres = { "Dennis", "Grace", "Bjarne", "James"}; String[] apellidos = new String[nombres.length]; void imprime() { int i = 0; System.out.println(nombres[i] i++; System.out.println(nombres[i] i++; System.out.println(nombres[i] i++; System.out.println(nombres[i] } {

+ " " + apellidos[i]); + " " + apellidos[i]); + " " + apellidos[i]); + " " + apellidos[i]);

public static void main (String arguments[]) ArregloNombres a = new ArregloNombres(); a.imprime(); System.out.println("-----"); a.apellidos[0] = "Ritchie"; a.apellidos[1] = "Hopper"; a.apellidos[2] = "Stroustrup"; a.apellidos[3] = "Gosling"; a.imprime();

} }

// Ejemplo de creación de un array en este caso de dos dimensiones: package ejemplos; public class matrices { public static void main( String args[] ) { // Declaramos el array con un tamano de 3 en su primera dimensión para // posteriormente declarar la segunda dimensión. int matriz[][] = new int[3][]; matriz[0] = new int[2]; matriz[1] = new int[3]; matriz[2] = new int[4]; // Ponemos datos en el array for ( int i=0; i < 3; i++ ) { for ( int j=0; j < matriz[i].length; j++ ) matriz[i][j] = i * j; } // y vemos su contenido, utilizando un bucle for for ( int i=0; i < 3; i++ ) { for ( int j=0; j < matriz[i].length; j++ ) System.out.print( matriz[i][j] ); System.out.println(); } // Intetamos acceder a un elemento que esta fuera de los limites del array System.out.println( "Elemento fuera de limites del array" ); matriz[4][0] = 7; // El compilador lanzara una excepción de tipo ArrayIndexOutOfBounds } }

8- COMPONENTES GRÁFICOS DE JAVA
8.1. ¿Qué es el AWT y SWING?: AWT es un conjunto de herramientas GUI (Interfaz Gráfica con el Usuario) diseñadas para trabajar con múltiples plataformas. Además del paquete java.awt, Java pone a disposición del programador el paquete javax.swing para crear unas interfaces gráficas. Swing ha sido totalmente escrito en Java utilizando el paquete awt, y pone a disposición del usuario muchas clases que están también en awt, pero mucho mejores y más potentes. Además introduce muchas más clases que no están en awt. 8.2. Componentes y Eventos
COMPONENTE Button Checkbox CheckboxMenuItem Choice Component EVENTO ActionEvent ItemEvent ItemEvent ItemEvent ComponentEvent FocusEvent KeyEvent MouseEvent Container List MenuItem Scrollbar TextComponent TextField Window ContainerEvent ActionEvent ItemEvent ActionEvent AdjustementEvent TextEvent ActionEvent WindowEvent Hacer click en el botón Seleccionar o deseleccionar un item. Seleccionar o deseleccionar un item. Seleccionar o deseleccionar un item. Mover, cambiar tamaño, mostrar u ocultar un componente. Obtener o perder el focus. Pulsar o soltar una tecla. Pulsar o soltar un botón del ratón; entrar o salir de un componente; mover o arrastrar el ratón. Añadir o eliminar un componente de un container. Hacer doble click sobre un item de la lista. Seleccionar o deseleccionar un item de la lista. Seleccionar un item de un menú. Cambiar el valor de la scrollbar. Cambiar el texto. Terminar de editar un texto pulsando intro. Acciones sobre una ventana: abrir, cerrar, restablecer e iniciar el cierre. RESUMEN

8.3. Layout Managers: Un Layout Managers es un objeto que controla como los componentes se sitúan en un Container. El AWT define cinco Layout Managers: dos muy sencillos (FlowLayout y GridLayout), dos más especializados (BorderLayout y CardLayout) y uno muy general (GridBagLayout). 8.3.1. FlowLayout: Los componentes se van añadiendo de izquierda a derecha y de arriba hacia abajo. Se puede elegir alineación por la izquierda, central o por la derecha, respecto al container. Esta clase tiene tres constructores:
- FlowLayout( ); - FlowLayout(int alineación); - FlowLayout(int alineación, int horizGap, int vertGap);

8.3.2. GridLayout: Se utiliza una matriz de celdas que se numeran de izquierda derecha y de arriba abajo. Todas las celdas tienen el mismo tamaño. Constructores:
- GridLayout(int nfilas, ncol); - GridLayout(int nfilas, int ncol, int horizGap, int vertGap);

8.3.3. Border Layout: El container se divide en 5 zonas: North, South, East, West y Center (que ocupa el resto del espacio). Si se aumenta el tamaño de la ventana todas las zonas se mantienen en su mínimo tamaño posible excepto Center, que absorbe casi todo el crecimiento. Por default BroderLayout no deja espacio entre componentes. Constructores:
- BorderLayout( ); - BorderLayout(int horizGap, int vertGap);

8.3.4. CardLayout: Permite disponer distintos componentes que comparten la misma ventana para ser mostrados sucesivamente. Son como diapositivas que van apareciendo una detrás de otra. Los siguientes métodos permiten controlar el orden en que aparecen las diapositivas:
void void void void void first (Container cont); last (Container cont); previous (Container cont); next (Container cont); show (Container cont, String nombre);

8.3.5. GridBagLayout: Se utiliza también una matriz de celdas, pero permite que algunos componentes ocupen más de una celda. La diferencia con GridLayout es que las filas pueden tener distinta altura, las columnas pueden tener distinta anchura, y además en el GridBagLayout un componente puede ocupar varias celdas contiguas.

II- APLICACIÓN 1. ELEMENTOS BÁSICOS
1.1. Comentarios En JAVA podemos hacer los comentarios de dos formas diferentes: utilizando '//' o '/* .. */' si el comentario se extiende a más de una línea.
// Comentario – Utilizó este si es solo una línea /* Comentario – Este si el comentario ocupa más de una línea */

1.2. Palabras Reservadas Son aquel grupo de palabras (identificadores) que no pueden ser utilizadas por el usuario par nombrar variables, funciones, métodos, objetos y demás elementos. Esto se debe a que el propio lenguaje ya las utiliza.
abstract boolean break byte byvalue case cast carch char class const continue default do double else extends false final finally float for future generic goto if implements import inner instanceof int interface long native new null operator outer package private protected public rest return short static super switch synchronized this threadsafe throw throws transient true try var void volatille while

1.3. Identificadores Son los nombres que reciben las clases, interfaces, paquetes, métodos, variables o instancias en un programa. Para su escritura esta lleva ciertas reglas generales: - Todos los identificadores han de comenzar con una letra, el carácter subrayado (_) o el carácter dollar ($). - Puede seguir con números o combinados. - No puede incluir caracteres de espacio en blanco. - Distingue entre letras mayúsculas y minúsculas. - No se pueden utilizar las palabras reservadas como identificadores.

IDENTIFICADOR Nombre de una Clase Nombre de Métodos Nombre de una Variable

CONVENCIÓN

EJEMPLO

Comienza con letra mayúscula Azul, Calculos Comienza con letra minúscula CalculaArea(), setColor() Comienza con letra minúscula area, base, altura ACMR, PI, ITBM

Nombre de una Constante En letras mayús

1.4. Tipos de Datos
TIPOS DE DATOS byte short int long float double char boolean RANGO DE VALORES Números Enteros 8-bit 16-bit 32-bit 64-bit 32-bit IEEE 754 64-bit IEEE 754 Otros Tipos 16-bit carácter True o False
Un sólo carácter Un valor booleano (true / false) Entero de un byte Entero corto Entero Entero largo

DESCRIPCIÓN

Números Reales
Coma flotante de precisión simple Coma flotante de precisión doble

1.5. Secuencia de Escape Las secuencias de escape son valores que se pueden incluir dentro de los print o println, también se pueden guardar como variables tipo 'String' y estas nos permiten: imprimir una nueva linea, dar espacio de tab, incluir retorno, entre otros.
SECUENCIA \b \t \n \f \r \“ \‘ \ \uxxxX Retroceso Tabulación Nueva línea Avance de página Retorno de carro sin avance de línea Dobles comillas ( “ ”) Comillas simples ('') Barra inclinada inversa ( / ) Carácter Unicode SIGNIFICADO

1.6. Variables: Almacenan datos cuyo valor puede ser modificado durante la ejecución de un programa. Un nombre que se asocia a una porción de memoria que recibe un valor como contenido. - Declaración de Variable: Para utilizar una variable se necesita declararla e indicar al compilador el nombre de la variable, así como el tipo de dato que representa. Sintáxis: tipoDato nombreVariable;. Java permite declarar las variables en cualquier parte de un bloque de instrucciones. EJEMPLOS DE VARIABLES DECLARADAS boolean b; int numero; float decimal=43.32f; int contador=0; char c=’a’; 1.7. Constantes Son datos cuyo valor no puede variar durante la ejecución de un programa. Java no soporta directamente constantes. Sin embargo, una variable static final es una constante. El modificador static hace que la variable que esté disponible sin tener que cargar una instancia de la clase donde se define. El modificador final hace que la variable a ser inmutable. En un programa pueden aparecer constantes de dos tipos: 1.7.1. Literales o por valor: - Por defecto siempre se consideran de tipo int. - Las constantes literales enteras se pueden representar en:
decimal octal hexadecimal 2, 156, 56453645 077, 07700 (empezando con un cero) 0xABFF, 0xCC00 (empezando con 0x)

- Seguido de L se considera long: 156L, 077L, 0xABFFL. - Un literal es de punto flotante si lleva:
Un punto decimal F o f (float) D o d (double) 3.14159, 2.0 279F, 2.79f 279D, 2.79d E o e (valor esponencial) 105e25, 1.05E27

- El literal de carácter debe ir entre comillas simples ‘ ’. Utiliza la siguiente notación:
cáracteres simples cáracteres especiales cáracteres Unicode 'a' '\t', '\n' '\u00BD'

1.7.2. Simbólicas o con nombre: - Sintáxis: static final tipoDato NOMBRECONSTANTE = valor; static
Permite que sólo exista una copia de la constante para todos los objetos que se declaren de esa clase.

final
Sirve para que el valor asignado no pueda ser modificado. Es obligatoria.

double
Tipo de dato.

PI = 3.1416
El nombre de las constantes se suele escribir en mayúscula.

1.8. Operadores: Los operadores de un lenguaje pueden cambiar o modificar los valores de un programa. Java define operadores aritméticos, relacionales, lógicos de manipulación de bits, de conversión de tipo, de clase, de selección y de asignación. 1.8.1. Operadores Aritméticos: Son operadores binarios (requieren siempre de dos operando) que realizan las operaciones aritméticas habituales.
OPERADOR + * / % ++ -Suma: a + b Resta a - b Multiplicación a * b División a / b Módulo a % b (residuo de la división) Incremento a++ ó ++a Decremento a-- ó --a a=a+1 a=a -1 DESCRIPCIÓN

1.8.2. Operadores Relacionales: Sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operando es siempre un valor boolean (true o false) según se cumpla o no la función considerada.
OPERADOR == != > < >= <= DESCRIPCIÓN Igualdad a = = b Desigualdad a != b Mayor que a > b Menor que a < b Mayor o igual a >= b Menor o igual a <= b

1.8.3. Operadores Lógicos: Se utilizan para construir expresiones lógicas, combinando valores lógicos (true y/o false) o los resultados de los operadores relacionales.
OPERADOR && || ! & | NOMBRE and or negación and or UTILIZACIÓN a && b a||b a! a&b a|b RESULTADO True si a y b son true True si a o b son true True si a es false, false si a es true. True si a y b son true (se evalua el valor 2) True si a o b son true (se evalua el valor 2)

1.8.4. Operadores de Asignación: Permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es: variable = expresión. Una expresión es un conjunto de operadores y operandos, pero una constante o variable también constituye una expresión.
OPERADOR += -= *= /= %= UTILIZACIÓN a += b a -= b a*= b a /= b a %= b EXPRESIÓN a=a+b a=a-b a= a * b a=a/b a=a%b

1.8.5. Operador Condicional '?': se utiliza en comparaciones, devolviendo un resultado cuyo valor depende de si la condición ha sido o no aprobada. Es equivalente a la sentencia if else. Su forma general es: Var = Condición ? sentencia 1: sentencia 2; Se evalúa la condición; si es true se ejecuta la sentencia 1, y si es false se ejecuta la sentencia 2. Es el único operador ternario (tres argumentos) de JAVA.

EJEMPLO

EQUIVALENCIA

x = 10; if (x>5) y = x > 5 ? 100 : 200; y=100; else y=200;

2. ESTRUCTURA DE UN PROGRAMA
2.1. Sentencia 'import': La sentencia 'import' sirve para establecer vínculos con otras clases de la biblioteca de java, o con clases propias. Sólo indica al compilador e intérprete de java dónde encontrar una (o varias) clases. En algunos casos puede omitirse; las clases públicas son importadas de manera automática para todos los programas. Debe escribirse antes de cualquier definición de clase. Para poder utilizar las clases que se agrupan en un paquete, se utiliza la instrucción:
import nombrepaquete.clases_a_importar

import java.awt.*;
Importar las clases declaradas públicas de un paquete completo, utilizando un asterisco (*) para reemplazar los nombres de clase individuales.

import java.awt.Font;
Importar una clase individual.

2.2. Clases: Patrones que indican cómo construir los objetos. Toda aplicación en java está formada por, al menos, una clase, la cual define un método denominado main (entrada y salida de la aplicación). CLASE Atributos Métodos Cuando se define una clase, el nombre de la clase se convierte en un nuevo tipo de dato y se utiliza tanto para:
- Declarar variables de ese tipo. - Como para crear objetos del mismo.

El programador elige los nombres de las clases, objetos y métodos. Debe hacerlo lo más significativo posible. Los nombres de las clases tienen características generales:

- Los nombres consisten de letras(mayúsculas y minúsculas) y dígitos (0-9). - Deben empezar con una letra. - La convención indica que los nombres de las clases empiezan con una letra mayúscula. - Los nombres de los objetos y métodos empiezan con letras minúsculas.
class <NombreClase> { // declaración de atributos <tipo> <variable>; // declaración de métodos <tipo> <nombreMétodo> ( <argumentos> ) { … } }

El nombre del fichero JAVA debe coincidir con el de la clase definida en él: <nombreclase>.java

- Estructura de una Clase
acceso class nombre de la clase { // atributos acceso tipo variable-1 ; acceso tipo variable-2; acceso tipo de variable-n; //métodos acceso tipo nombre_metodo1(lista de parámetros){cuerpo del metodo} acceso tipo nombre_metodo2(lista de parámetros){cuerpo del metodo} }

- Ejemplo
class Fecha { // Atributos int dia; int mes; int anno; // Métodos void asignarDía (int d) {…} String darFormato () {…} }

2.2.1. Atributos: características o propiedades de los objetos. Pueden ser variables numéricas o referencias a otros objetos. Una propiedad es una característica que posee un objeto la cual define su apariencia y afecta su comportamiento. 2.2.2. Métodos: Los métodos son acciones que se realizan por un objeto de una clase. Los métodos son bloques de código (subprogramas), definidos dentro de una clase. Existen dos tipos de métodos: los devuelven un valor único y aquellos que ejecutan alguna acción distinta de devolver un único valor. Los métodos que realizan alguna acción distinta de devolver un valor se denominan métodos void. - Invocación a un Método: La llamada o invocación a un método se puede realizar de dos formas, dependiendo de que el método devuelva o no un valor:
MÉTODO EJEMPLO

1. Si el método devuelve un valor, la int mayor = max(3,4); llamada al método se trata // Se llama al método max(3,4) y asigna el normalmente como un valor. resultado del método a la variable mayor.

2. Si el método devuelve void, una llamada al método debe ser una sentencia.

System.out.println(“Invocación”);
// El método println ( ) devuelve void.

- Definición de Métodos: Se define un método con la siguiente sintaxis:
<tipoRetorno> <nombreMétodo> (<lista argumentos>) { <bloqueCódigo> }

- <tipoRetorno>: tipo de dato que retorna el método (primivito o referencia, si no devuelve ningun valor debe ser void. - <nombreMétodo>: identificador del método. - <listaArgumentos>: el método admite que le pasen argumentos separados por comas con el formato:
[ <tipo> <argumento> [, <tipo> <argumento> … ]]

- Ejemplo
double tangente (double x) { return Math.sin(x) / Math.cos(x); } void imprimiHola() { System.out.println (“Hola”); } String darFormato (int dia, int mes, int anno) { String s; s = dia + “/” + mes + “/” + anno; return s; }

- Ejemplo Completo
/* Clase que realiza la resta */ /* Programa Principal */ class Resta class Principal_Resta { private int a, b; { public static void main(String [ ] arg) // clase inicializa public void asignar(int a1, int b1) { Resta objr = new Resta(); { a=a1; objr.asignar(20,10); b=b1; System.out.println(" Resta :" + } objr.calcular()); // clase que resta } public int calcular() } {return(a-b);} }

2.2.3. Objetos: Instancias de las clases en tiempo de ejecución. - Declaración: La declaración de un objeto simplemente asocia el objeto con una clase, haciendo al objeto una instancia de esa clase. La declaración no crea el objeto. Para crear el objeto de la clase se necesita utilizar el operador NEW, con el objeto de indicar a la computadora que cree un objeto y asigne espacio de memoria para ella.
CREACIÓN DE UN OBJETO
- Se utiliza la palabra reservada new <refObjeto> = new <NombreClase> (); - Ejemplo: Fecha reunión: reunion = new Fecha (); 1. Creación de la clase class Fecha { // declaración de //variables //declaración de los //métodos } Fecha reunion; reunion = new Fecha ()

2. Declarar los objetos 3. Crear el objeto

- Acceso a Datos y Métodos: después que se ha creado un objeto, se puede acceder a sus datos y métodos utilizando la notación siguiente:
nombreobjeto.datos Referencia a un dato de un objeto

nombreobjeto.método() Referencia a un método de objeto Fecha reunion = new Fecha (); reunion.dia = 15; reunion.mes = 12; reunion.anno = 2010; reunion.darFormato();

2.3. Main: El método main recibe un arreglo de Strings como único argumento.
// Este es el esqueleto de un programa en Java public accesible desde cualquier clase. método controlado por la clase, no necesita crear un objeto para llamarlo. (permite que main sea llamado por el intérprete de Java antes de que se cree cualquier objeto ). indica que el método no devuelve ningún valor. declara una variable args que es un vector que puede contener cadenas de caracteres por la línea de comando.

static class <NombrePrograma> { /* Definiciones globales*/ public static void main (String args[]) { /* Definiciones locales*/ /* cuerpo de instrucciones */ void } (String args[]) }

3. ENTRADA Y SALIDA
3.1. Entrada y salida estándar (teclado y pantalla) Están reguladas a través de la clase System. Contiene, entre otros, tres objetos static: - System.in: Objeto de la clase InputStream preparado para recibir datos desde la entrada estándar del sistema (habitualmente el teclado). - System.out: Objeto de la clase PrintStream que imprimirá los datos en la salida estándar del sistema (normalmente asociado con la pantalla). - System.err: Objeto de la clase PrintStream. Utilizado para mensajes de error que salen también por pantalla por defecto. 3.2. Métodos system.out.print() y system.out.println() - Pueden imprimir valores escritos directamente en el código o cualquier tipo de variable primitiva.
System.out.println("Hola!"); System.out.println(7); double numero PI = 3.141592654; System.out.println(numeroPI); String hola = new String("Hola"); System.out.println(hola);

- Se pueden imprimir varias variables en una llamada al método correspondiente utilizando el operador + de concatenación de cadenas de caracteres.
System.out.println(“Saludo: ! " + hola);

3.3. Método System.in.read() El método System.in.read() de la clase InputStream, lee un carácter por cada llamada. Su valor de retorno es un int, y si se espera cualquier otro tipo hay que hacer una conversión explícita mediante un cast.
char c; c=(char)System.in.read();

3.4. Buffered Reader (lectura de cadenas): Para que se lea una línea entera con una sola orden se utiliza un objeto BufferedReader.
BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in);

- InputStreamReader: convierte el flujo de bytes en cadena de caracteres. - readLine() : permite la entrada de datos desde teclado, pertenece a la clase BufferedReader.
variable=entrada.readLine();

Devuelve un objeto cadena con los caracteres leídos hasta encontrar el fin de línea, si no encuentra el fin de archivo devuelve null.

- Ejemplos:
import java.io.*; class Entrada { public static void main(String args[ ] ) throws IOException { InputStreamReader reader = new InputStreamReader(System.in); BufferedReader input = new BufferedReader(reader); System.out.print("Entre su nombre: "); String nom = input.readLine(); System.out.println("Hola, " + nom + "!"); } }

import java.io.*; class Edad { public static void main(String args[ ] ) throws IOException { InputStreamReader reader = new InputStreamReader(System.in); BufferedReader input = new BufferedReader(reader); System.out.print("Entre su Edad: "); String texto = input.readLine(); int edad = new Integer(texto).intValue(); System.out.println("Edad actual " + edad); int año = 2010 – edad; System.out.println(“Su año de nacimiento es:” + año); } }

3.5. JoptionPane La biblioteca de clases estándar de JAVA incluye una amplia gama de componentes para la construcción de interfaces gráficas de usuario. El componente javax.swing.JOptionPane se puede emplear para obtener datos de entrada y mostrar mensajes de salida. Cuando se emplea JOptionPane es aconsejable llamar a System.exit(0); para terminar la ejecución del programa - Formato de importación: import javax.swing.JOptionPane; / import javax.swing.*;

3.5.1. Entrada de datos con showInputDialog
String entrada; entrada = JoptionPane.showInputDialog ( "Introduzca un valor" );

entrada = JOptionPane.showInputDialog ( null,"Introduzca un valor", "Mi programa en Java", JOptionPane.QUESTION_MESSAGE );

entrada = JOptionPane.showInputDialog ( null, "Introduzca un valor”, “Otro programa en Java", JOptionPane.INFORMATION_MESSAGE );

3.5.2. Salida de datos con showMessageDialog
JOptionPane.showMessageDialog (null, “¡Bienvenido a Java!”);

JOptionPane.showMessageDialog (null, “¡Bienvenido a Java!”, “Programa de ejemplo”, JOptionPane.INFORMATION_MESSAGE );

JOptionPane.showMessageDialog (null, “¡Bienvenido a Java!”, “Programa de ejemplo”, JOptionPane.WARNING_MESSAGE );

JOptionPane.showMessageDialog (null, “¡Bienvenido a Java!”, “Programa de ejemplo”, JOptionPane.ERROR_MESSAGE );

III- REFERENCIAS BIBLIOGRÁFICAS
• API de JAVA: - http://download.oracle.com/javase/6/docs/api/ • Constructores: - http://programandoenjava.over-blog.es/article-32829724.html - http://javabasico.osmosislatina.com/curso/progbasico2/constructores.htm • Sobrecarga de Métodos: - http://www.ingenieriasw.com/sobrecargametodosjava - http://www.mitecnologico.com/Main/SobrecargaMetodos • Excepciones: - http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf - http://www.slideshare.net/jent46/excepciones-en-java-presentation - http://zarza.fis.usal.es/~fgarcia/doc/tuto2/II_8.htm • Arreglos: - http://www.slideshare.net/dare3_16/arreglos-en-java - http://delfosis.uam.mx/~sgb/Java/Arreglos.html • Componentes Gráficos (AWT & Swing) - http://usuarios.multimania.es/java_2000/pagina_nueva_1.htm - http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/IV_2.htm - http://www.htmlpoint.com/guidajava/java_27.htm - http://www.scribd.com/doc/19482326/Curso-de-Java2-AWT-y-Swing • JOptionPANE
- http://chuwiki.chuidiang.org/index.php?title=JOptionPane_y_di%C3%A1logos_modales

- http://www.javabeginner.com/java-swing/java-joptionpane-class-example - http://elvex.ugr.es/decsai/java/pdf/2F-Programas.pdf