Fundamentos de Java

(Docente Hugo Mamanchura Lima)

Fundamentos de Java

Indice
1

Bases de Lenguaje de Programacin Java .............................................................................. 4

1.1
Que es Java? ....................................................................................................................................... 4
Un Poco de Historia ......................................................................................................................................4
1.2
Caractersticas del Lenguaje ............................................................................................................. 4
Arquitectura .................................................................................................................................. ... 4
1.3
Estandares de Programacin ............................................................................................................. 5
Comentarios ................................................................................................................................. 5
Extensin...................................................................................................................................................... 5

TIPOS DE DATOS..................................................................................................................................... 5
2.1
Tipos de datos simples o Primitivos .................................................................................................. 5
Tipos de datos enteros................................................................................................................. .5
Tipos de datos en coma flotante .................................................................................................................. 6
Tipo de datos boolean.................................................................................................................. .6
Tipo de datos carcter ................................................................................................................. .6
2.2
Conversin de tipos de datos primitivos ............................................................................................ 6
2.3
Vectores y Matrices ........................................................................................................................... 7
2.4
Tipo de Dato basado en Clases - Cadenas ........................................................................................ 7
2.5
OPERADORES ...................................................................................................................................7
Operadores aritmticos................................................................................................................ .7
Operadores de comparacin y condicionales.............................................................................................. .8
Operadores de lgica de bits ....................................................................................................................... 8
Operadores de asignacin ........................................................................................................................... 8
2.6
Precedencia de operadores ................................................................................................................ 9

Arrays y Cadenas en Java......................................................................................................................... 9

3.1
Arrays................................................................................................................................................. 9
3.2
Strings............................................................................................................................................... 10
Concatenacin de Cadenas....................................................................................................... ..11
Funciones cadena....................................................................................................................................... 11

Sentencias de Control de Flujo en Java ................................................................................................ 12

4.1
4.2
4.3

La sentencia if-else.......................................................................................................................... 12
La sentencia switch ........................................................................................................................ 13
Sentencias de Bucle ........................................................................................................................ 15

Clases y Objetos en Java ......................................................................................................................... 17

5.1
Creacin de Clases........................................................................................................................... 17
5.2
Declaracin de La Clase.................................................................................................................. 17
Cuerpo de la clase ..................................................................................................................................... 17
5.3
Declaracin de Propiedades........................................................................................................... 18
5.4
Implementacin de mtodos .......................................................................................................... 18
5.5
Detalle de una declaracin de mtodo .......................................................................................... 19
Retorno de valor de un mtodo ............................................................................................................... 19
5.6
Sobrecarga de mtodos .................................................................................................................. 19
5.7
Creando Constructores para las Clases ........................................................................................ 19
5.8
Herencia ........................................................................................................................................ .20
Como funciona la herencia ...................................................................................................................... 20
Escondiendo Variables Miembro ............................................................................................................ 21
Sobreescritura de mtodos ..................................................................................................................... 21
Llamando el mtodo sobrescrito............................................................................................................... 22
Operador this ............................................................................................................................................ 22
Operador super ......................................................................................................................................... 22

2/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

Interfaces ....................................................................................................................................22
6.1
6.2
6.3

Que es una Interfaz?.........................................................................................................22

Definicin de una interfase ............................................................................................... 23
Implementacin de una interfaz ........................................................................................ 23

Creacin y Uso de Paquetes(Packages).................................................................................... 23

7.1
Creacin de un Paquete ..................................................................................................... 24
7.2
Nombrando un Paquete ..................................................................................................... 25
7.3
Usando miembros de un paquete ...................................................................................... 25
Referenciando a una clase miembro de un paquete por nombre..............................................25
Importar el paquete con la clase miembro................................................................................... 25
Importar el paquete completo ..................................................................................................... 25
7.4
Manejo de archivos fuente(*.java) y objeto(*.class) ........................................................ 26

Capturar y Manejar Excepciones ........................................................................................... 26

8.1
Manejo de Errores Usando Excepciones Java ................................................................ 26
8.2
Qu es un Excepcin y Por Qu Debo Tener Cuidado?................................................ 27
8.3
Bloques para Manejo de Errores...................................................................................... 27
El Bloque try ..............................................................................................................................27
Los bloques catch ...................................................................................................................... 27
El bloque finally .........................................................................................................................28
8.4
El Bloque Try .....................................................................................................................28
8.5
Los Bloques catch ..............................................................................................................28
Ocurre una IOException..............................................................................................................29
Capturar Varios Tipos de Excepciones con Un Manejador ........................................................30
8.6
El Bloque finally ................................................................................................................30

3/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

1 Bases de Lenguaje de Programacin Java

1.1 Que es Java?
Java es un lenguaje de programacin orientado a objetos, desarrollado por Sun Microsystems. En
poco tiempo, se ha convertido en el protagonista de toda tertulia electrnica que se
precie, arrebatndole este privilegio incluso a la aparicin de la reciente tercera
revisin del HTML. Java permite crear aplicaciones extensas. De hecho, cada vez
existen ms programas realizados en Java: navegadores, aplicaciones para crear tus propios
applets, etc. Es una forma de resolver simultneamente todos los problemas que se
le plantean a los desarrolladores de software por la proliferacin de arquitecturas
incompatibles, tanto entre las diferentes mquinas como entre los diversos sistemas
operativos y sistemas de ventanas que funcionaban sobre una misma mquina,
aadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet.

Un Poco de Historia

o
o

o
o

Sun Microsystem disea un lenguaje diseado para electrodomsticos

Lenguaje sencillo, pequeo, neutro
Ninguna empresa muestra inters por el lenguaje
1995 Java se introduce en Internet, lenguaje muy apropiado
Netscape 2.0 introduce la primea JVM en un navegador WWW
Filosofa Java "Write once, run everywhere"
1997 Aparece Java 1.1 muchas mejoras con respecto a 1.0

Oracle, Inprise, Hewtlett Packard, Netscape, etc.

1999 Java Enterprise Edition Java comienza a ser una plataforma de desarrollo

1998 Java 1.2 (Java 2) Plataforma muy madura, Apoyado por grandes empresas IBM,

profesional.

2005

Java es una plataforma madura soportada por las ms importantes corporaciones

empresariales como IBM, Oracle, etc.

1.2 Caractersticas del Lenguaje

Orientado a Objetos
Portable
Proposito general
Simple

Arquitectura

4/31
Docente : Hugo Mamanchura Lima

Distribudo
Seguro
Robusto
Arquitectura Neutral

Multiproceso
Dinmico
Interpretado

Fundamentos de Java

1.3 Estandares de Programacin

Criterios Generales de nombramiento en java
El nombre de un elemento en java esta formado por una o ms palabras.
No existen espacios en blanco entre una palabra y otra.
La primera letra de la primera palabra es mayscula solo para Clases e Interfaces el
resto de elementos empieza con minscula.
La primera letra de cada palabra adicional se debe escribir siempre en mayscula para

todo elemento.
Excepciones
Las constantes son todas las letras mayscula y los espacios entre palabras con subguion
_

Los paquetes son todos en minsculas

Elemento
Paquetes
Clases

Ejemplo
primerosegundo
PrimeroSegundo

Interfaces
Propiedades

PrimeroSegundo
primeroSegundo

Mtodos

primeroSegundo

Variables

primeroSegundo

Constantes

PRIMERO_SEGUNDO

Como nombrarlo
Nombre nico se escribe todo en minsculas
Nombres sustantivos siendo la primera letra de cada
palabra con Mayscula.
Similar a de las Clases
Generalmente Adjetivo, la primera letra con minscula,
las palabras internas empiezan con mayscula
Debe comenzar con un verbo en minscula y la primera
letra de las siguientes palabras (diferentes al verbo) con
mayscula
La primera letra con minscula, las palabras internas
empiezan con mayscula
Deben estar todas con maysculas y las palabras
separadas por el carcter de subrayado _

