COMPUTACION I

UNIDAD 2. PRINCIPIOS DE LA ORIENTACION A OBJETOS

Resumen
Se estudiara el paradigma de la orientacin a objetos y como se emplea en Java.

Tema TRABAJANDO CON CLASES


Resumen
Se realizara un estudio sobre caractersticas en la definicin de clases.

3.1. DEFINICIONES INICIALES.

El encapsulamiento se basa en los mtodos de instancia.
La sobrecarga de mtodos nos brinda una interfase mas legible.
Los constructores aseguran una consistente creacin de ob!etos
El "arbage Collector libera espacio en memoria.

3.1.1. Sobrecarga de mtodos.
Algunos mtodos en una clase pueden tener el mismo nombre.
Estos mtodos deben contar con diferentes argumentos.
El compilador decide #ue mtodo in$ocar comparando los argumentos.
%e generara un error si los mtodos solo $arian en el tipo de retorno.

public class Pelicula {
private float precio;
public void setPrecio() {
precio = 3.50;
}
public void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
}
}

3.1.2. Iniciacin de variables de instancia
Las $ariables de instancia se pueden iniciar en la declaracin.
Esta iniciacin ocurre cuando se crea un ob!eto.

public class Pelicula {
private String titulo; // iplicito
private String tipo = !"raa!; // e#plicito
private int nuero"e$scares; // iplicito
}

