1

c.
r
L
e
o
a
rs
a
ar
r
ra
ay
ys
s
s
ae
n
óc
nr
ie
a
m
on
s

CURSO DE JAVA
c
(o
n
p
o
re
l
e
(Desarrollo de Software II)
jo
p
e
e
m
Documentación Resumen por Alba Cristal Muñoz :)
r
p
la
d
o
,o
r
cn
re
e
w
a
rs
e
g
u
u
n
i
n
d
u
o
e
v
d
o
e
l
a
r
rt
i
a
yp
o
 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 { class MiClase implements VideoClip {

void play() {
// comienza la reproduccion del video <código>}
void play();
void bucle() {
// reproduce el clip en un bucle <código>}
void bucle();
void stop() {
// detiene la reproduccion <código>}
void stop();
 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 public class Empleado {

Nombre
private String Nombre;
Apellido
private String Apellido;
Edad
private Int Edad;
registrar()
mostrar() 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 Al compilar y ejecutar la aplicación Java,

excepción de división por cero: 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 CLAVE
Toma de decisión if-else / switch-case
Bucle for / while / do-while
Misceláneo 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 class Ejemplo2

{ ---------------- { private int a, b, monedas;
---------------- -----------------
// Métodos sobrecargados -----------------
// Métodos constructores sobrecargados
// Método de objeto public Ejemplo2(int x, int y) {
c = c1.elMayor(c2); a = x; b = y; }

// Método de clase (Se trata de un método diferente, public Ejemplo2() { monedas = 50;
aunque tenga el mismo nombre, ya que tiene dos }
parámetros) // Los métodos tienen el mismo nombre, pero difieren en
c = Circulo.elMayor(c1, c2); } 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 BIDIMENSIONALES
tipo nombre_array[] = new tipo [nº] tipo nombre_array[][] = new tipo [nº]
tipo nombre_array[] = {valores} 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 VALOR

byte 0
short 0
int 0
long 0
float 0.0
double 0.0
char /u0000
boolean false
object null

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] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[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 EVENTO RESUMEN

Button ActionEvent Hacer click en el botón
Checkbox ItemEvent Seleccionar o deseleccionar un item.
CheckboxMenuItem ItemEvent Seleccionar o deseleccionar un item.
Choice ItemEvent Seleccionar o deseleccionar un item.
Component ComponentEvent Mover, cambiar tamaño, mostrar u ocultar un componente.
FocusEvent Obtener o perder el focus.
KeyEvent Pulsar o soltar una tecla.
MouseEvent Pulsar o soltar un botón del ratón; entrar o salir de un
componente; mover o arrastrar el ratón.
Container ContainerEvent Añadir o eliminar un componente de un container.
List ActionEvent Hacer doble click sobre un item de la lista.
ItemEvent Seleccionar o deseleccionar un item de la lista.
MenuItem ActionEvent Seleccionar un item de un menú.
Scrollbar AdjustementEvent Cambiar el valor de la scrollbar.
TextComponent TextEvent Cambiar el texto.
TextField ActionEvent Terminar de editar un texto pulsando intro.
Window WindowEvent Acciones sobre una ventana: abrir, cerrar, restablecer e iniciar
el cierre.
 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 first (Container cont);
- void last (Container cont);
- void previous (Container cont);
- void next (Container cont);
- void 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 default goto operator synchronized

boolean do if outer this
break double implements package threadsafe
byte else import private throw
byvalue extends inner protected throws
case false instanceof public transient
cast final int rest true
carch finally interface return try
char float long short var
class for native static void
const future new super volatille
continue generic null switch 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 CONVENCIÓN EJEMPLO
Nombre de una Clase Comienza con letra mayúscula Azul, Calculos
Nombre de Métodos Comienza con letra minúscula CalculaArea(), setColor()
Nombre de una Variable Comienza con letra minúscula area, base, altura
Nombre de una Constante En letras mayús ACMR, PI, ITBM

1.4. Tipos de Datos

TIPOS DE DATOS RANGO DE VALORES DESCRIPCIÓN

Números Enteros
byte 8-bit Entero de un byte
short 16-bit Entero corto
int 32-bit Entero
long 64-bit Entero largo
Números Reales
float 32-bit IEEE 754 Coma flotante de precisión simple
double 64-bit IEEE 754 Coma flotante de precisión doble
Otros Tipos
char 16-bit carácter Un sólo carácter
boolean True o False Un valor booleano (true / false)

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 SIGNIFICADO
\b Retroceso
\t Tabulación
\n Nueva línea
\f Avance de página
\r Retorno de carro sin avance de línea
\“ Dobles comillas ( “ ”)
\‘ Comillas simples ('')
\\ Barra inclinada inversa ( / )
\uxxxX Carácter Unicode
 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 2, 156, 56453645
octal 077, 07700 (empezando con un cero)
hexadecimal 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 3.14159, 2.0
E o e (valor esponencial) 105e25, 1.05E27
F o f (float) 279F, 2.79f
D o d (double) 279D, 2.79d

- El literal de carácter debe ir entre comillas simples ‘ ’. Utiliza la

siguiente notación:
cáracteres simples 'a'
cáracteres especiales '\t', '\n'
cáracteres Unicode '\u00BD'
 1.7.2. Simbólicas o con nombre:
- Sintáxis: static final tipoDato NOMBRECONSTANTE = valor;

static final double PI = 3.1416

Permite que sólo exista Sirve para que el Tipo de dato. El nombre de las
una copia de la valor asignado no constantes se suele
constante para todos pueda ser escribir en mayúscula.
los objetos que se modificado. Es
declaren de esa clase. obligatoria.

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 DESCRIPCIÓN
+ 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 a=a+1
-- Decremento a-- ó --a a=a -1

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 UTILIZACIÓN RESULTADO

&& and a && b True si a y b son true
|| or a||b True si a o b son true
! negación a! True si a es false, false si
a es true.
& and a&b True si a y b son true
(se evalua el valor 2)
| or a|b 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 EXPRESIÓN

+= a += b a=a+b
-= a -= b a=a-b
*= a*= b a= a * b
/= a /= b a=a/b
%= 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.*; import java.awt.Font;

Importar las clases declaradas públicas de un Importar una clase individual.

paquete completo, utilizando un asterisco (*) para
reemplazar los nombres de clase individuales.

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.
 System.out.println(“Invocación”);
2. Si el método devuelve void, una
llamada al método debe ser una // El método println ( ) devuelve void.
sentencia.

- 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; {
// clase inicializa public static void main(String [ ] arg)
public void asignar(int a1, int b1) {
{ a=a1; Resta objr = new Resta();
b=b1; objr.asignar(20,10);
} System.out.println(" Resta :" +
// clase que resta objr.calcular());
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 1. Creación de la clase class Fecha
reservada new { // declaración de //variables
<refObjeto> = new //declaración de los //métodos }
<NombreClase> ();
2. Declarar los objetos Fecha reunion;
- Ejemplo: 3. Crear el objeto reunion = new Fecha ()
Fecha reunión:
reunion = new Fecha ();

- 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.

class <NombrePrograma> static método controlado por la clase, no necesita

{ /* Definiciones globales*/ crear un objeto para llamarlo. (permite que
public static void main (String args[]) main sea llamado por el intérprete de Java
{ /* Definiciones locales*/ antes de que se cree cualquier objeto ).
/* cuerpo de instrucciones */ void indica que el método no devuelve ningún valor.
}
} (String args[]) declara una variable args que es un vector que
puede contener cadenas de caracteres por la
línea de comando.
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