Comentarios
Los comentarios de documentacin, colocados inmediatamente antes de una declaracin (de
variable o funcin), indican que ese comentario ha de ser colocado en la documentacin que se

genera automticamente cuando se utiliza la herramienta de Java, javadoc.

// comentarios para una sola lnea
/* comentarios de una o ms lneas */
/** comentario de documentacin, de una o ms lneas */

Extensin
Archivos Fuente :
Archivos Pre Compilados :

.java
.class

2 TIPOS DE DATOS
2.1 Tipos de datos simples o Primitivos
Tipos de datos enteros
Tipo
byte
short
int
long

5/31
Docente : Hugo Mamanchura Lima

Tamao
1Byte (8 bits)
2 Bytes (16 bits)
4 Bytes (32 bits)
8 Bytes (64 bits)

Fundamentos de Java

Literales enteros
Decimal: sin ninguna notacin especial.
Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x 0X inicial
Octal: Los octales aparecen con un 0 inicial delante de los dgitos.
Por ejemplo, 12 en decimal, 0xC en hexadecimal, y como 014 en octal.
long numeroLargo = 0xC; // Por defecto vale 12

Tipos de datos en coma flotante

Tipo
Tamao
float
4 Byte (32 bits)
double
8 Bytes (64 bits)
Ejemplo:
double miPi = 314.16e-2 ; // Aproximadamente
float temperatura = (float)36.6; // Paciente sin fiebre

Tipo de datos boolean

Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso).
boolean reciboPagado = false; // Aun no nos han pagado?!

Tipo de datos carcter

Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres
Unicode se compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin
signo de 16 bits.
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.
Descripcin
Representacin Valor Unicote
\udddd
Carcter Unicote
\ddd
Numero octal
Barra invertida
\\
\u005C
Continuacin
\
\
\b
\u0008
Retroceso
\r
\u000D
Retorno de carro
Alimentacin de formularios
\f
\u000C
Tabulacin horizontal
\t
\u0009
\n
\u000A
Lnea nueva
\
\u0027
Comillas simples
Comillas dobles
\"
\u0022
Nmeros arbigos ASCII
0-9
\u0030 a \u0039
\u0041 a \u005A
Alfabeto ASCII en maysculas
A.-Z
Alfabeto ASCII en minsculas
a.-z
\u0061 a \u007A
char letraMayuscula = 'A'; // Observe la necesidad de las '
char letraV = '\u0056'; // Letra 'V'

2.2 Conversin de tipos de datos primitivos

En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el
que fue declarado. de la forma siguiente:
char c = (char)System.in.read();
La funcin read devuelve un valor int, que se convierte en un char debido a la conversin (char), y

el valor resultante se almacena en la variable de tipo carcter c.

6/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

Tipo Origen
Byte
Short
Char
Int
Long
Flota

Tipo Destino
double, float, long, int, char, short
double, float, long, int
double, float, long, int
double, float, long
double, float
Double

2.3 Vectores y Matrices

En Java los vectores se declaran utilizando corchetes ( [ y ] ), tras la declaracin del tipo de datos
que contendr el vector. Por ejemplo, esta sera la declaracin de un vector de nmeros enteros

(int):
int vectorNumeros[ ]; // Vector de nmeros
Para ello o se utiliza el operador new:
int vectorNumeros = new int[ 5 ]; // Vector de 5 nmeros
int vectorIni = { 2, 5, 8}; // == int vectorIni[3]=new int[3];

2.4 Tipo de Dato basado en Clases - Cadenas

En Java se tratan como una clase especial llamada
String. Las cadenas se gestionan
internamente por medio de una instancia de la clase String. Una instancia de la clase String es un

objeto que ha sido creado siguiendo la descripcin de la clase.

Vemos un ejemplo de cadena declarada con la clase String de Java:
String capitalUSA = "Washington D.C.";
String nombreBonito = "Amelia";

2.5 OPERADORES
Los operadores de Java se pueden dividir en las siguientes cuatro categoras:
Aritmticos.
De comparacin y condicionales.
A nivel de bits y lgicos.
De asignacin.

Operadores aritmticos
Operador Uso
+
op1 + op2
op1 - op2
*
op1 * op2
/
op1 / op2
%
op1 % op2

Descripcin
Suma op1 y op2
Resta op2 de op1
Multiplica op1 por op2
Divide op1 por op2
Calcula el resto de dividir op1 entre op2

Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones:
Operador Uso
Descripcin
Convierte op a entero si es un byte, short o
+
+op
char
-op
Niega aritmticamente op
Se evala al valor anterior al incremento;
++
op++
Incrementa op en 1
Incrementa op en 1; Se evala al valor posterior
++
++op
al incremento

7/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

--

op--

--

--op

Se evala al valor anterior al decremento;

Decrementa op en 1
Decrementa op en 1; se evala al valor
posterior al decremento

Operadores de comparacin y condicionales

Operador Uso
Devuelve verdadero si
>
op1 > op2
op1 es mayor que op2
>=
op1 >= op2
op1 es mayor o igual que op2
<
op1 < op2
op1 es menor que op2
<=
op1 <= op2
op1 es menor o igual que op2
==
op1 = = op2 op1 y op2 son iguales
!=
op1 != op2
op1 y op2 son distintos
Java soporta cinco operadores condicionales, mostrados en la siguiente tabla:
Operador Uso
Devuelve verdadero si...
op1
y
op2
son
ambos
verdaderos,
&&
op1 && op2 condicionalmente evala op2
op1 y op2 son ambos verdaderos, siempre
&
op1 & op2
evala op1 y op2
op1 o op2 son verdaderos, condicionalmente
||
op1 || op2
evala op2
op1 o op2 son verdaderos, siempre evala op1
|
op1 | op2
y op2
!
! op
Niega op (es falso si op es verdadero)
Operador logico ?:
x=expresion ? operacion1 : operacion2;
El operador ?: evala la expresion y devuelve operacin1 si es cierta, o devuelve operacin2 si
expresion es falsa.

Operadores de lgica de bits

En Java hay cuatro operadores de lgica de bits:
Operador Uso
Operacin
&
op1 & op2
AND
|
op1 | op2
OR
^
op1 ^ op2
OR Exclusivo
~
~op2
Complemento

Operadores de asignacin
Operador Uso
Equivalente a
=
op1 = op2
Asigna a op1 el valor de op2
+=
op1 += op2
op1 = op1 + op2
-=
op1 -= op2
op1 = op1 - op2
*=
op1 *= op2
op1 = op1 * op2
/=
op1 /= op2
op1 = op1 / op2
%=
op1 %= op2 op1 = op1 % op2
&=
op1 &= op2
op1 = op1 & op2

8/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

2.6 Precedencia de operadores

Cuando en una sentencia aparecen varios operadores el compilador deber de elegir en
Tipo de operadores
Operadores de este tipo
Operadores posfijos
[ ] . (parametros) expr++ expr-Operadores unarios
++expr --expr +expr -expr ~ !
Creacin o conversin
new (tipo) exp.
Multiplicacin
*/%
Suma
+Desplazamiento
<<
Comparacin
< <= = instanceof
Igualdad
== !=
AND a nivel de bit
&
OR a nivel de bit
^
XOR a nivel de bit
|
AND lgico
&&
OR lgico
||
Condicional
?:
Asignacin
= += -= *= /= %= &= ^= |= <<= = =

3 Arrays y Cadenas en Java

Al igual que otros lenguajes de programacin, Java permite juntar y manejar mltiples valores a
travs de un objeto array (matriz). Tambin se pueden manejar datos compuestos de mltiples