Las primiti$as se inician impl&citamente como'
c%ar
b&te' s%ort' int' long
boolean
float' double
(0(
0
false
0.0
(
COMPUTACION I
)eferencia a $b*eto null

En forma e)plicita se puede indicar un $alor inicial.
private String tipo = !"raa!;

Un constructor pro$ee una iniciacin de $ariables de instancia mas comple!a.

*
COMPUTACION I
Tema 5. HERENCIA Y POLIMORFISMO
Resumen
Se estudiara el uso de la herencia y el polimorfismo en el reuso de clases.
5.1. HERENCIA
5.1.1 Definicin
Permite a una clase compartir la misma estructura de datos + comportamiento de otra clase.
La ,erencia minimi-a la necesidad de duplicar cdigo.
El Polimorfismo permite utili-ar el mtodo de acuerdo al ob!eto ,eredado.
%uperclase

%ubclase

.ue atributos tienen en com/n las subclases0
.ue atributos no tienen en com/n las subclases0
.ue mtodo no tienen en com/n las subclases0
5.1.2. La herencia en Java
Una subclase se define indicando a #ue superclase e)tiende.
public class +te {
// "efinici,n de la superclase +te.
}
public class Pelicula e#tends +te {
// -tributos & .todos adicionales para distinguir una
// pelicula de otros tipos de ite
}
Una subclase ,ereda todas las $ariables instancia de la superclase.
Las $ariables de instancia deben ser pri$ate para #ue instancias de la subclase ,ereden sus $alores.
public class +te {
protected float precio = 0;
protected String estado = !/#celente!;
}
public class Pelicula e#tends +te {
private String titulo = !!;
private int duracion = 0;
}
Una subclase no ,ereda ning/n constructor de la superclase1 debe declararse e)pl&citamente.
%olo en caso no se declare e)pl&citamente1 se e!ecutaran los constructores por defecto de las superclases +
finalmente de la subclase.
Pelicula pelicula = ne0 Pelicula ();
// +nicia variables de la clase +te. 1onstructor por defecto.
// +nicia variables de la clase Pelicula. 1onstructor por defecto.
2
Item
Pelicula Libro Equipo
(DVD, VHS)
COMPUTACION I
3efina las subclases Libro + E#uipo.
Como declarar&a las clases'
4ombre 5 4om&nido 5 Primate 5 Placentario
Perro 5 Canino 5 Carni$oro 5 Placentario
Placentario 5 Mam&fero 5 6ertebrado 5 Animal 5 %er 6i$o.
5.1.3. La referencia suer
%e refiere a la clase padre
%e usa para in$ocar constructores de la clase padre
3ebe ser la primera sentencia del constructor de la clase ,i!o
Esta referencia tambin se usa para in$ocar cual#uier mtodo del padre.
public class +te {
protected float precio = 0;
+te (float precio) {
t%is.precio = precio;
}
}
public class Pelicula e#tends +te {
private String titulo = !!;
Pelicula (float precio' String titulo) {
super(precio);
t%is.titulo = titulo;
}
}
5.1.!. "todos
La superclase define los mtodos para todas las subclases.
La subclase puede especificar mtodos propios.
+te0.*ava
public class +te0 {
protected float precio = 0;

+te0 (float precio) {
t%is.precio = precio;
}

public float getPrecio() {
return precio;
}
}
Pelicula0.*ava
public class Pelicula0 e#tends +te0
{
private String titulo = !!;
Pelicula0 (float precio' String titulo) {
super(precio);
t%is.titulo = titulo;
}
public String get2itulo()
{
return titulo;
}
}
2estSuper.*ava
public class 2estSuper {
7
COMPUTACION I
public static void ain (String34 args) {

+te0 ite = ne0 +te0(5.5f);
S&ste.out.println( ite.getPrecio() );
Pelicula0 pelicula = ne0 Pelicula0(6.6f'!7elig!);
S&ste.out.println( pelicula.getPrecio() );
S&ste.out.println( pelicula.get2itulo() );
}
}
.ue diferencia e)iste entre t,is + super0
%e puede reempla-ar super(precio); por t%is.precio = precio; 0
.ue mtodos puede in$ocar una subclase0
La subclase ,ereda todos los mtodos del padre.
La subclase puede re8escribir un mtodo del padre.
+te5.*ava
public class +te5 {
public float calcular+porte(int cliente) {
return 50;
}
}
Pelicula5.*ava
public class Pelicula5 e#tends +te5 {
public float calcular+porte(int cliente) {
if (cliente 8 500)
return 50;
else
return 30;
}
}
2estSobrescribir.*ava
public class 2estSobrescribir {
public static void ain (String34 args) {

+te5 ite5 = ne0 +te5();
S&ste.out.println( ite5.calcular+porte(599) );
Pelicula5 pelicula5 = ne0 Pelicula5();
S&ste.out.println( pelicula5.calcular+porte(399) );
S&ste.out.println( pelicula5.calcular+porte(599) );

}
}
9
COMPUTACION I
5.1.5. La referencia suer
%i una subclase sobrescribe un mtodo de la superclase: el mtodo de la superclase se puede in$ocar con la
referencia super.
+te6.*ava
public class +te6 {
public float calcular+porte(int cliente) {
return 50;
}
}
/:uipo6.*ava
public class /:uipo6 e#tends +te6 {
public float calcular+porte(int cliente) {
float seguro/:uipo = 65;
float al:uiler = super.calcular+porte(cliente);
return seguro/:uipo ; al:uiler;
}
}
2estSuper6.*ava
public class 2estSuper6 {
public static void ain (String34 args) {

+te6 articulo = ne0 +te6();
S&ste.out.println( articulo.calcular+porte(599) );
/:uipo6 v%s = ne0 /:uipo6();
S&ste.out.println( v%s.calcular+porte(599) );

}
}
5.2. Polimorfismo
Permite efectuar una misma operacin dependiendo del tipo de ob!eto.
E!emplo
Tacora;ilms inicia sus operaciones al#uilando /nicamente pel&culas.
Tres meses despus amplia el al#uiler a e#uipos1 !uegos + libros.
El al#uiler de una pelicula es * soles por d&a de al#uiler.
El al#uiler de un e#uipo consta de un seguro de 9< soles adem=s de 9 soles por d&a.
El al#uiler de !uegos depende del fabricante. Pla+%tation *soles>d&a Nintendo (sol>d&a
Los libros no se al#uilan1 se prestan uno a la $e-1 mientras sean clientes de la tienda.
-l:uiler3.*ava
public class -l:uiler3 {
private int dias;
public -l:uiler3(int dias) {
t%is.dias = dias;
}
public int get"ias () {
return dias;
}
}
+te3.*ava
public class +te3 {
protected float calcular+porte(-l:uiler3 contrato) {
return 0;
}
?
COMPUTACION I
}
Pelicula3.*ava
public class Pelicula3 e#tends +te3 {
protected float calcular+porte(-l:uiler3 contrato) {
int iporte = 6<contrato.get"ias();
return iporte;
}
}
/:uipo3.*ava
public class /:uipo3 e#tends +te3 {
protected float calcular+porte(-l:uiler3 contrato) {
int seguro/:uipo = 50;
int iporte = seguro/:uipo ; 5<contrato.get"ias();
return seguro/:uipo ; iporte;
}
}
=uego3.*ava
public class =uego3 e#tends +te3 {
String fabricante;
public =uego3(String fabricante) {
t%is.fabricante = fabricante;
}
public String get>abricante() {
return fabricante;
}
protected float calcular+porte(-l:uiler3 contrato) {
String fabricante = t%is.fabricante;
int tasa = 0;
if (fabricante.e:uals(!Pla&Station!)) tasa = 6;
if (fabricante.e:uals(!?intendo!)) tasa = 5;
int iporte = tasa<contrato.get"ias();
return iporte;
}
}
@ibro3.*ava
public class @ibro3 e#tends +te3 {
protected float calcular+porte(-l:uiler3 contrato) {
return 0;
}
}
2estPoliorfiso.*ava
public class 2estPoliorfiso {
public static void ain (String34 args) {

-l:uiler3 contrato = ne0 -l:uiler3(50);

Pelicula3 oscar = ne0 Pelicula3();
S&ste.out.println( oscar.calcular+porte(contrato) );
/:uipo3 v%s = ne0 /:uipo3();
S&ste.out.println( v%s.calcular+porte(contrato) );

=uego3 u = ne0 =uego3(!?intendo!);
S&ste.out.println( u.calcular+porte(contrato) );
@ibro3 agua = ne0 @ibro3();
S&ste.out.println( agua.calcular+porte(contrato) );
}
}
@
COMPUTACION I
5.3. El operador insan!eof " !as
El operador instanceof permite determinar la clase de un ob!eto en tiempo de e!ecucin.
La operacin cast permite modificar la clase de un ob!eto.
public class 2est$perador {
public static void ain (String34 args) {
Pelicula3 oscar = ne0 Pelicula3();
/:uipo3 v%s = ne0 /:uipo3();
=uego3 u = ne0 =uego3(!?intendo!);
@ibro3 agua = ne0 @ibro3();

test$perador(oscar);
test$perador(v%s);
test$perador(u);
test$perador(agua);
}
public static void test$perador (+te3 articulo) {
if (articulo instanceof =uego3) {
=uego3 *uego = (=uego3) articulo;
S&ste.out.println(*uego.get>abricante());
}
else {
S&ste.out.println(!?o tiene >abricante!);
}
}
}
5.#. Ari$%os& m'odos " !lases final
5.!.1. #ariables final
Una $ariable final es una constante
Una $ariable final no puede ser modificada
Una $ariable final debe ser iniciada
Una $ariable final por lo general es publica para #ue pueda ser accesada e)ternamente.
public final static String ?/A)$ = !>>>>>>!;
public final static float P+ = 3.5B5596f;
public final static int C-D+C$E+2/CS = 50;
5.!.2. "todos final
Un mtodo puede ser definida como final para e$itar la sobre8escritura en una subclase.
Un mtodo final no se puede redefinir en una clase ,i!o.
public final static String getFlanco() {
return !000000!;
}
public final boolean verificarPass0ord(String pass0ord) {
if (pass0ord.e:uals(...
}
5.!.3. $lases final
Una clase final no puede ser padre de otra clase.
Una clase puede ser definida como final para e$itar la ,erencia.
A
COMPUTACION I
El compilador es mas eficiente con definiciones final por #ue no buscara estas clases o mtodos al tratar clases
,eredadas.
public final class 1olor {
public final static String ?/A)$ = !>>>>>>!;
public final static String getFlanco() {
return !000000!;
}
}
E!ercicio'
@ibrerGa.*ava
public final class @ibreria {
public final static String F@-?1$ = !000000!;
public final static float P+ = 3.5B5596f;

public final static int getCodulo50(int nuero)
{
// $btiene el odulo 50 de la sua de digitos
if (nuero 8 0) nuero = Hnuero;
String cadena = String.value$f(nuero);
int sua = 0;
for (int i=5; i 8 cadena.lengt%(); i;;) {
String caracter = cadena.substring(iH5'i);
int digito = +nteger.parse+nt(caracter);
sua ;= digito;
}
int residuo = suaI50;
return residuo;
}
}
2est@ibreria.*ava
public class 2est@ibreria {
public static void ain (String34 args) {
S&ste.out.println(@ibreria.F@-?1$);
S&ste.out.println(@ibreria.P+);
S&ste.out.println(@ibreria.getCodulo50(55));
S&ste.out.println(@ibreria.getCodulo50(JJ03J5));
}
}
5.5. El m'odo finali(e)*
Cuando todas las referencias de un ob!eto se pierden1 se marcan para #ue el "arbage Collector los reco!a +
libere ese espacio en memoria.
Pelicula pelicula = ne0 Pelicula(!7elig!);
pelicula = null;
El ob!eto B7eligB #ue estaba referenciado por pelicula ,a perdido todas sus referencias.
Luego el "arbage Collector liberara el espacio ocupado por B7eligB
El mtodo finali-e es llamado !usto antes #ue el "arbage Collector libere la memoria. En este instante se puede
apro$ec,ar para reali-ar otras operaciones.
public class PeliculaB {
private String titulo;
public PeliculaB(String titulo) {
t%is.titulo = titulo;
}
public void finaliKe()
{
S&ste.out.println(!Se acabo !;titulo);
}
C
COMPUTACION I
}
public class 2est>inaliKe {
public static void ain (String34 args) {

PeliculaB globo = ne0 PeliculaB(!7elig!);
globo = null;

}
}
Tema 6. MANEJO DE EXCEPCIONES.

Resumen
Se estudiara conceptos bsicos para el manejo de excepciones.

+.1. E,CEPCIONES
%.1.1. Definiciones
&ue es una e'cecin(
Es un e$ento #ue interrumpe la e!ecucin de un programa
8 Usar un &ndice fuera de los limites de un arreglo
8 3i$idir entre cero
8 Deali-ar mtodos de ob!etos nulos.
&ue es un error(
En !a$a es cuando la situacin es irrecuperable + termina el programa.
8 No ,a+ memoria para correr E6M
8 Errores internos en E6M
$ual es la diferencia(
Una e)cepcin se puede controlar en el programa. Un error no.
%.1.2. $aracter)sticas del Java
Cuando ocurre una e)cepcin en un mtodo1 Ea$a lan-a Ft,roGsH una e)cepcion FE)ceptionH.
El ob!eto E)ception generado contiene el tipo de e)cepcin1 + el estado del programa cuando ocurri
el error.