caracteres utilizando el objeto String (cadena).

3.1 Arrays
Esta seccin te ensear todo lo que necesitas para crear y utilizar arrays en tus programas Java.
Como otras variables, antes de poder utilizar un array primero se debe declarar. De nuevo, al igual
que otras variables, la declaracin de un array tiene dos componentes primarios: el tipo del array y
su nombre. Un tipo de array incluye el tipo de dato de los elementos que va contener el array. Por
ejemplo, el tipo de dato para un array que slo va a contener elementos enteros es un array de
enteros. No puede existir un array de tipo de datos genrico en el que el tipo de sus elementos

est indefinido cuando se declara el array. Aqu tienes la declaracin de un array de enteros.
int[] arrayDeEnteros;
La parte int[] de la declaracin indica que arrayDeEnteros es un array de enteros. La declaracin

no asigna ninguna memoria para contener los elementos del array.

Si se intenta asignar un valor o acceder a cualquier elemento de arrayDeEnteros antes de haber
asignado la memoria para l, el compilador dar un error como este y no compilar el programa.
testing.java:64: Variable arraydeenteros may not have been initialized.
Para asignar memoria a los elementos de un array, primero se debe ejemplarizar el array. Se

puede hacer esto utilizando el operador new de Java. (Realmente, los pasos que se deben seguir
para crear un array son similares a los se deben seguir para crear un objeto de una clase:

declaracin, ejemplarizacin e inicializacin.

9/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

La siguiente sentencia asigna la suficiente memoria para que arrayDeEnteros pueda contener

diez enteros.
int[] arraydeenteros = new int[10];
En general, cuando se crea un array, se utiliza el operador new, ms el tipo de dato de los
elementos del array, ms el nmero de elementos deseados encerrado entre corchetes cuadrados

('[' y ']').
TipodeElemento[] NombredeArray = new TipodeElementos[tamanoArray];
Ahora que se ha asignado memoria para un array ya se pueden asignar valores a los elemetos y

recuperar esos valores.

for (int j = 0; j < arrayDeEnteros.length; j ++) {
arrayDeEnteros[j] = j;
System.out.println("[j] = " + arrayDeEnteros[j]);
}

Como se puede ver en el ejemplo anterior, para referirse a un elemento del array, se aade
corchetes cuadrados al nombre del array. Entre los corchetes cuadrados se indica (bien con una
variable o con una expresin) el ndice del elemento al que se quiere acceder. Observa que en

Java, el ndice del array empieza en 0 y termina en la longitud del array menos uno.
Hay otro elemento interesante en el pequeo ejemplo anterior. El bucle for itera sobre cada
elemento de arrayDeEnteros asignndole valores e imprimiendo esos valores. Observa el uso de

arrayDeEnteros.length para obtener el tamao real del array.

proporcionada para todos los arrays de Java.

length es una propiedad

Los arrays pueden contener cualquier tipo de dato legal en Java incluyendo los tipos de referencia
como son los objetos u otros array. Por ejemplo, el siguiente ejemplo declara un array que puede

contener diez objetos String.

String[] arrayDeStrings = new String[10];
Los elementos en este array son del tipo referencia, esto es, cada elemento contiene una
referencia a un objeto String. En este punto, se ha asignado suficiente memoria para contener las
referencias a los Strings, pero no se ha asignado memoria para los propios strings. Si se intenta

acceder a uno de los elementos de arraydeStrings obtendr una excepcin 'NullPointerException'

porque el array est vacio y no contiene ni cadenas ni objetos String. Se debe asignar memoria de

forma separada para los objetos String.

for (int i = 0; i < arraydeStrings.length; i ++) {
arraydeStrings[i] = new String("Hello " + i);
}

3.2 Strings
Una secuencia de datos del tipo carcter se llama un string (cadena) y en el entorno Java est

implementada por la clase String (un miembro del paquete java.lang).

10/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

String[] args;
Este cdigo declara explcitamente un array, llamado args, que contiene objetos del tipo String.
Los corchetes vacios indican que la longitud del array no se conoce en el momento de la

compilacin, porque el array se pasa en el momento de la ejecucin.

El segundo uso de String es el uso de cadenas literales (una cadena de caracteres entre comillas "

y ").
"Hola mundo!"
El compilador asigna implicitamente espacio para un objeto String cuando encuentra una cadena

literal.
Los objetos String son inmutables - es decir, no se pueden modificar una vez que han sido

creados.
El paquete java.lang proporciona una clase diferente, StringBuffer, que se podr utilizar para crear

y manipular caracteres al vuelo.

Concatenacin de Cadenas
Java permite concatenar cadenas fcilmente utilizando el operador +. El siguiente fragmento de
cdigo concatena tres cadenas para producir su salida.
"La entrada tiene " + contador + " caracteres."
Dos de las cadenas concatenadas son cadenas literales: "La entrada tiene " y " caracteres.". La
tercera cadena - la del medio- es realmente un entero que primero se convierte a cadena y luego

se concatena con las otras.

Funciones cadena
Tipo de Dato
Devuelto Sintaxis del metodo y descripcinn
char charAt(int index)
Returns the char value at the specified index.
int
String
boolean
int

compareTo(String anotherString)
Compares two strings lexicographically.
concat(String str)
Concatenates the specified string to the end of this string.
equals(Object anObject)
Compares this string to the specified object.
indexOf(String str)
Returns the index within this string of the first occurrence of the specified

substring.
int

lastIndexOf(String str)
Returns the index within this string of the rightmost occurrence of the

specified substring.

11/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

int

length()
Returns the length of this string.

String

replace(char oldChar,char newChar)

Returns a new string resulting from replacing all occurrences of oldChar
in this string with newChar.

String

replaceAll(String regex,String replacement)

Replaces each substring of this string that matches the given regular
expression with the given replacement.

String

replaceFirst(String regex,String replacement)

Replaces the first substring of this string that matches the given regular

expression with the given replacement.

String[]

split(String regex)
Splits this string around matches of the given regular expression.

String

substring(int beginIndex)
Returns a new string that is a substring of this string.

String

substring(int beginIndex,int endIndex)

Returns a new string that is a substring of this string.

String

toLowerCase()
Converts all of the characters in this String to lower case using the

rules of the default locale.

String

toUpperCase()
Converts all of the characters in this String to upper case using the
rules of the default locale.

String

trim()
Returns a copy of the string, with leading and trailing whitespace omitted.

4 Sentencias de Control de Flujo en Java

Las sentencias de control de flujo determinan el orden en que se ejecutarn las otras sentencias

dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo.
Sentencias
palabras clave
toma de decisiones
if-else, switch-case
bucles
for, while, do-while
miscelaneas
break, continue, label:, return, exit
Nota: Aunque goto es una palabra reservada, actualmente el lenguaje Java no la soporta.
Podemos utilizar las rupturas etiquetadas en su lugar.

4.1 La sentencia if-else

La sentencia if-else de java proporciona a los programas la posibilidad de ejecutar selectivamente
otras sentencias basndose en algn criterio.
Por ejemplo, supon que tu programa imprime informacin de depurado basndose en el valor de

una variable booleana llamada DEBUG. Si DEBUG fuera verdadera true, el programa imprimira la

informacin de depurado, como por ejemplo, el valor de una variable como x. Si DEBUG es false
el programa proceder normalmente. Un segmento de cdigo que implemente esto se podra

parecer a este.
if (DEBUG)
System.out.println("DEBUG: x = " + x);

12/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

Esta es la versin ms sencilla de la sentencia if: la sentencia gobernada por if se ejecuta si

alguna codicin es verdadera. Generalmente, la forma sencilla de if se puede escribir as.

if (expresin)
sentencia
Pero, y si quieres ejecutar un juego diferente de sentencias si la expresin es falsa? Bien, puedes
utilizar la sentencia else. Echemos un vistazo a otro ejemplo. Supon que tu programa necesita

realizar diferentes acciones dependiendo de que el usuario pulse el botn OK o el botn Cancel en

un ventana de alarma. Se podra hacer esto utilizando una sentencia if.

...
// Respuesta dependiente del boton que haya pulsado el usuario
// OK o Cancel
...
if (respuesta == OK) {
...
// Cdigo para la accin OK
...
} else {

...
// cdigo para la accin Cancel
...
}

Este uso particular de la sentencia else es la forma de capturarlo todo.

Existe otra forma de la sentecia else, else if que ejecuta una sentencia basada en otra expresin.
Por ejemplo, supon que has escrito un programa que asigna notas basadas en la puntuacin de un
examen, un Sobresaliente para una puntuacin del 90% o superior, un Notable para el 80% o
superior y dems. odras utilizar una sentencia if con una serie de comparaciones else if y una

setencia else para escribir este cdigo.

int puntuacion;
String nota;
if (puntuacion >= 90) {
nota = "Sobresaliente";
} else if (puntuacion >= 80) {
nota = "Notable";
} else if (puntuacion >= 70) {
nota = "Bien";
} else if (puntuacion >= 60) {
nota = "Suficiente";
} else {

nota = "Insuficiente";
}

Una sentencia if puede tener cualquier nmero de sentencias de acompaamiento else if.
Podras haber observado que algunos valores de puntuacion pueden satisfacer ms una de las
expresiones que componen la sentencia if. Por ejemplo, una puntuacin de 76 podra evaluarse
como true para dos expresiones de esta sentencia:puntuacion >= 70 y puntuacion >= 60.
Sin embargo, en el momento de ejecucin, el sistema procesa una sentencia if compuesta como

una sla; una vez que se ha satisfecho una condicin (76 >= 70), se ejecuta la sentencia apropiada

(nota = "Bien";), y el control sale fuera de la sentencia if sin evaluar las condiciones restantes.

4.2 La sentencia switch

La sentencia switch se utiliza para realizar sentencias condicionalmente basadas en alguna
expresin. Por ejemplo, supon que tu programa contiene un entero llamado mes cuyo valor indica
el mes en alguna fecha. Supon que tambin quieres mostrar el nombre del mes basndose en su

nmero entero equivalente. Podras utilizar la sentencia switch de Java para realizar esta tarea.
13/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

int mes;
...
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("May0"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
}

La

sentencia

switch

evala

su

expresin,

en

este

caso

el

valor

de

mes,

ejecuta

la

sentencia case apropiada. Decidir cuando utilizar las sentencias if o switch dependen del juicio
personal.Puedes decidir cual tilizar basndose en la buena lectura del cdigo o en otros factores.
Cada sentencia case debe ser nica y el valor proporcionado a cada sentencia case debe ser del mismo tipo
que el tipo de dato devuelto por la expresin proporcionada a la sentencia switch.Otro punto de interes en la
sentencia switch son las sentencias break despus de cada case. La sentencia break hace que

el

control salga de la sentencia switch y contine con la siguiente lnea. La sentencia break es
necesaria
break

porque

explcito, el

las

sentencias

flujo

case

de control

se

seguira

siguen

ejecutando

secuencialmente

hacia
a

travs

abajo. Esto
de

es,

sin

un

las sentencias case

siguientes.En el ejemplo anterior, no se quiere que el flujo vaya de una sentencia case a otra, por eso se han
tenido que poner las sentencias break. Sin embargo, hay ciertos escenario en los que querrs que el control
proceda secuencialmente a travs

de

las

sentencias

case.

Como

este

cdigo

que

calcula

nmero de das de un mes de acuerdo con el tmico refrn que dice "Treinta dias tiene Septiembre...".

int mes;
int numeroDias;
...
switch (mes) {
case 1.
case 3.
case 5.
case 7.
case 8.
case 10.
case 12.
numeroDias = 31;
break;
case 4.
case 6.
case 9.
case 11.
numeroDias = 30;
break;
case 2.
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || ano % 400 == 0) )
numeroDias = 29;
else

14/31
Docente: Hugo Mamanchura Lima

el

Fundamentos de Java

numeroDias = 28;
break;
}