Searando el mane*o de errores
El mane!o de e)cepciones en !a$a permite separarlos del algoritmo principal.
El resultado es un cdigo mas legible + menos propenso a errores de programacin.

Mane!o tradicional de errores.

int leer)egistro-rc%ivo() {
int error1ode = 0;
abrir-rc%ivo();
if (error-brir-rc%ivo) {
error1ode = $P/?E/))$);
}
else {
leer-rc%ivo();
Mane!o de e)cepciones en Ea$a.

leer)egistro-rc%ivo() {
tr& {
abrir-rc%ivo();
leer-rc%ivo();
cerrar-rc%ivo();
}
catc% (error-brir-rc%ivo) {
ane*ar/rror-brir-rc%ivo;
(<
COMPUTACION I
if (error@eer-rc%ivo) {
error1ode = )/-"E/))$);
}
cerrar-rc%ivo();
if (error1errar-rc%ivo) {
error1ode = 1@$S/E/))$);
}
}
return error1ode;
}
}
catc% (error@eer-rc%ivo) {
ane*ar/rror@eer-rc%ivo;
}
catc% (error1errar-rc%ivo) {
ane*ar/rror1errar-rc%ivo;
}
}


Ea$a separa los detalles del mane!o de errores del cdigo principal1 obtenindose un cdigo mas
legible + menos propenso a errores de codificacin.