Finalmente, puede utilizar la sentencia default al final de la sentencia switch para manejar los
valores que no se han manejado explcitamente por una de las sentencias case.
int mes;
...
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
default: System.out.println("Ee, no es un mes vlido!");
break;
}

4.3 Sentencias de Bucle

Generalmente hablando, una sentencia while realiza una accin mientras se cumpla una cierta

condicin. La sintaxis general de la sentencia while es.

while (expresin)
sentencia
Esto es, mientras la expresin sea verdadera, ejecutar la sentencia.
sentencia puede ser una sla sentencia o puede ser un bloque de sentencias. Un bloque de

sentencias es un juego de sentencias legales de java contenidas dentro de corchetes('{'y '}').

Por ejemplo, supon que adems de incrementar contador dentro de un bucle while tambin quieres

imprimir el contador cada vez que se lea un carcter. Podras escribir esto en su lugar.
...
while (System.in.read() != -1) {
contador++;
System.out.println("Se ha leido un el carcter = " + contador);
}

...
Por convencin el corchete abierto '{' se coloca al final de la misma lnea donde se encuentra la

sentencia while y el corchete cerrado '}' empieza una nueva lnea indentada a la lnea en la que se

encuentra el while.
Adems de while Java tiene otros dos constructores de bucles que puedes utilizar en tus

programas.
el bucle for y el bucle do-while.
Primero el bucle for. Puedes utilizar este bucle cuando conozcas los lmites del bucle (su
instruccin de inicializacin, su criterio de terminacin y su instruccin de incremento). Por ejemplo,
el bucle for se utiliza frecuentemente para iterar sobre los elementos de un array, o los caracteres

de una cadena.
// a es un array de cualquier tipo
...
int i;
int length = a.length;
for (i = 0; i < length; i++) {

15/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

...
// hace algo en el elemento i del array a
...
}

Si sabes cuando estas escribiendo el programa que quieres empezar en el inicio del array, parar al
final y utilizar cada uno de los elementos. Entonces la sentencia for es una buena eleccin. La

forma general del bucle for puede expresarse asi.

for (inicializacin; terminacin; incremento)
sentencias
inicializacin es la sentencia que inicializa el bucle -- se ejecuta una vez al iniciar el bucle.
terminacin es una sentecia que determina cuando se termina el bucle. Esta expresin se evala al principio de cada
iteraccin en el bucle. Cuando la exprein se evala a false el bucle se termina. Finalmente, incremento es
una expresin que se invoca en cada interaccin del bucle. Cualquiera (o todos) de estos componentes puden ser
una sentencia vaca (un punto y coma). Java proporciona otro bucle, el bucle do-while,que es similar al bucle
while que se vi al principio, excepto en que la expresin se aval al final del bucle.
do {
sentencias
} while (Expresin Booleana);
La sentencia do-while se usa muy poco en la construccin de bucles pero tiene sus usos. Por
ejemplo, es conveniente utilizar la sentencia do-while cuando el bucle debe ejecutarse al menos
una vez. Por ejemplo, para leer informacin de un fichero, sabemos que al menos debe leer un

carcter.
int c;
InputStream in;
...
do {
c = in.read();
...
} while (c != -1);

16/31

Fundamentos de Java

5 Clases y Objetos en Java

5.1 Creacin de Clases
En resumen el siguiente diagrama muestra la estructura de la definicin de una clase.
Descripcin
Declaracin de Clase
Cuerpo de la clase.-

Declaracin de Propiedades
Cuerpo de la clase.Declaracin de Constructor