%.1.3. +'ceciones
Devolviendo la e'cecin hasta el mane*ador de e'ceciones.
No se re#uiere #ue cada mtodo in$ocado mane!e la e)cepcin1 sino /nicamente lo ,ar= el primer
mane!ador de e)cepciones de la lista de mtodos in$ocados.


Maneo Tradicional de errores


E)cepciones en Ea$a


El mtodo7 retorna el cdigo de error al
mtodo2.
El mtodo2 retorna el cdigo de error al
mtodo*
El mtodo* retorna el cdigo de error al
metodo(
El metodo( mane!a el error.
El metodo7 lan-a una e)cepcin
El metodo( captura la e)cepcin + la mane!a


Las e'ceciones no ueden ignorarse
Una $e- #ue un mtodo lan-a un error no puede ignorarse a diferencia de la programacin tradicional
donde se debe controlar en cada punto de in$ocacin.

((
Metodo(
Mane!o de errores
Metodo*
Metodo2
Metodo7
Cdi go de error
Cdi go de error
Cdi go de error
Metodo(
Mane!o de e)cepciones
Metodo*
Metodo2
Metodo7
E)cepcion
COMPUTACION I
Maneo Tradicional de errores


E)cepciones en Ea$a



%.1.!. ,hro-able

Todos los errores + e)cepciones ,eredan de la clase 2%ro0able




+rrores.
4eredan de la clase /rror: estos se generan cuando ocurren errores fatales para el programa como
por e!emplo' cuando la memoria esta llena o cuando es imposible encontrar una clase re#uerida.

+'ceciones no controladas
4eredan de la clase )untie/#ception.
Estas ocurren cuando por e!emplo se di$ide entre cero o se intenta acceder a un elemento del arreglo
fuera de sus limites.
Mediante cdigo se puede capturar1 manipular o ignorar estas e)cepciones.
%i no mane!a el error1 el !a$a terminara el programa indicando el estado del error.