Cuerpo de la clase.Declaracin de Mtodos

Fin de la clase

Cdigo java
class Circulo {
private double x;
private double y;
private double r;
public Circulo(double p1,double p2,double p3){
this.x=p1;
this.y=p2;
this.r=p3;
}
public double calcArea(){
double a;
a=Math.PI*Math.pow(r,2);
return a;
}
public void imprimir(){
System.out.println("coordenada x: "+x);
System.out.println("coordenada y: "+y);
System.out.println("radio.......: "+r);
}
}

5.2 Declaracin de La Clase

El siguiente cuadro muestra los posibles componentes en la declaracin de una clase, los
componentes obligatorios estn en negrita el resto es opcional itlica representa un identificador.
Un componente opcional si no es especificado por el usuario java asumir valores por defecto.
La clase tiene acceso pblico
La clase no puede ser instanciada
La clase no pede tener subclases
Nombre de la clase
Hereda de una clase padre
Implementa interfaces(herencia multiple)

Public
Abstract
Final
class NombreClase
extends NombreClasePadre
implements Interfaces

Definicin de propiedades y mtodos

Cuerpo de la clase
}

Cuerpo de la clase
Contiene todo el cdigo que provee el ciclo de vida de un objeto creado a partir de esta clase.
Propiedades que proveen el estado de la clase y sus objetos
Constructores para la inicializacin de los objetos
17/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

Mtodos para implementar el comportamiento de la clase y sus objetos

En algunos casos el mtodo finaliza para limpiar el objeto una vez finalizada el trabajo.

5.3 Declaracin de Propiedades

El siguiente cuadro muestra una declaracin de una variable miembro o tambin llamada
propiedad de una clase.
Indica el nivel de acceso para la propiedad
La propiedad es solo de la clase(no del objeto)
Indica que es una constante
Tipo de dato y nombre del mtodo

Nivel de acceso
Static
Final
tipo nombre

Nivel de acceso
Permite controlar que otras clases pueden acceder a este elemento, tiene cuatro niveles de
acceso: public, protected, package, y private. El control de acceso para los mtodos es el mismo.
El siguiente cuadro muestra los niveles de acceso

Especificador\nivel de acceso

Clase

Subclase

Paquete

private

Protected

public

No especificado ( package)

Todo

static
Declara que es una propiedad de la clase y no de la instancia u objeto. Tambin se usa a nivel de
mtodos.
final
Indica que el valor no puede cambiar. Por convencin, el nombre de una constante es en

MAYUSCULAS.

5.4 Implementacin de mtodos

El siguiente cuadro muestra la estructura de un mtodo compuesto por su declaracin y su cuerpo.

Declaracin del Mtodo

Cuerpo del Mtodo

Fin del mtodo

public void imprimir(){

System.out.println("coordenada x: "+x);
System.out.println("coordenada y: "+y);
System.out.println("radio.......: "+r);
}

Al igual que una clase tiene dos partes fundamentales:

Declaracin del Mtodo y Cuerpo del Mtodo.

18/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

5.5 Detalle de una declaracin de mtodo

El siguiente cuadro muestra los elementos en la declaracin de una variable:
Indica el nivel de acceso para el mtodo
Nivel de acceso
El mtodo es solo de la clase(no del objeto)
Static
El mtodo no es instanciado
Abstract
El mtodo no puede ser sobrescrito
Final
Tipo de dato devuelto y nombre del mtodo
tipo nombre
Lista de parmetros o argumentos
(parmetros)
La Excepcin lanzada por este mtodo

throws exeptions

Nivel de acceso

Es el mismo que el de las propiedades:

Retorno de valor de un mtodo

Si el mtodo no devuelve ningn valor usar void como tipo de retorno.
Si el mtodo retorna un valor especificar el tipo de dato u objeto devuelto y debe usar el operador
return para devolver el valor.
El cuerpo del mtodo contiene todas las instrucciones java que implementa un mtodo.

5.6 Sobrecarga de mtodos

Java soporta sobrecarga de mtodos lo cual significa que varios mtodos de una clase pueden

tener el mismo nombre. La identidad de un mtodo se basa en la signatura de este el cual se forma

de los siguientes elementos:

nombre + tipo de argumentos + el numero de argumentos
En una clase no es posible repetir una misma signatura.
Por ejemplo una clase podra tener la declaracin de los siguientes mtodos
public double calcArea(){
//cdigo del mtodo
}
public double calcArea(int b, int h){
//cdigo del mtodo
}
public double calcArea(double b,double h){
//cdigo del mtodo
}

5.7 Creando Constructores para las Clases

Toda clase de java tiene por lo menos un constructor aun si no es declarado explcitamente java le

genera uno por defecto.

El constructor es un mtodo que se ejecuta al inicializar el objeto y su contenido de cdigo

generalmente inicializa las variables o propiedades de la clase.

El nombre de un mtodo constructor debe ser siempre el nombre de la clase.
En la clase Circulo defina arriba tiene declarada un constructor de forma explcita
Por ejemplo:
19/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

public Circulo(double p1,double p2,double p3){

this.x=p1;
this.y=p2;
this.r=p3;
}
Si no se hubiera declarado un constructor java declarara por defecto el siguiente:
public Circulo(){
}
El nivel de acceso del constructor determina el poder o no instanciar el objeto:
private
Ninguna otra clase puede instanciar el objeto
protected
Solo subclases pueden instanciar el objeto.
public
Cualquier clase puede instanciar el objeto.
No especificado
Solo desde una clase dentro del paquete puede ser instanciado.

5.8 Herencia
Como especificamos en la declaracin de la clase la clusula extends declara que la clase
definida es una subclase de otra. A esta clase padre se le denomina superclase. Una clase solo

puede tener solo una superclase.

Toda clase tiene una clase padre, si no es especificado java automticamente hereda de la clase

padre de todas Object la cual esta definida en el paquete java.lang.

Entonces toda clase en java hereda de la clase Object.

Una subclase es una clase que extiende (o hereda) de otra clase, esta subclase hereda el estado y

comportamiento de su padre el termino superclase refiere a la clase ancestral directa.

Como funciona la herencia

Una subclase hereda todas las propiedades y mtodos de su superclase y todos sus ancestros. La
subclase podra usar estos miembros (propiedades y mtodos) tal como los heredo o podra

sobrescribirlos.
Qu Miembros hereda una subclase?

20/31
Docente: Hugo Mamanchura Lima

Fundamentos de
Java

Una subclase hereda todos los miembros de la superclase, los constructores no son miembros y no son
heredados por las subclases.
Una subclase hereda todos los miembros de la superclase declarados como public o protected Los
miembros donde no se especificaron el nivel de acceso solo son heredados por
subclases
dentro del mismo paquete. Una subclase no hereda un miembro de la superclase si la
subclase declara un miembro con el mismo nombre. En el caso de las propiedades
miembro, una variable miembro con el mismo nombre esconde la variable miembro de la
superclase y en caso de los mtodos el mtodo sobrescribe el de la superclase.
La clase Object padre de todas las clases java La clase Object
se encuentra en el inicio de
la jerarqua de herencia de la plataforma Java toda clase en java es directa o indirectamente
subclase de Object.
Esta clase define las caractersticas bsicas de que todo objeto debe tener como:

El mtodo equals Compara dos objetos por igualdad devuelve verdadero si son
iguales .
El mtodo finalize Este mtodo limpia un objeto antes que el recolector de
basura(garbage collector)
El mtodo toString Devuelve la representacin en cadena de la clase.
El mtodo getClass Es un mtodo final
que devuelve
en tiempo de ejecucin de la clase de un objeto.

una

representacin

Escondiendo Variables Miembro