+'ceciones controladas
4eredan de la clase /#ception.
Estas deben ser capturadas + mane!adas en algun lugar de la aplicacin.
Las e)cepciones creadas por el programador seran ,eredadas de la clase /#ception.

(*
Metodo(
Mane!o de e)cepciones
Metodo*
Metodo2
Metodo7
E)cepcion
Metodo(
Mane!o de errores
Metodo*
Metodo2
Metodo7
Cdi go de error
T,roGable
Error
DuntimeE)ception
E)ception
Errores
Irrecuperables
E)cepciones
Controladas
E)cepciones
no Controladas
Frun8timeH
COMPUTACION I
%.1.5. &ue se uede hacer con una +'cecin(

+'ceciones controladas
%e puede'
8 Capturar la e)cepcin + manipularla
8 Pasar la e)cepcin al mtodo in$ocador.
8 Capturar la e)cepcin + lan-ar una e)cepcin diferente.

+'ceciones no controladas
No necesitan ser controladas en el cdigo.
El E6M terminara el programa cuando las encuentra.
%i no desea #ue el programa termine tendr= #ue mane!arlas.

+.2. E,CEPCIONES CON -A.A

%.2.1. $omo caturar . mane*ar una e'cecin

8 Encierre el cdigo del mtodo en un blo#ue
tr+
8 Mane!e cada e)ception en un blo#ue catc,.
8 Cual#uier proceso final real&celo en un
blo#ue finall+. Este blo#ue siempre se
e!ecutara1 ocurra o no una e)cepcin.




tr& {
// c,digo del .todo
}
catc% (e#ception5) {
// ane*ar la e#cepci,n5
}
catc% (e#ception6) {
// ane*ar la e#cepci,n6
}
...
finall& {
// cual:uier otro proceso final
}


La documentacin del !a$a indicara #ue e)cepciones lan-a los mtodos del !a$a.

1lase L *ava.io.>ile+nputStrea
C.todoL public >ile+nputStrea(String nae)
t%ro0s >ile?ot>ound/#ception
C.todoL public int read() t%ro0s +$/#ception



(2
COMPUTACION I
%.2.2. $aturando una e'cecin.

Este e!emplo con$ierte una cadena en un entero

int cantidad;
String cadena = !5!;
tr& {
cantidad = +nteger.parse+nt(cadena);
}
catc% ( ?uber>orat/#ception e) {
S&ste.err.println(cadena ; ! no es un entero!);
}

Laboratorio'
Pruebe este e!emplo en un programa 2est/#ception.*ava. Cambie la cadena por BcincoB1 B(.(B1
B*fB.
%.2.3. $aturando m/ltiles e'ceciones

Este e!emplo con$ierte una cadena en un entero + reali-a una di$ision.

public class 2estCulti/#ception {

public static void ain (String34 args) {

int cantidad= 0;
int divisor = 0;
String cadena = !5!;
tr& {
cantidad = +nteger.parse+nt(cadena);
S&ste.out.println(cantidad);
int resultado = cantidad / divisor;
S&ste.out.println(resultado);
}
catc% ( ?uber>orat/#ception e) {
S&ste.err.println(cadena ; ! no es un entero!);
}
catc% ( -rit%etic/#ception e) {
S&ste.err.println(!/rror en !;cantidad;!/!;divisor);
}
}
}