Una variable de una subclase esconde a otra con el mismo nombre en la superclase
Por ejemplo:
class Super {
Number aNumber;
}

class Subbie extends Super {

Float aNumber;
}

La variable aNumber en Subbie esconde aNumber en Super. Pero podra acceder a la variable
aNumber de Super desde Subbie con la sentencia super.aNumber.
Super es en el lenguaje Java una palabra clave que permite referenciar a la superclase.

Sobreescritura de mtodos
Cuando una subclase declara un mtodo con la misma signatura de un mtodo ya definido en la
superclase entonces este mtodo sobrescribe la de la superclase. Por ejemplo la clase Object
tiene el mtodo toString que devuelve un dato de tipo String con el nombre del objeto si se
crea una nueva clase y no se especifica su clase padre o superclase entonces hereda

directamente de la clase Object. Al declarar en Circulo un mtodo toString con la misma

signatura entonces este mtodo sobrescribir la de su superclase Object.
public class Circulo
{

public String toString() {

return (Esta clase maneja una entidad Circulo);
}
}

21/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

La sentencia c.toString llamara al mtodo definido en la subclase Circulo en ves de la superclase

Object.
Circulo c= new Circulo();
System.out.println(c.toString())

Llamando el mtodo sobrescrito

Algunas veces lo deseado es expandir la funcionalidad del mtodo heredado antes d e
sobrescribirlo, para ello es posible referencia al mtodo sobrescrito de la superclase con el
operador super. Por ejemplo: el siguiente mtodo declara un mtodo toString que usa la
funcionalidad del mtodo heredado y le agrega funcionalidad adicionndole una cadena descriptiva

al nombre de la clase devuelta por el mtodo toString de la clase Object.

public class Circulo
{

public String toString() {

return (Esta clase maneja una entidad +super.toString());
}
}

Operador this
tpicamente dentro del cuerpo de un mtodo se puede referenciar directamente a una variable
miembro (una propiedad) , sin embargo algunas veces tienes que referenciarlo mediante el

operador this.
Por ejemplo en el mtodo setr se ingresa un argumento con el mismo nombre que la variable
miembro si referenciamos a la variable miembro de forma directa mediante r esto causara una

ambigedad por no saber si estamos especificando a la variable miembro o al argumento. as en

este caso se podra referenciar a la variable miembro mediante this.r donde el operador this indica
que r es un miembro de la clase actual. Entones ahora si this.r reverenciara a la variable miembro

y r a la variable argumento del mtodo.

class Circulo {
int r;
public void setr (int r) {
this.r = r;
}

Operador super
al igual que this referencia la clase actual super referencia a la clase padre.

6 Interfaces
6.1 Que es una Interfaz?
Una interfase define un protocolo de comportamiento que puede ser implementado por cualquier
clase en cualquier lugar de la jerarqua de la clase. La interfaz define un conjunto de mtodos y

pero no los implementa. Una clase que implementa una interfaz acepta implementar todos los

mtodos definidos en la interfaz por lo que acepta cierto comportamiento.

22/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

Definicin: Una interfase es una coleccin de de nombres de definicin de mtodos sin

implementarlos. Adems puede tambin definir constantes.

6.2 Definicin de una interfase

La figura inferior muestra que una interfase tiene dos componentes : la declaracin de la

interfase la cual puede tener acceso publico y heredar de una lista de interfaces padre y el cuerpo
esta solo declara los mtodos pero no las implementa y adems puede tambin declara

constantes.
Declaracin de la interfaz
Cuerpo de la interfaz

public interface confComp extends supCnf {

final String sunT = "SUNW";
final String oracleT = "ORCL";
final String ciscoT = "CSCO";
void cambioValor(String s,double v);
}

6.3 Implementacin de una interfaz

Una interfaz define un protocolo de comportamiento y una clase que implementa la interfaz se une
al protocolo definido por la interfaz. Para que una clase implemente una interfase agregar la
clusula implements en la definicin de la clase. Es posible que una clase implemente mas de

una interfase estas debe especificarse separadas por comas

Por Convencin: la clusula implements continua despus de la clusula extens si existe.
Ejemplo de una implementacin de la interfaz supCnf:
public class ConfApplet extends Applet implements confComp {
...
public void cambioValor (String s,double v) {
if (s.equals(sunT)) {
...
} else if (s.equals(oracleT)) {
...
} else if (s.equals(ciscoT)) {
...
}
}
}

7 Creacin y Uso de Paquetes(Packages)

Para hacer fcil el encontrar y usar una clase ya creada, para manejar conflicto de nombres y
controlar el acceso los programadores en java generan grupos de clases relacionadas dentro de

paquetes.
Definicin.- Un Paquete (package) es una coleccin de clases e interfaces para proveer proteccin

de acceso y manejo de nombres.

Las clases e interfaces que son parte de la plataforma java son miembros de varios paquetes
organizados funcionalmente, por ejemplo: en java.lang estn las clases fundamentales yen

Java.io estn las clases para leer y escribir (input y output).

Tambin es posible poner nuestras clases en paquetes

23/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

Veamos por que es importe poner nuestra coleccin de clases dentro de un paquete. Supongamos
que escribimos un grupo de clases para manejar objetos

grficos como puntos, crculos,

rectngulos, tringulos lneas, etc.

//Archivo Punto.java
public class Punto{
...
}

//Archivo Figura.java
public abstract class Figura {
...
}

//Archivo Circulo.java
public class Circulo extends Figura {
...
}

//Archivo Triangulo.java
public class Triangulo extends Figura {
...
}

//Archivo Rectangulo.java
public class Rectangulo extends Figura {
...
}

Se debera juntar estas clases en un mismo paquete por varias razones::

Es fcil determinar para cualquier programador que estas clases estn relacionadas.
Permite conocer en que lugar (paquete) encontramos clases que proveen funcionalidades

graficas.
Los nombres de nuestras clases no estn en conflicto con otras del mismo nombre puesto

que un paquete genera su propio espacio de nombre.

Es posible restringir el nivel de acceso a las clases y sus atributos y propiedades desde

otras clases fuera del paquete.

7.1 Creacin de un Paquete

Para crear un paquete hay que especificar en la primera lnea de cdigo en el archivo fuente

,donde la clase es definida, la sentencia:

package paquete;
Por ejemplo las clases definidas en los siguientes archivos serian parte del paquete grficos:
//Archivo Figura.java
package graficos;
public abstract class Figura {
...
}

//Archivo Circulo.java
package graficos;
public class Circle extends Figura {
...
}

24/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

Si existen mltiples clases en un solo archive fuente solo uno puede ser publico y este debe tener
el mismo nombre que el archivo fuente (.java). solo clases publicas son acezadas desde fuera del

paquete.
A pesar de que es posible crear clases sin especificar el paquete es altamente recomendable para

aplicaciones con varias clases organizarlas en paquetes.

7.2 Nombrando un Paquete

Con programadores de todo el mundo es posible encontrar mas de una repeticin en el nombre de
un a clase incluso con las clases propias de la plataforma java. Por ello el nombre completo para
referenciar una clase empieza con el paquete al cual pertenece, por ejemplo nuestra clase

Circulo su nombre completo seria graficos.Circulo.

Esto debera ser suficiente para evitar repeticiones pero para asegurase es recomendable seguir

los estndares de java como:

Por Convencin:

Compaas deben usar su nombre de dominio reservado en Internet en el

nombre de sus paquetes por ejemplo: pe.com.mttvcorp.graficos.

7.3 Usando miembros de un paquete

solo paquetes pblicos pueden ser usados fuera del paquete para ello se debe hacer los siguiente:
Importar todas las clases del paquete
Importar el la clase sola
Referenciar la clase por su nombre completo (paquete.nombreclase)
Cada alternativa es mas adecuada que otra en diferentes situaciones.

Referenciando a una clase miembro de un paquete por nombre

Es posible referenciar la clase rectngulo creada en el paquete grficos de la siguiente forma
graficos.Rectangulo
usando esta referencia por ejemplo podemos instanciar un objeto de tipo rectngulo
graficos.Rectangulo Rect = new graficos.Rectangulo();

Importar el paquete con la clase miembro

Otra forma es importar Solo la clase miembro del paquete con la sentencia
:
import graficos.Rectangulo;
y luego poder referenciar la clase por su nombre simple:
Rectangulo Rect = new Rectangulo ();

Importar el paquete completo

Para importar el paquete completo usar el asterisco que indica todas las clases:
import grficos.*;
y ahora se podra referenciar por su nombre simple a cualquier clase dentro de ese paquete por

ejemplo:
Rectangulo Rect = new Rectangulo ();
Circulo cir = new Circulo();

25/31
Docente: Hugo Mamanchura Lima

Fundamentos de Java

Por defecto todo programa java importa automticamente todas las clases del paquete java.lang
y del paquete por defecto.

7.4 Manejo de archivos fuente(*.java) y objeto(*.class)

Poner el cdigo fuente para clase o interfase en un archive de texto plano cuyo nombre es el de
clase o interfaz y su extensin es .java. luego poner el archivo fuente en un directorio cuyo nombre

es el mismo que el del nombre de paquete indicado en el archivo fuente.

Por ejemplo la clase Rectngulo que pertenece al paquete grficos fsicamente debera estar en un

archivo Rectangulo.java y esta estar en una carpeta llamada grficos.

Grficos
package graficos;
:Recatangulo.java
public class Rectangulo {
...
}

Entonces el nombre complete de la clase rectngulo y su ruta fsica en un sistema operativo

Windows seria:
graficos.Rectangulo
Nombre de la clase
Ruta del archivo

Graficos\Rectangulo.java

Ahora si seguimos las convenciones de nombres de java y nombramos al paquete contenedor de

nuestras clase

incluyendo el nombre de dominio de Internet esto exigira que cada componente

del paquete tenga su respectiva carpeta al mismo nivel es decir para el paquete
pe.com.mttvcorp.graficos se tendra que crear cuatro directorios la desde pe hasta grficos

y uno conteniendo al otro como en la figura:

.
package pe.com.mttvcorp.graficos;
public class Rectangulo
...

Pe
:.com
:.mttvcorp
:.grficos
:Recatangulo.java

Al compilar un cdigo fuente el compilador de java genera un archivo .class deferente para cada
clase definida en el archive fuente en otras palabras si el mismo archivo fuente .java tiene definida las clases Punto
y Figura entonces al compilarse se generan dos archivos Punto.class y Figura.class.
Los archivos .class deben respetar la misma estructura fsica que los archivos fuentes. Es

recomendable separar los archivos fuente de las clases en diferentes lugares fsicos
Ambos el compilador y el interprete (virtual machine) buscan las clases en directorios o archivos

comprimidos (*.zip,*.jar, etc) listados el la variable de sistema operativo CLASSPATH.

Definicin:

CLASSPATH es una lista ordenada de directorios o archivos comprimidos donde

buscar archivos de tipo .class

Cada directorio listado en el CLASSPATH es el mximo nivel o el directorio raz en donde deben
encontrarse los directorios del paquete. El compilador y el interprete puede reconstruir el resto de

la ruta basado en el paquete y el nombre de la clase para cada clase.

8 Capturar y Manejar Excepciones

8.1 Manejo de Errores Usando Excepciones Java
Existe una regla de oro en el mundo de la programacin: en los programas ocurren errores.
Esto es sabido. Pero qu sucede realmente despus de que ha ocurrido el error? Cmo se

maneja el error? Quin lo maneja?, Puede recuperarlo el programa?

26/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

El lenguaje Java utiliza excepciones para proporcionar capacidades de manejo de errores. En esta leccin
aprenders qu es una excepcin, cmo lanzar y capturar excepciones, qu hacer con una excepcin una
vez capturada, y cmo hacer un mejor uso de las excepciones heredadas de las
Clases proporcionadas por el entorno de desarrollo de Java.

8.2 Qu es un Excepcin y Por Qu Debo Tener Cuidado?

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

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

Ventaja 2: Propagar los Errores sobre la Pila de Llamadas

Ventaja 3: Agrupar los Tipos de Errores y la Diferenciacin de stos

8.3 Bloques para Manejo de Errores

El Bloque try
El primer paso en la escritura de una manejador de excepciones es poner la sentencia Java dentro
de la cual se puede producir la excepcin dentro de un bloque try. Se dice que el bloque
try
gobierna las sentencias encerradas dentro de l y define el mbito de cualquier manejador de
excepciones (establecido por el bloque catch subsecuente) asociado con l.

Los bloques catch

Despus se debe asociar un manejador de excepciones con un bloque try proporcionndole uno o
ms bloques catch directamente despus del bloque try.

27/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

El bloque finally
El bloque finally de Java proporciona un mecanismo que permite a sus mtodos limpiarse a si
mismos sin importar lo que sucede dentro del bloque try. Se utiliza el bloque finally para cerrar

ficheros o liberar otros recursos del sistema.

8.4 El Bloque Try

El primer paso en la construccin de un manejador de excepciones es encerrar las sentencias que
podran lanzar una excepcin dentro de un bloque try. En general, este bloque se parece a esto.
try {
sentencias Java
}

El segmento de cdigo etiquetado sentencias java est compuesto por una o ms sentencias

legales de Java que podran lanzar una excepcin.

Para construir un manejador de excepcn para el mtodo writeList() de la clase ListOfNumbers, se
necesita encerrar la sentencia que lanza la excepcin en el mtodo writeList() dentro de un bloque
try.
Existe ms de una forma de realizar esta tarea. Podramos poner cada una de las sentencias que

potencialmente pudieran lanzar una excepcin dentro de su propio bloque try, y proporcionar
manejadores de excepciones separados para cada uno de los bloques try. O podramos poner
todas las sentencias de writeList() dentro de un slo bloque try y asociar varios manejadores con
l. El suguiente listado utiliza un slo bloque try para todo el mtodo porque el cdigo tiende a ser
ms fcil de leer.
PrintStream pstr;
try {
int i;
System.out.println("Entering try statement");
pStr = new PrintStream(
new BufferedOutputStream(
new FileOutputStream("OutFile.txt")));
for (i = 0; i < size; i++)
pStr.println("Value at: " + i + " = " + victor.elementAt(i));
}

Se dice que el bloque try gobierna las sentencias encerradas dentro del l y define el mbito decualquier
manejador de excepcin (establecido por su subsecuente bloque catch) asociado con l. En otras palabras,
si ocurre una excepcin dentro del bloque try, esta excepcin ser manejada por el manejador de
excepcin asociado con esta sentencia try. Una sentencia try debe ir acompaada de al menos un bloque
catch o un bloque finally.

8.5 Los Bloques catch

La sentencia try define el mbito de sus manejadores de excepcin asociados. Se pueden asociar
manejadores de excepcin a una sentencia try proporcionando uno o ms bloques catch
directamente despus del bloque try.
try {
...
} catch ( . . . ) {
...
} catch ( . . . ) {
...
}...
No puede haber ningn cdigo entre el final de la sentencia try y el principio de la
primera

sentencia catch . La forma general de una sentencia catch en Java es esta.

28/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

catch (AlgunObjetoThrowable nombreVariable) {

Sentencias Java
}

Como puedes ver, la sentencia catch requiere un slo argumento formal. Este argumento
parece un argumento de una declaracin de mtodo. El tipo del argumento AlgunObjetoThrowable declara el
tipo de excepcin que el manejador puede manejar y debe ser el nombre de una clase heredada de la clase
Throwable definida en el paquete java.lang. (Cuando los programas Java lanzan una excepcin
realmente estn lanzado un objeto, slo pueden lanzarse los objetos derivados de laclase
Throwable. Aprenders cmo lanzar excepciones en la leccin Cmo Lanzar Excepciones?.)
nombreVariable es el nombre por el que el manejador puede referirse a la excepcin capturada. Por ejemplo,
los manejadores de excepciones para el mtodo writeList() (mostrados ms adelante) llaman al
mtodo getMessage() de la excepcin utilizando el nombre de excepcin declarado e.
e.getMessage()
Se puede acceder a las variables y mtodos de las excepciones en la misma forma que accede a los de
cualquier otro objeto. getMessage() es un mtodo proporcionado por la clase Throwable que
imprime informacin adicional sobre el error ocurrido. La clase Throwable tambin implementa dos mtodos
para rellenar e imprimir el contenido de la pila de ejecucin cuando ocurre la excepcin. Las
subclases de Throwable pueden aadir otros mtodos o variables de ejemplar, Para buscar qu
metodos implementar en una excpecin, se puede comprobar la definicin de la clase y las definiciones de las
clases antecesoras.
El bloque catch contiene una serie de sentencias Java legales. Estas sentencias se
ejecutan cuando se llama al manejador de excepcin. El sistema de ejecucin llama al
manejador de excepcin cuando el manejador es el primero en la pila de llamadas cuyo tipo coincide con el
de la excepcin lanzada. El mtodo writeList() de la clase de ejemplo ListOfNumbers utiliza dos manejadores
de excepcin para su sentencia try, con un manejador para cada uno de los tipos de excepciones que
pueden lanzarse dentro del bloque try -- ArrayIndexOutOfBoundsException y IOException.

try {
...
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println("Caught
ArrayIndexOutOfBoundsException:
e.getMessage());
} catch (IOException e) {
System.err.println("Caught IOException: " + e.getMessage());

"

Ocurre una IOException

Supongamos que ocurre una excepcin IOException dentro del bloque try. El sistema de ejecucin
inmediatamente

toma

posesin

intenta

localizar

el

manejador

de

excepcin

adecuado.

El

sistema de ejecucin empieza buscando al principio de la pila de llamadas. Sin embargo, el

constructor de FileOutputStream no tiene un manejador de excepcin apropiado por eso el sistema de
ejecucin comprueba el siguiente mtodo en la pila de llamadas -- el mtodo writeList(). Este mtodo tiene dos
manejadores de excepciones: uno para ArrayIndexOutOfBoundsException y otro para IOException.
El sistema de ejecucin comprueba los manejadores de writeList() por el orden en el que aparecen
despus del bloque try. El primer manejador de excepcin cuyo argumento corresponda con el de la
excepcin lanzada es el elegido por el sistema de ejecucin. (El orden de los manejadores de
excepcin es importante!) El argumento del primer manejador es una ArrayIndexOutOfBoundsException,
pero la excepcin que se ha lanzado era una IOException. Una excepcin IOException no puede
asignarse legalmente a una ArrayIndexOutOfBoundsException, por eso el sistema de ejecucin contina
la bsqueda de un manejador de excepcin apropiado.
El argumento del segundo manejador de excepcin de writeList() es una IOException. La
excepcin lanzada por el constructor de FileOutputStream tambin es un una IOException y
por eso puede ser asignada al argumento del manejador de excepciones de IOException. As,
este

29/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

manejador parece el apropiado y el sistema de ejecucin ejecuta el manejador, el cual imprime

esta sentencia.
Caught IOException: OutFile.txt
El sistema de ejecucin sigue un proceso similar
ArrayIndexOutOfBoundsException. Para ms detalles puedes ver.

si

ocurre

una

excepcin

Capturar Varios Tipos de Excepciones con Un Manejador

Los dos manejadores de excepcin utilizados por el mtodo writeList() son muy especializados.
Cada uno slo maneja un tipo de excepcin. El lenguaje Java permite escribir manejadores
de excepciones generales que pueden manejar varios tipos de excepciones.
Como ya sabes, las excepciones Java son objetos de la clase Throwable (son ejemplares de
la clase Throwable a de alguna de sus subclases) Los paquetes Java contienen numerosas clases
derivadas de la clase Throwable y as construyen un rbol de clases Throwable.
El manejador de excepcin puede ser escrito para manejar cualquier clase heredada de
Throwable. Si se escribe un manejador para una clase 'hoja? (una clase que no tiene subclases), se habr
escrito un manejador especializado: slo maneja excepciones de un tipo especfico. Si se escribe un
manejador para una clase 'nodo' (una clase que tiene subclases), se habr escrito un
manejador general: se podr manejar cualquier excepcin cuyo tipo sea el de la clase nodo o de cualquiera
de sus subclases.
Modifiquemos de nuevo el mtodo writeList(). Slo esta vez, escribamoslo para que maneje
las dos excepciones IOExceptions y ArrayIndexOutOfBoundsExceptions. El antecesor ms cercano de estas
dos excepciones es la clase Exception. As un manejador de excepcin que quisiera manejar los dos tipos se
parecera a esto.

try {
...
}

catch (Exception e) {
System.err.println("Exception caught: " + e.getMessage());
}

La clase Exception est bastante arriba en el rbol de herencias de la clase Throwable.

Por eso, adems de capturar los tipos de IOException y ArrayIndexOutOfBoundsException este manejador
de excepciones, puede capturar otros muchos tipos. Generalmente hablando, los manejadores de
excepcin deben ser ms especializados.
Los manejadores que pueden capturar la mayora o todas las excepciones son menos
utilizados para la recuperacn de errores porque el menejador tiene que determinar qu tipo de excepcin ha
ocurrido de todas formas (para determinar la mejor estrategia de recuperacin). Los manejadores de
excepciones que son demasiado generales pueden hacer el cdigo ms propenso a errores
mediante la captura y menejo de excepciones que no fueron anticipadas por el programador y para las que el
manejador no est diseado.

8.6 El Bloque finally

El paso final en la creacin de un manejador de excepcin es proporcionar un mecanismo
que limpie el estado del mtodo antes (posiblemente) de permitir que el control pase a otra
parte diferente del programa. Se puede hacer esto encerrando el cdigo de limpieza dentro de un bloque
finally.
El bloque try del mtodo writeList() ha estado trabajando con un PrintStream abierto. El programa
debera cerrar ese canal antes de pemitir que el control salga del mtodo writeList(). Esto plantea
un problema complicado, ya que el bloque try del writeList() tiene tres posibles salidas.
1. La sentencia new FileOutputStream falla y lanza una IOException.
2. La sentencia victor.elementAt(i) falla y lanza una ArrayIndexOutOfBoundsException.
3. Todo tiene xito y el bloque try sale normalmente.

30/31
Docente : Hugo Mamanchura Lima

Fundamentos de Java

El sistema de ejecucin siempre ejecuta las sentencias que hay dentro del bloque finally sin
importar lo que suceda dentro del bloque try. Esto es, sin importar la forma de salida del bloque try del mtodo
writeList() debido a los escenarios 1, 2 3 listados arriba, el cdigo que hay dentro del bloque finally ser
ejecutado de todas formas.
Este es el bloque finally para el mtodo writeList(). Limpia y cierra el canal PrintStream.

finally {
if (pStr != null) {
System.out.println("Closing PrintStream");
pStr.close();
} else {
System.out.println("PrintStream not open");
}
}

Es realmente necesaria la sentencia finally?

No es obligatorio especificarla pero ayuda a limpiar objetos ya no usados al finalizar un bloque.

31/31
Docente : Hugo Mamanchura Lima