Laboratorio'
Pruebe este e!emplo en un programa 2estCulti/#ception.*ava. Cambie la cadena por BcincoB1
B(.(B1 B9B + di$isor cambie por <1 (1 9<<

(7
COMPUTACION I
%.2.!. +*ecucin del blo0ue finall.
El blo#ue finall+ siempre se e!ecuta dependiendo como se termina el blo#ue tr+.
8 4asta terminar la ultima sentencia del blo#ue tr+.
8 3ebido a sentencias return o breaI en el blo#ue tr+.
8 3ebido a una e)cepcin.

public class 2est>inall& {
public static void ain (String34 args) {
int cantidad= 0;
int divisor = 0;
String cadena = !5!;
tr& {
if (cadena.e:uals(!5!))
return;
cantidad = +nteger.parse+nt(cadena);
S&ste.out.println(cantidad);
int resultado = cantidad / divisor;
S&ste.out.println(resultado);
}
catc% ( ?uber>orat/#ception e) {
S&ste.err.println(cadena ; ! no es un entero!);
}
catc% ( -rit%etic/#ception e) {
S&ste.err.println(!/rror en !;cantidad;!/!;divisor);
}
finall& {
S&ste.err.println(!Se traba*o con !;cadena;! &
!;divisor);
}
}
}

Laboratorio'
Pruebe este e!emplo1 cambie la cadena por BcincoB1 B(.(B1 B9B + di$isor cambie por <1 (1 9<<

%.2.5. $omo asar la e'cecin al mtodo invocado.

Para pasar el mtodo al in$ocador1 se declara con la declaracin t%ro0s.
La e)cepcin se propaga al mtodo #ue lo in$oco.
En el e!emplo1 las e)cepciones de los mtodos se mane!an en el mtodo in$ocador.

public void etodo+nvocador() {
tr& {
iCetodo();
get)esultado();
}
catc% {
}
finall& {
}
}
public int iCetodo() t%ro0s /#ception {
// c,digo :ue podria lanKar la /#ception
}
public int get)esultado() t%ro0s ?uber>orat/#ception {
// c,digo :ue podria lanKar la e#ception ?uber>orat/#ception
(9
COMPUTACION I
}
2est2%ro0s.*ava
public class 2est2%ro0s {

public static void ain (String34 args) {

String cadena = !abcde!;
int posicion = M;
c%ar letra = ( (;
tr& {
letra = get@etra(cadena'posicion);
S&ste.out.println(letra );
}
catc% (+nde#$ut$fFounds/#ception e) {
S&ste.err.println(!/rror en !;cadena;! !;posicion);
}
}
public static c%ar get@etra(String cadena' int posicion)
t%ro0s +nde#$ut$fFounds/#ception
{
c%ar c = cadena.c%ar-t(posicion);
return c;
}
}

Laboratorio. Cambie posicin ? por J(1 <1 (

%.2.%. $omo lan1ar una e'cecin
Para lan-ar una e)cepcin use las declaraciones t%ro0s + t%ro0
Puede crear e)cepciones para mane!ar posibles problemas en el cdigo.

public String getNalor(int indice) t%ro0s +nde#$ut$fFounds/#ception {
if (indice 8 0 OO indice P 500) {
t%ro0 +nde#$ut$fFounds/#ception();
}
}

%.2.2. $omo crear una e'cecin
Para crear su propia e)cepcin tiene #ue ,eredarla de la clase E)ception.
Puede ser usado en caso #uiera tratar cada problema en el cdigo en forma diferente.
Por e!emplo el mane!o del arc,i$o( puede tratarlo con una e)cepcin(. El mane!o de un arc,i$o*
puede tratarlo con una e)cepcion*. Cada arc,i$o tendria su propia e)cepcin.

Qser>ile/#ception.*ava
public class Qser>ile/#ception e#tends /#ception {
public Qser>ile/#ception (String ensa*e) {
super(ensa*e);
}
}
%.2.3. $omo caturar una e'cecin . lan1ar otra diferente.
En el e!emplo si ocurre un problema de IO Fentrada>salidaH se captura la e)cepcin + se lan-a una
e)cepcin propia.

(?
COMPUTACION I
public void )eadQser>ile t%ro0s Qser>ile/#ception {
tr& {
// c,digo :ue anipula un arc%ivo
}
catc% (+$/#ception e) {
t%ro0 ne0 Qser>ile/#ception(e.toString());
}
}

E!ercicioH
public class 1errado/#ception e#tends /#ception {
public 1errado/#ception () {}
public 1errado/#ception (String sg) {
super(sg);
}
}
public class 2est1errado/#ception {

public static void ain(String34 args) {
tr& {
abrir@aPuerta();
} catc%(1errado/#ception e) {
// printStacR2race uestra la traKa de la e#cepcion.
e.printStacR2race(S&ste.err);
}
tr& {
abrir@aNentana();
} catc%(1errado/#ception e) {
// S&ste.err es el strea de salida de errores
// siilar a S&ste.out.
e.printStacR2race(S&ste.err);
}
}

public static void abrir@aPuerta() t%ro0s 1errado/#ception {
S&ste.out.println(!abrir@aPuerta()S tiene candadoT!);
t%ro0 ne0 1errado/#ception (!$riginado en abrir@aPuerta()!);
}

public static void abrir@aNentana() t%ro0s 1errado/#ception {
S&ste.out.println(!abrir@aNentana()S /sta con cerro*oT!);
t%ro0 ne0 1errado/#ception (!$riginado en abrir@aNentana()!);
}
}
(@