Guia de Iniciación en Java

Gua de iniciacin al lenguaje Java.
Versin 2.0. Octubre de 1999
!"#$%&'%()(*($*(+)%$,%,')!"$-'%-$.$%
!"#$%&'()*+(',-./012/(3/(4555(
!"#$%&'()&*+),-)./, .%*0(1*+),%&/,
#"$67"'(
!"#$%#&'(')*%+*&&$",*-.$%'%/-'%0/1'%23/$%"$&4%,&$"$-#'.'%$-%5*&6'#*%789:;%3/$%"<&='%
.$%<-<+<'+<>-%'%?'%,&*0&'6'+<>-%$-%$?%?$-0/')$%@'='A%!-%B?%"$%#&'#'-%?*"%.<=$&"*"%
'",$+#*"%(4"<+*"%3/$%+*6,&$-.$-%$?%',&$-.<C')$%.$%/-%?$-0/')$%.$%,&*0&'6'+<>-D%'"1%
+*6*%/-'%(&$=$%-*+<>-%.$%?'%E&*0&'6'+<>-%F&<$-#'.'%'?%F()$#*%$-%?'%3/$%@'='%"$%
('"'A%
G"1%6<"6*%"$%<-+?/H$-%+*6,'&'#<='"%+*-%*#&*"%?$-0/')$"%.$%,&*0&'6'+<>-%2$",$+<'?%
I<-+',<B%$-%JKK;D%H%"$%#&'#'-%+*-%/-%,*+*%64"%.$%,&*5/-.<.'.%(<(?<*#$+'"%0&45<+'"%
+*6*%GL8%H%MN<-0A%
M$%+*6$-#'-%#'6(<B-%'",$+#*"%&$?'+<*-'.*"%+*-%O-#$&-$#D%+*6*%"*-%?'"%(<(?<*#$+'"%.$%
M*+P$#"%H%?'"%5'6*"'"%',,?$#"%@'='A%
89:9;#9$(<:9!"(
@'='D%8/#*&<'?D%:$-0/')$%.$%,&*0&'6'+<>-D%E&*0&'6'+<>-%F&<$-#'.'%'%F()$#*"D%G,,?$#D%
J>.<0*%.$%QH#$D%J?'"$D%F()$#*D%O-#$&-$#D%M*+P$#D%M/-D%@RSD%8/#*&<'?D%J>.<0*%5/$-#$D%
JKKA%
Pgina 1 de 189
='>%<"$(
='>%<"(>"(<?'@"'%>?$(
Resumen............................................................................................................................................... 1
Palabras clave....................................................................................................................................... 1
!"#$%&' (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()
ndice de contenidos............................................................................................................................. 2
ndice de imgenes............................................................................................................................... 6
ndice de tablas..................................................................................................................................... 6
*+,-.&'(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((/
0.12-3-((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((4
Prlogo de la primera versin de la gua de Java ................................................................................. 9
Prlogo de la segunda versin de la gua de Java............................................................................... 11
0.&5*%$-(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6)
Contenidos ......................................................................................................................................... 12
Agradecimientos ................................................................................................................................ 14
,&7*8$98$",.-#+%%$1"((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6:
(232,(&4.)+"''(5&,*,0*,-.)6.*7*'(5&,).(%&4*+*,*,)#8%4)! 222222222222 39
A. Programacin Orientada a Objetos................................................................................................ 16
B. Los objetos .................................................................................................................................... 16
C. Las clases....................................................................................................................................... 17
D. Modelo de objetos ......................................................................................................................... 17
E. Relaciones entre objetos ................................................................................................................ 19
(2:2,;(!4).(*,+%,8*$*22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 :3
A. Por qu se dise Java? ............................................................................................................... 21
B. Comienzos ..................................................................................................................................... 22
C. Primeros proyectos en que se aplic Java...................................................................................... 23
D. Resurgimiento de Java................................................................................................................... 23
E. Futuro de Java................................................................................................................................ 24
F. Especulacin sobre el futuro de Java ............................................................................................. 25
(2<2,'*.*'4%.=!4('*!,+%,8*$* 2222222222222222222222222222222222222222222222222222222222222222222222222222222222 :9
A. Introduccin .................................................................................................................................. 26
B. Potente ........................................................................................................................................... 26
C. Simple............................................................................................................................................ 27
D. Interactivo y orientado a red.......................................................................................................... 27
E. Y mucho ms ................................................................................................................................. 29
(2>2,')7-*.*4($*,')&,)4.)!,0%&6"*8%!,+%,-.)6.*7*'(5&,
).(%&4*+)!,*,)#8%4) 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 <3
A. Introduccin .................................................................................................................................. 31
B. Comparacin de los tipos de datos ........................................................................................... ..... 31
C. Operadores relacionales y aritmticos. .......................................................................................... 32
D. Vectores......................................................................................................................................... 32
E. Cadenas.......................................................................................................................................... 32
F. Otras caractersticas ....................................................................................................................... 32
,&7*8$$985+"#*7&",-'8#&282&"3+*;& (((((((((((((((((((((((((((((((((((((((((((((((((((((((((<=
((232,?"&+*7%&4)! 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 <@
A. Introduccin .................................................................................................................................. 37
B. Tokens ........................................................................................................................................... 37
Pgina 2 de 189
C. Expresiones.................................................................................................................................... 39
D. Bloques y mbito........................................................................................................................... 40
((2:2,4(-)!,+%,+*4)! 22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 >:
A. Tipos de datos simples .................................................................................................................. 42
B. Vectores y Matrices ....................................................................................................................... 45
C. Cadenas ......................................................................................................................................... 45
((2<2,)-%.*+).%!22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 >@
A. Introduccin .................................................................................................................................. 47
B. Operadores aritmticos .................................................................................................................. 48
C. Operadores de comparacin y condicionales................................................................................. 49
D. Operadores de bit .......................................................................................................................... 50
E. Operadores de asignacin .............................................................................................................. 52
F. Precedencia de operadores ............................................................................................................. 52
((2>2,%!4."'4".*!,+%,')&4.)022222222222222222222222222222222222222222222222222222222222222222222222222222222 A>
A. Introduccin .................................................................................................................................. 54
B. Las sentencias condicionales: if y switch ...................................................................................... 54
C. Sentencias de iteracin o bucles: for, do, while............................................................................. 57
D. Sentencias de salto: break, continue y return............................................................................... .. 58
E. Excepciones ................................................................................................................................... 61
((2A2,'0*!%!,B,)#8%4)! 22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 9:
A. Introduccin .................................................................................................................................. 62
B. Definicin de una clase.................................................................................................................. 63
C. La instanciacin de las clases: Los objetos................................................................................. ... 65
D. Acceso al objeto ............................................................................................................................ 67
E. La destruccin del objeto............................................................................................................... 68
((292,0*,;%.%&'(* 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 @C
A. Introduccin .................................................................................................................................. 70
B. Jerarqua ........................................................................................................................................ 70
C. Herencia mltiple .......................................................................................................................... 70
D. Declaracin.................................................................................................................................... 71
E. Limitaciones en la herencia ........................................................................................................... 71
F. La clase Object............................................................................................................................... 72
((2@2,)-%.*'()&%!,*$*&1*+*!,%&,0*!,'0*!%! 22222222222222222222222222222222222222222222222222 @>
A. Introduccin .................................................................................................................................. 74
B. Operaciones avanzadas en la herencia........................................................................................... 74
C. El polimorfismo............................................................................................................................. 76
D. las referencias polimrficas: this y super ...................................................................................... 78
E. la composicin ............................................................................................................................... 79
((2D2,6%!4(5&,+%,%E'%-'()&%!,B,%..).%!22222222222222222222222222222222222222222222222222222222222 DC
A. Introduccin .................................................................................................................................. 80
B. Tipos de excepciones..................................................................................................................... 80
C. Funcionamiento ............................................................................................................................. 81
D. Excepciones que incorpora Java 1.2.............................................................................................. 85
((2F2,(&4%.?*'%! 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 D@
A. Introduccin .................................................................................................................................. 87
B. Declaracin.................................................................................................................................... 87
C. Implementacin de una interfaz..................................................................................................... 87
D. Herencia mltiple .......................................................................................................................... 88
E. Colisiones en la herencia mltiple ................................................................................................. 88
F. Envolturas de los tipos simples ............................................................................................. ......... 89
((23C2,-*G"%4%!222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 FC
A. Introduccin .................................................................................................................................. 90
B. Creacin de un paquete.................................................................................................................. 90
C. Uso de un paquete ......................................................................................................................... 91
D. mbito de los elementos de un paquete ........................................................................................ 91
Pgina 3 de 189
((2332,0)!,4;.%*+!,),-.)6.*7*'(5&,7"04(;(0)2222222222222222222222222222222222222222222 F<
A. Introduccin .................................................................................................................................. 93
B. Utilizacin de thread...................................................................................................................... 93
C. Sincronizacin de threads.............................................................................................................. 94
D. Y mucho ms................................................................................................................................. 96
((23:,'.%*'(5&,+%,-.)6.*7*!,8*$* 222222222222222222222222222222222222222222222222222222222222222222222 F@
A. Introduccin .................................................................................................................................. 97
B. Tipos de aplicaciones..................................................................................................................... 97
C. Recomendaciones de programacin .............................................................................................. 98
D. Grandes programas........................................................................................................................ 99
,&7*8$$$98>$>2$-,&%*'8#&82*8*0$8#&8;*?* (((((((((((((((((((((((((((((((((((((((((((((((((((6@6
(((232,#(#0()4%'*!,+%,0*,*-(,+%,8*$* 2222222222222222222222222222222222222222222222222222222222222222222 3C:
A. Introduccin ................................................................................................................................ 102
B. Paquetes de utilidades.................................................................................................................. 102
C. Paquetes para el desarrollo grfico .............................................................................................. 102
D. Paquetes para el desarrollo en red ............................................................................................... 103
E. Para ms informacin .................................................................................................................. 103
(((2:2,'*+%&*! 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3C>
A. Introduccin ................................................................................................................................ 104
B. Mtodos de la clase String........................................................................................................... 105
C. Mtodos de la clase StringBuffer ............................................................................................ .... 107
D. Ejemplos de uso de cadenas ........................................................................................................ 108
(((2<2,%&4.*+*H!*0(+*22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 333
A. Introduccin ................................................................................................................................ 111
B. Entrada/Salida estndar ............................................................................................................... 111
C. Entrada/Salida por fichero ........................................................................................................... 112
,&7*8$?(8>$2$-,&%*'83.A5$%*'((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((66/
($232,0)!,-*G"%4%!,6.I?(')!,+%,0*!,8?'2222222222222222222222222222222222222222222222222222222222 33F
A. Introduccin ................................................................................................................................ 119
B. Modelo de eventos....................................................................................................................... 119
C. Subpaquetes de AWT .................................................................................................................. 120
D. Subpaquetes de Swing................................................................................................................. 121
($2:2,*J4,K*LMNOPQN,JRSTUVRSW,4UUXYRNZ222222222222222222222222222222222222222222222222222222222222222222222222 3::
A. Introduccin ................................................................................................................................ 122
B. Component .................................................................................................................................. 122
C. Container ..................................................................................................................................... 124
D. Gestores de impresin ................................................................................................................. 124
E. Otras clases .................................................................................................................................. 124
F. Eventos de AWT.......................................................................................................................... 125
($2<2,!J(&6 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3:@
A. Introduccin ................................................................................................................................ 127
B. Nuevas caractersticas.................................................................................................................. 127
C. Principales clases......................................................................................................................... 128
D. Nuevos gestores de impresin ..................................................................................................... 129
E. JrootPane ..................................................................................................................................... 129
F. Nuevos eventos de Swing ............................................................................................................ 130
G. El patrn de diseo Modelo-Vista-Controlador .......................................................................... 130
,&7*8?(8;*?*8&8$",&."&, (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6<)
$23,8*$*,%,(&4%.&%4 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3<<
A. Introduccin ................................................................................................................................ 133
B. El paquete java.net....................................................................................................................... 134
C. Futuro del Java en Internet .......................................................................................................... 134
$2:,0)!,!)'[%4!,%&,8*$* 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3<A
Pgina 4 de 189
A. Fundamentos ............................................................................................................................... 135

B. Ejemplo de uso ............................................................................................................................ 136
,&7*8?$98*002&,'8;*?*((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6<4
$(232,(&4.)+"''(5&,*,0*!,*--0%4! 2222222222222222222222222222222222222222222222222222222222222222222222 3>C
A. Introduccin ................................................................................................................................ 140
B. Consideraciones sobre la seguridad en las applets ...................................................................... 140
$(2:2,0*,'0*!%,*--0%4 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3>:
A. Situacin de la clase Applet en la API de Java............................................................................ 14 2
B. Mtodos del ciclo de vida............................................................................................................ 142
C. La clase URL............................................................................................................................... 143
D. Inclusin de la applet en una pgina Web ................................................................................... 143
E. Obtencin de los parmetros de la applet .................................................................................... 144
F. Obtencin de Informacin sobre una applet ................................................................................ 144
G. Manipulacin del entorno de una applet...................................................................................... 145
H. Soporte multimedia ..................................................................................................................... 145
$(2<2,%8%7-0),+%,')&!4."''(5&,+%,"&*,*--0%4 22222222222222222222222222222222222222222 3>9
A. Cdigo ......................................................................................................................................... 146
B. Ejecucin ..................................................................................................................................... 146
C. Creacin de applets ms avanzadas ............................................................................................. 147
D. Creacin de una aplicacin que utilice la applet (AWT)............................................................. 147
E. Creacin de una aplicacin que utilice la applet (Swing) ............................................................ 149
$(2>2,%8%7-0)!,+%,*--0%4! 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 3AC
A. Instantneas: Tumbling Duke .................................................................................................. 150
B. Animacin y sonido: Animator................................................................................................ 151
C. Grficos interactivos: Link Button........................................................................................... 152
D. Trucos de texto: Nervous Text................................................................................................. 153
E. Financias y negocios: Bar Chart............................................................................................... 153
F. Juegos y educacionales: Graph Layout..................................................................................... 155
*0B"#$%&' ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6:C
*-\&+('%,(2,%0,8+[,K8P]P,+^]^XU_`^SN,[RNZ 22222222222222222222222222222222222222222222222222222222222222 3AD
A. Introduccin ................................................................................................................................ 158
B. Componentes del JDK ................................................................................................................. 158
C. Uso del JDK ................................................................................................................................ 161
D. Obtencin e instalacin del JDK ................................................................................................. 162
E. Novedades en la versin 1.2 del JDK (Java 2)............................................................................. 162
*-\&+('%,((/,;%..*7(%&4*!,+%,+%!*..)00)222222222222222222222222222222222222222222222222 39>
A. Programas de navegacin............................................................................................................ 164
B. Entornos de desarrollo ................................................................................................................. 164
C. Bibliotecas de programacin ....................................................................................................... 167
*-\&+('%,(((/,7\4)+)!,&*4($)!,8*$*,K8&(Z 22222222222222222222222222222222222222222222222222222 39D
A. Introduccin ................................................................................................................................ 168
B. Ejemplo de uso de mtodos nativos........................................................................................... .. 168
*-\&+('%,($/,6"=*,+%,.%?%.%&'(*,+%,'aa,*,8*$* 2222222222222222222222222222222222222222 3@3
A. Introduccin ................................................................................................................................ 171
B. Diferencias sintticas................................................................................................................... 171
C. Diferencias de diseo................................................................................................................... 172
D. Diferencias de ejecucin ............................................................................................................. 173
*-\&+('%,$/,6"=*,+%,.%?%.%&'(*,+%0,0%&6"*8%,8*$* 2222222222222222222222222222 3@A
A. Fundamentos ............................................................................................................................... 175
B. Tipos de datos.............................................................................................................................. 175
C. Operadores................................................................................................................................... 176
D. Estructuras de control.................................................................................................................. 177
E. Clases........................................................................................................................................... 178
Pgina 5 de 189
F. Atributos ...................................................................................................................................... 178

G. Mtodos....................................................................................................................................... 179
H. Objetos ........................................................................................................................................ 179
I. Interfaces....................................................................................................................................... 179
J. Paquetes........................................................................................................................................ 180
K. Excepciones................................................................................................................................. 180
L. Threads ........................................................................................................................................ 181
32-'*.$-(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6/)
>$>2$-3.*5!* ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6//
A. Bibliografa consultada para la actual versin:............................................................................ 188
B. Bibliografa adicional o citada en la actual versin:.................................................................... 189
C. Bibliografa adicional que se utiliz en la versin 1.0................................................................. 189
D. Direcciones de inters ................................................................................................................. 189
='>%<"(>"(%7AB"'"$(
$DEFGH8698&IGDJKL8MG8NOPLK8MG8QGOGHRSE(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6/8
$DEFGH8)982LFLTSJL8MG8KE8GDJOGUE8'VH87SROLUWUTGDU(((((((((((((((((((((((((((((((((((((((((((((((((())8
$DEFGH8<98$RLHL8MG8#VXGY8KE8DEURLTE8MG8;EZE(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()<8
$DEFGH8[98&IGDJKL8MG8LTOL8NOPLK8MG8QGOGHRSE(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((C@8
$DEFGH8:98\GOGHRSE8MG8G]RGJRSLHGU8;EZE (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((/@8
$DEFGH8=98&IGDJKL8MG8QGOGHRSE8D^KTSJKG ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((//8
$DEFGH8C98;GOEO_VÈ8MG8KEU8RKEUGU8MG8*a, (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6))8
$DEFGH8/98#SbGOGHTGU8EUJGRTLU8MG8VHE8SHTGObEc8'dSHF ((((((((((((((((((((((((((((((((((((((((((((((((6)C8
$DEFGH8498&IGRVRSeH8MG8VH8ReMSFL8MG8PWTG((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6<<8
$DEFGH86@985VHRSLHEDSGHTL8MG8VHE8RLHG]SeH8ULRXGT((((((((((((((((((((((((((((((((((((((((((((((((6<:8
$DEFGH86698%SRKL8MG8ZSME8MG8VHE8EJJKGT ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6[)8
$DEFGH86)98*JJKGT8b0cS^Pd((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6[C8
$DEFGH86<98*JJKGT8$HUTEHTNHGE8f,VDPKSHF8#VXGg ((((((((((((((((((((((((((((((((((((((((((((((((((((6:@8
$DEFGH86[98*JJKGT8MG8*HSDERSeH8W8ULHSML8f*HSDETLOg(((((((((((((((((((((((((((((((((((((((((((((6:68
$DEFGH86:98*JJKGT8MG8FONbSRLU8SHTGOERTSZLU8f2SHX8>VTTLHg ((((((((((((((((((((((((((((((((((((((((6:)8
$DEFGH86=98*JJKGT8MG8TG]TL8EHSDEML8f"GOZLVU8,G]Tg ((((((((((((((((((((((((((((((((((((((((((((((((6:<8
$DEFGH86C98*JJKGT8MG8bSHEHRSEU8W8HGFLRSLU8f>EO8%QEOTg (((((((((((((((((((((((((((((((((((((((((((6:<8
$DEFGH86/98*JJKGT8MG8IVGFLU8W8GMVRERSLHEKGU8f3OEJQ82EWLVTg(((((((((((((((((((((((((((((((((6::8
$DEFGH86498+TSKScERSeH8MGK8;#h(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((6=68
='>%<"(>"(@9;:9$(
,EPKE8698%LDJEOERSeH8GHTOG8;EZEY8'DEKK,EKX8W8%ii (((((((((((((((((((((((((((((((((((((((((((((((((((<<8
,EPKE8)980EKEPOEU8OGUGOZEMEU8;EZE ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((</8
Pgina 6 de 189
,EPKE8<98-JGOEMLOGU8;EZE ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((<48
,EPKE8[985LODETLU8MG8RLDGHTEOSLU8;EZE (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((<48
,EPKE8:98,SJLU8MG8METLU8GHTGOLU(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([)8
,EPKE8=98,SJLU8MG8METLU8HVDjOSRLU88GH8RLDE88bKLTEHTG(((((((((((((((((((((((((((((((((((((((((((((((((([<8
,EPKE8C98%EOERTGOGU8GUJGRSEKGU8;EZE (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([[8
,EPKE8/98%LHZGOUSLHGU8USH8JjOMSMEU8MG8SHbLODERSeH((((((((((((((((((((((((((((((((((((((((((((((((((((([:8
,EPKE8498-JGOEMLOGU8EOSTDjTSRLU8PSHEOSLU8MG8;EZE(((((((((((((((((((((((((((((((((((((((((((((((((((((((([/8
,EPKE86@98?GOUSLHGU8VHEOSEU8MG8KLU8LJGOEMLOGU8kik8W8klk ((((((((((((((((((((((((((((((((((((((((((([/8
,EPKE86698-JGOERSLHGU8RLH8kiik8W8kllk(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([/8
,EPKE86)98-JGOEMLOGU8MG8RLDJEOERSeH(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([48
,EPKE86<98-JGOEMLOGU8RLHMSRSLHEKGU ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([48
,EPKE86[98-JGOEMLOGU8MG8MGUJKEcEDSGHTL8MG8PSTU ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((:@8
,EPKE86:98-JGOEMLOGU8MG8KeFSRE8MG8PSTU((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((:@8
,EPKE86=98-JGOEMLOGU8MG8ETEIL8MG8EUSFHERSeH (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((:)8
,EPKE86C980OGMGMGHRSE8MG8LJGOEMLOGU((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((:<8
,EPKE86/98&UTOVRTVOEU8MG8RLHTOLK (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((:[8
,EPKE86498?SUSPSKSMEM8MGHTOL8MG8VH8JE_VGTG(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((468
,EPKE8)@98%LHZGOUSLHGU8MG8REMGHEU8E8TSJLU8USDJKGU((((((((((((((((((((((((((((((((((((((((((((((((((((6@C8
Pgina 7 de 189
96@?#"$(
+(.%'4).,+%0,-.)B%'4), ')).+(&*+).,4\'&('),
Miguel ngel Manzanedo del Campo, Francisco Jos Garca Pealvo,
rea de Organizacin de Empresas, rea de Ciencias de la Computacin e
Inteligencia Artificial,
Dpto. de Ingeniera Civil, Dpto. de Informtica y Automtica,
Universidad de Burgos, Universidad de Salamanca,
.%+*'4*+)e,%+(4*+)e,*7-0(*+),B,-"#0('*+),-)./,
Ignacio Cruzado Nuo
Becario del rea de Lenguajes y Sistemas Informticos
Departamento de Ingeniera Civil
Universidad de Burgos
)4.)!,(&$%!4(6*+).%!,
Csar Ignacio Garca Osorio
Jess Manuel Maudes Raedo Juan Jos Rodrguez Dez,
Carlos Pardo Aguilar,
rea de Lenguajes y Sistemas Informticos, rea de Lenguajes y Sistemas Informticos,
Departamento de Ingeniera Civil, Departamento de Informtica,
Universidad de Burgos, Universidad de Valladolid,
*0"7&)!,')0*#).*+).%!,%&,0*,$%.!(5&,32C,
Alumnos de la asignatura de Programacin Avanzada, asignatura optativa del 3
Curso de la Titulacin de Ingeniera Tcnica en Informtica de Gestin en la
Universidad de Burgos. Alumnos del curso 1997-1998 (Primera promocin).
Rubn Cobos Pomares Ignacio Cruzado Nuo Fernando Delgado Pea
Raquel Dez Alcalde Alberto Dez Cremer Ana Berta Garca Benito
Jorge Garca del Egido Esteban Jos Garca Zamora Alberto Gmez Revilla
Ismael Gonzlez Domingue M Begoa Martn Ortega Javier Portugal Alonso
Pablo Santos Luances David Surez Villasante
Direccin electrnica del proyecto: qjava@ubu.es
Pgina 8 de 189
8#&:?B?(
8#&:?B?(>"(:9(8#%7"#9(!"#$%&'(>"(:9(B6=9(>"(C9!9(
Java es actualmente uno de esos trminos mgicos que revolucionan las tecnologas de
la informacin cada cierto tiempo. Java es un lenguaje de programacin orientado a
objetos creado por la compaa Sun Microsystems, que desde su aparicin en 1995 ha
provocado una autentica conmocin en los entornos informticos. El xito del lenguaje
Java viene de la mano de la filosofa y la forma de operacin de las aplicaciones escritas
en Java, todo ello estrechamente ligado a Internet y al WWW.
El hecho de que el lenguaje Java sea un lenguaje joven en evolucin no le ha permitido
entrar a formar parte habitualmente de los currculum universitarios, poco dados a
admitir innovaciones con tanta celeridad. Sin embargo, Java comienza a entrar en las
Universidades Espaolas, especialmente de la mano de los proyectos de final de carrera
en las titulaciones de informtica.
Aprovechando la convocatoria de 1998 de la Consejera de Educacin y Cultura de la
Junta de Castilla y Len para la concesin de ayudas para la elaboracin de Recursos
de Apoyo a la Enseanza Universitaria en esta Comunidad Autonmica, se decidi
realizar una actividad que tuviera como protagonista al lenguaje Java, a la vez que se
exploraba una nueva forma de involucrar de una manera ms activa al alumnado en las
actividades docentes, as como de incentivar al profesorado en aras de conseguir una
docencia de mayor calidad.
La actividad que se propuso llevar a cabo fue una Gua Hipermedia para el Aprendizaje
del Lenguaje Java.
Con la realizacin de esta gua se perseguan una serie de objetivos tanto docentes como
pragmticos. Los objetivos docentes estaban centrados en la bsqueda de la mejora de la
calidad docente, reflejada en una mayor participacin de los alumnos y en una mejora
de la relacin profesor-alumno. Los objetivos pragmticos se centraban en el
acercamiento del lenguaje Java al curriculum de los alumnos matriculados en la
asignatura Programacin Avanzada correspondiente al tercer curso de la titulacin
Ingeniera Tcnica en Informtica de Gestin en la Universidad de Burgos.
A continuacin se recogen tanto los objetivos docentes como los objetivos pragmticos
propuestos.
)Lf^NR]UM,+UQ^SN^M/,
!"Establecer una nueva forma de participacin activa de los alumnos en el desarrollo
de su currculum universitario, en contraposicin de la actitud pasiva que
tradicionalmente asume el alumno en las clases.
!"Dotar a alumnos y profesores de las responsabilidades que conlleva la realizacin de
una actividad en grupo.
!"Completar los contenidos del curriculum universitario del alumno con temas
novedosos que no suelen tener cabida en el programa de las asignaturas.
!"Aumentar la cantidad y la calidad de la relacin profesor-alumno.
Pgina 9 de 189
)Lf^NR]UM,-OPW`gNRQUM/,
!"Introducir el lenguaje Java dentro de la titulacin Ingeniera Tcnica en Informtica
de Gestin de la Universidad de Burgos.
!"Elaborar una gua de referencia hipermedia del lenguaje Java accesible va Internet y
distribuble en CD-ROM. Esta gua podr ser utilizada tanto para el autoaprendizaje,
como para material docente o como material de consulta en los proyectos de final de
carrera.
!"Aprender de la experiencia para repetir esta tcnica en otras asignaturas de la
titulacin e incluso en otras Universidades.
Este proyecto se va a acometer en dos fases bien diferenciadas:
Una primera fase (!-$&*%TUUV%W%R<+<$6(&$%TUUV) donde se planifica todo el proyecto y
se obtiene una primera gua bsica de referencia bsica (,&*./+#*% 3/$% =<$-$%
&$,&$"$-#'.*%,*&%?'%,&$"$-#$%0/1').
Una segunda fase (!-$&*% TUUU% W% R<+<$6(&$% TUUU) donde se ampla la primera gua
introductoria con los conceptos ms avanzados del lenguaje y se enriquece de los
comentarios recibidos sobre la primera gua.
Para la realizacin prctica de esta primera gua se ha utilizado exclusivamente HTML
(Hyper Text Markup Language), debido a que sus caractersticas hipermedia lo hacen
idneo para el desarrollo de este tipo de productos.
La metodologa empleada para la creacin de esta gua ha consistido en formar grupos
de trabajo formados por tres alumnos cada uno (?*"%'?/6-*"%3/$%5*&6'('-%+'.'%/-*%.$%
?*"%0&/,*"%$&'-%'?/6-*"%.$%?'%'"<0-'#/&'%E&*0&'6'+<>-%G='-C'.'%.$?%#$&+$&%+/&"*%.$%
?'% O-0$-<$&1'% 8B+-<+'% $-% O-5*&64#<+'% .$% X$"#<>-% .$% ?'% Y-<=$&"<.'.% .$% Q/&0*"D% 3/$%
=*?/-#'&<'6$-#$% "$% *5&$+<$&*-% ,'&'% +*?'(*&'&% $-% $"#'% <-<+<'#<='). Cada grupo se
encargaba de elaborar una serie de temas que en su conjunto dan forma a la presente
gua, siendo su trabajo coordinado por alguno de los profesores colaboradores. Una vez
que los temas estaban terminados eran revisados e integrados en la gua por el
coordinador tcnico del proyecto.
Burgos, 5 de Octubre de 1998

Miguel ngel Manzanedo del Campo
Francisco Jos Garca Pealvo
Pgina 10 de 189
8#&:?B?(>"(:9($"B6'>9(!"#$%&'(>"(:9(B6=9(>"(C9!9(
En los casi dos aos en los que se ha venido desarrollando esta gua introductoria al
lenguaje Java, hemos asistido al afianzamiento de Java como plataforma de desarrollo y
a una constante evolucin que, aunque todava lejos de una madurez plena, ha abierto
numerosos campos de aplicacin para esta plataforma (acceso a bases de datos,
interaccin con CORBA, aplicaciones distribuidas...).
Durante este tiempo han proliferado multitud de referencias en torno al fenmeno Java
(en forma de libros, artculos, tutoriales...), sin embargo, la gua que hemos realizado no
pretende sustituir a ninguno de ellos, sino ms bien completarlos presentando una forma
sencilla y directa de introducirse al lenguaje Java y ofreciendo un acceso sencillo
basado en la facilidad de navegacin hipermedia que aporta HTML.
A parte de la gua realizada, como producto final resultado del proyecto financiado por
la Consejera de Educacin y Cultura de la Junta de Castilla y Len en su convocatoria
de ayudas de 1998, este proyecto ha aportado unas experiencias especialmente
interesantes al verse satisfechos los objetivos docentes y pragmticos que se buscaban al
iniciar este trabajo, y que se indicaban en el prlogo a la primera versin de esta gua
que aqu se presenta.
Si personalmente, tuviera que destacar una sola cosa de esta experiencia, no dudara en
destacar el valor humano logrado al potenciar la relacin profesor-alumno (hoy en da
ex-alumnos) y entre compaeros de diferentes Universidades de Castilla y Len para
lograr el fin extra acadmico propuesto.
Tambin me gustara destacar el hecho constatado de que la elaboracin de esta gua a
contribuido en gran manera a la introduccin del lenguaje Java dentro de la titulacin de
Ingeniera Tcnica en Informtica de Gestin de la Universidad de Burgos, y est
haciendo lo propio en la Ingeniera Tcnica en Informtica de Sistemas de la
Universidad de Salamanca.
En el mbito tcnico destacar la revisin realizada de los contenidos de la primera
versin de la gua, as como la ampliacin en temas relacionados con la programacin
cliente/servidor en Internet, los entornos grficos de usuario o la incorporacin de
mtodos nativos entre otros interesantes temas, que dan un enorme valor a esta gua
como fuente de referencia prctica.
No quisiera terminar este prlogo sin antes tener unas palabras de agradecimiento y
recuerdo para todos aqullos que participaron de una u otra manera en la elaboracin de
esta gua, especialmente para mis ex-compaeros del rea de Lenguajes y Sistemas
Informticos de la Universidad de Burgos, para todos mis antiguos alumnos que se
dejaron engaar para iniciar esta aventura y para Ignacio Cruzado cuyo trabajo en
estos ltimos meses ha dotado de contenido y forma a la versin de la gua que hoy se
hace realidad.
Salamanca, 13 de octubre de 1999
Francisco Jos Garca Pealvo
Pgina 11 de 189
8#"D9<%?(
Cuando hace dos cursos el profesor Francisco Jos Garca Pealvo nos propuso redactar
el esbozo de un tutorial sobre Java, de carcter voluntario, y aunque los alumnos
siempre somos reacios a una carga de trabajo sin compensacin en la calificacin,
sorprendentemente, los alumnos aceptamos. La continua apuesta de "Fran" por su
alumnado, y la confianza que en nosotros deposit, realmente nos estimul a dar todo lo
mejor de nosotros.
Aunque desgraciadamente aquel ao no toda la clase pudiera superar la asignatura,
sobre todo por la carga docente, pocas voces he odo en desacuerdo con las novedosas
formas docentes que aquel ao se experimentaron.
Aunque la redaccin de la primera versin, hecha por diferentes grupos de trabajo, era
muy vaga, heterognea y estaba llena de erratas, ha sido el pilar de este tutorial, tanto
como esquema de temas a tratar, como bibliografa a manejar.
En la redaccin de este tutorial se ha pretendido abarcar el mayor nmero de aspectos
posibles de la gran variedad de temas que rodean a Java. Espero no haber perdido nunca
de vista que este tutorial debe de servir tanto a expertos informticos como a
programadores de cualquier tipo que, aun no teniendo idea de programacin orientada a
objetos, tengan inters en Java.
As mismo espero que la bibliografa aportada sea suficiente para aquellos que hayis
quedado prendados de la potencia de este nuevo lenguaje de programacin.
Debo decir que mientras desarrollaba este tutorial me ha impresionado la potencia de
Java por tres motivos principales:
1. Sus amplias bibliotecas multiplataforma.
2. La posibilidad de desarrollar aplicaciones que funcionen en Internet mediante
navegadores (',,?$#").
3. Todo ello con un lenguaje orientado a objeto sencillo pero potente.
Esperemos que pronto los problemas de incompatibilidad entre Microsoft Explorer y
Netscape Navigator se solucionen, con lo que se vivir un futuro lleno de esplendor para
Java.
<?'@"'%>?$(
Este tutorial ha sido dividido en una serie de temas (cada uno de ellos compuesto de
varios apartados) para una ms fcil consulta y una mayor claridad en cunto a qu se
est intentando explicar.
A continuacin se detalla de una forma general los contenidos de cada uno de los
apartados.
En el primer tema ZOA%O-#&*./++<>-Z se intenta acercar al lector el mundo Java desde una
perspectiva global; su historia, sus caractersticas principales y una comparativa con
otros lenguajes orientados a objeto, para que el lector pueda juzgar si le interesa
aprender Java y para que vaya vislumbrando en qu puntos le va a interesar profundizar.
Pgina 12 de 189
En un primer apartado se introducen todos los conceptos necesarios para poder entender
un lenguaje de programacin orientado a objeto, como es Java. Este apartado debe ser
de especial inters para todos aquellos lectores que no hayan desarrollado jams
programas en un lenguaje orientado a objeto, y debe facilitar la comprensin de muchos
conceptos bsicos para un mejor entendimiento del resto del tutorial.
El segundo tema ZOOA% :$-0/')$Z define todos los conceptos bsicos y sintaxis del
lenguaje Java; las estructuras que utiliza, su sintaxis, sus sistemas de control...
Los cuatro primeros apartados de este tema son fundamentales para comprender
cualquier fragmento de cdigo Java, y aunque sencillos son similares a los de cualquier
otro lenguaje de programacin.
Los temas cinco, seis y siete introducen los aspectos orientados a objeto del lenguaje
Java, comenzando desde los ms sencillos como son los objetos y las clases hasta los
ms complejos como pueden ser la herencia y el polimorfismo.
Entre los apartados ocho y once se comentan diversos aspectos propios del lenguaje
Java, que dotan a los programas de una mayor potencia como son las excepciones, los
#I&$'.", las interfaces y los paquetes.
Por ltimo en el apartado doce se explican los fundamentos sobre la construccin de
programas Java, aplicaciones que se pueden construir y diversos aspectos referentes a
ellas.
El tercer tema ZOOOA%Q<(?<*#$+'"%.$%?'%GEO%.$%@'='Z trata, de una forma global, todas las
bibliotecas de la API de Java que servirn para dotar a los programas de una gran
potencia con multitud de clases e interfaces estndar ya programadas y distribuidas por
Sun.
Adems, en un par de apartados se explican las gestiones de las cadenas y de los flujos
de entrada/salida que hace Java. Estas acciones se realizan de forma sensiblemente
diferente a la de otros lenguajes de programacin, como por ejemplo C o C++.
En el cuarto tema ZO[A% Q<(?<*#$+'"% 0&45<+'"Z, se explican las dos bibliotecas que Java
incorpora para desarrollar interfaces grficas de usuario: AWT y la nueva Swing.
En el quinto tema Z[A%@'='%$%O-#$&-$#Z, se explica la potencia de Java para el desarrollo
de aplicaciones en red, as como el paquete )'='A-$#D el cual da soporte a un montn de
operaciones para el dilogo de diversas aplicaciones de red con aspectos como los
"*+P$#".
En el sexto tema Z[OA% G,,?$#"Z se explica el fundamento de este tipo de aplicaciones
especialmente diseadas para su uso en Internet. Son caractersticas de Java y le aportan
una potencia inusitada para el desarrollo de aplicaciones para Internet. Adems en este
tema se acompaan una serie de ejemplos para intentar aclarar el desarrollo y
funcionamiento de este tipo de aplicaciones.
Por ltimo al tutorial se le adjuntan una serie de apndices que sirvan como breves
reseas sobre diferentes aspectos de Java que por una u otra cuestin se ha decidido que
vayan aparte de lo que es el bloque del lenguaje.
As en el primer apndice ZG,B-.<+$%O\%@RSZ, se explica en detalle el funcionamiento
del JDK, herramienta que distribuye Sun para el desarrollo de aplicaciones Java.
En el segundo apndice ZG,B-.<+$% OO\% 7$&&'6<$-#'"% .$% .$"'&&*??*Z, se comentan las
diferentes herramientas disponibles en el mercado para desarrollar aplicaciones Java,
depurarlas y probarlas.
Pgina 13 de 189
En un tercer apndice ZG,B-.<+$%OOO\%9B#*.*"%]'#<=*"Z se explica mediante un ejemplo

de cmo Java es capaz de utilizar cdigo de aplicaciones escritas en otros lenguajes de
programacin.%
En el cuarto apndice ZG,B-.<+$%O[\%X/1'%.$%&$5$&$-+<'%.$%@'='%'%JKKZ se explican las
similitudes y diferencias entre estos dos lenguajes de programacin, dado que Java es
un lenguaje derivado de C++, pero con notables diferencias respecto a su predecesor.
Este apndice puede ser fundamental para aquellos programadores que proviniendo de
C++ quieran conocer el lenguaje Java, ya que su similitud sintctica es, en muchos
casos, engaosa.
En el ltimo apndice ZG,B-.<+$% [\% X/1'% .$% &$5$&$-+<'% .$?% ?$-0/')$Z, se explican, a
modo de resumen, las caractersticas fundamentales del lenguaje Java
9B#9>"<%7%"'@?$(
Me gustara aprovechar este momento para felicitar a Francisco Jos Garca Pealvo por
el esfuerzo que hace por una docencia ms moderna y atractiva, as como la confianza
que deposita en su alumnado, y por el agradable clima de trabajo que ha creado para la
realizacin de este tutorial.
As mismo me gustara agradecer al rea de Lenguajes y Sistemas Informticos de la
Universidad de Burgos la confianza depositada en mi as como toda la documentacin
bibliogrfica que me han facilitado.
Por ltimo me gustara agradecer muy especialmente a Amelia Pajares Rojo su
colaboracin espontnea en este proyecto, consiguiendo as un tutorial mucho ms claro
y legible.
Espero que este tutorial realmente os agrade a todos.
Ignacio Cruzado Nuo
Burgos, Septiembre de 1999
Pgina 14 de 189
@"79(%E(%'@#?>6<<%&'(
Pgina 15 de 189
(/0/%()123&"**(+)%$%,$%423!2$5$*(+)%32(')1$&$%$%36-'137%
9*(8#?B#979<%&'(?#%"'@9>9(9(?;C"@?$(
La orientacin a objetos es un paradigma de programacin que facilita la creacin de
software de calidad por sus factores que potencian el mantenimiento, la extensin y la
reutilizacin del software generado bajo este paradigma.
La programacin orientada a objetos trata de amoldarse al modo de pensar del hombre y
no al de la mquina. Esto es posible gracias a la forma racional con la que se manejan
las abstracciones que representan las entidades del dominio del problema, y a
propiedades como la jerarqua o el encapsulamiento.
El elemento bsico de este paradigma no es la funcin (elemento bsico de la
programacin estructurada), sino un ente denominado objeto. Un objeto es la
representacin de un concepto para un programa, y contiene toda la informacin
necesaria para abstraer dicho concepto: los datos que describen su estado y las
operaciones que pueden modificar dicho estado, y determinan las capacidades del
objeto.
Java incorpora el uso de la orientacin a objetos como uno de los pilares bsicos de su
lenguaje.
;*(:?$(?;C"@?$(
Podemos definir objeto como el "encapsulamiento de un conjunto de operaciones
(mtodos) que pueden ser invocados externamente, y de un estado que recuerda el
efecto de los servicios". h-RPNNRSR,^N,PX2e,3FF9i.
Un objeto adems de un estado interno, presenta una interfaz para poder interactuar con
el exterior. Es por esto por lo que se dice que en la programacin orientada a objetos "se
unen datos y procesos", y no como en su predecesora, la programacin estructurada, en
la que estaban separados en forma de variables y funciones.
Un objeto consta de:
!"Tiempo de vida: La duracin de un objeto en un programa siempre est limitada en
el tiempo. La mayora de los objetos slo existen durante una parte de la ejecucin
del programa. Los objetos son creados mediante un mecanismo denominado
<-"#'-+<'+<>-, y cuando dejan de existir se dice que son .$"#&/<.*"A%
!"Estado: Todo objeto posee un estado, definido por sus '#&<(/#*". Con l se definen
las propiedades del objeto, y el estado en que se encuentra en un momento
determinado de su existencia.
!"Comportamiento: Todo objeto ha de presentar una interfaz, definida por sus
6B#*.*", para que el resto de objetos que componen los programas puedan
interactuar con l.
El equivalente de un *()$#* en el paradigma estructurado sera una ='&<'(?$. As mismo
la <-"#'-+<'+<>-%.$%*()$#*" equivaldra a la .$+?'&'+<>-%.$%='&<'(?$", y el #<$6,*%.$%=<.'%
.$%/-%*()$#* al 46(<#*%.$%/-'%='&<'(?$.
Pgina 16 de 189
<*(:9$(<:9$"$(
Las clases son abstracciones que representan a un conjunto de objetos con un
comportamiento e interfaz comn.
Podemos definir una clase como "un conjunto de cosas (fsicas o abstractas) que tienen
el mismo comportamiento y caractersticas... Es la implementacin de un tipo de objeto
(considerando los objetos como instancias de las clases)". h-RPNNRSR,^N,PX2e,3FF9i.
Una clase no es ms que una plantilla para la creacin de objetos. Cuando se crea un
objeto (<-"#'-+<'+<>-) se ha de especificar de qu clase es el objeto instanciado, para
que el compilador comprenda las caractersticas del objeto.
Las clases presentan el estado de los objetos a los que representan mediante variables
denominadas '#&<(/#*". Cuando se instancia un objeto el compilador crea en la memoria
dinmica un espacio para tantas variables como atributos tenga la clase a la que
pertenece el objeto.
Los 6B#*.*" son las funciones mediante las que las clases representan el
comportamiento de los objetos. En dichos mtodos se modifican los valores de los
atributos del objeto, y representan las capacidades del objeto (en muchos textos se les
denomina "$&=<+<*").
Desde el punto de vista de la programacin estructurada, una clase se asemejara a un
mdulo, los atributos a las variables globales de dicho mdulo, y los mtodos a las
funciones del mdulo.
>*(7?>":?(>"(?;C"@?$(
Existen una serie de principios fundamentales para comprender cmo se modeliza la
realidad al crear un programa bajo el paradigma de la orientacin a objetos. Estos
principios son: la abstraccin, el encapsulamiento, la modularidad, la jerarqua, el paso
de mensajes y el poliforfismo.
8/9%4:;<=;>;?%@A%$BCD:8==;E<%
Mediante la abstraccin la mente humana modeliza la realidad en forma de objetos. Para
ello busca parecidos entre la realidad y la posible implementacin de *()$#*"% .$?%
,&*0&'6' que simulen el funcionamiento de los *()$#*"%&$'?$".
Los seres humanos no pensamos en las cosas como un conjunto de cosas menores; por
ejemplo, no vemos un cuerpo humano como un conjunto de clulas. Los humanos
entendemos la realidad como objetos con comportamientos bien definidos. No
necesitamos conocer los detalles de porqu ni cmo funcionan las cosas; simplemente
solicitamos determinadas acciones en espera de una respuesta; cuando una persona
desea desplazarse, su cuerpo le responde comenzando a caminar.
Pero la abstraccin humana se gestiona de una manera jerrquica, dividiendo
sucesivamente sistemas complejos en conjuntos de subsistemas, para as entender ms
fcilmente la realidad. Esta es la forma de pensar que la orientacin a objeto intenta
cubrir.
B/9%4:;<=;>;?%@A%'<=8>CFG8H;A<D?%
El encapsulamiento permite a los objetos elegir qu informacin es publicada y qu
informacin es ocultada al resto de los objetos. Para ello los objetos suelen presentar sus
Pgina 17 de 189
mtodos como interfaces pblicas y sus atributos como datos privados e inaccesibles
desde otros objetos.
Para permitir que otros objetos consulten o modifiquen los atributos de los objetos, las
clases suelen presentar mtodos de acceso. De esta manera el acceso a los datos de los
objetos es controlado por el programador, evitando efectos laterales no deseados.
Con el encapsulado de los datos se consigue que las personas que utilicen un objeto slo
tengan que comprender su interfaz, olvidndose de cmo est implementada, y en
definitiva, reduciendo la complejidad de utilizacin.
=/9%4:;<=;>;?%@A%5?@FG8:;@8@%
Mediante la modularidad, se propone al programador dividir su aplicacin en varios
mdulos diferentes (ya sea en forma de clases, paquetes o bibliotecas), cada uno de ellos
con un sentido propio.
Esta fragmentacin disminuye el grado de dificultad del problema al que da respuesta el
programa, pues se afronta el problema como un conjunto de problemas de menor
dificultad, adems de facilitar la comprensin del programa.
@/9%4:;<=;>;?%@A%-A:8:IFJ8%%
La mayora de nosotros ve de manera natural nuestro mundo como objetos que se
relacionan entre s de una manera jerrquica. Por ejemplo, un perro es un mamfero, y
los mamferos son animales, y los animales seres vivos...
Del mismo modo, las distintas clases de un programa se organizan mediante la
)$&'&3/1'. La representacin de dicha organizacin da lugar a los denominados 4&(*?$"%
.$%I$&$-+<':
Clase Padre
Clase Hija1 Clase Hija2
Clase Nieta1 Clase Nieta2 Clase Nieta3
O6'0$-%T\%!)$6,?*%.$%4&(*?%.$%I$&$-+<'%
Mediante la I$&$-+<' una +?'"$%I<)' puede tomar determinadas propiedades de una +?'"$%
,'.&$. As se simplifican los diseos y se evita la duplicacin de cdigo al no tener que
volver a codificar mtodos ya implementados.
Al acto de tomar propiedades de una clase padre se denomina I$&$.'&.
A/9%4:;<=;>;?%@AG%48C?%@A%5A<C8KAC%%
Mediante el denominado ,'"*%.$%6$-"')$", un objeto puede solicitar de otro objeto que
realice una accin determinada o que modifique su estado. El paso de mensajes se suele
implementar como llamadas a los mtodos de otros objetos.
Desde el punto de vista de la programacin estructurada, esto correspondera con la
llamada a funciones.
Pgina 18 de 189
L/9%4:;<=;>;?%@A%4?G;H?:L;CH?%
Polimorfismo quiere decir "un objeto y muchas formas". Esta propiedad permite que un
objeto presente diferentes comportamientos en funcin del contexto en que se
encuentre. Por ejemplo un mtodo puede presentar diferentes implementaciones en
funcin de los argumentos que recibe, recibir diferentes nmeros de parmetros para
realizar una misma operacin, y realizar diferentes acciones dependiendo del nivel de
abstraccin en que sea llamado.
"*(#":9<%?'"$("'@#"(?;C"@?$(
Durante la ejecucin de un programa, los diversos objetos que lo componen han de
interactuar entre s para lograr una serie de objetivos comunes.
Existen varios tipos de relaciones que pueden unir a los diferentes objetos, pero entre
ellas destacan las relaciones de: asociacin, todo/parte, y generalizacin/especializacin.
8/9%2AG8=;?<AC%@A%$C?=;8=;E<%
Seran relaciones generales, en las que un objeto realiza llamadas a los servicios
(mtodos) de otro, interactuando de esta forma con l.
Representan las relaciones con menos riqueza semntica.
B/9%2AG8=;?<AC%@A%1?@?M48:DA%
Muchas veces una determinada entidad existe como conjuncin de otras entidades,
como un conglomerado de ellas. La orientacin al objeto recoge este tipo de relaciones
como dos conceptos; la agregacin y la composicin.
En este tipo de relaciones un *()$#*%+*6,*-$-#$ se integra en un *()$#*%+*6,/$"#*. La
diferencia entre agregacin y composicin es que mientras que la composicin se
entiende que dura durante toda la vida del objeto componedor, en la agregacin no tiene
por qu ser as.
Esto se puede implementar como un objeto (*()$#*% +*6,/$"#*) que cuenta entre sus
atributos con otro objeto distinto (*()$#*%+*6,*-$-#$).
=/9%2AG8=;?<AC%@A%!A<A:8G;N8=;E<M'C>A=;8G;N8=;E<%
A veces sucede que dos clases tiene muchas de sus partes en comn, lo que
normalmente se abstrae en la creacin de una tercera clase (,'.&$ de las dos) que rene
todas sus caractersticas comunes.
El ejemplo ms extendido de este tipo de relaciones es la herencia, propiedad por la que
una clase (+?'"$%I<)') recoge aquellos mtodos y atributos que una segunda clase (+?'"$%
,'.&$) ha especificado como "heredables".
Este tipo de relaciones es caracterstico de la programacin orientada a objetos.
En realidad, la generalizacin y la especializacin son diferentes perspectivas del mismo
concepto, la generalizacin es una perspectiva ascendente ((*##*6^/,), mientras que la
especializacin es una perspectiva descendente (#*,^.*N-).
Pgina 19 de 189
Para ms informacin sobre el modelo de objetos en la programacin avanzada, y las

relaciones entre objetos vase h6POQcPe, 3FFDi o para una informacin ms detallada
consulte h#UUQje,3FF9i.
Pgina 20 de 189
(/O/%P(7132($%&'%-$.$%
9*(F8?#(G6H($"(>%$"I&(C9!9J(
Los lenguajes de programacin C y Fortran se han utilizado para disear algunos de los
sistemas ms complejos en lenguajes de programacin estructurada, creciendo hasta
formar complicados procedimientos. De ah provienen trminos como cdigo de
espagueti o canguros referentes a programas con mltiples saltos y un control de
flujo difcilmente trazable.
No slo se necesitaba un lenguaje de programacin para tratar esta complejidad, sino un
nuevo estilo de programacin. Este cambio de paradigma de la programacin
estructurada a la programacin orientada a objetos, comenz hace 30 aos con un
lenguaje llamado Simula67.
El lenguaje C++ fue un intento de tomar estos principios y emplearlos dentro de las
restricciones de C. Todos los compiladores de C++ eran capaces de compilar programas
de C sin clases, es decir, un lenguaje capaz de interpretar dos estilos diferentes de
programacin. Esta compatibilidad (ZI'+<'% '#&4"Z) que habitualmente se vende como
una caracterstica de C++ es precisamente su punto ms dbil. No es necesario utilizar
un diseo orientado a objetos para programar en C++, razn por la que muchas veces
las aplicaciones en este lenguaje no son realmente orientadas al objeto, perdiendo as los
beneficios que este paradigma aporta.
As Java utiliza convenciones casi idnticas para declaracin de variables, paso de
parmetros, y dems, pero slo considera las partes de C++ que no estaban ya en C.
Las principales caractersticas que Java no hereda de C++ son:
!"Punteros: Las direcciones de memoria son la caracterstica ms poderosa de C++. El
inadecuado uso de los punteros provoca la mayora de los errores de colisin de
memoria, errores muy difciles de detectar. Adems, casi todos los virus que se han
escrito aprovechan la capacidad de un programa para acceder a la memoria voltil
(RAM) utilizando punteros. En Java, no existen punteros, evitando el acceso directo
a la memoria voltil.
!"Variables globales: Con ellas cualquier funcin puede producir efectos laterales, e
incluso se pueden producir fallos catastrficos cuando algn otro mtodo cambia el
estado de la variable global necesaria para la realizacin de otros procesos. En Java
lo nico global es el nombre de las clases.
!"0*#*: Manera rpida de arreglar un programa sin estructurar el cdigo. Java no tiene
ninguna sentencia 0*#*. Sin embargo Java tiene las sentencias (&$'P y +*-#<-/$ que
cubren los casos importantes de 0*#*.
!"Asignacin de memoria: La funcin 6'??*+ de C, asigna un nmero especificado de
bytes de memoria devolviendo la direccin de ese bloque. La funcin 5&$$ devuelve
un bloque asignado al sistema para que lo utilice. Si se olvida de llamar a 5&$$%para
liberar un bloque de memoria, se estn limitando los recursos del sistema,
ralentizando progresivamente los programas. Si por el contrario se hace un 5&$$%
sobre un puntero ya liberado, puede ocurrir cualquier cosa. Ms tarde C++ aadi
-$N% y .$?$#$, que se usan de forma similar, siendo todava el programador, el
responsable de liberar el espacio de memoria. Java no tiene funciones%6'??*+%ni 5&$$.
Pgina 21 de 189
Se utiliza el operador -$N para asignar un espacio de memoria a un objeto en el

6*-#1+/?* de memoria. Con -$N% no se obtiene una direccin de memoria sino un
descriptor al objeto del 6*-#1+/?*. La memoria real asignada a ese objeto se puede
mover a la vez que el programa se ejecuta, pero sin tener que preocuparse de ello.
Cuando no tenga ninguna referencia de ningn objeto, la memoria ocupada estar
disponible para que la reutilice el resto del sistema sin tener que llamar a 5&$$ o
.$?$#$A A esto se le llama &$+*0<.'% .$% ('"/&'. El recolector de basura se ejecuta
siempre que el sistema est libre, o cuando una asignacin solicitada no encuentre
asignacin suficiente.
!"Conversin de tipos insegura: Los moldeados de tipo (#H,$% +'"#<-0) son un
mecanismo poderoso de C y C++ que permite cambiar el tipo de un puntero. Esto
requiere extremada precaucin puesto que no hay nada previsto para detectar si la
conversin es correcta en tiempo de ejecucin. En Java se puede hacer una
comprobacin en tiempo de ejecucin de la compatibilidad de tipos y emitir una
excepcin cuando falla.
;*(<?7%"'K?$(
Java fue diseado en 1990 por James Gosling, de Sun Microsystems, como software
para dispositivos electrnicos de consumo. Curiosamente, todo este lenguaje fue
diseado antes de que diese comienzo la era World Wide Web, puesto que fue diseado
para dispositivos electrnicos como calculadoras, microondas y la televisin interactiva.
O6'0$-%_\%:*0*#<,*%.$%?'%$6,&$"'%M/-%9<+&*"H"#$6"%
En los primeros aos de la dcada de los noventa, Sun Microsystems decidi intentar
introducirse en el mercado de la electrnica de consumo y desarrollar programas para
pequeos dispositivos electrnicos. Tras unos comienzos dudosos, Sun decidi crear
una filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo
responsable del proyecto.
Inicialmente Java se llam Oak (roble en ingls), aunque tuvo que cambiar de
denominacin, debido a que dicho nombre ya estaba registrado por otra empresa. Se
dice este nombre se le puso debido a la existencia de tal rbol en los alrededores del
lugar de trabajo de los promotores del lenguaje.
Tres de las principales razones que llevaron a crear Java son:
1. Creciente necesidad de interfaces mucho ms cmodas e intuitivas que los sistemas
de ventanas que proliferaban hasta el momento.
2. Fiabilidad del cdigo y facilidad de desarrollo. Gosling observ que muchas de las
caractersticas que ofrecan C o C++ aumentaban de forma alarmante el gran coste
de pruebas y depuracin. Por ello en los sus ratos libres cre un lenguaje de
programacin donde intentaba solucionar los fallos que encontraba en C++.
Pgina 22 de 189
3. Enorme diversidad de controladores electrnicos. Los dispositivos electrnicos se

controlan mediante la utilizacin de microprocesadores de bajo precio y reducidas
prestaciones, que varan cada poco tiempo y que utilizan diversos conjuntos de
instrucciones. Java permite escribir un cdigo comn para todos los dispositivos.
Por todo ello, en lugar de tratar nicamente de optimizar las tcnicas de desarrollo y dar
por sentada la utilizacin de C o C++, el equipo de Gosling se plante que tal vez los
lenguajes existentes eran demasiado complicados como para conseguir reducir de forma
apreciable la complejidad de desarrollo asociada a ese campo. Por este motivo, su
primera propuesta fue idear un nuevo lenguaje de programacin lo ms sencillo posible,
con el objeto de que se pudiese adaptar con facilidad a cualquier entorno de ejecucin.
Basndose en el conocimiento y estudio de gran cantidad de lenguajes, este grupo
decidi recoger las caractersticas esenciales que deba tener un lenguaje de
programacin moderno y potente, pero eliminando todas aquellas funciones que no eran
absolutamente imprescindibles.
Para ms informacin vase h'k^SQPe,3FF@i.
<*(8#%7"#?$(8#?L"<@?$("'(G6"($"(98:%<&(C9!9(
El proyecto Green fue el primero en el que se aplic Java, y consista en un sistema de
control completo de los aparatos electrnicos y el entorno de un hogar. Con este fin se
construy un ordenador experimental denominado *7 (Star Seven). El sistema
presentaba una interfaz basada en la representacin de la casa de forma animada y el
control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema apareca
ya R/P$, la actual mascota de Java.
O6'0$-%`\%O+*-*%.$%R/P$D%?'%6'"+*#'%.$%@'='%
Ms tarde Java se aplic a otro proyecto denominado VOD (Video On Demand) en el
que se empleaba como interfaz para la televisin interactiva que se pensaba iba a ser el
principal campo de aplicacin de Java. Ninguno de estos proyectos se convirti nunca
en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo.
Una vez que en Sun se dieron cuenta de que a corto plazo la televisin interactiva no iba
a ser un gran xito, instaron a FirstPerson a desarrollar nuevas estrategias que
produjeran beneficios. Entre ellas se encontraba la aplicacin de Java a Internet, la cual
no se consider productiva en ese momento.
Para ms informacin vase h?OUklê,3FF@i2
>*(#"$6#B%7%"'@?(>"(C9!9(
Aunque muchas de las fuentes consultadas sealan que Java no lleg a caer en un
olvido, lo cierto es que tuvo que ser Bill Joy (cofundador de Sun y uno de los
Pgina 23 de 189
desarrolladores principales del sistema operativo Unix de Berckley) el que sac a Java
del letargo en que estaba sumido. Joy juzg que Internet podra llegar a ser el campo
adecuado para disputar a Microsoft su primaca en el terreno del software, y vio en Oak
el instrumento idneo para llevar a cabo estos planes.
Para poder presentarlo en sociedad se tuvo que modificar el nombre de este lenguaje de
programacin y se tuvo que realizar una serie de modificaciones de diseo para poderlo
adaptar al propsito mencionado. As Java fue presentado en sociedad en agosto de
1995.
Algunas de las razones que llevaron a Bill Joy a pensar que Java podra llegar a ser
rentable son:
!"Java es un lenguaje orientado a objetos: Esto es lo que facilita abordar la resolucin
de cualquier tipo de problema.
!"Es un lenguaje sencillo, aunque sin duda potente.
!"La ejecucin del cdigo Java es segura y fiable: Los programas no acceden
directamente a la memoria del ordenador, siendo imposible que un programa escrito
en Java pueda acceder a los recursos del ordenador sin que esta operacin le sea
permitida de forma explcita. De este modo, los datos del usuario quedan a salvo de
la existencia de virus escritos en Java. La ejecucin segura y controlada del cdigo
Java es una caracterstica nica, que no puede encontrarse en ninguna otra
tecnologa.
!"Es totalmente multiplataforma: Es un lenguaje sencillo, por lo que el entorno
necesario para su ejecucin es de pequeo tamao y puede adaptarse incluso al
interior de un navegador.
Las consecuencias de la utilizacin de Java junto a la expansin universal de Internet
todava estn comenzando a vislumbrarse.
Para ms informacin vase h?OUklê,3FF@i.
"*(D6@6#?(>"(C9!9(
Existen muchas crticas a Java debido a su lenta velocidad de ejecucin,
aproximadamente unas 20 veces ms lento que un programa en lenguaje C. Sun est
trabajando intensamente en crear versiones de Java con una velocidad mayor.
El problema fundamental de Java es que utiliza una representacin intermedia
denominada +>.<0*%.$%(H#$ para solventar los problemas de portabilidad. Los +>.<0*"%
.$%(H#$ posteriormente se tendrn que transformar en cdigo mquina en cada mquina
en que son utilizados, lo que ralentiza considerablemente el proceso de ejecucin.
La solucin que se deriva de esto parece bastante obvia: fabricar ordenadores capaces
de comprender directamente los cdigos de byte. stas seran unas mquinas que
utilizaran Java como sistema operativo y que no requeriran en principio de disco duro
porque obtendran sus recursos de la red.
A los ordenadores que utilizan Java como sistema operativo se les llama Network
Computer, WebPC o WebTop. La primera gran empresa que ha apostado por este tipo
de mquinas ha sido Oracle, que en enero de 1996 present en Japn su primer NC
(Network Computer), basado en un procesador RISC con 8 Megabytes de RAM. Tras
Pgina 24 de 189
Oracle, han sido compaas del tamao de Sun, Apple e IBM las que han anunciado
desarrollos similares.
La principal empresa en el mundo del software, Microsoft, que en los comienzos de
Java no estaba a favor de su utilizacin, ha licenciado Java, lo ha incluido en Internet
Explorer (versin 3.0 y posteriores), y ha lanzado un entorno de desarrollo para Java,
que se denomina Visual J++.
El nico problema aparente es la seguridad para que Java se pueda utilizar para
transacciones crticas. Sun va a apostar por firmas digitales, que sern clave en el
desarrollo no slo de Java, sino de Internet.
Para ms informacin vase h?OP`RmgSe,3FF@i.
D*("$8"<6:9<%&'($?;#"(":(D6@6#?(>"(C9!9(
En opinin de los redactores de este tutorial, Java es una plataforma que le falta
madurar, pero que a buen seguro lo va a hacer. La apuesta realizada por empresas con
mucho peso especfico ha sido tan grande que va a dar un impulso a Java que no le
permitir caer
Adems, el parque de productos (entornos de desarrollo, bibliotecas, elementos de
conectividad...) ya disponible en la actualidad es tan amplio que es improbable que se
quede en nada.
Por otra parte, la relacin simbitica que tiene con Internet (y por derivacin con las
Intranets) es un punto a favor de Java de muy difcil refutacin.
Pgina 25 de 189
(/Q/%*$2$*1'2#71(*$7%&'%-$.$%
9*(%'@#?>6<<%&'(
No es arriesgado afirmar que Java supone un significativo avance en el mundo de los
entornos software, y esto viene avalado por tres elementos claves que diferencian a este
lenguaje desde un punto de vista tecnolgico:
!"Es un lenguaje de programacin que ofrece la potencia del diseo orientado a
objetos con una sintaxis fcilmente accesible y un entorno robusto y agradable.
!"Proporciona un conjunto de clases potente y flexible.
!"Pone al alcance de cualquiera la utilizacin de aplicaciones que se pueden incluir
directamente en pginas Web (aplicaciones denominadas ',,?$#")A
Java aporta a la Web una interactividad que se haba buscado durante mucho tiempo
entre usuario y aplicacin.
A lo largo de este apartado se estudian en detalle las principales caractersticas de Java.
;*(8?@"'@"(
8/9%3:;A<D8=;E<%8%?BKAD?C%
En este aspecto Java fue diseado partiendo de cero, no siendo derivado de otro
lenguaje anterior y no tiene compatibilidad con ninguno de ellos.
En Java el concepto de objeto resulta sencillo y fcil de ampliar. Adems se conservan
elementos no objetos, como nmeros, caracteres y otros tipos de datos simples.
B/9%2;IFAN8%CAHR<D;=8%
Pese a su simpleza se ha conseguido un considerable potencial, y aunque cada tarea se
puede realizar de un nmero reducido de formas, se ha conseguido un gran potencial de
expresin e innovacin desde el punto de vista del programador.
=/9%2?BFCD?%
Java verifica su cdigo al mismo tiempo que lo escribe, y una vez ms antes de
ejecutarse, de manera que se consigue un alto margen de codificacin sin errores. Se
realiza un descubrimiento de la mayor parte de los errores durante el tiempo de
compilacin, ya que Java es estricto en cuanto a tipos y declaraciones, y as lo que es
rigidez y falta de flexibilidad se convierte en eficacia. Respecto a la gestin de memoria,
Java libera al programador del compromiso de tener que controlar especialmente la
asignacin que de sta hace a sus necesidades especficas. Este lenguaje posee una
gestin avanzada de memoria llamada gestin de basura, y un manejo de excepciones
orientado a objetos integrados. Estos elementos realizarn muchas tareas antes tediosas
a la vez que obligadas para el programador.
Pgina 26 de 189
@/9%5?@AG?%@A%?BKAD?%:;=?%
Existen varias clases que contienen las abstracciones bsicas para facilitar a los
programas una gran capacidad de representacin. Para ello se contar con un conjunto
de clases comunes que pueden crecer para admitir todas las necesidades del
programador.
Adems la biblioteca de clases de Java proporciona un conjunto nico de protocolos de
Internet.
El conjunto de clases ms complicado de Java son sus paquetes grficos AWT (G("#&'+#%
L<-.*N%8**?P<#) y%MN<-0. Estos paquetes implementan componentes de una interfaz de
usuario grfica bsica comn a todos los ordenadores personales modernos.
<*($%78:"(
8/9%SR=;G%8>:A<@;N8KA%
El nico requerimiento para aprender Java es tener una comprensin de los conceptos
bsicos de la programacin orientada a objetos. As se ha creado un lenguaje simple
(aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del
programador sin que las interioridades del sistema subyacente sean desveladas.
Java es ms complejo que un lenguaje simple, pero ms sencillo que cualquier otro
entorno de programacin. El nico obstculo que se puede presentar es conseguir
comprender la programacin orientada a objetos, aspecto que, al ser independiente del
lenguaje, se presenta como insalvable.
B/9%*?H>GAD8@?%=?<%FD;G;@8@AC%
El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos
complejas y sus mtodos asociados, que sern de inestimable ayuda para implementar
',,?$#" y otras aplicaciones ms complejas. Se dispone tambin de estructuras de datos
habituales, como ,<?'" y #'(?'"%I'"I, como clases ya implementadas.
Existir una interfaz F("$&=$&aF("$&='(?$ que permitir la implementacin simple de
objetos dinmicos cuyo estado se visualiza en pantalla.
El JDK (@'='% R$=$?*,6$-#% S<#; suministrado por Sun Microsystems incluye un
compilador, un intrprete de aplicaciones, un depurador en lnea de comandos, y un
visualizador de ',,?$#" entre otros elementos.
>*(%'@"#9<@%!?(L(?#%"'@9>?(9(#">(
8/9%(<DA:8=D;T?%U%8<;H8@?%
Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en
red interactivos, por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo
que debera suceder y cundo. Para se da soporte a la utilizacin de mltiples hilos de
programacin (6/?#<#I&$'.).
Las aplicaciones de Java permiten situar figuras animadas en las pginas Web, y stas
pueden concebirse con logotipos animados o con texto que se desplace por la pantalla.
Pgina 27 de 189
Tambin pueden tratarse grficos generados por algn proceso. Estas animaciones
pueden ser interactivas, permitiendo al usuario un control sobre su apariencia.
B/9%$:IF;DA=DF:8%<AFD:8G%
Java est diseado para que un programa escrito en este lenguaje sea ejecutado
correctamente independientemente de la plataforma en la que se est actuando
(Macintosh, PC, UNIX). Para conseguir esto utiliza una compilacin en una
representacin intermedia que recibe el nombre de +>.<0*"% .$% (H#$, que pueden
interpretarse en cualquier sistema operativo con un intrprete de Java. La desventaja de
un sistema de este tipo es el rendimiento; sin embargo, el hecho de que Java fuese
diseado para funcionar razonablemente bien en microprocesadores de escasa potencia,
unido a la sencillez de traduccin a cdigo mquina hacen que Java supere esa
desventaja sin problemas.
=/9%1:8B8K?%A<%:A@%
Java anima las pginas Web y hace posible la incorporacin de aplicaciones interactivas
y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de manera
que los suministradores de informacin de la Web pueden crear una pgina de
hipertexto (,40<-'%L$() con una interaccin continuada y compleja en tiempo real; el
contenido ejecutable es transferido literalmente al ordenador del usuario.
Los protocolos bsicos para trabajar en Internet estn encapsulados en unas cuantas
clases simples. Se incluyen implementaciones ampliables de los protocolos FTP, HTTP,
NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado.
Esto le permite interactuar con esos servicios de red poderosos sin tener que
comprender realmente los detalles de bajo nivel de esos protocolos. Este lenguaje est
diseado para cumplir los requisitos de entrega de contenidos interactivos mediante el
uso de applets insertados en sus pginas HTML. Adems, las clases de Java admiten
muy bien estos protocolos y formatos. El envo de las clases de Java a travs de Internet
se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo as los
tpicos problemas de diferencia de versiones.
Java proporciona un conjunto de clases para tratar con una abstraccin de los conectores
de red ("*+P$#"; originales de la versin UNIX de Berckley, encapsular la nocin de una
direccin de Internet o conectar sockets con flujos de datos de Entrada/Salida.
Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web,
puesto que es capaz de captar el inters del usuario durante largo tiempo y permite a los
programadores convertir la Web en un sistema de entrega de software.
@/9%$>>GADC%
Una ',,?$# (miniaplicacin) es un pequeo programa en Java transferido
dinmicamente a travs de Internet. Presentan un comportamiento inteligente, pudiendo
reaccionar a la entrada de un usuario y cambiar de forma dinmica. Sin embargo, la
verdadera novedad es el gran potencial que Java proporciona en este aspecto, haciendo
posible que los programadores ejerzan un control sobre los programas ejecutables de
Java que no es posible encontrar en otros lenguajes.
Pgina 28 de 189
"*(L(76<M?(7A$(
8/9%7AVF:;@8@%
Existe una preocupacin lgica en Internet por el tema de la seguridad: virus, caballos
de Troya, y programas similares navegan de forma usual por la red, constituyendo una
amenaza palpable. Java ha sido diseado poniendo un nfasis especial en el tema de la
seguridad, y se ha conseguido lograr cierta inmunidad en el aspecto de que un programa
realizado en Java no puede realizar llamadas a funciones globales ni acceder a recursos
arbitrarios del sistema, por lo que el control sobre los programas ejecutables no es
equiparable a otros lenguajes.
Los niveles de seguridad que presenta son:
!"Fuertes restricciones al acceso a memoria, como son la eliminacin de punteros
aritmticos y de operadores ilegales de transmisin.
!"Rutina de verificacin de los +>.<0*"%.$%(H#$ que asegura que no se viole ninguna
construccin del lenguaje.
!"Verificacin del nombre de clase y de restricciones de acceso durante la carga.
!"Sistema de seguridad de la interfaz que refuerza las medidas de seguridad en
muchos niveles.
En futuras versiones se prev contar tambin con encriptacin y tcnicas similares.
B/9%,A<VF8KA%B8C8@?%A<%*WW%
Java fue desarrollado basndose en C++, pero eliminando rasgos del mismo poco
empleados, optndose por una codificacin comprensible. Bsicamente, encontramos
las siguientes diferencias con C++:
!"Java no soporta los tipos "#&/+#D%/-<*-%ni punterosA
!"No soporta #H,$.$5 ni b.$5<-$A
!"Se distingue por su forma de manejar ciertos operadores y no permite una
sobrecarga de operadores.
!"No soporta herencia mltiple.
!"Java maneja argumentos en la lnea de comandos de forma diversa a como lo hacen
C o C++.
!"Tiene una clase M#&<-0 que es parte del paquete )'='A?'-0 y se diferencia de la matriz
de caracteres terminada con un nulo que usan C y C++.
!"Java cuenta con un sistema automtico para asignar y liberar memoria, con lo que
no es necesario utilizar las funciones previstas con este fin en C y C++.
=/9%!ACD;E<%@A%G8%'<D:8@8M78G;@8%
En lugar de utilizar primitivas como las de C para trabajar con ficheros, se utlizan
primitivas similares a las de C++, mucho ms elegantes, que permiten tratar los
ficheros, sockets, teclado y monitor como flujos de datos.
Pgina 29 de 189
De este modo se pueden utilizar dichas primitivas para cualquier operacin de

Entrada/Salida.
@/9%&;LA:A<DAC%D;>?C%@A%8>G;=8=;?<AC%
En Java podemos crear los siguientes tipos de aplicaciones:
!"Aplicaciones: Se ejecutan sin necesidad de un navegador.
!"G,,?$#": Se pueden descargar de Internet y se observan en un navegador.
!"@'='Q$'-": Componentes software Java, que se puedan incorporar grficamente a
otros componentes.
!"@'='M+&<,#: Conjunto del lenguaje Java que puede codificarse directamente sobre
cualquier documento HTML
!"M$&=?$#": Mdulos que permiten sustituir o utilizar el lenguaje Java en lugar de
programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a
las pginas Web.
Pgina 30 de 189
(/X/%*354$2$1(.$%*3)%31237%,')!"$-'7%&'%423!2$5$*(+)%
32(')1$&37%$%36-'13%
9*(%'@#?>6<<%&'(
En este apartado se va a comparar Java con otros lenguajes de programacin orientados
a objeto.
En principio Java fue diseado tomando C y C++ como base para la creacin de un
nuevo lenguaje con la modificacin de todos aquellos aspectos que no eran tiles o
dificultosos para la programacin de componentes electrnicos de bajo coste. Para ello
el nuevo lenguaje deba incluir interfaces cmodas, deba ser fiable y fcil de desarrollar
y los programas deban ser portables de un sistema a otro sin ningn tipo de problema.
;*(<?789#9<%&'(>"(:?$(@%8?$(>"(>9@?$(
8/9%1;>?C%@A%@8D?C%C;H>GAC%Y>:;H;D;T?C9%
Java es muy parecido a C++ en el juego bsico de tipos de datos con algunas pequeas
modificaciones.
En Java se distingue entre tipos de datos primitivos y clases, aunque existen unas clases
especiales ($-=*?#*&<*" o N&',,$&") que permiten modificar los tipos de datos
primitivos.
Los tipos de datos primitivos (o simples) pueden ser numricos, booleanos o caracteres.
B/9%&8D?C%<FHZ:;=?C%
Hay cuatro tipos numricos: (H#$ de 1 byte, "I*&# de 2 bytes, <-# de 4 bytes, y los ?*-0
de 8 bytes. El tipo ms habitual de los cuatro es el tipo <-#. El (H#$ viene a sustituir el
tipo +I'& de C++, ya que Java introduce una interpretacin diferente al tipo de datos
+I'&A%
Las principales diferencias con C++ son:
!"No existe un tipo sin signo (/-"<0-$.;%para los nmeros en Java.
!"Los tipos numricos reales son el 5?*'#%2V bytes) y el .*/(?$%(16 bytes).
!"Los nmeros que utilizan coma flotante (por ejemplo 18.96) son considerados
.*/(?$ por defecto, y habr que realiza un moldeado (+'"#<-0) explcito para que
sean 5?*'#.
=/9%*8:8=DA:AC%
Los datos carcter en Java se basan en los de C++ que a su vez son heredados de C. Los
caracteres son Y-<+*.$ de 2 bytes. Los caracteres Y-<+*.$ son valores de 2 bytes sin
signo, con lo que se define obtiene un rango de 65535 caracteres diferentes, que son
suficientes para las los diferentes lenguajes y sistemas de representacin del planeta.
El carcter de datos del lenguaje Java proviene del tradicional C. Hay que sealar que
los caracteres en C++ eran de slo 1 byte, con lo que en Java podremos representar
muchos ms caracteres que en C++.
Pgina 31 de 189
@/9%&8D?C%B??GA8<?C%
En Java se definen para las variables con valores Verdadero/Falso o S/No, en
definitiva, valores bi-estado. Una variable booleana puede tener los valores #&/$%
2verdadero) o 5'?"$%2falso). Son parecidos a los de C++, aunque en cualquier caso, y a
diferencia de C++ estas variables no pueden ser convertidas a datos numricos, y es un
tipo de datos bsico.
<*(?8"#9>?#"$(#":9<%?'9:"$(L(9#%@7H@%<?$*(
Se permite en Java los mismos operadores que C++, con la variacin de ccc
(desplazamiento sin signo) y la utilizacin del operador K para la concatenacin de
cadenas de caracteres.
>*(!"<@?#"$(
Los vectores en Java, a diferencia de C++, son una clase de objetos. Un vector es un
objeto real con una representacin en tiempo real. Se pueden declarar y almacenar
vectores de cualquier tipo, y almacenar tambin vectores de vectores para obtener
matrices (vectores con varias dimensiones). En este ltimo aspecto no existe diferencia
con C++.
"*(<9>"'9$(
Las cadenas en Java son objetos del lenguaje, no existen seudo-arrays de caracteres
(cadenas) como era el caso de C++. Existen dos tipos de cadenas de objetos:
Las que se obtienen de la clase M#&<-0, para cadenas de slo lectura.
Las que se obtienen de la clase M#&<-0Q/55$& para cadenas que se pueden modificar.
Al igual que C++, el compilador de Java entiende que una cadena de caracteres rodeada
de dobles comillas es una cadena, y es iniciada como un objeto de tipo M#&<-0 (en C++
sera como vector de caracteres con el carcter fin de cadena \0 al final de la misma).
D*(?@#9$(<9#9<@"#=$@%<9$(
8/9%(<D:?@F==;E<%
En este apartado se va a comparar Java con los lenguajes C++ y Smalltalk (primer
lenguaje que presentaba un modelo de objeto).
'POPQNÔcMNRQP, 8P]P, !`PXXNPXY, 'aa,,
Sencillez S S No
Robustez S S No
Seguridad S Algo No
Interpretado S S No
Dinamicidad S S No
Portabilidad S Algo No
Pgina 32 de 189
Neutralidad S Algo No
Threads S No No
Garbage Colection S S No
Excepciones S S Algunas
Representacin Alta Media Alta
8'(?'%T\%J*6,'&'+<>-%$-#&$%@'='D%M6'??8'?P%H%JKK%
B/9%7A<=;GGAN%
Java tiene una sencillez que no posee C++ aunque s Smalltalk. Esto es debido a que
una de las razones de la creacin de Java es la de obtener un lenguaje parecido a C++
pero reduciendo los errores ms comunes de la programacin, algo que se logra con
mucho xito puesto que Java reduce un 50% los errores que se comenten en C++ entre
los que destacan:
!"Eliminacin de la aritmtica de punteros y de las &$5$&$-+<'".
!"Desaparecen los registros ("#&/+#), heredados del paradigma estructurado.
!"No se permite ni la definicin de tipos (#H,$.$5) ni la de macros (b.$5<-$).
!"Ya no es necesario liberar memoria (5&$$%*%.$?$#$).
De todas formas, lo que Java hace, en realidad, es la eliminacin de palabras reservadas,
y la utilizacin de un intrprete bastante pequeo.
=/9%2?BFCDAN%
Java realiza verificaciones en busca de problemas tanto en tiempo de compilacin como
en tiempo de ejecucin, lo que hace que se detecten errores lo antes posible,
normalmente en el ciclo de desarrollo. Algunas de estas verificaciones que hacen que
Java sea un lenguaje robusto son:
!"Verificacin del +>.<0*%.$%(H#$.
!"Gestin de excepciones y errores.
!"Comprobacin de punteros y de lmites de vectores.
Se aprecia una clara diferencia con C++ quin no realiza ninguna de estas
verificaciones.
@/9%7AVF:;@8@%
En Java no se permite los accesos ilegales a memoria, algo que s se permita en C++.
Esto es algo muy importante puesto que este tipo de problema puede ocasionar la
propagacin de virus y otras clases de programas dainos por la red.
El cdigo Java pasa muchos tests antes de ejecutarse en una mquina. El cdigo se pasa
a travs de un verificador de +>.<0*% .$% (H#$ que comprueba el formato de los
fragmentos de cdigo y aplica un probador de teoremas para detectar fragmentos de
cdigo ilegal, cdigo que falsea punteros, viola derechos de acceso sobre objetos o
intenta cambiar el tipo o clase de un objeto.
Algunos de los conocimientos que podemos obtener de los cdigos de byte si pasan la
verificacin sin generar ningn mensaje de error son:
Pgina 33 de 189
!"El cdigo no produce desbordamiento de operandos en la pila.

!"El tipo de los parmetros de todos los cdigos de operacin es conocido y correcto.
!"No ha ocurrido ninguna conversin ilegal de datos, tal como convertir enteros en
punteros.
!"El acceso a los campos de un objeto se sabe si es legal mediante las palabras
reservadas ,/(?<+, ,&<='#$ y ,&*#$+#$..
!"No hay ningn intento de violar las reglas de acceso y seguridad establecidas.
Por todo esto, y por no permitirlo mediante Java la utilizacin de mtodos de un
programa sin los privilegios del ncleo (P$&-$?) del sistema operativo, la obligacin de
autentificacin por clave pblica para la realizacin de modificaciones, se considera
Java un lenguaje seguro. Todo esto no lo incorporan ni C++ ni Smalltalk, por lo que
Java es el nico de los tres considerable como seguro.
A/9%,A<VF8KA%;<DA:>:AD8@?%
Java es un lenguaje que puede ejecutar el cdigo directamente, es decir es un lenguaje
interpretado. Esto es una caracterstica que s que posee Smalltalk, aunque no C++. No
obstante, y aunque en teora se consumen menos recursos siendo los lenguajes
interpretados, el actual compilador que existe es bastante lento, unas 20 veces menos
rpido que C++. Esto normalmente no es vital para la aplicacin ni demasiado
apreciable por el usuario, y adems esta diferencia se est reduciendo con los nuevos
compiladores JIT (@/"#%O-%8<6$;A%
L/9%&;<8H;=;@8@%
Para la obtencin de un mayor provecho de la tecnologa orientada a objetos, Java no
intenta conectar todos los mdulos que comprenden una aplicacin hasta el tiempo de
ejecucin. Esta caracterstica ya es contemplada por Smalltalk, aunque no C++, que
enlaza todos los mdulos cuando se compila.
V/9%4?:D8B;G;@8@%
Un programa Java puede ser ejecutado en diferentes entornos, algo imposible para C++.
[/9%)AFD:8G;@8@%
Se dice que Java tiene una arquitectura neutra puesto que compila su cdigo a un
fichero objeto de formato independiente de la arquitectura de la mquina en que se
ejecutar.
Cualquier mquina que tenga el sistema de ejecucin (@d! o @'='%d/-#<6$%!-=<&*6$-#)
puede ejecutar ese cdigo objeto, sin importar en modo alguno la mquina en que ha
sido generado.
Actualmente existen sistemas de ejecucin (@d!) para Solaris 2.x, SunOs 4.1.x,
Windows 95, Windows NT, Linux, Irix, Aix, Mac, Apple y probablemente haya grupos
de desarrollo trabajando el portado a otras plataformas.
No es as para C++ y para Smalltalk, donde el cdigo generado podr ejecutarse
nicamente en la plataforma en la que se gener.
Pgina 34 de 189
;/9%1[:A8@C%
Java permite mltiples hilos (6/?#<#I&$'.<-0) antes de su ejecucin y en tiempo de
ejecucin. La posibilidad de construir pequeos procesos o piezas independientes de un
gran proceso permite programar de una forma ms sencilla y es una herramienta muy
potente que no se ofrece en C++.
K/9%2A=?GA==;E<%8FD?HRD;=8%@A%B8CF:8%Y%!8:B8VA%=?GA=D;?<%9%
Java modifica completamente la gestin de la memoria que se hace en C/C++. En
C/C++ se utilizan punteros, reservas de memoria (con las ordenes 6'??*+, -$N, 5&$$,
.$?$#$...) y otra serie de elementos que dan lugar a graves errores en tiempo de ejecucin
difcilmente depurables.
Java tiene operadores nuevos para reservar memoria para los objetos, pero no existe
ninguna funcin explcita para liberarla.
La recoleccin de basura (objetos ya inservibles) es una parte integral de Java durante la
ejecucin de sus programas. Una vez que se ha almacenado un objeto en el tiempo de
ejecucin, el sistema hace un seguimiento del estado del objeto, y en el momento en que
se detecta que no se va a volver a utilizar ese objeto, el sistema vaca ese espacio de
memoria para un uso futuro.
Esta gestin de la memoria dinmica hace que la programacin en Java sea ms fcil.
\/9%2A>:ACA<D8=;E<%
Uno de los objetivos perseguidos en el desarrollo de Java era la obtencin de programas
con interfaces cmodas e intuitivas. Esto tambin se permite en C++, aunque con unos
mtodos ms costosos, y en ningn caso con interfaces portables como los que Java
crea.
Tanto en Java como en C++ se logran unas interfaces con una representacin mejor que
la que se puede alcanzar con Smalltalk.
Pgina 35 de 189
@"79(%%E(D6'>97"'@?$(>":(:"'B69C"(
Pgina 36 de 189
((/0/%S")&$5')137%
9*(%'@#?>6<<%&'(
Java es un lenguaje orientado a objetos, que se deriva en alto grado de C++, de tal forma
que puede ser considerado como un C++ nuevo y modernizado o bien como un C++ al
que se le han amputado elementos heredados del lenguaje estructurado C.
;*(@?N"'$(
Un #*P$- es el elemento ms pequeo de un programa que es significativo para el
compilador. Estos #*P$-" definen la estructura de Java.
Cuando se compila un programa Java, el compilador analiza el texto, reconoce y
elimina los espacios en blanco y comentarios y extrae #*P$-" individuales. Los #*P$-"
resultantes se compilan, traducindolos a cdigo de byte Java, que es independiente del
sistema e interpretable dentro de un entorno Java.
Los cdigos de byte se ajustan al sistema de mquina virtual Java, que abstrae las
diferencias entre procesadores a un procesador virtual nico.
Los #*P$-" Java pueden subdividirse en cinco categoras: Identificadores, palabras
clave, constantes, operadores y separadores.
8/9%(@A<D;L;=8@?:AC%
Los identificadores son #*P$-" que representan nombres asignables a variables, mtodos
y clases para identificarlos de forma nica ante el compilador y darles nombres con
sentido para el programador.
Todos los identificadores de Java diferencian entre maysculas y minsculas (Java es
J'"$% M$-"<#<=$ o M$-"<(?$% '% 6'He"+/?'") y deben comenzar con una letra, un
subrayado(_) o smbolo de dlar($). Los caracteres posteriores del identificador pueden
incluir las cifras del 0 al 9. Como nombres de identificadores no se pueden usar palabras
claves de Java.
Adems de las restricciones mencionadas existen propuestas de estilo. Es una prctica
estndar de Java denominar:
!"Las clases: J?'"$ o 9<J?'"$.
!"Las interfaces: O-#$&5'C o 9<O-#$&5'C.
!"Los mtodos: 6$#*.*2; o 6$#*.*:'&0*2;A%
!"Las variables: '?#/&' o '?#/&'9$.<'.
!"Las constantes: JF]M8G8! o JF]M8G]8!f:GdXG.
!"Los paquetes: )'='A,'3/$#$A"/(,'3/$#$.
Sin entrar en ms detalle en la siguiente lnea de cdigo se puede apreciar la declaracin
de una variable entera (<-#) con su correspondiente identificador:
int alturaMedia;
Pgina 37 de 189
B/9%48G8B:8C%=G8TA%
Las palabras claves son aquellos identificadores reservados por Java para un objetivo
determinado y se usan slo de la forma limitada y especfica. Java tiene un conjunto de
palabras clave ms rico que C o que C++, por lo que s est aprendiendo Java con
conocimientos de C o C++, asegrese de que presta atencin a las palabras clave de
Java.
Las siguientes palabras son palabras reservadas de Java:
'("#'+#% (**?$'-% (&$'P% (H#$% (H='?/$%
+'"$% +'"#% +'#+I% +I'&% +?'""%
+*-"#% +*-#<-/$% .$5'/?#% .*% .*/(?$%
$?"$% $g#$-."% 5'?"$% 5<-'?% 5<-'??H%
5?*'#% 5*&% 5/#/&$% 0$-$&<+% 0*#*%
<5% <6,?$6$-#"% <6,*&#% <--$&% <-"#'-+$*5%
<-#% <-#$&5'+$% ?*-0% -'#<=$% -$N%
-/??% *,$&'#*&% */#$&% ,'+P'0$% ,&<='#$%
,&*#$+#$.% ,/(?<+% &$"#% &$#/&-% "I*&#%
"#'#<+% "/,$&% "N<#+I% "H-+&*-<+$.% #I<"%
#I&*N% #I&*N"% #&'-"<$-#% #&/$% #&H%
='&% =*<.% =*?'#<?$% NI<?$% %
8'(?'%_\%E'?'(&'"%&$"$&='.'"%@'='%
Las palabras subrayadas son palabras reservadas pero no se utilizan. La definicin de
estas palabras clave no se ha revelado, ni se tiene un calendario respecto a cundo estar
alguna de ellas en la especificacin o en alguna de las implementaciones de Java.,
=/9%,;DA:8GAC%U%=?<CD8<DAC%
Los literales son sintaxis para asignar valores a las variables. Cada variables es de un
tipo de datos concreto, y dichos tipos de datos tienen sus propios literales.
Mediante determinados modificadores ("#'#<+ y 5<-'?) podremos crear variables
+*-"#'-#$", que no modifican su valor durante la ejecucin de un programa. Las
constantes pueden ser numricas, booleanas, caracteres (Unicode) o cadenas (M#&<-0).
Las cadenas, que contienen mltiples caracteres, an se consideran constantes, aunque
estn implementadas en Java como objetos.
Veamos un ejemplo de constante declarada por el usuario:
final static int ALTURA_MAXIMA = 200;
Se puede observar que utilizamos 5<-'?% "#'#<+, para que la variable sea total y
absolutamente invariable.
@/9%3>A:8@?:AC%
Conocidos tambin como operandos, indican una evaluacin o computacin para ser
realizada en objetos o datos, y en definitiva sobre identificadores o constantes. Los
operadores admitidos por Java son:
K% h% ij% KK% kj%
cccj% ^% l% cj% ^%
mj% A% n% mm% ii%
jj% iij% o% a% pp%
cc% Kj% hj% q% k%
Pgina 38 de 189
r% ccc% j% rj% 2%
m% i% nj% ;% p%
c% srr% aj% cc% %
8'(?'%`\%F,$&'.*&$"%@'='%
As por ejemplo el siguiente fragmento de cdigo incrementa el valor de una variable en
dos unidades, mediante la utilizacin del operador aritmtico K que se utiliza para la
suma:
int miNumero=0;
miNumero = miNumero + 2;
En el apartado ZOOA`%F,$&'.*&$"Z de este tutorial aprenderemos que en Java hay formas
ms sencillas de hacer esto mismo, y estudiaremos el significado de cada uno de estos
operadores.
A/%7A>8:8@?:AC%
Se usan para informar al compilador de Java de cmo estn agrupadas las cosas en el
cdigo.
Los separadores admitidos por Java son: t%%%u%%%D%%%\%%%v%
L/%*?HA<D8:;?C%U%AC>8=;?C%A<%BG8<=?%
El compilador de Java reconoce y elimina los espacios en blanco, tabuladores, retornos
de carro y comentarios durante el anlisis del cdigo fuente.
Los comentarios se pueden presentar en tres formatos distintos:
?UO`PNU, "MU,
/*comentario*/ Se ignoran todos los caracteres entre /* */. Proviene del C
//comentario Se ignoran todos los caracteres detrs de // hasta el fin de lnea. Proviene del C++
/**comentario*/ Lo mismo que /* */ pero se podrn utilizar para documentacin automtica.
8'(?'%w\%x*&6'#*"%.$%+*6$-#'&<*"%@'='%
Por ejemplo la siguiente lnea de cdigo presenta un comentario:
int alturaMinima = 150; // No menos de 150 centmetros
<*("O8#"$%?'"$(
Los operadores, variables y las llamadas a mtodos pueden ser combinadas en
secuencias conocidas como expresiones. El comportamiento real de un programa Java
se logra a travs de expresiones, que se agrupan para crear "$-#$-+<'".
Una expresin es una serie de variables, operadores y llamadas a mtodos (construida
conforme a la sintaxis del lenguaje) que se evala a un nico valor.
Entre otras cosas, las expresiones son utilizadas para realizar clculos, para asignar
valores a variables, y para ayudar a controlar la ejecucin del flujo del programa. La
tarea de una expresin se compone de dos partes: realiza el clculo indicado por los
elementos de la expresin y devuelve el valor obtenido como resultado del clculo.
Los operadores devuelven un valor, por lo que el uso de un operador es una expresin.
Por ejemplo, la siguiente sentencia es una expresin:
int contador=1;
Pgina 39 de 189
contador++;
La expresin +*-#'.*&KK%en este caso particular se evala al valor T, que era el valor de
la variable +*-#'.*& antes de que la operacin ocurra, pero la variable +*-#'.*&
adquiere un valor de _.
El tipo de datos del valor devuelto por una expresin depende de los elementos
utilizados en la expresin. La expresin +*-#'.*&KK devuelve un entero porque KK
devuelve un valor del mismo tipo que su operando y +*-#'.*& es un entero. Otras
expresiones devuelven valores booleanos, cadenas...
Una expresin de llamada a un mtodo se evala al valor de retorno del mtodo; as el
tipo de dato de la expresin de llamada a un mtodo es el mismo que el tipo de dato del
valor de retorno de ese mtodo.
Otra sentencia interesante sera:
in.read( ) != -1 // in es un flujo de entrada
Esta sentencia se compone de dos expresiones:
1. La primera expresin es una llamada al mtodo <-A&$'.2;A El mtodo <-A&$'.2; ha
sido declarado para devolver un entero, por lo que la expresin <-A&$'.2; se evala a
un entero.
2. La segunda expresin contenida en la sentencia utiliza el operador rj, que
comprueba si dos operandos son distintos. En la sentencia en cuestin, los
operandos son <-A&$'.2; y -1. El operando <-A&$'.2; es vlido para el operador rj
porque i-A&$'.2; es una expresin que se evala a un entero, as que la expresin
<-A&$'.2;rj^T compara dos enteros. El valor devuelto por esta expresin ser
verdadero o falso dependiendo del resultado de la lectura del fichero <-.
Como se puede observar, Java permite construir sentencias (expresiones compuestas) a
partir de varias expresiones ms pequeas con tal que los tipos de datos requeridos por
una parte de la expresin concuerden con los tipos de datos de la otra.
>*(;:?G6"$(L(A7;%@?(
En Java el cdigo fuente est dividido en partes separadas por llaves, denominas
(?*3/$". Cada bloque existe independiente de lo que est fuera de l, agrupando en su
interior sentencias (expresiones) relacionadas.
Desde un bloque externo parece que todo lo que est dentro de llaves se ejecuta como
una sentencia. Pero, qu es un bloque externo?. Esto tiene explicacin si entendemos
que existe una )$&'&3/1'% .$% (?*3/$", y que un bloque puede contener uno o ms
subbloques anidados.
El concepto de mbito est estrechamente relacionado con el concepto de bloque y es
muy importante cuando se trabaja con variables en Java. El mbito se refiere a cmo las
secciones de un programa (bloques) afectan el tiempo de vida de las variables.
Toda variable tiene un mbito, en el que es usada, que viene determinado por los
bloques. Una variable definida en un bloque interno no es visible por el bloque externo.
Las llaves de separacin son importantes no slo en un sentido lgico, ya que son la
forma de que el compilador diferencie dnde acaba una seccin de cdigo y dnde
comienza otra, sino que tienen una connotacin esttica que facilita la lectura de los
programas al ser humano.
Pgina 40 de 189
As mismo, para identificar los diferentes bloques se utilizan sangras. Las sangras se
utilizan para el programador, no para el compilador. La sangra (tambin denominada
<-.$-#'+<>-) ms adecuada para la esttica de un programa Java son dos espacios:
{
// Bloque externo
int x = 1;
{
// Bloque interno invisible al exterior
int y = 2;
}
x = y; // Da error: Y fuera de ambito
}
Pgina 41 de 189
((/O/%1(437%&'%&$137%
9*(@%8?$(>"(>9@?$($%78:"$(
Es uno de los conceptos fundamentales de cualquier lenguaje de programacin. Estos
definen los mtodos de almacenamiento disponibles para representar informacin, junto
con la manera en que dicha informacin ha de ser interpretada.
Para crear una variable (de un tipo simple) en memoria debe declararse indicando su
tipo de variable y su identificador que la identificar de forma nica. La sintaxis de
declaracin de variables es la siguiente:
TipoSimple Identificador1, Identificador2;
Esta sentencia indica al compilador que reserve memoria para dos variables del tipo
simple 8<,*M<6,?$ con nombres O.$-#<5<+'.*&T e O.$-#<5<+'.*&_A%
Los tipos de datos en Java pueden dividirse en dos categoras: simples y compuestos.
Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de
coma flotante, booleanos y de carcter. Los tipos compuestos se basan en los tipos
simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en
general.
Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados,
para darles valor. En este apartado se explican los tipos de datos simples (o primitivos)
que presenta Java, as como los literales que soporta (sintaxis de los valores que se les
puede asignar).
8/9%1;>?C%@A%@8D?C%A<DA:?C%
Se usan para representar nmeros enteros con signo. Hay cuatro tipos:%(H#$D%"I*&#D%<-#%H%
?*-0A
4R_U, 4P`PmU,
(H#$% 1Byte (8 bits)
"I*&#%% 2 Bytes (16 bits)
<-#% 4 Bytes (32 bits)
?*-0% 8 Bytes (64 bits)
8'(?'%y\%8<,*"%.$%.'#*"%$-#$&*"%
Literales enteros
Son bsicos en la programacin en Java y presentan tres formatos:
Decimal: Los literales decimales aparecen como nmeros ordinarios sin ninguna
notacin especial.
Hexadecimal: Los hexadecimales (base 16) aparecen con un zg z{ inicial,
notacin similar a la utilizada en C y C++.
Octal: Los octales aparecen con un 0 inicial delante de los dgitos.
Por ejemplo, un literal entero para el nmero decimal 12 se representa en Java como 12
en decimal, como 0xC en hexadecimal, y como 014 en octal.
Pgina 42 de 189
Los literales enteros se almacenan por defecto en el tipo <-#, (4 bytes con signo), o si se
trabaja con nmeros muy grandes, con el tipo ?*-0, (8 bytes con signo), aadiendo una
L l al final del nmero.
La declaracin de variables enteras es muy sencilla. Un ejemplo de ello sera:
long numeroLargo = 0xC; // Por defecto vale 12
B/9%1;>?C%@A%@8D?C%A<%=?H8%LG?D8<DA%
Se usan para representar nmeros con partes fraccionarias. Hay dos tipos de coma
flotante: 5?*'# y .*/(?$. El primero reserva almacenamiento para un nmero de
precisin simple de 4 bytes y el segundo lo hace para un numero de precisin doble de 8
bytes.
4R_U, 4P`PmU,
5?*'#% 4 Byte (32 bits)
.*/(?$% 8 Bytes (64 bits)
8'(?'%|\%8<,*"%.$%.'#*"%-/6B&<+*"%%$-%+*6'%%5?*#'-#$%
Literales en coma flotante
Representan nmeros decimales con partes fraccionarias. Pueden representarse con
notacin estndar (563,84) o cientfica (5.6384e2).
De forma predeterminada son del tipo .*/(?$ (8 bytes). Existe la opcin de usar un tipo
ms corto (el tipo 5?*'# de 4 bytes), especificndolo con una F f al final del nmero.
La declaracin de variables de coma flotante es muy similar a la de las variables enteras.
Por ejemplo:
double miPi = 314.16e-2 ; // Aproximadamente
float temperatura = (float)36.6; // Paciente sin fiebre
Se realiza un moldeado a #$6,$&'#/&', porque todos los literales con decimales por
defecto se consideran .*/(?$.
=/9%1;>?%@A%@8D?C%B??GA8<%
Se usa para almacenar variables que presenten dos estados, que sern representados por
los valores #&/$ y 5'?"$. Representan valores bi-estado, provenientes del denominado
4?0$(&'%.$%(**?.
Literales Booleanos
Java utiliza dos palabras clave para los estados:% #&/$ (para verdadero) y 5'?"$ (para
falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de
falso se representaba por un 0 numrico, y verdadero cualquier nmero que no fuese el
0.
Para declarar un dato del tipo booleano se utiliza la palabra reservada (**?$'-\
boolean reciboPagado = false; // Aun no nos han pagado?!
@/9%1;>?%@A%@8D?C%=8:R=DA:%
Se usa para almacenar caracteres Y-<+*.$ simples. Debido a que el conjunto de
caracteres Y-<+*.$ se compone de valores de 16 bits, el tipo de datos +I'& se almacena
en un entero sin signo de 16 bits.
Pgina 43 de 189
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.

Literales carcter
Representan un nico carcter (de la tabla de caracteres Unicode 1.1) y aparecen dentro
de un par de comillas simples. De forma similar que en C/C++. Los caracteres
especiales (de control y no imprimibles) se representan con una barra invertida ('\')
seguida del cdigo carcter.
+^MQOR_QRnS, .^_O^M^SNPQRnS, $PXUO,"SRQUT^,
Caracter Unicode }/....% %
Numero octal }...% %
Barra invertida }}% }/zzyJ%
Continuacin }% }%
Retroceso }(% }/zzzV%
Retorno de carro }&% }/zzzR%
Alimentacin de formularios }5% }/zzzJ%
Tabulacin horizontal }#% }/zzzU%
Lnea nueva }-% }/zzzG%
Comillas simples }~% }/zz_%
Comillas dobles }% }/zz__%
Nmeros arbigos ASCII zÛ% }/zz`z%'%}/zzÙ%
Alfabeto ASCII en maysculas GA^% }/zzwT%'%}/zzyG%
Alfabeto ASCII en minsculas 'A^C% }/zz|T%'%}/zzG%
8'(?'%\%J'&'+#$&$"%$",$+<'?$"%@'='%
Las variables de tipo +I'& se declaran de la siguiente forma:
char letraMayuscula = A; // Observe la necesidad de las
char letraV = \u0056; // Letra V
A/9%*?<TA:C;?<%@A%D;>?C%@A%@8D?C%
En Java es posible transformar el tipo de una variable u objeto en otro diferente al
original con el que fue declarado. Este proceso se denomina "conversin", "moldeado"
o "tipado".%La conversin se lleva a cabo colocando el tipo destino entre parntesis, a la
izquierda del valor que queremos convertir de la forma siguiente:
char c = (char)System.in.read();
La funcin &$'. devuelve un valor <-#, que se convierte en un +I'& debido a la
conversin 2+I'&;, y el valor resultante se almacena en la variable de tipo carcter +.
El tamao de los tipos que queremos convertir es muy importante. No todos los tipos se
convertirn de forma segura. Por ejemplo, al convertir un ?*-0%en un <-#, el compilador
corta los 32 bits superiores del ?*-0%(de 64 bits), de forma que encajen en los 32 bits del
<-#, con lo que si contienen informacin til, esta se perder.
Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe
ser igual o mayor que el tipo fuente":
Pgina 44 de 189
4R_U,)ORW^S, 4R_U,+^MNRSU,
(H#$% .*/(?$D%5?*'#D%?*-0D%<-#D%+I'&D%"I*&#%
"I*&#% .*/(?$D%5?*'#D%?*-0D%<-#%
+I'&% .*/(?$D%5?*'#D%?*-0D%<-#%
<-#% .*/(?$D%5?*'#D%?*-0%
?*-0% .*/(?$D%5?*'#%
5?*'#% .*/(?$%
8'(?'%V\%J*-=$&"<*-$"%"<-%,B&.<.'"%.$%<-5*&6'+<>-%
;*(!"<@?#"$(L(79@#%<"$(
Una matriz es una construccin que proporciona almacenaje a una lista de elementos del
mismo tipo, ya sea simple o compuesto. Si la matriz tiene solo una dimensin, se la
denomina =$+#*&.
En Java los vectores se declaran utilizando corchetes ( o%H%q%;, tras la declaracin del tipo
de datos que contendr el vector. Por ejemplo, esta sera la declaracin de un vector de
nmeros enteros (<-#):
int vectorNumeros[ ]; // Vector de nmeros
Se observa la ausencia de un nmero que indique cuntos elementos componen el
vector, debido a que Java no deja indicar el tamao de un vector vaco cuando le
declara. La asignacin de memoria al vector se realiza de forma explcita en algn
momento del programa.
Para ello o se utiliza el operador -$N:
int vectorNumeros = new int[ 5 ]; // Vector de 5 nmeros
O se asigna una lista de elementos al vector:
int vectorIni = { 2, 5, 8}; // == int vectorIni[3]=new int[3];
Se puede observar que los corchetes son opcionales en este tipo de declaracin de
vector, tanto despus del tipo de variable como despus del identificador.
Si se utiliza la forma de -$N se establecer el valor z a cada uno de los elementos del
vector.
<*(<9>"'9$(
En Java se tratan como una clase especial llamada M#&<-0. Las cadenas se gestionan
internamente por medio de una instancia de la clase M#&<-0. Una instancia de la clase
M#&<-0 es un objeto que ha sido creado siguiendo la descripcin de la clase.
Cadenas constantes
Representan mltiples caracteres y aparecen dentro de un par de comillas dobles. Se
implementan en Java con la clase M#&<-0. Esta representacin es muy diferente de la de
C/C++ de cadenas como una matriz de caracteres.
Cuando Java encuentra una constante de cadena, crea un caso de la clase M#&<-0 y define
su estado, con los caracteres que aparecen dentro de las comillas dobles.
Vemos un ejemplo de cadena declarada con la clase M#&<-0 de Java:
String capitalUSA = Washington D.C.;
Pgina 45 de 189
String nombreBonito = Amelia;

Ms tarde profundizaremos con detenimiento en las cadenas Java.
Pgina 46 de 189
((/Q/%34'2$&32'7%
9*(%'@#?>6<<%&'(
Los operadores son un tipo de #*P$-" que indican una evaluacin o computacin para
ser realizada en objetos o datos, y en definitiva sobre identificadores o constantes.
Adems de realizar la operacin, un operador devuelve un valor, ya que son parte
fundamental de las expresiones.
El valor y tipo que devuelve depende del operador y del tipo de sus operandos. Por
ejemplo, los operadores aritmticos devuelven un nmero como resultado de su
operacin.
Los operadores realizan alguna funcin sobre uno, dos o tres operandos.
Los operadores que requieren un operando son llamados *,$&'.*&$"% /-'&<*"A% Por
ejemplo, el operador "KK" es un operador unario que incrementa el valor de su
operando en una unidad.
Los operadores unarios en Java pueden utilizar tanto la notacin prefija como la posfija.
La notacin prefija indica que el operador aparece antes que su operando.
++contador // Notacin prefija, se evala a: contador+1
La notacin posfija indica que el operador aparece despus de su operando:
contador++ // Notacin posfija, se evala a: contador
Los operadores que requieren dos operandos se llaman *,$&'.*&$"% (<-'&<*". Por
ejemplo el operador "j" es un operador binario que asigna el valor del operando del
lado derecho al operando del lado izquierdo.
Todas los operadores binarios en Java utilizan notacin infija, lo cual indica que el
operador aparece entre sus operandos.
operando1 operador operando2
Por ltimo, los operadores ternarios son aquellos que requieren tres operandos. El
lenguaje Java tiene el operador ternario, "s":, que es una sentencia similar a la if-else.
Este operador ternario usa notacin infija; y cada parte del operador aparece entre
operandos:
expresin ? operacin1 : operacin2
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.
Pgina 47 de 189
;*(?8"#9>?#"$(9#%@7H@%<?$(
El lenguaje Java soporta varios operadores aritmticos para los nmeros enteros y en
coma flotante. Se incluye K (suma), ^ (resta), n (multiplicacin), a (divisin), y k
(mdulo, es decir, resto de una divisin entera). Por ejemplo:
sumaEste + aEste; //Suma los dos enteros
divideEste % entreEste; //Calcula el resto de dividir 2 enteros
)_ÔPTUO, "MU, +^MQOR_QRnS,
K% *,T%K%*,_% Suma op1 y op2
^% *,T%^%*,_% Resta op2 de op1
n% *,T%n%*,_% Multiplica op1 por op2
a% *,T%a%*,_% Divide op1 por op2
k% *,T%k%*,_% Calcula el resto de dividir op1 entre op2
8'(?'%U\%F,$&'.*&$"%'&<#6B#<+*"%(<-'&<*"%.$%@'='%
El tipo de los datos devueltos por una operacin aritmtica depende del tipo de sus
operandos; si se suman dos enteros, se obtiene un entero como tipo devuelto con el
valor de la suma de los dos enteros.
Estos operadores se deben utilizar con operandos del mismo tipo, o si no realizar una
conversin de tipos de uno de los dos operandos al tipo del otro.
El lenguaje Java sobrecarga la definicin del operador K para incluir la concatenacin
de cadenas. El siguiente ejemplo utiliza K para concatenar la cadena "J*-#'.*"%Z, con el
valor de la variable +*-#'.*& y la cadena " +'&'+#$&$"AZ:
System.out.print("Contados" + contador + "caracteres.");
Esta operacin automticamente convierte el valor de +*-#'.*& a una cadena de
caracteres.
Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones:
+ +op Convierte op a entero si es un byte, short o char
- -op Niega aritmticamente op
8'(?'%Tz\%[$&"<*-$"%/-'&<'"%.$%?*"%*,$&'.*&$"%ZKZ%H%Z^Z%
El operador - realiza una negacin del nmero en complemento A2, es decir, cambiando
de valor todos sus bits y sumando 1 al resultado final:
42 -> 00101010
-42 -> 11010110
Existen dos operadores aritmticos que funcionan como atajo de la combinacin de
otros: ++ que incrementa su operando en 1, y -- que decrementa su operando en 1.
Ambos operadores tienen una versin prefija, y otra posfija. La utilizacin la correcta es
crtica en situaciones donde el valor de la sentencia es utilizado en mitad de un clculo
ms complejo, por ejemplo para control de flujos:
KK% *,KK% Incrementa op en 1; se evala al valor anterior al incremento
KK% KK*,% Incrementa op en 1; se evala al valor posterior al incremento
^^% *,^^% Decrementa op en 1; se evala al valor anterior al incremento
^^% ^^*,% Decrementa op en 1; se evala al valor posterior al incremento
8'(?'%TT\%F,$&'+<*-$"%+*-%ZKKZ%H%Z^^Z%
Pgina 48 de 189
<*(?8"#9>?#"$(>"(<?789#9<%&'(L(<?'>%<%?'9:"$(
Un operador de comparacin compara dos valores y determina la relacin existente
entre ambos. Por ejemplo, el operador rj devuelve verdadero (#&/$) si los dos
operandos son distintos. La siguiente tabla resume los operadores de comparacin de
Java:
)_ÔPTUO, "MU, +^]k^X]^,]ÔTPTÔU,MR,
> 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
8'(?'%T_\%F,$&'.*&$"%.$%+*6,'&'+<>-%
Los operadores de comparacin suelen ser usados con los operadores condicionales para
construir expresiones complejas que sirvan para la toma de decisiones. Un operador de
este tipo es mm, el cual realiza la operacin booleana '-.. Por ejemplo, se pueden
utilizar dos operaciones diferentes de comparacin con mm para determinar si ambas
relaciones son ciertas. La siguiente lnea de cdigo utiliza esta tcnica para determinar si
la variable <-.$g de una matriz se encuentra entre dos lmites (mayor que cero y menor
que la constante ]Y9!dFf!]8dGRGM;:
( 0 < index ) && ( index < NUMERO_ENTRADAS )
Se debe tener en cuenta que en algunos casos, el segundo operando de un operador
condicional puede no ser evaluado. En caso de que el primer operando del operador mm%
valga falso, Java no evaluar el operando de la derecha:
(contador < NUMERO_ENTRADAS) && ( in.read() != -1 )
Si +*-#'.*& es menor que ]Y9!dFf!]8dGRGM, el valor de retorno de mm puede ser
determinado sin evaluar el operando de la parte derecha. En este caso <-A&$'. no ser
llamado y un carcter de la entrada estndar no ser ledo.
Si el programador quiere que se evale la parte derecha, deber utilizar el operador m en
lugar de mm.
De la misma manera se relacionan los operadores || y p para la exclusin lgica (OR).
Java soporta cinco operadores condicionales , mostrados en la siguiente tabla:
)_ÔPTUO, "MU, +^]k^X]^,]ÔTPTÔU,MR222,
mm% *,T%mm%*,_% op1 y op2 son ambos verdaderos, condicionalmente evala op2
m% *,T%m%*,_% op1 y op2 son ambos verdaderos, siempre evala op1 y op2
pp% *,T%pp%*,_% op1 o op2 son verdaderos, condicionalmente evala op2
p% *,T%p%*,_% op1 o op2 son verdaderos, siempre evala op1 y op2
r% r%*,% op es falso
8'(?'%T`\%F,$&'.*&$"%+*-.<+<*-'?$"%
Adems Java soporta un operador ternario, el s\, que se comporta como una versin
reducida de la sentencia <5^$?"$:
expresion ? operacion1 : operacion2
El operador s: evala la $g,&$"<*- y devuelve *,$&'+<>-T si es cierta, o devuelve
*,$&'+<>-_ si $g,&$"<*-%es falsa.
Pgina 49 de 189
>*(?8"#9>?#"$(>"(;%@(
Un operador de bit permite realizar operaciones de bit sobre los datos. Existen dos tipos:
los que desplazan (mueven) bits, y operadores lgicos de bit.
8/9%3>A:8@?:AC%@A%@AC>G8N8H;A<D?%@A%B;DC%
)_ÔPTUO, "MU, )_ÔPQRnS,
cc% *,T%cc%*,_% Desplaza los bits de op1 a la derecha op2 veces
ii% *,T%ii%*,_% Desplaza los bits de op1 a la izquierda op2 veces
ccc% *,T%ccc%*,_% Desplaza los bits de op1 a la derecha op2 veces (sin signo)
8'(?'%Tw\%F,$&'.*&$"%.$%.$",?'C'6<$-#*%.$%(<#"%
Los tres operadores de desplazamiento simplemente desplazan los bits del operando de
la parte izquierda el nmero de veces indicado por el operando de la parte derecha. El
desplazamiento ocurre en la direccin indicada por el operador. Por ejemplo, la
siguiente sentencia, desplaza los bits del entero 13 a la derecha una posicin:
13 >> 1;
La representacin en binario del nmero 13 es 1101. El resultado de la operacin de
desplazamiento es 1101 desplazado una posicin a la derecha, 110 o 6 en decimal. Se
debe tener en cuenta que el bit ms a la derecha se pierde en este caso.
Un desplazamiento a la derecha una posicin es equivalente a dividir el operando del
lado izquierdo por 2, mientras que un desplazamiento a la izquierda de una posicin
equivale a multiplicar por 2, pero un desplazamiento es ms eficiente,
computacionalmente hablando, que una divisin o multiplicacin.
El desplazamiento sin signo ccc funciona de la siguiente manera:
!"Si se desplaza con signo el nmero -1 (1111), seguir valiendo -1, dado que la
extensin de signo sigue introduciendo unos en los bits ms significativos.
!"Con el desplazamiento sin signo se consigue introducir ceros por la izquierda,
obteniendo el nmero 7 (0111).
Este tipo de desplazamientos es especialmente til en la utilizacin de mscaras
grficas.
B/9%3>A:8@?:AC%@A%GEV;=8%@A%B;DC%
La lgica de bits (lgica de Bool) se utiliza para modelizar condiciones biestado y
trabajar con ellas (cierto/falso, #&/$/5'?"$, 1/0).
En Java hay cuatro operadores de lgica de bits:
m% *,T%m%*,_% AND
p% *,T%p%*,_% OR
h% *,T%h%*,_% OR Exclusivo
l% l*,_% Complemento
8'(?'%Ty\%F,$&'.*&$"%.$%?>0<+'%.$%(<#"%
El operador m realiza la operacin AND de bit. Aplica la 5/-+<>-%G]R sobre cada par
de bits de igual peso de cada operando. La 5/-+<>-%G]R es evaluada a cierto si ambos
operandos son ciertos.
Por ejemplo vamos a aplicar la operacin G]R a los valores 12 y 13:
Pgina 50 de 189
12 & 13
El resultado de esta operacin es 12. Por qu?. La representacin en binario de 12 es
1100, y de 13 es 1101. La 5/-+<>-%G]R pone el bit de resultado a uno si los dos bits de
los operandos son 1, sino, el bit de resultado es 0:
1101
& 1100
------
1100
El operador p realiza la operacin OR de bit. Aplica la 5/-+<>-%Fd sobre cada par de bits
de igual peso de cada operando. La 5/-+<>-% Fd es evaluada a cierto si alguno de los
operandos es cierto.
El operador ^ realiza la operacin OR exclusivo de bit (XOR). Aplica la 5/-+<>-%{Fd
sobre cada par de bits de igual peso de cada operando. La 5/-+<>-%{Fd es evaluada a
cierto si los operandos tienen el mismo valor.
Para finalizar, el operador de complemento invierte el valor de cada bit del operando.
Convierte el falso en cierto, y el cierto en falso:
Entre otras cosas, la manipulacin bit es til para gestionar indicadores booleanos
(banderas). Supongamos, por ejemplo, que se tiene varios indicadores booleanos en
nuestro programa, los cuales muestran el estado de varios componentes del programa:
$"[<"<(?$, $"G&&'"#&'(?$D... En lugar de definir una variable booleana para cada
indicador, se puede definir una nica variable para todos ellos. Cada bit de dicha
variable representar el estado vigente de uno de los indicadores. Se debern utilizar
entonces manipulaciones de bit para establecer y leer cada indicador.
Primero, se deben preparar las constantes de cada indicador. Esos indicadores deben ser
diferentes unos de otros (en sus bits) para asegurar que el bit de activacin no se solape
con otro indicador. Despus se debe definir la variable de banderas, cuyos bits deben de
poder ser configurados segn el estado vigente en cada indicador.
El siguiente ejemplo inicia la variable de banderas 5?'0" a 0, lo que significa que todos
los indicadores estn desactivados (ninguno de los bits es 1):
final int VISIBLE = 1;
final int ARRASTRABLE = 2;
final int SELECCIONABLE = 4;
final int MODIFICABLE = 8;
int flags = 0;
Para activar el indicador [OMOQ:!, se deber usar la sentencia:
flags = flags | VISIBLE;
Para comprobar la visibilidad se deber usar la sentencia:
if ( (flags & VISIBLE) == 1 )
//Lo que haya que hacer
Pgina 51 de 189
"*(?8"#9>?#"$(>"(9$%B'9<%&'(
El operador de asignacin bsico es el j, que se utiliza para asignar un valor a otro. Por
ejemplo:
int contador = 0;
Inicia la variable +*-#'.*& con un valor zA%
Java adems proporciona varios operadores de asignacin que permiten realizar un atajo
en la escritura de cdigo. Permiten realizar operaciones aritmticas, lgicas, de bit y de
asignacin con un nico operador.
Supongamos que necesitamos sumar un nmero a una variable y almacenar el resultado
en la misma variable, como a continuacin:
i = i + 2;
Se puede abreviar esta sentencia con el operador de atajo Kj, de la siguiente manera\
i += 2;
La siguiente tabla muestra los operadores de atajo de asignacin y sus equivalentes
largos:
)_ÔPTUO, "MU, %okR]PX^SN^,P,,
Kj% *,T%Kj%*,_% op1 = op1 + op2
^j% *,T%^j%*,_% op1 = op1 - op2
nj% *,T%nj%*,_% op1 = op1 * op2
aj% *,T%aj%*,_% op1 = op1 / op2
kj% *,T%kj%*,_% op1 = op1 % op2
mj% *,T%mj%*,_% op1 = op1 & op2
8'(?'%T|\%F,$&'.*&$"%.$%'#')*%.$%'"<0-'+<>-%
D*(8#"<">"'<%9(>"(?8"#9>?#"$(
Cuando en una sentencia aparecen varios operadores el compilador deber de elegir en
qu orden aplica los operadores. A esto se le llama ,&$+$.$-+<'.
Los operadores con mayor precedencia son evaluados antes que los operadores con una
precedencia relativa menor.
Cuando en una sentencia aparecen operadores con la misma precedencia:
!"Los operadores de asignacin son evaluados de derecha a izquierda.
!"Los operadores binarios, (menos los de asignacin) son evaluados de izquierda a
derecha.
Se puede indicar explcitamente al compilador de Java cmo se desea que se evale la
expresin con parntesis balanceados ( ). Para hacer que el cdigo sea ms fcil de leer
y mantener, es preferible ser explcito e indicar con parntesis que operadores deben ser
evaluados primero.
La siguiente tabla muestra la precedencia asignada a los operadores de Java. Los
operadores de la tabla estn listados en orden de precedencia: cuanto ms arriba
aparezca un operador, mayor es su precedencia. Los operadores en la misma lnea
tienen la misma precedencia:
Pgina 52 de 189
4R_U,T^,U_ÔPTUO^M, )_ÔPTUO^M,T^,^MN^,NR_U,
Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creacin o conversin new (tipo) expr
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 = += -= *= /= %= &= ^= |= <<= = =
8'(?'%T\%E&$.$.$-+<'%.$%*,$&'.*&$"%
Por ejemplo, la siguiente expresin produce un resultado diferente dependiendo de si se
realiza la suma o divisin en primer lugar:
x + y / 100
Si no se indica explcitamente al compilador el orden en que se quiere que se realicen
las operaciones, entonces el compilador decide basndose en la precedencia asignada a
los operadores. Como el operador de divisin tiene mayor precedencia que el operador
de suma el compilador evaluar HaTzz primero.
As:
x + y / 100
Es equivalente a:
x + (y / 100)
Pgina 53 de 189
((/X/%'712"*1"2$7%&'%*3)123,%
9*(%'@#?>6<<%&'(
Durante un programa existen acciones que se han de repetir un nmero determinado de
veces. Por ejemplo, leer 3 caracteres de un flujo de entrada <- se codificara:
in.read();
in.read();
in.read();
Este cdigo adems de poco elegante sera inviable para una repeticin de 3000
lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas
acciones se realicen varias veces, mientras que una condicin se cumpla, y en definitiva,
tomar decisiones de qu hacer en funcin de las condiciones que se den en el programa
en un momento dado de su ejecucin.
As, nuestro ejemplo se podra indicar como:
int i=0;
for ( i=0 ; i <= 3 ; i++ )
in.read();
Donde bastara cambiar el ` por cualquier otro nmero para que la lectura se repitiese
ese nmero de veces.
El lenguaje Java soporta las estructuras de control:
!^SN^SQRP, 'XP]^,
Toma de decisin if-else, switch-case
Bucle for, while, do-while
Miscelneo break, continue, label:, return, goto
8'(?'%TV\%!"#&/+#/&'"%.$%+*-#&*?%
Aunque 0*#*% es una palabra reservada, actualmente el lenguaje Java no soporta la
sentencia 0*#*. Se puede utilizar las sentencias de bifurcacin en su lugar.
;*(:9$($"'@"'<%9$(<?'>%<%?'9:"$E(%D(L($P%@<M(
8/9%,8%CA<DA<=;8%;L%]%AGCA%
La sentencia <5^$?"$ de Java dota a los programas de la habilidad de ejecutar distintos
conjuntos de sentencias segn algn criterio.
La sintaxis de la sentencia <5^$?"$%es:
if ( condicin )
Bloque de cdigo a ejecutar si la condicin es cierta
else
Bloque de cdigo a ejecutar si la condicin es falsa
La parte del $?"$ es opcional, y un bloque de cdigo puede ser simplemente la sentencia
vaca v para representar que en ese caso no se ha de ejecutar nada.
Pgina 54 de 189
Supongamos que un programa debe realizar diferentes acciones dependiendo de si el

usuario oprime el botn aceptar o el botn cancelar en una ventana de dialogo. Nuestro
programa puede realizar esto usando la sentencia <5%^%$?"$:
// La respuesta es Aceptar o Cancelar
if (respuesta == Aceptar) {
// cdigo para realizar la accin Aceptar
System.out.println( "Su peticion esta siendo atendida" );
}
else {
// cdigo para realizar la accin Cancelar
System.out.println( "Cancelando accion" );
}
Se pueden anidar expresiones <5^$?"$, para poder implementar aquellos casos con
mltiples acciones. Esto es lo que se suele denominar como sentencias $?"$%<5.
Por ejemplo, supongamos que se desea escribir un programa que clasifique segn el
contenido de una variable ='?*&, asigne una letra a una variable +?'"<5<+'+<*-: A para un
valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:
int valor;
char clasificacion;
if (valor > 90)
{clasificacion=A;}
else
if (valor > 80)
{clasificacion=B;}
else
if (valor > 70)
{clasificacion=C;}
else
{clasificacion=F;}
Se pueden escribir los <5 en las mismas lneas que los $?"$, pero desde este tutorial se
insta a utilizar la forma indentada (como se ha podido ver en el ejemplo), pues es ms
clara para el lector.
Este sistema de programacin ($?"$% <5;% no es demasiado recomendable, y por ello el
lenguaje Java incluye la sentencia "N<#+ID que veremos a continuacin, para dirigir el
flujo de control de variables con mltiples valores.
B/9%,8%CA<DA<=;8%C^;D=[%
Mediante la sentencia "N<#+I se puede seleccionar entre varias sentencias segn el valor
de cierta expresin.
La forma general de "N<#+I es la siguiente:
Pgina 55 de 189
switch ( expresionMultivalor ) {
case valor1 : conjuntoDeSentencias; break;
case valor3: conjuntoDeSentencias; break;
default: conjuntoDeSentencias; break;
}
La sentencia "N<#+I evala la $g,&$"<>-9/?#<='?*& y ejecuta el +*-)/-#*R$M$-#$-+<'"%
que aparece junto a la clusula +'"$ cuyo ='?*& corresponda con el de la
$g,&$"<>-9/?#<='?*&.
Cada sentencia +'"$ debe ser nica y el ='?*& que evala debe ser del mismo tipo que el
devuelto por la $g,&$"<>-9/?#<='?*& de la sentencia "N<#+I.
Las sentencias (&$'P que aparecen tras cada +*-)/-#*R$M$-#$-+<'"% provocan que el
control salga del "N<#+I y contine con la siguiente instruccin al "N<#+I. Las sentencias
(&$'P son necesarias porque sin ellas se ejecutaran secuencialmente las sentencias +'"$
siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente
algunas o todas las sentencias +'"$, para lo que habr que eliminar algunos (&$'PA
Finalmente, se puede usar la sentencia .$5'/?# para manejar los valores que no son
explcitamente contemplados por alguna de las sentencias +'"$. Su uso es altamente
recomendado.
Por ejemplo, supongamos un programa con una variable entera 6$"$" cuyo valor indica
el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar
la sentencia "N<#+I para realizar esta operacin:
int meses;
switch ( meses ){
case 1: System.out.println( "Enero" ); break;
case 2: System.out.println( "Febrero" ); break;
case 3: System.out.println( "Marzo" ); break;
//Demas meses
// . . .
case 12: System.out.println( "Diciembre" ); break;
default: System.out.println( "Mes no valido" ); break;
}
Por supuesto, se puede implementar esta estructura como una sentencia <5%$?"$%<5:
int meses;
if ( meses == 1 ) {
System.out.println( "Enero" );
}
else
if ( meses == 2 ) {
System.out.println( "Febrero" );
Pgina 56 de 189
}
// Y as para los dems meses
El decidir si usar la sentencia <5 o "N<#+I depende del criterio de cada caso. Se puede
decidir cul usar basndonos en la legibilidad, aunque se recomienda utilizar "N<#+I
para sentencias con ms de tres o cuatro posibilidades.
<*($"'@"'<%9$(>"(%@"#9<%&'(?(;6<:"$E(D?#Q(>?Q(PM%:"(
8/9%6F=GA%^[;GA%
El bucle NI<?$ es el bucle bsico de iteracin. Sirve para realizar una accin
sucesivamente mientras se cumpla una determinada condicin.
La forma general del bucle NI<?$ es la siguiente:
while ( expresinBooleana ) {
sentencias;
};
Las "$-#$-+<'" se ejecutan mientras la $g,&$"<>-Q**?$'-' tenga un valor de =$&.'.$&*.
Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se
cumpla una determinada condicin. Por ejemplo, multiplicar un nmero por 2 hasta que
sea mayor que 100:
int i = 1;
while ( i <= 100 ) {
i = i * 2;
}
Con l se podran eliminar los bucles .*^NI<?$ y 5*& por ser extensiones de ste, pero
que se incluyen en el lenguaje para facilitar la programacin.
B/9%6F=GA%@?]^[;GA%
El bucle .*^NI<?$ es similar al bucle NI<?$, pero en el bucle NI<?$ la expresin se evala
al principio del bucle y en el bucle .*^NI<?$%la evaluacin se realiza al final.
La forma general del bucle .*^NI<?$ es la siguiente:
do {
sentencias;
} while ( expresinBooleana );
La sentencia .*^NI<?$ es el constructor de bucles menos utilizado en la programacin,
pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez.
Por ejemplo, cuando se lee informacin de un archivo, se sabe que siempre se debe leer
por lo menos un carcter:
int c;
do {
c = System.in.read( );
Pgina 57 de 189
// Sentencias para tratar el carcter c

} while ( c != -1 ); // No se puede leer ms (Fin fichero)
=/9%6F=GA%L?:%
Mediante la sentencia 5*& se resume un bucle .*^NI<?$ con una iniciacin previa. Es
muy comn que en los bucles NI<?$ y .*^NI<?$ se inicien las variables de control de
nmero de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso
el bucle 5*& est tan extendido.
La forma general de la sentencia 5*& es la siguiente:
for ( iniciacin ; terminacin ; incremento )
sentencias;
La iniciacin es una sentencia que se ejecuta una vez antes de entrar en el bucle.
La terminacin es una expresin que determina cundo se debe terminar el bucle. Esta
expresin se evala al final de cada iteracin del bucle. Cuando la expresin se evala a
falso, el bucle termina.
El incremento es una expresin que es invocada en cada iteracin del bucle. En realidad
puede ser una accin cualquiera, aunque se suele utilizar para incrementar una variable
contador:
for ( i = 0 ; i < 10 ; i++ )
Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre
deben aparecer (aunque sea sin nada entre s).
Se debe utilizar el bucle 5*& cuando se conozcan las restricciones del bucle (su
instruccin de iniciacin, criterio de terminacin e instruccin de incremento).
Por ejemplo, los bucles 5*& son utilizados comnmente para iterar sobre los elementos
de una matriz, o los caracteres de una cadena:
// cad es una cadena (String)
for ( int i = 0; i < cad.length() ; i++){
// hacer algo con el elemento i-simo de cad
}
>*($"'@"'<%9$(>"($9:@?E(;#"9NQ(<?'@%'6"(L(#"@6#'(
8/9%7A<DA<=;8%B:A8\%
La sentencia (&$'P provoca que el flujo de control salte a la sentencia inmediatamente
posterior al bloque en curso. Ya se ha visto anteriormente la sentencia (&$'P dentro de
la sentencia "N<#+I.
El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la
sentencia 0*#*, que no es soportada por el lenguaje Java.
Se puede etiquetar una sentencia poniendo una identificador Java vlido seguido por
dos puntos antes de la sentencia:
nombreSentencia: sentenciaEtiquetada
Pgina 58 de 189
La sentencia (&$'P se utiliza para salir de una sentencia etiquetada, llevando el flujo del
programa al final de la sentencia de programa que indique:
break nombreSentencia2;
Un ejemplo de esto sera el programa:
void gotoBreak() {
System.out.println("Ejemplo de break como goto ");
a: for( int i=1; i<10; i++ ){
System.out.print(" i="+i);
for( int j=1; j<10; j++ ){
if ( j==5 )
break a; //Sale de los dos bucles!!!
System.out.print(" j="+j);
}
System.out.print("No llega aqu");
}
}
Al interpretar (&$'P%', no solo se rompe la ejecucin del bucle interior (el de )), sino que
se salta al final del bucle <, obtenindose:
i=1 j=1 j=2 j=3
&UNP/ Se desaconseja esta forma de programacin, basada en 0*#*, y con saltos de flujo
no controlados.
B/9%7A<DA<=;8%=?<D;<FA%
Del mismo modo que en un bucle se puede desear romper la iteracin, tambin se puede
desear continuar con el bucle, pero dejando pasar una determinada iteracin.
Se puede usar la sentencia +*-#<-/$ dentro de los bucles para saltar a otra sentencia,
aunque no puede ser llamada fuera de un bucle.
Tras la invocacin a una sentencia +*-#<-/$ se transfiere el control a la condicin de
terminacin del bucle, que vuelve a ser evaluada en ese momento, y el bucle contina o
no dependiendo del resultado de la evaluacin. En los bucles 5*& adems en ese
momento se ejecuta la clusula de incremento (antes de la evaluacin). Por ejemplo el
siguiente fragmento de cdigo imprime los nmeros del 0 al 9 no divisibles por 3:
for ( int i = 0 ; i < 10 ; i++ ) {
if ( ( i % 3 ) == 0 )
continue;
System.out.print( " " + i );
}
Del mismo modo que (&$'P, en las sentencias +*-#<-/$ se puede indicar una etiqueta de
bloque al que hace referencia. Con ello podemos referirnos a un bloque superior, si
Pgina 59 de 189
estamos en bucles anidados. Si dicha etiqueta no es indicada, se presupone que nos

referimos al bucle en el que la sentencia +*-#<-/$ aparece.
Por ejemplo, el siguiente fragmento de cdigo:
void gotoContinue( ) {
f: for ( int i=1; i <5; i++ ) {
for ( int j=1; j<5; j++ ) {
if ( j>i ) {
System.out.println(" ");
continue f;
}
System.out.print( " " + (i*j) );
}
}
}
En este cdigo la sentencia +*-#<-/$ termina el bucle de ) y continua el flujo en la
siguiente iteracin de i. Ese mtodo imprimira:
1
2 4
3 6 9
4 8 12 16
&UNP/ Se desaconseja esta forma de programacin, basada en 0*#*, y con saltos de flujo
no controlados.
=/9%7A<DA<=;8%:ADF:<%
La ltima de las sentencias de salto es la sentencia &$#/&-, que puede usar para salir del
mtodo en curso y retornar a la sentencia dentro de la cual se realiz la llamada.
Para devolver un valor, simplemente se debe poner el valor (o una expresin que calcule
el valor) a continuacin de la palabra &$#/&-A%El valor devuelto por &$#/&- debe coincidir
con el tipo declarado como valor de retorno del mtodo.
Cuando un mtodo se declara como =*<. se debe usar la forma de &$#/&- sin indicarle
ningn valor. Esto se hace para no ejecutar todo el cdigo del programa:
int contador;
boolean condicion;
int devuelveContadorIncrementado(){
return ++contador;
}
void metodoReturn(){
//Sentencias
if ( condicion == true )
Pgina 60 de 189
return;
//Ms sentencias a ejecutar si condicin no vale true
}
"*("O<"8<%?'"$(
Las excepciones son otra forma ms avanzada de controlar el flujo de un programa. Con
ellas se podrn realizar acciones especiales si se dan determinadas condiciones, justo en
el momento en que esas condiciones se den.
Estudiaremos ms este sistema de control en el captulo ZOOAVA%X$"#<>-%.$%$g+$,+<*-$"%H%
$&&*&$"Z de este tutorial.
Pgina 61 de 189
((/_/%*,$7'7%`%36-'137%
9*(%'@#?>6<<%&'
Durante los captulos anteriores se han dado unas nociones bsicas de la sintaxis de
Java. A partir de ahora es cuando entramos la verdadera potencia de Java como lenguaje
orientado a objetos: las clases y los objetos.
Aquellas personas que nunca hayan programado en un lenguaje orientado a objeto, o
que no conozcan las nociones bsicas de paradigma conviene que lean el captulo ZOAT%
O-#&*./++<>-%'%?'%,&*0&'6'+<>-%*&<$-#'.'%'%*()$#*"Z de este tutorial, ya que a partir de
ahora los conceptos que en l se exponen se darn por entendidos.
Durante todo este captulo se va a trabajar en la construccin de una clase 9<E/-#*, que
modeliza un punto en un espacio plano:
class MiPunto{
int x, y;
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
double distancia(int x, int y) {
int dx= this.x pX;
int dy = this.y pY;
return Math.sqrt(dx*dx + dy*dy);
}
void metodoVacio( ) { }
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}
void inicia2( int x, int y ) {
x = x; // Ojo, no modificamos la variable de instancia!!!
this.y = y; // Modificamos la variable de instancia!!!
}
MiPunto( int paramX, int paramY ) {
this.x = paramX; // Este this se puede omitir
y = paramY; // No hace falta this
}
MiPunto() {
inicia(-1,-1); //Por defecto ; this(-1,-1) hace lo mismo
}
}
Pgina 62 de 189
;*(>"D%'%<%&'(>"(6'9(<:9$"
8/9%(<D:?@F==;E<!
El elemento bsico de la programacin orientada a objetos en Java es la clase. Una clase
define la forma y comportamiento de un objeto.
Para crear una clase slo se necesita un archivo fuente que contenga la palabra clave
reservada +?'"" seguida de un identificador legal y un bloque delimitado por dos llaves
para el cuerpo de la clase.
class MiPunto {
}
Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele
asignar la extensin ZA)'='ZA Por ejemplo la clase 9<E/-#*% se guardara en un fichero
que se llamase 9<E/-#*A)'='. Hay que tener presente que en Java se diferencia entre
maysculas y minsculas; el nombre de la clase y el de archivo fuente han de ser
exactamente iguales.
Aunque la clase 9<E/-#* es sintcticamente correcta, es lo que se viene a llamar una
+?'"$%='+1', es decir, una clase que no hace nada. Las clases tpicas de Java incluirn
variables y mtodos de instancia. Los programas en Java completos constarn por lo
general de varias clases de Java en distintos archivos fuente.
Una clase es una plantilla para un objeto. Por lo tanto define la estructura de un objeto y
su interfaz funcional, en forma de mtodos. Cuando se ejecuta un programa en Java, el
sistema utiliza definiciones de clase para crear instancias de las clases, que son los
objetos reales. Los trminos instancia y objeto se utilizan de manera indistinta. La forma
general de una definicin de clase es:
class Nombre_De_Clase {
tipo_de_variable nombre_de_atributo1;
tipo_de_variable nombre_de_atributo2;
// . . .
tipo_devuelto nombre_de_mtodo1( lista_de_parmetros ) {
cuerpo_del_mtodo1;
}
tipo_devuelto nombre_de_mtodo2( lista_de_parmetros ) {
cuerpo_del_mtodo2;
}
// . . .
}
Los tipos #<,*f.$f='&<'(?$ y #<,*f.$=/$?#*, han de ser tipos simples Java o nombres de
otras clases ya definidas. Tanto ]*6(&$fR$fJ?'"$, como los -*6(&$f.$f'#&<(/#* y
-*6(&$f.$f6B#*.*, han de ser identificadores Java vlidos.
Pgina 63 de 189
B/9%,?C%8D:;BFD?C%
Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de
apertura y cierre de la declaracin de la clase, variables que se conocen como atributos.
Se declaran igual que las variables locales de un mtodo en concreto.
Por ejemplo, este es un programa que declara una clase 9<E/-#*, con dos atributos
enteros llamados ! e ".
class MiPunto {
int x, y;
}
Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya
descritos), o el nombre de una clase (ser una &$5$&$-+<'%'%*()$#*, vase el punto C.a de
este mismo apartado).
Cuando se realiza una instancia de una clase (creacin de un objeto) se reservar en la
memoria un espacio para un conjunto de datos como el que definen los atributos de una
clase. A este conjunto de variables se le denomina ='&<'(?$"%.$%<-"#'-+<'.
=/9%,?C%HZD?@?C%
Los mtodos son subrutinas que definen la interfaz de una clase, sus capacidades y
comportamiento.
Un mtodo ha de tener por nombre cualquier identificador legal distinto de los ya
utilizados por los nombres de la clase en que est definido. Los mtodos se declaran al
mismo nivel que las variables de instancia dentro de una definicin de clase.
En la declaracin de los mtodos se define el tipo de valor que devuelven y a una lista
formal de parmetros de entrada, de sintaxis #<,*%<.$-#<5<+'.*&%separadas por comas. La
forma general de una declaracin de mtodo es:
tipo_devuelto nombre_de_mtodo( lista-formal-de-parmetros ) {
cuerpo_del_mtodo;
}
Por ejemplo el siguiente mtodo devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
};
En el caso de que no se desee devolver ningn valor se deber indicar como tipo la
palabra reservada =*<.. As mismo, si no se desean parmetros, la declaracin del
mtodo debera incluir un par de parntesis vacos (sin =*<.):
void metodoVacio( ) { };
Los mtodos son llamados indicando una instancia individual de la clase, que tendr su
propio conjunto nico de variables de instancia, por lo que los mtodos se pueden
referir directamente a ellas.
El mtodo <-<+<'2;% para establecer valores a las dos variables de instancia sera el
siguiente:
Pgina 64 de 189
void inicia( int paramX, int paramY ) {

x = paramX;
y = paramY;
}
<*(:9(%'$@9'<%9<%&'(>"(:9$(<:9$"$E(:?$(?;C"@?$(
8/9%2ALA:A<=;8C%8%3BKAD?%A%(<CD8<=;8C%
Los tipos simples de Java describan el tamao y los valores de las variables. Cada vez
que se crea una clase se aade otro tipo de dato que se puede utilizar igual que uno de
los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de
clase como tipo. A estas variables se las conoce como &$5$&$-+<'"%'%*()$#*.
Todas las referencias a objeto son compatibles tambin con las instancias de subclases
de su tipo. Del mismo modo que es correcto asignar un (H#$ a una variable declarada
como <-#, se puede declarar que una variable es del tipo 9<J?'"$ y guardar una
referencia a una instancia de este tipo de clase:
MiPunto p;
Esta es una declaracin de una variable , que es una referencia a un objeto de la clase
9<E/-#*, de momento con un valor por defecto de -/??. La referencia -/?? es una
referencia a un objeto de la clase F()$+#, y se podr convertir a una referencia a
cualquier otro objeto porque todos los objetos son I<)*" de la clase F()$+#.
B/9%*?<CD:F=D?:AC%
Las clases pueden implementar un mtodo especial llamado +*-"#&/+#*&. Un constructor
es un mtodo que inicia un objeto inmediatamente despus de su creacin. De esta
forma nos evitamos el tener que iniciar las variables explcitamente para su iniciacin.
El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no
puede haber ningn otro mtodo que comparta su nombre con el de su clase. Una vez
definido, se llamar automticamente al constructor al crear un objeto de esa clase (al
utilizar el operador -$N).
El constructor no devuelve ningn tipo, ni siquiera =*<.. Su misin es iniciar todo
estado interno de un objeto (sus atributos), haciendo que el objeto sea utilizable
inmediatamente; reservando memoria para sus atributos, iniciando sus valores...
Por ejemplo:
MiPunto( ) {
inicia( -1, -1 );
}
Este constructor denominado +*-"#&/+#*&% ,*&% .$5$+#*, por no tener parmetros,
establece el valor ^T a las variables de instancia g e H de los objetos que construya.
El compilador, por defecto ,llamar al constructor de la superclase F()$+#2;% si no se
especifican parmetros en el constructor.
Este otro constructor, sin embargo, recibe dos parmetros:
Pgina 65 de 189
MiPunto( int paraX, int paraY ) {

inicia( paramX, paramY );
}
La lista de parmetros especificada despus del nombre de una clase en una sentencia
-$N se utiliza para pasar parmetros al constructor.
Se llama al mtodo constructor justo despus de crear la instancia y antes de que -$N
devuelva el control al punto de la llamada.
As, cuando ejecutamos el siguiente programa:
MiPunto p1 = new MiPunto(10, 20);
System.out.println( p1.- x = + p1.x + y = + p1.y );
Se muestra en la pantalla:
p1.- x = 10 y = 20
Para crear un programa Java que contenga ese cdigo, se debe de crear una clase que
contenga un mtodo 6'<-2;. El intrprete )'=' se ejecutar el mtodo 6'<- de la clase
que se le indique como parmetro.
Para ms informacin sobre cmo crear y ejecutar un programa, as como los tipos de
programas que se pueden crear en Java, vase el captulo ZOOAT_A%J&$'+<>-%.$%,&*0&'6'"%
@'='Z de este tutorial.
=/9%'G%?>A:8@?:%<A^%
El operador%-$N crea una instancia de una clase (*()$#*") y devuelve una referencia a
ese objeto. Por ejemplo:
MiPunto p2 = new MiPunto(2,3);
Este es un ejemplo de la creacin de una instancia de 9<E/-#*, que es controlador por la
referencia a objeto ,_.
Hay una distincin crtica entre la forma de manipular los tipos simples y las clases en
Java: Las referencias a objetos realmente no contienen a los objetos a los que
referencian. De esta forma se pueden crear mltiples referencias al mismo objeto, como
por ejemplo:
MiPunto p3 =p2;
Aunque tan slo se cre un objeto 9<E/-#*, hay dos variables (,_ y ,`) que lo
referencian. Cualquier cambio realizado en el objeto referenciado por ,_ afectar al
objeto referenciado por ,`. La asignacin de ,_ a ,` no reserva memoria ni modifica el
objeto.
De hecho, las asignaciones posteriores de ,_ simplemente desengancharn ,_ del
objeto, sin afectarlo:
p2 = null; // p3 todava apunta al objeto creado con new
Aunque se haya asignado -/?? a ,_, ,` todava apunta al objeto creado por el operador
-$N.
Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama
automticamente la memoria utilizada por ese objeto, a lo que se denomina &$+*0<.'%.$%
('"/&'.
Pgina 66 de 189
Cuando se realiza una instancia de una clase (mediante -$N) se reserva en la memoria
un espacio para un conjunto de datos como el que definen los atributos de la clase que
se indica en la instanciacin. A este conjunto de variables se le denomina ='&<'(?$"%.$%
<-"#'-+<'.
La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas
cada vez que se crea un objeto nuevo. Es importante el comprender que cada objeto
tiene su propia copia de las variables de instancia de su clase, por lo que los cambios
sobre las variables de instancia de un objeto no tienen efecto sobre las variables de
instancia de otro.
El siguiente programa crea dos objetos 9<E/-#* y establece los valores de g e H de cada
uno de ellos de manera independiente para mostrar que estn realmente separados.
MiPunto p4 = new MiPunto( 10, 20 );
System.out.println(p4.- x = + p4.x + y = + p4.y);
System.out.println(p5.- x = + p5.x + y = + p5.y);
Este es el aspecto de salida cuando lo ejecutamos.
p4.- x = 10 y = 20
p5.- x = 42 y = 99
>*(9<<"$?(9:(?;C"@?(
8/9%'G%?>A:8@?:%>F<D?%Y/9%
El operador punto (.) se utiliza para acceder a las variables de instancia y los mtodos
contenidos en un objeto, mediante su referencia a objeto:
referencia_a_objeto.nombre_de_variable_de_instancia
referencia_a_objeto.nombre_de_mtodo( lista-de-parmetros )#$
Hemos creado un ejemplo completo que combina los operadores -$N y punto para crear
un objeto 9<E/-#*, almacenar algunos valores en l e imprimir sus valores finales:
System.out.println (p6.- 1. X= + p6.x + , Y= + p6.y);
p6.inicia( 30, 40 );
System.out.println (p6.- 2. X= + p6.x + , Y= + p6.y);
Cuando se ejecuta este programa, se observa la siguiente salida:
p6.- 1. X=10 , Y=20
p6.- 2. X=30 , Y=40
Durante las impresiones (mtodo ,&<-#?-2;)%"e accede al valor de las variables mediante
,|Ag y ,|AH, y entre una impresin y otra se llama al mtodo <-<+<'2;, cambiando los
valores de las variables de instancia.
Este es uno de los aspectos ms importantes de la diferencia entre la programacin
orientada a objetos y la programacin estructurada. Cuando se llama al mtodo
,|A<-<+<'2;, lo primero que se hace en el mtodo es sustituir los nombres de los atributos
Pgina 67 de 189
de la clase por las correspondientes variables de instancia del objeto con que se ha
llamado. As por ejemplo g se convertir en ,|Ag.
Si otros objetos llaman a <-<+<'2;, incluso si lo hacen de una manera concurrente, no se
producen $5$+#*"%?'#$&'?$", ya que las variables de instancia sobre las que trabajan son
distintas.
B/9%,8%:ALA:A<=;8%D[;C%
Java incluye un valor de referencia especial llamado #I<", que se utiliza dentro de
cualquier mtodo para referirse al objeto actual. El valor #I<" se refiere al objeto sobre el
que ha sido llamado el mtodo actual. Se puede utilizar #I<" siempre que se requiera una
referencia a un objeto del tipo de una clase actual. Si hay dos objetos que utilicen el
mismo cdigo, seleccionados a travs de otras instancias, cada uno tiene su propio valor
nico de #I<".
Un refinamiento habitual es que un constructor llame a otro para construir la instancia
correctamente. El siguiente constructor llama al constructor parametrizado 9<E/-#*2gDH;
para terminar de iniciar la instancia:
MiPunto() {
this( -1, -1 ); // Llama al constructor parametrizado
}
En Java se permite declarar variables locales, incluyendo parmetros formales de
mtodos, que se solapen con los nombres de las variables de instancia.
No se utilizan g e H como nombres de parmetro para el mtodo <-<+<', porque
ocultaran las variables de instancia g e H reales del mbito del mtodo. Si lo hubisemos
hecho, entonces g se hubiera referido al parmetro formal, ocultando la variable de
instancia g\%
void inicia2( int x, int y ) {
x = x; // Ojo, no modificamos la variable de instancia!!!
this.y = y; // Modificamos la variable de instancia!!!
}
"*(:9(>"$@#6<<%&'(>":(?;C"@?(
8/9%,8%@ACD:F==;E<%@A%G?C%?BKAD?C%
Cuando un objeto no va a ser utilizado, el espacio de memoria de dinmica que utiliza
ha de ser liberado, as como los recursos que posea, permitiendo al programa disponer
de todos los recursos posibles. A esta accin se la da el nombre de .$"#&/++<>-% .$?%
*()$#*.
En Java la destruccin se puede realizar de forma automtica o de forma personalizada,
en funcin de las caractersticas del objeto.
B/9%,8%@ACD:F==;E<%>?:%@ALA=D?a%2A=?V;@8%@A%B8CF:8%
El intrprete de Java posee un sistema de recogida de basura, que por lo general permite
que no nos preocupemos de liberar la memoria asignada explcitamente.
Pgina 68 de 189
El recolector de basura ser el encargado de liberar una zona de memoria dinmica que
haba sido reservada mediante el operador -$N, cuando el objeto ya no va a ser utilizado
ms durante el programa (por ejemplo, sale del mbito de utilizacin, o no es
referenciado nuevamente).
El sistema de recogida de basura se ejecuta peridicamente, buscando objetos que ya no
estn referenciados.
=/9%,8%@ACD:F==;E<%>A:C?<8G;N8@8a%L;<8G;NA%
A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo
o un tipo de letra del sistema de ventanas. En este caso sera acertado el utilizar la
finalizacin explcita, para asegurar que dicho recurso se libera. Esto se hace mediante
la .$"#&/++<>-%,$&"*-'?<C'.', un sistema similar a los destructores de C++.
Para especificar una .$"#&/++<>-% ,$&"*-'?<C'.' se aade un mtodo a la clase con el
nombre 5<-'?<C$\%
class ClaseFinalizada{
ClaseFinalizada() { // Constructor
// Reserva del recurso no Java o recurso compartido
}
protected void finalize() {
// Liberacin del recurso no Java o recurso compartido
}
}
El intrprete de Java llama al mtodo 5<-'?<C$2;, si existe% cuando vaya a reclamar el
espacio de ese objeto, mediante la recogida de basura.
Debe observarse que el mtodo 5<-'?<C$2; es de tipo ,&*#$+#$.%=*<. y por lo tanto deber
de sobreescribirse con este mismo tipo.
Pgina 69 de 189
((/b/%,$%P'2')*($%
9*(%'@#?>6<<%&'(
La verdadera potencia de la programacin orientada a objetos radica en su capacidad
para reflejar la abstraccin que el cerebro humano realiza automticamente durante el
proceso de aprendizaje y el proceso de anlisis de informacin.
Las personas percibimos la realidad como un conjunto de objetos interrelacionados.
Dichas interrelaciones, pueden verse como un conjunto de abstracciones y
generalizaciones que se han ido asimilando desde la niez. As, los defensores de la
programacin orientada a objetos afirman que esta tcnica se adecua mejor al
funcionamiento del cerebro humano, al permitir descomponer un problema de cierta
magnitud en un conjunto de problemas menores subordinados del primero.
La capacidad de descomponer un problema o concepto en un conjunto de objetos
relacionados entre s, y cuyo comportamiento es fcilmente identificable, puede ser muy
til para el desarrollo de programas informticos.
;*(C"#9#G6=9(
La herencia es el mecanismo fundamental de relacin entre clases en la orientacin a
objetos. Relaciona las clases de manera jerrquica; una clase ,'.&$ o "/,$&+?'"$ sobre
otras clases I<)'" o "/(+?'"$".
Clase Padre
Clase Hija1 Clase Hija2

O6'0$-%w\%!)$6,?*%.$%*#&*%4&(*?%.$%I$&$-+<'%
Los descendientes de una clase heredan todas las variables y mtodos que sus
ascendientes hayan especificado como I$&$.'(?$", adems de crear los suyos propios.
La caracterstica de herencia, nos permite definir nuevas clases derivadas de otra ya
existente, que la especializan de alguna manera. As logramos definir una jerarqua de
clases, que se puede mostrar mediante un rbol de herencia.
En todo lenguaje orientado a objetos existe una jerarqua, mediante la que las clases se
relacionan en trminos de herencia. En Java, el punto ms alto de la jerarqua es la clase
F()$+# de la cual derivan todas las dems clases.
<*(M"#"'<%9(7R:@%8:"(
En la orientacin a objetos, se consideran dos tipos de herencia, simple y mltiple. En el
caso de la primera, una clase slo puede derivar de una nica superclase. Para el
segundo tipo, una clase puede descender de varias superclases.
Pgina 70 de 189
En Java slo se dispone de herencia simple, para una mayor sencillez del lenguaje, si
bien se compensa de cierta manera la inexistencia de herencia mltiple con un concepto
denominado <-#$&5'+$, que estudiaremos ms adelante.
>*(>"<:9#9<%&'(
Para indicar que una clase deriva de otra, heredando sus propiedades (mtodos y
atributos), se usa el trmino $g#$-.", como en el siguiente ejemplo:
public class SubClase extends SuperClase {
// Contenido de la clase$
}
Por ejemplo, creamos una clase 9<E/-#*`R, hija de la clase ya mostrada 9<E/-#*:
class MiPunto3D extends MiPunto {
int z;
MiPunto3D( ) {
x = 0; // Heredado de MiPunto
y = 0; // Heredado de MiPunto
z = 0; // Nuevo atributo
}
}
La palabra clave $g#$-." se utiliza para decir que deseamos crear una subclase de la
clase que es nombrada a continuacin, en nuestro caso 9<E/-#*`R es hija de 9<E/-#*.
"*(:%7%@9<%?'"$("'(:9(M"#"'<%9(
Todos los campos y mtodos de una clase son siempre accesibles para el cdigo de la
misma clase.
Para controlar el acceso desde otras clases, y para controlar la herencia por las subclase,
los miembros (atributos y mtodos) de las clases tienen tres modificadores posibles de
control de acceso:
!",/(?<+: Los miembros declarados ,/(?<+ son accesibles en cualquier lugar en que sea
accesible la clase, y son heredados por las subclases.
!",&<='#$: Los miembros declarados ,&<='#$ son accesibles slo en la propia clase.
!",&*#$+#$.: Los miembros declarados ,&*#$+#$. son accesibles slo para sus
subclases
Por ejemplo:
class Padre { // Hereda de Object
// Atributos
private int numeroFavorito, nacidoHace, dineroDisponible;
// Mtodos
public int getApuesta() {
Pgina 71 de 189
return numeroFavorito;
}
protected int getEdad() {
return nacidoHace;
}
private int getSaldo() {
return dineroDisponible;
}
}
class Hija extends Padre {
// Definicin
}
class Visita {
// Definicin
}
En este ejemplo, un objeto de la clase 7<)', hereda los tres atributos (-/6$&*x'=*&<#*,
-'+<.*7'+$ y .<-$&*R<",*-<(?$) y los tres mtodos ( 0$#G,/$"#'2;, 0$#!.'.2; y
0$#M'?.*2; ) de la clase E'.&$, y podr invocarlos. Cuando se llame al mtodo
0$#!.'.2; de un objeto de la clase 7<)', se devolver el valor de la variable de instancia
-'+<.*7'+$ de ese objeto, y no de uno de la clase E'.&$.
Sin embargo, un objeto de la clase 7<)', no podr invocar al mtodo 0$#M'?.*2; de un
objeto de la clase E'.&$, con lo que se evita que el 7<)* conozca el estado de la cuenta
corriente de un E'.&$.
La clase [<"<#', solo podr acceder al mtodo 0$#G,/$"#'2;, para averiguar el nmero
favorito de un E'.&$, pero de ninguna manera podr conocer ni su saldo, ni su edad
(sera una indiscrecin, no?).
D*(:9(<:9$"(?;C"<@(
La clase F()$+# es la superclase de todas las clases da Java. Todas las clases derivan,
directa o indirectamente de ella. Si al definir una nueva clase, no aparece la clusula
$g#$-.", Java considera que dicha clase desciende directamente de F()$+#.
La clase F()$+# aporta una serie de funciones bsicas comunes a todas las clases:
!",/(?<+%(**?$'-%$3/'?"2%F()$+#%*()%;: Se utiliza para comparar, en valor, dos objetos.
Devuelve #&/$ si el objeto que recibe por parmetro es igual, en valor, que el objeto
desde el que se llama al mtodo. Si se desean comparar dos referencias a objeto se
pueden utilizar los operadores de comparacin == y !=.
!",/(?<+% <-#% I'"IJ*.$2;: Devuelve un cdigo hash para ese objeto, para poder
almacenarlo en una 7'"I#'(?$.
!",&*#$+#$.%F()$+#%+?*-$2;%#I&*N"%J?*-$]*#M/,,*&#$.!g+$,#<*-\ Devuelve una copia
de ese objeto.
Pgina 72 de 189
!",/(?<+% 5<-'?% J?'""% 0$#J?'""2;: Devuelve el objeto concreto, de tipo J?'"", que
representa la clase de ese objeto.
!",&*#$+#$.%=*<.%5<-'?<C$2;%#I&*N"%8&*N'(?$: Realiza acciones durante la recogida de
basura.
Para ms informacin vase h*OSUXT,p,6UMXRSWe,3FF@i.
Pgina 73 de 189
((/c/%34'2$*(3)'7%$.$)d$&$7%')%,$7%*,$7'7%
9*(%'@#?>6<<%&'(
La programacin orientada a objetos en Java va mucho ms all de las clases, los
objetos y la herencia. Java presenta una serie de capacidades que enriquecen el modelo
de objetos que se puede representar en un programa Java. En este captulo entraremos
en ellos.
Vamos a ver cmo programar conceptos avanzados de la herencia, polimorfismo y
composicin, como conceptos que se pueden programar en Java.
;*(?8"#9<%?'"$(9!9'K9>9$("'(:9(M"#"'<%9(
8/9%(<D:?@F==;E<!
En el captulo anterior ya se han estudiado los fundamentos de la herencia en Java. Sin
embargo, el lenguaje tiene muchas ms posibilidades en este aspecto, como
estudiaremos a continuacin.
Conviene recordar que estamos utilizando el cdigo de la clase 9<E/-#*, cuyo cdigo se
puede encontrar en el apartado OOAyA%J?'"$"%H%F()$#*" de este tutorial.
B/9%,?C%AGAHA<D?C%VG?B8GACa%CD8D;=%
A veces se desea crear un mtodo o una variable que se utiliza fuera del contexto de
cualquier instancia, es decir, de una manera global a un programa. Todo lo que se tiene
que hacer es declarar estos elementos como "#'#<+A%
Esta es la manera que tiene Java de implementar funciones y variables globales.
Por ejemplo:
static int a = 3;
static void metodoGlobal() {
// implementacin del mtodo
}
No se puede hacer referencia a #I<" o a "/,$&% dentro de una mtodo "#'#<+.
Mediante atributos estticos, todas las instancias de una clase adems del espacio propio
para variables de instancia, comparten un espacio comn. Esto es til para modelizar
casos de la vida real.
Otro aspecto en el que es til "#'#<+ es en la creacin de mtodos a los que se puede
llamar directamente diciendo el nombre de la clase en la que estn declarados. Se puede
llamar a cualquier mtodo "#'#<+, o referirse a cualquier variable "#'#<+D% utilizando el
operador punto con el nombre de la clase, sin necesidad de crear un objeto de ese tipo:
class ClaseStatic {
int atribNoStatic = 42;
static int atribStatic = 99;
Pgina 74 de 189
static void metodoStatic() {

System.out.println(Met. static = + atribStatic);
}
static void metodoNoStatic() {
System.out.println(Met. no static = + atribNoStatic);
}
}
El siguiente cdigo es capaz de llamar a 6$#*.*M#'#<+ y '#&<(M#'#<+ nombrando
directamente la clase (sin objeto, sin -$N), por haber sido declarados "#'#<+.
System.out.println(At. static = + ClaseStatic.atribStatic);
ClaseStatic.metodoStatic(); // Sin instancia
new ClaseStatic().metodoNoStatic(); // Hace falta instancia
Si ejecutamos este programa obtendramos:
At. static = 99
Met. static = 99
Met. no static = 42
Debe tenerse en cuenta que en un mtodo esttico tan slo puede hacerse refernecia a
variables estticas.
=/9%,8C%=G8CAC%U%HZD?@?C%8BCD:8=D?Ca%8BCD:8=D%
Hay situaciones en las que se necesita definir una clase que represente un concepto
abstracto, y por lo tanto no se pueda proporcionar una implementacin completa de
algunos de sus mtodos.
Se puede declarar que ciertos mtodos han de ser sobrescritos en las subclases,
utilizando el modificador de tipo '("#&'+#A A estos mtodos tambin se les llama
&$",*-"'(<?<.'.% .$% "/(+?'"$. Cualquier subclase de una clase '("#&'+# debe
implementar todos los mtodos '("#&'+# de la superclase o bien ser declarada tambin
como '("#&'+#A%
Cualquier clase que contenga mtodos declarados como '("#&'+# tambin se tiene que
declarar como '("#&'+#, y no se podrn crear instancias de dicha clase (operador -$N).
Por ltimo se pueden declarar constructores '("#&'+#% o mtodos '("#&'+#%"#'#<+.%
Veamos un ejemplo de clases abstractas:
abstract class claseA {
abstract void metodoAbstracto();
void metodoConcreto() {
System.out.println(En el metodo concreto de claseA);
}
}
class claseB extends claseA {
void metodoAbstracto(){
Pgina 75 de 189
System.out.println(En el metodo abstracto de claseB);

}
}
La clase abstracta +?'"$G%ha implementado el mtodo concreto 6$#*.*J*-+&$#*2;, pero
el mtodo 6$#*.*G("#&'+#*2; era abstracto y por eso ha tenido que ser redefinido en la
clase hija +?'"$Q.
claseA referenciaA = new claseB();
referenciaA.metodoAbstracto();
referenciaA.metodoConcreto();
La salida de la ejecucin del programa es:
En el metodo abstracto de claseB
En el metodo concreto de claseA
<*(":(8?:%7?#D%$7?(
8/9%7AGA==;E<%@;<RH;=8%@A%HZD?@?%
Las dos clases implementadas a continuacin tienen una relacin subclase/superclase
simple con un nico mtodo que se sobrescribe en la subclase:
class claseAA {
void metodoDinamico() {
System.out.println(En el metodo dinamico de claseAA);
}
}
class claseBB extends claseAA {
void metodoDinamico() {
System.out.println(En el metodo dinamico de claseBB);
}
}
Por lo tanto si ejecutamos:
claseAA referenciaAA = new claseBB();
referenciaAA.metodoDinamico();
La salida de este programa es:
En el metodo dinamico de clase%%
Se declara la variable de tipo +?'"$G, y despus se almacena una referencia a una
instancia de la clase +?'"$Q en ella. Al llamar al mtodo 6$#*.*R<-'6<+*2; de +?'"$G, el
compilador de Java verifica que +?'"$G tiene un mtodo llamado 6$#*.*R<-'6<+*2;,
pero el intrprete de Java observa que la referencia es realmente una instancia de
+?'"$Q, por lo que llama al mtodo 6$#*.*R<-'6<+*2; de +?'"$Q en vez de al de +?'"$G.
Pgina 76 de 189
Esta forma de ,*?<6*&5<"6*%.<-46<+*%$-%#<$6,*%.$%$)$+/+<>- es uno de los mecanismos

ms poderosos que ofrece el diseo orientado a objetos para soportar la reutilizacin del
cdigo y la robustez.
B/9%7?B:AC=:;DF:8%@A%F<%HZD?@?%
Durante una jerarqua de herencia puede interesar volver a escribir el cuerpo de un
mtodo, para realizar una funcionalidad de diferente manera dependiendo del nivel de
abstraccin en que nos encontremos. A esta modificacin de funcionalidad se le llama
sobrescritura de un mtodo.
Por ejemplo, en una herencia entre una clase M$&[<=*% y una clase hija E$&"*-'; si la
clase M$&[<=* tuviese un mtodo '?<6$-#'&"$2;, debera volver a escribirse en el nivel de
E$&"*-', puesto que una persona no se alimenta ni como un G-<6'?, ni como una
E?'-#'...
La mejor manera de observar la diferencia entre sobrescritura y sobrecarga es mediante
un ejemplo. A continuacin se puede observar la implementacin de la sobrecarga de la
distancia en 3D y la sobrescritura de la distancia en 2D.
class MiPunto3D extends MiPunto {
int x,y,z;
double distancia(int pX, int pY) { // Sobrescritura
int retorno=0;
retorno += ((x/z)-pX)*((x/z)-pX);
retorno += ((y/z)-pY)*((y/z)-pY);
return Math.sqrt( retorno );
}
}
Se inician los objetos mediante las sentencias:
MiPunto p3 = new MiPunto(1,1);
MiPunto p4 = new MiPunto3D(2,2);
Y llamando a los mtodos de la siguiente forma:
p3.distancia(3,3); //Mtodo MiPunto.distancia(pX,pY)
p4.distancia(4,4); //Mtodo MiPunto3D.distancia(pX,pY)
Los mtodos se seleccionan en funcin del tipo de la instancia en tiempo de ejecucin,
no a la clase en la cual se est ejecutando el mtodo actual. A esto se le llama "$?$++<>-%
.<-46<+'%.$%6B#*.*.
=/9%7?B:A=8:V8%@A%HZD?@?%
Es posible que necesitemos crear ms de un mtodo con el mismo nombre, pero con
listas de parmetros distintas. A esto se le llama "*(&$+'&0'%.$?%6B#*.*. La sobrecarga
de mtodo se utiliza para proporcionar a Java un comportamiento ,*?<6>&5<+*A%
Un ejemplo de uso de la sobrecarga es por ejemplo, el crear constructores alternativos
en funcin de las coordenadas, tal y como se haca en la clase 9<E/-#*:
MiPunto( ) { //Constructor por defecto
Pgina 77 de 189
inicia( -1, -1 );
}
MiPunto( int paramX, int paramY ) { // Parametrizado
this.x = paramX;
y = paramY;
}
Se llama a los constructores basndose en el nmero y tipo de parmetros que se les
pase. Al nmero de parmetros con tipo de una secuencia especfica se le llama
"<0-'#/&'%.$%#<,*. Java utiliza estas signaturas de tipo para decidir a qu mtodo llamar.
Para distinguir entre dos mtodos, no se consideran los nombres de los parmetros
formales sino sus tipos:
MiPunto p1 = new MiPunto(); // Constructor por defecto
MiPunto p2 = new MiPunto( 5, 6 ); // Constructor parametrizado
@/9%,;H;D8=;E<%@A%G8%C?B:AAC=:;DF:8a%L;<8G%
Todos los mtodos y las variables de instancia se pueden sobrescribir por defecto. Si se
desea declarar que ya no se quiere permitir que las subclases sobrescriban las variables
o mtodos, stos se pueden declarar como final. Esto se utiliza a menudo para crear el
equivalente de una constante de C++.
Es un convenio de codificacin habitual elegir identificadores en maysculas para las
variables que sean 5<-'?D por ejemplo:
final int NUEVO_ARCHIVO = 1;
>*(:9$(#"D"#"'<%9$(8?:%7&#D%<9$E(@M%$(L($68"#(
B/9%$==AC?%8%G8%>:?>;8%=G8CAa%D[;C%
Aunque ya se explic en el apartado ZOOAyA%J?'"$"%H%*()$#*"Z de este tutorial el uso de la
referencia #I<" como modificador de mbito, tambin se la puede nombrar como
ejemplo de polimorfismo
Adems de hacer continua referencia a la clase en la que se invoque, tambin vale para
sustituir a sus constructores, utilizndola como mtodo:
this(); // Constructor por defecto
this( int paramX, int paramY ); // Constructor parametrizado
B/9%$==AC?%8%G8%CF>A:=G8CAa%CF>A:!
Ya hemos visto el funcionamiento de la referencia #I<" como referencia de un objeto
hacia s mismo. En Java existe otra referencia llamada "/,$&, que se refiere
directamente a la superclase.
La referencia "/,$& usa para acceder a mtodos o atributos de la superclase.
Podamos haber implementado el constructor de la clase 9<E/-#*`R%(hija de 9<E/-#*)
de la siguiente forma:
MiPunto3D( int x, int y, int z ) {
Pgina 78 de 189
super( x, y ); // Aqu se llama al constructor de MiPunto

this.z = super.metodoSuma( x, y ); // Mtodo de la superclase
}
Con una sentencia "/,$&A6$#*.*M/6'2gD%H; se llamara al mtodo 6$#*.*M/6'2; de la
superclase de la instancia #I<". Por el contrario con "/,$&2; llamamos al constructor de la
superclase.
"*(:9(<?78?$%<%&'(
Otro tipo de relacin muy habitual en los diseos de los programas es la composicin.
Los objetos suelen estar compuestos de conjuntos de objetos ms pequeos; un coche es
un conjunto de motor y carrocera, un motor es un conjunto de piezas, y as
sucesivamente. Este concepto es lo que se conoce como +*6,*"<+<>-.
La forma de implementar una relacin de composicin en Java es incluyendo una
referencia a objeto de la clase componedora en la clase compuesta.
Por ejemplo, una clase G&$'d$+#'-0/?'&, quedara definida por dos objetos de la clase
9<E/-#*, que representasen dos puntas contrarias de un rectngulo:
class AreaRectangular {
MiPunto extremo1; //extremo inferior izquierdo
MiPunto extremo2; //extremo superior derecho
AreaRectangular() {
extremo1=new MiPunto();
extremo2=new MiPunto();
}
boolean estaEnElArea( MiPunto p ){
if ( ( p.x>=extremo1.x && p.x<=extremo2.x ) &&
( p.y>=extremo1.y && p.y<=extremo2.y ) )
return true;
else
return false;
}
}
Puede observarse que las referencias a objeto ($g#&$6*T% y $g#&$6*_) son iniciadas,
instanciando un objeto para cada una en el constructor. As esta clase mediante dos
puntos, referenciados por $g#&$6*T%y $g#&$6*_, establece unos lmites de su rea, que
sern utilizados para comprobar si un punto est en su rea en el mtodo
$"#'!-!?G&$'2;.
Pgina 79 de 189
((/e/%!'71(+)%&'%'f*'4*(3)'7%`%'2232'7%
9*(%'@#?>6<<%&'(
El control de flujo en un programa Java puede hacerse mediante las ya conocidas
sentencias estructuradas (<5D%NI<?$D%&$#/&-). Pero Java va mucho ms all, mediante una
tcnica de programacin denominada 0$"#<>-%.$%$g+$,+<*-$".
Mediante las excepciones se podr evitar repetir continuamente cdigo, en busca de un
posible error, y avisar a otros objetos de una condicin anormal de ejecucin durante un
programa.
Durante este captulo estudiaremos la gestin de excepciones y errores, sin pretender
profundizar demasiado, pero s fijando la base conceptual de lo que este modo de
programacin supone.
Mediante la gestin de excepciones se prescindir de sentencias de control de errores
del tipo:
if ( error == true )
return ERROR;
;*(@%8?$(>"("O<"8<%?'"$(
Existen varios tipos fundamentales de excepciones:
!"Error: Excepciones que indican problemas muy graves, que suelen ser no
recuperables y no deben casi nunca ser capturadas.
!"!g+$,#<*-: Excepciones no definitivas, pero que se detectan fuera del tiempo de
ejecucin.
!"d/-#<6$!g+$,#<*-: Excepciones que se dan durante la ejecucin del programa.
Object
Throwable
Exception Error
Clases de Exception RuntimeException Clases de Error
Clases de RuntimeException
O6'0$-%y\%7$&$-+<'%.$%$g+$,+<*-$"%@'='%
Todas las excepciones tienen como clase base la clase 8I&*N'(?$, que est incluida en
el paquete )'='A?'-0, y sus mtodos son:
!"8&*N'(?$2%M#&<-0%6$-"')$%;v Constructor. La cadena es opcional
!"8I&*N'(?$%5<??O-M#'+P8&'+$2;v Llena la pila de traza de ejecucin.
!"M#&<-0%0$#:*+'?<C$.9$""'0$2;v Crea una descripcin local de este objeto.
Pgina 80 de 189
!"M#&<-0%0$#9$""'0$2;v Devuelve la cadena de error del objeto.

!"=*<.%,&<-#M#'+P8&'+$2E&<-#M#&$'6f*fE&<-#L&<#$&%";v Imprime este objeto y su traza
en el flujo del parmetro s, o en la salida estndar (por defecto).
!"M#&<-0%#*M#&<-02;v Devuelve una breve descripcin del objeto.
<*(D6'<%?'97%"'@?(
8/9%(<D:?@F==;E<%
Para que el sistema de gestin de excepciones funcione, se ha de trabajar en dos partes
de los programas:
!"Definir qu partes de los programas crean una excepcin y bajo qu condiciones.
Para ello se utilizan las palabras reservadas throw y throws.
!"Comprobar en ciertas partes de los programas si una excepcin se ha producido, y
actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y
finally.
B/9%58<AK?%@A%Ag=A>=;?<ACa%D:U%]%=8D=[%]%L;<8GGU%
Cuando el programador va a ejecutar un trozo de cdigo que pueda provocar una
excepcin (por ejemplo, una lectura en un fichero), debe incluir este fragmento de
cdigo dentro de un bloque #&H:
try {
// Cdigo posiblemente problemtico
}
Pero lo importante es cmo controlar qu hacer con la posible excepcin que se cree.
Para ello se utilizan las clausulas +'#+I, en las que se especifica que accin realizar:
try {
// Cdigo posiblemente problemtico
} catch( tipo_de_excepcion e) {
// Cdigo para solucionar la excepcin e
} catch( tipo_de_excepcion_mas_general e) {
// Cdigo para solucionar la excepcin e
}
En el ejemplo se observa que se pueden anidar sentencias +'#+I, pero conviene hacerlo
indicando en ltimo lugar las excepciones ms generales (es decir, que se encuentren
ms arriba en el rbol de herencia de excepciones), porque el intrprete Java ejecutar
aquel bloque de cdigo +'#+I cuyo parmetro sea del tipo de una excepcin lanzada.
Si por ejemplo se intentase capturar primero una excepcin 8I&*N'(?$, nunca
llegaramos a gestionar una excepcin d/-#<6$, puesto que cualquier clase hija de
d/-#<6$ es tambin hija de 8I&*N'(?$, por herencia.
Si no se ha lanzado ninguna excepcin el cdigo contina sin ejecutar ninguna sentencia
+'#+I.
Pgina 81 de 189
Pero, y si quiero realizar una accin comn a todas las opciones?. Para insertar
fragmentos de cdigo que se ejecuten tras la gestin de las excepciones. Este cdigo se
ejecutar tanto si se ha tratado una excepcin (+'#+I) como sino. Este tipo de cdigo se
inserta en una sentencia 5<-'??H, que ser ejecutada tras el bloque #&H o +'#+I\%
try {
} catch( Exception e ) {
} finally {
// Se ejecutara tras try o catch
}
=/9%,8<N8H;A<D?%@A%Ag=A>=;?<ACa%D[:?^%]%D[:?^C%
Muchas veces el programador dentro de un determinado mtodo deber comprobar si
alguna condicin de excepcin se cumple, y si es as lanzarla. Para ello se utilizan las
palabras reservadas #I&*N y #I&*N".
Por una parte la excepcin se lanza mediante la sentencia #I&*N:
if ( condicion_de_excepcion == true )
throw new miExcepcion();
Se puede observar que hemos creado un objeto de la clase 6<!g+$,+<*-, puesto que las
excepciones son objetos y por tanto debern ser instanciadas antes de ser lanzadas.
Aquellos mtodos que pueden lanzar excepciones, deben cules son esas excepciones en
su declaracin. Para ello se utiliza la sentencia #I&*N":
tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {
// Codigo capaz de lanzar excepciones miExcep1 y miExcep2
}
Se puede observar que cuando se pueden lanzar en el mtodo ms de una excepcin se
deben indicar en su declaracin separadas por comas.
@/9%'KAH>G?%@A%VACD;E<%@A%Ag=A>=;?<AC%
Ahora que ya sabemos cmo funciona este sistema, conviene ver al menos un pequeo
ejemplo, que ilustre al lector en el uso de las excepciones:
// Creo una excepcin personalizada
class MiExcepcion extends Exception {
MiExcepcion(){
super(); // constructor por defecto de Exception
}
MiExcepcion( String cadena ){
super( cadena ); // constructor param. de Exception
}
}
// Esta clase lanzar la excepcin
Pgina 82 de 189
class Lanzadora {
void lanzaSiNegativo( int param ) throws MiExcepcion {
if ( param < 0 )
throw new MiExcepcion( "Numero negativo" );
}
}
class Excepciones {
public static void main( String[] args ) {
// Para leer un fichero
Lanzadora lanza = new Lanzadora();
FileInputStream entrada = null;
int leo;
try {
entrada = new FileInputStream( "fich.txt" );
while ( ( leo = entrada.read() ) != -1 )
lanza.lanzaSiNegativo( leo );
entrada.close();
System.out.println( "Todo fue bien" );
} catch ( MiExcepcion e ){ // Personalizada
System.out.println( "Excepcion: " + e.getMessage() );
} catch ( IOException e ){ // Estndar
} finally {
if ( entrada != null )
try {
entrada.close(); // Siempre queda cerrado
} catch ( Exception e ) {
}
System.out.println( "Fichero cerrado." );
}
}
}
class Excepciones {
// Para leer un fichero
FileInputStream entrada = null;
Pgina 83 de 189
Lanzadora lanza = new Lanzadora();

int leo;
try {
entrada = new FileInputStream("fich.txt");
while ( ( leo = entrada.read() ) != -1 )
lanza.lanzaSiNegativo( leo );
System.out.println( "Todo fue bien" );
} catch ( MiExcepcion e ){ // Personalizada
} catch ( IOException e ){ // Estndar
} finally {
entrada.close(); // As el fichero siempre queda cerrado
System.out.println( "Fichero cerrado" );
}
}
}
Este programa lee un fichero (5<+I$&*A#g#), y lee su contenido en forma de nmeros.
Si alguno de los nmeros ledos es negativo, lanza una excepcin 9<!g+$,+<*-,
Adems gestiona la excepcin OF!g+$,#<*-, que es una excepcin de las que Java
incluye y que se lanza si hay algn problema en una operacin de entrada/salida.
Ambas excepciones son gestionadas, imprimiendo su contenido (cadena de error) por
pantalla.
La salida de este programa, suponiendo un nmero negativo sera:
Excepcion: Numero negativo
Fichero cerrado
En el caso de que no hubiera ningn nmero negativo sera:
Todo fue bien
Fichero cerrado
En el caso de que se produjese un error de E/S, al leer el primer nmero, sera:
Excepcion: java.io.IOException
Fichero cerrado
A/9%*?<=GFC;?<AC%
En cualquier caso se recomienda al programador no abusar de este sistema como control
de flujos simples, sino utilizarlo slo en aquellos estados del programa que realmente
creen un problema de ejecucin que pueda ser letal para el programa.
Para ms informacin sobre las excepciones Java, vanse h1UXXRe, 3FF@i y h&PkWjNUSe,
3FF9i2%
Pgina 84 de 189
>*("O<"8<%?'"$(G6"(%'<?#8?#9(C9!9(4*)(
8/9%*G8CAC%@A%'::?:%
:<-P'0$!&&*&: Una clase no satisface la dependencia que tiene respecto a otra.
!"J?'""J<&+/?'&<#H!&&*&: Se detect una herencia circular entre clases.
!"J?'""x*&6'#!&&*&: Una clase cargada no ha sido incompletamente descrita.
!"Y-"/,,*&#$.J?'""[$&"<*-!&&*&: La versin de una clase no es correcta.
!"!g+$,#<*-O-O-<#<'?<C$&!&&*&: Error al iniciar un miembro static.
!"O-+*6,'#<(?$J?'""JI'-0$!&&*&: En una clase, su interfaz no es igual al declarado
!"G("#&'+#9$#I*.!&&*&: Se ha invocado un mtodo abstracto.
!"O??$0'?G++$""!&&*&: La aplicacin intent acceder a algn miembro no visible.
!"O-"#'-#<'#<*-!&&*&: Se intent instanciar una clase abstracta o interfaz.
!"]*M/+Ix<$?.!&&*&: No se encontr determinado atributo.
!"]*M/+I9$#I*.!&&*&: No se encontr determinado mtodo.
!"]*J?'""R$5x*/-.!&&*&: No se encontr una clase cuando se necesitaba.
!"Y-"'#<"5<$.:<-P!&&*&: Se encontr un enlace insatisfecho en un mtodo nativo.
!"[$&<5H!&&*&: Se ha producido un error de verificacin al cargar una clase.
8I&$'.R$'#I: Se ha lanzado en el #I&$'. vctima tras llamar a "#*,2;.
[<&#/'?9'+I<-$!&&*&: La mquina virtual se ha averiado o quedado sin recursos.
!"O-#$&-'?!&&*&: Error interno en tiempo de ejecucin.
!"F/#F59$6*&H!&&*&: El lector ha agotado la memoria.
!"M#'+PF=$&5?*N!&&*&: Desbordamiento de pila. Recursin infinita?.
!"Y-P-*N-!&&*&: Grave error desconocido.
B/9%*G8CAC%@A%'g=A>D;?<%
J?*-$]*#M/,,*&#$.!g+$,#<*-: No se pudo copiar un objeto mediante clone().
O??$0'?G++$""!g+$,#<*-: Algn mtodo invocado es no visible.
O-"#'-#<'#<*-!g+$,#<*-: Se ha intentado instanciar una interfaz o una clase abstracta.
O-#$&&/,#$.!g+$,#<*-: Cuando se invoca a <-#$&&/,#2; sobre un #I&$'. dormido.
]*M/+Ix<$?.!g+$,#<*-: La clase no tiene un atributo con ese nombre.
]*M/+I9$#I*.!g+$,#<*-: La clase no tiene un mtodo con ese nombre.
=/9%*G8CAC%@A%2F<D;HA'g=A>D;?<%
G&<#I6$#<+!g+$,#<*-: Error de clculo (como divisin por cero...).
G&&'HM#*&$!g+$,#<*-: Intento de almacenar un objeto equivocado en un vector.
J?'""J'"#!g+$,#<*-: Intento de conversin invlida.
O??$0'?G&0/6$-#!g+$,#<*-: Se ha pasado un argumento invlido a un mtodo:
Pgina 85 de 189
!"O??$0'?8I&$'.M#'#$!g+$,#<*-: Un thread no estaba en el estado adecuado.

!"]/6($&x*&6'#!g+$,#<*-: Una cadena contenedora de un nmero, no lo contiene.
O??$0'?9*-<#*&M#'#$!g+$,#<*-: Se ha usado N'<#a-*#<5H fuera de cdigo sincronizado.,
O??$0'?M#'#$!g+$,#<*-: Mtodo invocado en un momento inapropiado.
O-.$gF/#F5Q*/-."!g+$,#<*-: Acceso a un vector fuera de sus lmites:
!"G&&'HO-.$gF/#F5Q*/-."!g+$,#<*-: Idem, para una matriz.
!"M#&<-0O-.$gF/#F5Q*/-."!g+$,#<*-: Idem, para una cadena.
]$0'#<=$G&&'HM<C$!g+$,#<*-: Intento de creacin de un vector de tamao negativo.
]/??E*<-#$&!g+$,#<*-: Se ha usado una referencia -/?? para acceder a un campo.
M$+/&<#H!g+$,#<*-: Algo ha sido vedado por el sistema de seguridad.
Y-"/,,*&#$.F,$&'#<*-!g+$,#<*-: Una operacin invocada no se soporta.
Para ms informacin vase la documentacin del JDK que usted vaya a utilizar.
Pgina 86 de 189
((/h/%()1'2S$*'7%
9*(%'@#?>6<<%&'(
Las interfaces Java son expresiones puras de diseo. Se trata de autnticas
conceptualizaciones no implementadas que sirven de gua para definir un determinado
concepto (clase) y lo que debe hacer, pero sin desarrollar un mecanismo de solucin.
Se trata de declarar mtodos abstractos y constantes que posteriormente puedan ser
implementados de diferentes maneras segn las necesidades de un programa.
Por ejemplo una misma interfaz podra ser implementada en una versin de prueba de
manera poco ptima, y ser acelerada convenientemente en la versin definitiva tras
conocer ms a fondo el problema.
;*(>"<:9#9<%&'(
Para declarar una interfaz se utiliza la sentencia <-#$&5'+$, de la misma manera que se
usa la sentencia +?'"":
interface MiInterfaz {
int CONSTANTE = 100;
int metodoAbstracto( int parametro );
}
Se observa en la declaracin que las variables adoptan la declaracin en maysculas,
pues en realidad actuarn como constantes 5<-'?. En ningn caso estas variables
actuarn como variables de instancia.
Por su parte, los mtodos tras su declaracin presentan un punto y coma, en lugar de su
cuerpo entre llaves. Son mtodos abstractos, por tanto, mtodos sin implementacin
<*(%78:"7"'@9<%&'(>"(6'9(%'@"#D9K(
Como ya se ha visto, las interfaces carecen de funcionalidad por no estar implementados
sus mtodos, por lo que se necesita algn mecanismo para dar cuerpo a sus mtodos.
La palabra reservada <6,?$6$-#" utilizada en la declaracin de una clase indica que la
clase implementa la interfaz, es decir, que asume las constantes de la interfaz, y codifica
sus mtodos:
class ImplementaInterfaz implements MiInterfaz{
int multiplicando=CONSTANTE;
int metodoAbstracto( int parametro ){
return ( parametro * multiplicando );
}
}
Pgina 87 de 189
En este ejemplo se observa que han de codificarse todos los mtodos que determina la
interfaz (m$#*.*G("#&'+#*2;), y la validez de las constantes (JF]M8G]8!) que define
la interfaz durante toda la declaracin de la clase.
Una interfaz no puede implementar otra interfaz, aunque s extenderla ($g#$-.")
amplindola.
>*(M"#"'<%9(7R:@%8:"(
Java es un lenguaje que incorpora herencia simple de implementacin pero que puede
aportar herencia mltiple de interfaz. Esto posibilita la herencia mltiple en el diseo de
los programas Java.
Una interfaz puede heredar de ms de una interfaz antecesora.
interface InterfazMultiple extends Interfaz1,Interfaz2{ }
Una clase no puede tener ms que una clase antecesora, pero puede implementar ms de
una interfaz:
class MiClase extends SuPadre implements Interfaz1,Interfaz2{ }
El ejemplo tpico de herencia mltiple es el que se presenta con la herencia en diamante:
O6'0$-%|\%!)$6,?*%.$%I$&$-+<'%6e?#<,?$%
Para poder llevar a cabo un esquema como el anterior en Java es necesario que las
clases A, B y C de la figura sean interfaces, y que la clase D sea una clase (que recibe la
herencia mltiple):
interface A{ }
interface B extends A{ }
interface C extends A{ }
class D implements B,C{ }
"*(<?:%$%?'"$("'(:9(M"#"'<%9(7R:@%8:"(
En una herencia mltiple, los identificadores de algunos mtodos o atributos pueden
coincidir en la clase que hereda, si dos de las interfaces padres tienen algn mtodo o
atributo que coincida en nombre. A esto se le llama +*?<"<>-.
Esto se dar cuando las clases padre (en el ejemplo anterior Q y J) tienen un atributo o
mtodo que se llame igual. Java resuelve el problema estableciendo una serie de reglas.
Para la colisin de nombres de atributos, se obliga a especificar a qu interfaz base
pertenecen al utilizarlos.
Pgina 88 de 189
Para la colisin de nombres en mtodos:

!"Si tienen el mismo nombre y diferentes parmetros: se produce sobrecarga de
mtodos permitiendo que existan varias maneras de llamar al mismo.
!"Si slo cambia el valor devuelto: se da un error de compilacin, indicando que no se
pueden implementar los dos.
!"Si coinciden en su declaracin: se elimina uno de los dos, con lo que slo queda
uno.
D*("'!?:@6#9$(>"(:?$(@%8?$($%78:"$(
Los tipos de datos de Java no forman parte de la jerarqua de objetos. Sin embargo a
veces es necesario crear una representacin como objeto de alguno de los tipos de datos
simples de Java.
La API de Java contiene un conjunto de interfaces especiales para modificar el
comportamiento de los tipos de datos simple. A estas interfaces se las conoce como
$-=*?#/&'"%.$%#<,*%"<6,?$.
Todas ellas son hijas de la clase abstracta ]/6($& y son:
!"R*/(?$: Da soporte al tipo double.
!"x?*'#: Da soporte al tipo float.
!"O-#$0$&: Da soporte a los tipos int, short y byte.
!":*-0: Da soporte al tipo long.
!"JI'&'+#$&: Envoltura del tipo char.
!"Q**?$'-: Envoltorio al tipo boolean.
Para ms informacin sobre as envolturas de tipos simples, consltese h&PkWjNUSe,
3FF9i.
Pgina 89 de 189
((/0i/%4$j"'1'7%
9*(%'@#?>6<<%&'(
Los paquetes son el mecanismo por el que Java permite agrupar clases, interfaces,
excepciones y constantes. De esta forma, se agrupan conjuntos de estructuras de datos y
de clases con algn tipo de relacin en comn.
Con la idea de mantener la reutilizacin y facilidad de uso de los paquetes desarrollados
es conveniente que las clases e interfaces contenidas en los mismos tengan cierta
relacin funcional. De esta manera los desarrolladores ya tendrn una idea de lo que
estn buscando y fcilmente sabrn qu pueden encontrar dentro de un paquete.
;*(<#"9<%&'(>"(6'(89G6"@"(
8/9%&A=G8:8=;E<%
Para declarar un paquete se utiliza la sentencia ,'+P'0$ seguida del nombre del paquete
que estemos creando:
package NombrePaquete;
La estructura que ha de seguir un fichero fuente en Java es:
!"Una nica sentencia de paquete (opcional).
!"Las sentencias de importacin deseadas (opcional).
!"La declaracin de una (y slo una) clase pblica (,/(?<+).
!"Las clases privadas del paquete (opcional).
Por lo tanto la sentencia de declaracin de paquete ha de ser la primera en un archivo
fuente Java.
B/9%)?HA<=G8DF:8%
Para que los nombres de paquete puedan ser fcilmente reutilizados en toda una
compaa o incluso en todo el mundo es conveniente darles nombres nicos. Esto puede
ser una tarea realmente tediosa dentro de una gran empresa, y absolutamente imposible
dentro de la comunidad de Internet.
Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro
de Internet. Se ver un ejemplo para un dominio que se llamase )',*-A6'0<+A+*6D un
nombre apropiado sera +*6A6'0<+A)',*-A,'3/$#$.
=/9%7FB>8IFADAC%
Cada paquete puede tener a su vez paquetes con contenidos parecidos, de forma que un
programador probablemente estar interesado en organizar sus paquetes de forma
jerrquica. Para eso se definen los "/(,'3/$#$"A%
Para crear un subpaquete bastar con almacenar el paquete hijo en un directorio
E'3/$#$aM/(,'3/$#$A%
Pgina 90 de 189
As una clase dentro de un "/(,'3/$#$ como E'3/$#$AM/(,'3/$#$A+?'"$ estar

codificada en el fichero E'3/$#$aM/(,'3/$#$A)'='.
El JDK define una variable de entorno denominada J:GMMEG87 que gestiona las rutas
en las que el JDK busca los subpaquetes. El directorio actual suele estar siempre
incluido en la variable de entorno J:GMMEG87.
Para ms informacin sobre el JDK vase el ZG,B-.<+$%OA%@RSZ de este tutorial.
<*(6$?(>"(6'(89G6"@"(
Con el fin de importar paquetes ya desarrollados se utiliza la sentencia <6,*&# seguida
del nombre de paquete o paquetes a importar.
Se pueden importar todos los elementos de un paquete o slo algunos.
Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter n:
import PaquetePrueba.*;
Tambin existe la posibilidad de que se deseen importar slo algunas de las clases de un
cierto paquete o subpaquete:
import Paquete.Subpaquete1.Subpaquete2.Clase1;
Para acceder a los elementos de un paquete, no es necesario importar explcitamente el
paquete en que aparecen, sino que basta con referenciar el elemento tras una
especificacin completa de la ruta de paquetes y subpaquetes en que se encuentra.
Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento
En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden
incluir en cualquier aplicacin (o ',,?$#) Java que se desarrolle. Estos paquetes son
explicados con ms detalle en el captulo "OOOATAQ<(?<*#$+'"%.$%?'%GEO%.$%@'='" de este
tutorial.
>*(A7;%@?(>"(:?$(":"7"'@?$(>"(6'(89G6"@"(
Al introducir el concepto de paquete, surge la duda de cmo proteger los elementos de
una clase, qu visibilidad presentan respecto al resto de elementos del paquete, respecto
a los de otros paquetes...
Ya en la herencia se vieron los identificadores de visibilidad ,/(?<+ (visible a todas las
clases), ,&<='#$%(no visible ms que para la propia clase), y ,&*#$+#$.%(visible a clases
hijas).
Por defecto se considera los elementos (clases, variables y mtodos) de un mismo
paquete como visibles entre ellos (supliendo las denominadas +?'"$"%'6<0'" de C++).
!RNkPQRnS,T^X,^X^`^SNU, JOSZETG8 USH8DLMSbSREMLO8 JOLTGRTGM8 JVPKSR8
%S,XP,`RM`P,QXPM^, S S S S
%S,kSP,QXPM^,
No S S S
^S,^X,`RMÙ,_Pok^N^,
%S,kSP,QXPM^,jRfP,
No No S S
^S,UNOU,_Pok^N^,
%S,kSP,QXPM^,SU,jRfP,
No No No S
^S,UNOU,_Pok^N^,
8'(?'%TU\%[<"<(<?<.'.%.$-#&*%.$%/-%,'3/$#$%
Pgina 91 de 189
Todas las reglas explicadas en este apartado son igualmente vlidas para las interfaces
Java.
Para ms informacin vase h&PkWjNUSe,3FF9i2,
Pgina 92 de 189
((/00/%,37%1P2'$&7%3%423!2$5$*(+)%5",1(P(,3%
9*(%'@#?>6<<%&'(
Durante la ejecucin de los programas existen muchas operaciones que precisan de una
espera; en busca de una interaccin con el exterior, dejando pasar el tiempo, esperando a
que otro proceso acabe...
Java permite que estos tiempos desaprovechados sean utilizados por el programador
para realizar determinadas tareas, y as aprovechar el microprocesador durante toda la
ejecucin del programa. Para ello implementa el concepto de #I&$'.", o hilos de control
del programa.
Mediante el uso de varios #I&$'.", se consigue ejecutar varios procesos en paralelo, de
forma que cuando uno de ellos est esperando algn evento, permita que el
microprocesador ejecute alguno de los otros #I&$'." en espera. Cuando el evento que el
primer #I&$'. esperaba sucede, de nuevo se intercambian los #I&$'." para que el primer
#I&$'. contine su ejecucin.
Todo esto viene a suplir a la tcnica de exclusin mutua denominada /#<?<C'+<>-% .$
"$645*&*", extendida entre los programadores de C en UNIX.
;*(6@%:%K9<%&'(>"(@M#"9>(
Para crear un #I&$'., se ha de implementar una clase, extendiendo la clase base
d/--'(?$, y crear un objeto de la clase 8I&$'.. Este objeto representar un nuevo hilo
de control, que ser accionado cuando invoquemos al mtodo "#' del #I&$'.. En ese
momento este hilo se activar, ejecutando (si el planificador de hilos considera que es el
momento), el mtodo &/-2; de la clase en que todo esto suceda.
Por ejemplo, el siguiente programa utiliza dos hilos, el hilo general 6'<-, y el hilo
#IR$6* que creamos\
import java.io.*;
import java.net.*;
class ThreadDemo implements Runnable {
ThreadDemo() {
Thread thDemo = new Thread( this, "ThDemo" );
thDemo.start();
};
public void run() {
try {
Thread.sleep(3000);
} catch( InterruptedException e ) { };
System.out.println("Saliendo del hilo hijo");
};
public static void main( String args[] ){
Pgina 93 de 189
new ThreadDemo();
try {
for ( int i = 5 ; i >0 ; i-- ) {
System.out.println(" Seg: " + i );
Thread.sleep(1000);
}
} catch( InterruptedException e ) { };
System.out.println("Saliendo del main");
};
};
Ambos hilos esperan utilizando el mtodo "?$$,2; de la clase 8I&$'.; #IR$6* tres
segundos, y 6'<- cinco segundos. Java utilizar los tres segundos de #IR$6* para ir
esperando los tres primeros segundos del hilo 6'<-.
Por lo tanto la salida por pantalla al ejecutar el programa es:
prompt> java ThreadDemo
Seg: 5
Seg: 4
Seg: 3
Saliendo del hilo hijo
Seg: 2
Seg: 1
Saliendo del hilo main
<*($%'<#?'%K9<%&'(>"(@M#"9>$(
Durante la ejecucin de un programa, muchas veces varios procesos han de realizar
tareas de una forma sincronizada, actuando en un determinado orden. Para ello en Java
se utilizan la palabra reservada "H-+&*-<C$., en la declaracin de los procesos con este
tipo de caractersticas.
Los procesos declarados como "H-+&*-<C$. mediante la utilizacin de excepciones, y de
las funciones N'<#2; y -*#<5<H2;, respectivamente esperarn a que otro proceso acabe
antes de continuar su ejecucin.
A continuacin se va a ir viendo cmo implementar el clsico problema de exclusin
mutua conocido como $?% ,&*(?$6'% .$?% ,&*./+#*&a+*-"/6<.*&, en el que dos procesos
han de acceder a una cola comn, en la que el proceso ,&*./+#*& inserta elementos en la
pila, y el proceso +*-"/6<.*& ha de ir consumiendo los elementos en la pila, cada vez
que sean insertados:
class ColaSincronizada {
int n;
boolean bandera = false;
synchronized int obten() {
Pgina 94 de 189
if ( !bandera )
try wait(); catch( InterruptedException e );
System.out.println( "Obtenido: " + n );
bandera = false;
notify();
return n;
}
synchronized void coloca( int paramN ) {
if ( bandera )
try wait(); catch( InterruptedException e );
n = paramN;
bandera =true;
System.out.println( "Colocado: " + n );
notify();
}
}
class Productor implements Runnable {

ColaSincronizada colaProductor;
Productor( ColaSincronizada paramCola ) {
colaProductor = paramCola;
new Thread( this, "Producer" ).start();
}
public void run() {
int i = 0;
while ( true ) // Bucle infinito
colaProductor.coloca( i++ );
}
}
class Consumidor implements Runnable {

ColaSincronizada colaConsumidor;
Consumidor( ColaSincronizada paramCola ) {
colaConsumidor = paramCola;
new Thread( this, "Consumidor" ).start();
}
public void run() {
Pgina 95 de 189
while ( true ) // Bucle infinito

colaConsumidor.obten( );
}
}
public static void main( String args[] ) {

ColaSincronizada colaLocal = new ColaSincronizada();
new Productor( colaLocal );
new Consumidor( colaLocal );
}
La salida del programa ser:
Colocado: 1
Obtenido: 1
Colocado: 2
Obtenido: 2
Colocado: 3
Obtenido: 3
. . .
>*(L(76<M?(7A$(
La utilizacin de programacin concurrente y de los hilos de Java con toda su potencia
va mucho ms all de los objetivos de este tutorial. Lo que aqu se ha visto es
simplemente una introduccin para que el lector sea consciente de cul es la potencia de
este tipo de programacin.
La utilizacin de los #I&$'." se extiende con mtodos para que el programador controle
la alternancia de los hilos. Estos mtodos son:
!""/",$-.2;v Bloquea temporalmente la ejecucin de un hilo.
!"&$"/6$2;v%Activa un hilo bloqueado.
!""#*,2;v%Finaliza la ejecucin de un hilo.
Para ms informacin sobre los #I&$'." vase h1UXXRe,3FF@i.
Pgina 96 de 189
((/0O%*2'$*(+)%&'%423!2$5$7%-$.$%
9*(%'@#?>6<<%&'(
Una vez entendida la sintaxis y funcionalidad de Java, hay que explicar cmo combinar
todos los elementos introducidos para desarrollar programas Java.
La programacin Java va mucho ms all de lo que la definicin del lenguaje permite.
Son muchos los tipos de aplicaciones que se pueden crear con Java, as como su
utilizacin, especialmente gracias a la versatilidad de las bibliotecas de clases que
completan el Java bsico.
;*(@%8?$(>"(98:%<9<%?'"$(
8/9%(<D:?@F==;E<%
Con Java se pueden construir varios tipos de programas, cada uno con unas
caractersticas especficas, y que se ejecutan de distintas maneras.
A continuacin se explican los principales tipos: Aplicaciones, G,,?$#", @'='Q$'-",
@'='M+&<,# y M$&=?$#".
Para ms informacin vase h7UOWPSe,3FFFi y h1UXXRe,3FF@i.
B/9%$>G;=8=;?<AC%
Son los programas bsicos de Java. Se ejecutan en una determinada mquina, por el
Java Runtime Enviroment (JRE).
Para crear una aplicacin hace falta incluir en alguna de las clases que compongan la
aplicacin un mtodo denominado:
!",/(?<+%"#'#<+%=*<.%6'<-2M#&<-0oq%";t%u%
Hay que indicar al JRE (comando )'=' del JDK) el nombre de la clase (previamente
compilada a A+?'""), que queremos ejecutar. Cuando se ejecute el programa lo que
realmente se ejecutar ser el mtodo 6'<-2; de la clase indicada al JRE.
Las aplicaciones soportan mtodos nativos, o sea, incluir en el programa cdigo escrito
en otros lenguajes de programacin, as como violar algunas de las directrices de
seguridad.
En cada fichero Java (A)'=') slo debe haber una clase pblica.
=/9%$>>GADC%
Las ',,?$#" o miniaplicaciones Java, son programas que deben incluirse en pginas Web
para ser observadas por otra aplicacin (visualizador de applets o navegador Web), y
que se ejecutan cuando el usuario intenta visualizarlas (cargando la pgina Web).
Las ',,?$#" deben incluir un mtodo de nombre "#', que ser ejecutado cuando el
navegador intente mostrar por pantalla la ',,?$#.
Estas aplicaciones, son seguras (cumplen la especificacin Java), y al ser distribuibles
por Internet no permiten incluir mtodos nativos Java.
Pgina 97 de 189
@/9%-8T86A8<C%
Los @'='Q$'-" son componentes grficos de Java, que se pueden incorporar a otros
componentes grficos. Se incluyen en la API de Java (paquete )'='A($'-").
Existe una herramienta de Sun, denominada BDK (Beans Developer Kit), que es un
conjunto de herramientas para desarrollar @'='Q$'-". El BDK, es el @RS para el
desarrollo de @'='Q$'-".
Existen ya multitud de bibliotecas con @'='Q$'-", para que puedan ser utilizados.
A/9%-8T87=:;>D%
@'='M+&<,# es un subconjunto del lenguaje Java que puede codificarse directamente
sobre cualquier documento HTML; el cdigo fuente de @'='M+&<,# forma parte del
propio documento HTML.
@'='M+&<,# tiene menos potencia que Java, a cambio de ms control sobre el navegador
Web que lo ejecute.
Se utiliza sobre todo para dar animacin e interactividad a pginas Web.
@'='M+&<,# posee una habilidad limitada para interactuar con applets Java, pero Java no
puede interactuar de ningn modo con @'='M+&<,#.
L/9%7A:TGADC%
Son mdulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas
CGI (Common Gateway Interface) a la hora de dotar de interactividad a las pginas
Web.
Estas aplicaciones se ejecutan como aplicaciones servidoras en Internet, y normalmente
incluyen bucles infinitos a la espera de peticiones a las que atender.
Los M$&=?$#" no tienen entorno grfico, ya que se ejecutan en el servidor. Reciben datos
y su respuesta ms habitual suele ser cdigo HTML (pginas Web).
<*(#"<?7"'>9<%?'"$(>"(8#?B#979<%&'(
8/9%(<D:?@F==;E<%
Es un hecho innegable que cada programador tiene su forma personal de programar, sus
preferencias de indentacin...
En cualquier caso, desde este tutorial se proponen una serie de pautas que ayudarn a
que sus programas sean ms legibles, mantenibles y eficientes:
B/9%4:?>FACD8C%@A%ACD;G?%@A%G?C%LFA<DAC%
Utilice nombres significativos para los identificadores, y procure respetar la siguiente
notacin de maysculas y minsculas:
!"Las clases:%J?'"$%*%9<J?'"$A%
!"Las interfaces: O-#$&5'C%*%9<O-#$&5'CA%
!"Los mtodos: 6$#*.*2;%*%6$#*.*:'&0*2;A%
!"Los mtodos de acceso:%0$#G#&<(/#*2;D%"$#G#&<(/#*2;A%
Pgina 98 de 189
!"Las variables:%'?#/&'%*%'?#/&'9$.<'A%
!"Las constantes: JF]M8G8!%*%JF]M8G]8!f:GdXGA%
!"Los paquetes: )'='A,'3/$#$A"/(,'3/$#$A%
Cuide los nombres de sus clases y paquetes para que no coincidan con otros ya
existentes, mediante la utilizacin de prefijos identificativos de usted o de su empresa.
Adems se enuncian las siguientes recomendaciones:
!"No utilice lneas de ms de 80 caracteres, en su lugar divida la lnea en varias.
!"Escriba una nica operacin en cada lnea.
!"Inserte lneas en blanco en sus fuentes cuando mejoren la legibilidad.
!"No deje de incluir comentarios en sus clases, describiendo su funcionalidad. Si
utiliza la notacin estandarizada ann%na, adems podr recolectarles automticamente
con )'='.*+.
=/9%4:?>FACD8C%@A%@;CAk?%@A%G?C%>:?V:8H8C%
Para cada clase:
!"Cree un constructor por defecto.
!"Los atributos de las clases no deben de ser ,/(?<+.
!"Declare mtodos de acceso a los atributos.
!"Cree mtodos de acceso a los atributos; 0$#G#&<(/#*2;%y "$#G#&<(/#*2-/$=*['?*&;. Si
no estn implementados declrelos como private.
!"Cree un mtodo 6'<-2; que valga para probar la clase.
!"Sobre 5<-'?<C$2;: Cree una bandera de finalizacin en cada clase, y en los 5<-'?<C$2;,
si la bandera no ha sido establecida, lance una clase derivada de d/-#<6$!g+$,#<*-A%
No olvide llamar a "/,$&A5<-'?<C$2;A%
Adems se enuncian las siguientes recomendaciones:
!"Cree paquetes para agrupar clases relacionadas. Utilizar la herencia para simplificar
las clases con caractersticas comunes.
!"Utilice interfaces antes que clases abstractas.
!"Utilice composicin cuando sea apropiado, no abuse de la herencia.
Para ms informacin vase h8UjSMUSe,3FF9i y h%QY^Xe,3FF@i2,
>*(B#9'>"$(8#?B#979$(
Aunque con todo lo que se ha visto podramos aventurarnos a desarrollar programas
Java un tanto complejos (con varias clases, paquetes, #I&$'."...), lo cierto es que el
desarrollo de programas complejos es materia de la Ingeniera del Software.
Desde este tutorial se apuesta por la Ingeniera del Software para el desarrollo de
software de calidad, en un tiempo mnimo y con unos costes mnimos. La Ingeniera del
Software hace posible que un programa sea mantenible y eficiente, y resuelva un
problema de una forma adecuada.
Pgina 99 de 189
Desde aqu se recomienda el uso de una metodologa orientada a objeto para el

desarrollo del software. Por ejemplo OMT de h.P`LPkWj, ^N, PX2e, 3FFDi, se ajusta
bastante bien al desarrollo de Java, adems de ser la metodologa ms extendida
actualmente.
Todos los diagramas que se realicen siguiendo una metodologa software deben de
realizarse utilizando una notacin unificada. El lenguaje de modelado UML h.PNRUSPXe,
3FF@i, se presenta como estndar de modelado.
Pgina 100 de 189

@"79(%%%E(;%;:%?@"<9$(>"(:9(98%(>"(C9!9(
Pgina 101 de 189

(((/0/%6(6,(31'*$7%&'%,$%$4(%&'%-$.$%
9*(%'@#?>6<<%&'(
Con cada una de las versiones que Sun lanza del JDK, se acompaa de una serie de
bibliotecas con clases estndar que valen como referencia para todos los programadores
en Java.
Estas clases se pueden incluir en los programas Java, sin temor a fallos de portabilidad.
Adems, estn bien documentadas (mediante pginas Web), y organizadas en paquetes
y en un gran rbol de herencia.
A este conjunto de paquetes (o bibliotecas) se le conoce como la API de Java
(Application Programming Interface).
En este apartado explicaremos los paquetes bsicos de la API de Java, aunque algunos
de ellos tienen subpaquetes.
;*(89G6"@"$(>"(6@%:%>9>"$(
!")'='A?'-0: Fundamental para el lenguaje. Incluye clases como M#&<-0 o M#&<-0Q/55$&,
que se tratan ms en detenimiento en el captulo ZOOOA_%J'.$-'"Z de este tutorial.
!")'='A<*: Para la entrada y salida a travs de flujos de datos, y ficheros del sistema. Se
estudia en el captulo ZOOOA`%!-#&'.'aM'?<.'Z de este tutorial.
!")'='A/#<?: Contiene colecciones de datos y clases, el modelo de eventos, facilidades
horarias, generacin aleatoria de nmeros, y otras clases de utilidad.
!")'='A6'#I: Clases para realizar aritmtica con la precisin que se desee.
!")'='A#$g#: Clases e interfaces para manejo de texto, fechas, nmeros y mensajes de
una manera independiente a los lenguajes naturales.
!")'='A"$+/&<#H: Clases e interfaces para seguridad en Java: Encriptacin RSA...
<*(89G6"@"$(89#9(":(>"$9##?::?(B#AD%<?(
!")'='A',,?$#: Para crear applets y clases que las applets utilizan para comunicarse con
su contexto. Se estudia en el captulo Z[OA%G,,?$#"Z de este tutorial.
!")'='A'N#: Para crear interfaces con el usuario, y para dibujar imgenes y grficos. Se
estudia en el captulo ZO[A%Q<(?<*#$+'"%0&45<+'"Z de este tutorial.
!")'='gA"N<-0: Conjunto de componentes grficos que funcionan igual en todas las
plataformas que Java soporta. Se estudia en el captulo ZO[A%Q<(?<*#$+'"%0&45<+'"Z de
este tutorial.
!")'='gA'++$"<(<?<#H: Da soporte a clases de accesibilidad para personas discapacitadas.
!")'='A($'-": Para el desarrollo de @'='Q$'-".
Pgina 102 de 189

>*(89G6"@"$(89#9(":(>"$9##?::?("'(#">(
!")'='A-$#: Clases para aplicaciones de red. Se estudia en el captulo Z[A% @'='% $%
O-#$&-$#Z de este tutorial.
!")'='A"3?: Paquete que contiene el JDBC, para conexin de programas Java con
Bases de datos.
!")'='A&6<: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e
incluso enviar objetos como parmetros de un objeto a otro.
!"*&0A*60AJFdQG: Facilita la posibilidad de utilizar OMG CORBA, para la conexin
entre objetos distribuidos, aunque est codificados en distintos lenguajes.
!"*&0A*6(AJ*"]'6<-0 : Da servicio al IDL de Java, similar al RMI pero en CORBA
"*(89#9(7A$(%'D?#79<%&'(
Para ms informacin consulte con la documentacin del JDK que vaya a utilizar o la
direccin www.sun.com.
Esta informacin ha sido extrada de la documentacin de la API de Java
correspondiente al JDK 1.2 h!kSe,3FFDi.
Pgina 103 de 189

(((/O/%*$&')$7%
9*(%'@#?>6<<%&'(
8/9%(<D:?@F==;E<%8%G8C%=G8CAC%7D:;<V%U%7D:;<V6FLLA:%
En Java las cadenas se tratan de forma diferente a C/C++, donde las cadenas son
matrices de caracteres en las que se indica el final de la cadena con un carcter de valor
\0.
En Java las cadenas son objetos de las clases predefinida M#&<-0 o M#&<-0Q/55$&, que
estn incluidas en el paquete )'='A?'-0AnA%
Siempre que aparecen conjuntos de caracteres entre comillas dobles, el compilador de
Java crea automticamente un objeto M#&<-0.
Si slo existieran cadenas de slo lectura (M#&<-0), durante una serie de manipulaciones
sobre un objeto M#&<-0 habra que crear un nuevo objeto para cada uno de los resultados
intermedios.
El compilador es ms eficiente y usa un objeto M#&<-0Q/55$& para construir cadenas a
partir de las expresiones, creando el M#&<-0 final slo cuando es necesario. Los objetos
M#&<-0Q/55$& se pueden modificar, de forma que no son necesarios nuevos objetos para
albergar los resultados intermedios.
Los caracteres de las cadenas tienen un ndice que indica su posicin. El primer carcter
de una cadena tiene el ndice 0, el segundo el 1, el tercero el 2 y as sucesivamente. Esto
puede sonar familiar a los programadores de C/C++, pero resultar chocante para
aquellos programadores que provengan de otros lenguajes.
B/9%3>A:8=;?<AC%BRC;=8Cl%=?HF<AC%8%7D:;<V%U%7D:;<V6FLLA:%
Existen una serie de mtodos que son comunes a ambas clases.
Los siguientes mtodos de acceso a las cadenas:
!"<-#%?$-0#I2;; Devuelve el nmero de caracteres de la cadena.
!"+I'&%+I'&G#2%<-#%<%;v Devuelve el carcter correspondiente de ndice <.
Los siguientes mtodos para crear cadenas derivadas:
!"M#&<-0%#*M#&<-02;v Devuelve una copia del objeto como una M#&<-0A%
!"M#&<-0% "/("#&<-02% <-#% <D% <-#% 5<-% ;v Devuelve una instancia de la clase M#&<-0 que
contenga una subcadena desde la posicin <-<, hasta la 5<- (si no se indica hasta el
final de la cadena), del objeto cadena que invoque el mtodo.%
Y el mtodo para transformar la cadena en un vector de caracteres:%
!"=*<.%0$#JI'&"2<-#%<-<D%<-#%5<-D%+I'&oq%.$"#<-*D%<-#%.$"#O-<;v Convierte la cadena en un
vector de caracteres .$"#<-*.
Pgina 104 de 189

;*(7H@?>?$(>"(:9(<:9$"($@#%'B%
8/9%*?<CD:F=D?:AC%
La clase M#&<-0 proporciona cadenas de slo lectura y soporta operaciones con ellas. Se
pueden crear cadenas implcitamente mediante una cadena entrecomillada o usando K
Kj con dos objetos M#&<-0.
Tambin se pueden crear objetos M#&<-0 explcitamente con el mecanismo -$N.
La clase M#&<-0 soporta multitud de constructores.
!"M#&<-02;v Constructor por defecto. El nuevo M#&<-0 toma el valor ZZ.
!"M#&<-02%M#&<-0%"%;v Crea un nuevo M#&<-0, copiando el que recibe por parmetro.
!"M#&<-02%M#&<-0Q/55$&%"%;v Crea un M#&<-0 con el valor que en ese momento tenga el
M#&<-0Q/55$& que recibe como parmetro.
!"M#&<-02%+I'&oq%=%;v El nuevo M#&<-0 toma el valor de los caracteres que tiene el vector
de caracteres recibido por parmetro.
!"M#&<-02%(H#$oq%=%;v El nuevo M#&<-0 toma el valor de los caracteres que corresponden
a los valores del vector de bytes en el sistema de caracteres de la ordenador en que
se ejecute.
B/9%6mCIFA@8%A<%=8@A<8C%7D:;<V%
Adems presenta los siguientes mtodos para buscar caracteres o subcadenas en la
cadena, y devuelven el ndice que han encontrado o el valor WT si la bsqueda no ha sido
satisfactoria:
!"<-#% <-.$gF52% +I'&% +ID% <-#% "#'&#% ;: Devuelve el ndice correspondiente a la primera
aparicin del carcter +I en la cadena, comenzando a buscar desde el carcter "#'&#
(si no se especifica se busca desde el principio).
!"<-#% <-.$gF52% M#&<-0% "#&% ;: Devuelve el ndice correspondiente al carcter en que
empieza la primera aparicin de la subcadena "#&A
!"<-#%?'"#O-.$gF52%+I'&%+ID%<-#%"#'&#%;: Devuelve el ndice correspondiente a la ltima
aparicin del carcter +I en la cadena, comenzando a buscar desde el carcter "#'&#
(si no se especifica se busca desde el final).
!"<-#%?'"#O-.$gF52%M#&<-0%"#&%;: Devuelve el ndice correspondiente al carcter en que
empieza la ltima aparicin de la subcadena "#&A
=/9%*?H>8:8=;?<AC%@A%=8@A<8C%7D:;<V%
Java no trabaja con el cdigo GMJOO habitual, sino con el cdigo avanzado Y-<+*.$A
El cdigo Y-<+*.$ (cdigo universal) se caracteriza, sobre todo, por el uso de dos bytes
por carcter. Esto permite aumentar los caracteres hasta 65000, y as se pueden
representar los caracteres que componen las lenguas, vivas o muertas, ms importantes
del mundo.
Hay que tener en cuenta que si nos salimos del rango 0-255 que coincide con el cdigo
GMJOO puede que las comparaciones no sean las esperadas.
Pgina 105 de 189

Las funciones de comparacin son las siguientes:

!"(**?$'-%$3/'?"2%F()$+#%*%;v Devuelve #&/$ si se le pasa una referencia a un objeto
M#&<-0 con los mismos caracteres, o 5'?"$ si no.
!"(**?$'-% $3/'?"O0-*&$J'"$2% M#&<-0% "% ;v Compara cadenas ignorando las diferencias
de ortografa maysculas/minsculas.
!"(**?$'-%&$0<*-9'#+I$"2%(**?$'-%(D%<-#%*D%M#&<-0%"%D%<-#%<D%<-#%-%;v Compara parte de
dos cadenas, carcter a carcter.
!"(**?$'-%"#'&#"L<#I2%M#&<-0%"D%<-#%i%;; Comprueba si la cadena%tiene el prefijo "%desde
<A
!"(**?$'-%$-."L<#I2%M#&<-0%"%;v Comprueba si la cadena termina con el sufijo ".
!"<-#% +*6,'&$8*2% F()$+#% *% ;v Devuelve un entero que es menor, igual o mayor que
cero cuando la cadena sobre la que se le invoca es menor, igual o mayor que la otra.
Si el parmetro es un M#&<-0, la comparacin es lxica.
!"<-#% +*6,'&$8*O0-*&'J'"$2% M#&<-0% "% ;v Compara lexicogrficamente, ignorando las
diferencias de ortografa maysculas/minsculas.
@/9%*8@A<8C%7D:;<V%@A:;T8@8C%
En Java se devuelven nuevas cadenas cada vez que se invoca a un mtodo que crea una
cadena diferente porque las cadenas M#&<-0 son de slo lectura:
!"M#&<-0% &$,?'+$2% +I'&% *?.JI'&D% +I'&% -$NJI'&% ;v Devuelve una nueva cadena con
todos los caracteres *?.JI'& sustituidos por el carcter -$NJI'&.
!"M#&<-0% #*:*N$&J'"$2;v Devuelve una nueva cadena con los caracteres en
minsculas, o si se especifica parmetro, siguiendo sus reglas.
!"M#&<-0% #*Y,$&J'"$2% :*+'?$% ?% ;v Devuelve una nueva cadena con los caracteres en
maysculas, o si se especifica parmetro, siguiendo sus reglas.
!""#'#<+%M#&<-0%#&<62;: Devuelve una nueva cadena del que se ha eliminado los espacios
en blanco por el principio y por el final.
!""#'#<+%M#&<-0%+*,H['?/$F52%+I'&oq%=D%<-#%<-<D%<-#%5<-%;v Devuelve una cadena igual que
la contenida en el vector =, entre los lmites <-< y 5<-%(si no se especifican copia todo
el vector).
!""#'#<+%M#&<-0%+*-+'#2%M#&<-0%"%;; Concatena la cadena que recibe al final de sta.
A/9%*?<TA:C;?<AC%A<D:A%=8@A<8C%7D:;<V%U%D;>?C%C;H>GAC%-8T8%
Para convertir una variable de un tipo de datos simple (+I'&, (**?$'-D%<-#D%?*-0D%5?*'#D%
.*/(?$; en una cadena (M#&<-0), bastar con invocar al mtodo ='?/$F52;% del objeto
M#&<-0 correspondiente:
!""#'#<+%M#&<-0%='?/$F52%#<,*%;v El parmetro #<,* soporta un carcter (+I'&) un vector
de caracteres (+I'&oq) o un objeto (F()$+#).
Sin embargo para convertir el valor de una cadena en un tipo de datos simple deberemos
utilizar los siguientes mtodos:
Pgina 106 de 189

,SJL8 #G8'TOSHF8
(**?$'-% -$N%Q**?$'-2M#&<-0;A(**?$'-['?/$2;%
<-#% O-#$0$&AE'&"$O-#2M#&<-0D%<-#%('"$;%
?*-0% :*-0AE'&"$:*-02M#&<-0D%<-#%('"$;%
5?*'#% -$N%x?*'#2M#&<-0;A5?*'#['?/$2;%
.*/(?$% -$N%R*/(?$2M#&<-0;A.*/(?$['?/$2;%
8'(?'%_z\%J*-=$&"<*-$"%.$%+'.$-'"%'%#<,*"%"<6,?$"%
No hay ningn mtodo que convierta los caracteres escapados Java ( \b, \u....% ) en
variables carcter (+I'&;D o a la inversa. Lo que se puede hacer es invocar ='?/$F52;%con
un carcter (+I'&) para obtener una cadena de la clase M#&<-0 que contenga ese carcter.
As mismo no hay formas de crear o decodificar cadenas de nmeros en formatos octal
(z) o hexadecimal(zg).
L/9%*?<TA:C;?<AC%A<D:A%=8@A<8C%7D:;<V%U%TA=D?:AC%
Tambin existen diversos constructores y mtodos de la clase M#&<-0 para tratar con
vectores, tanto de caracteres como de bytes.
En cuanto a los vectores de caracteres existen:
!"El constructor ya citado de M#&<-02%+I'&oq%=%;. Hace copia de los datos, por lo que las
modificaciones posteriores del vector no afectarn a la cadena.
!"+I'&oq%#*JI'&G&&'H2;v Convierte la cadena en un vector de caracteres.
En cuanto a los mtodos para convertir vectores de (H#$ (de 8 bits) en objetos M#&<-0 con
caracteres Y-<+*.$ de 16 bits existen:
!"El constructor ya citado de M#&<-02%(H#$oq%=%;. Hace copias de los datos, por lo que
las modificaciones posteriores del vector no afectarn a la cadena.
!"(H#$oq%0$#QH#$"2%M#&<-0%"%;v Convierte la cadena en un vector de (H#$, atendiendo a la
tabla de caracteres especificada en ", o a la de la mquina si se omite.
<*(7H@?>?$(>"(:9(<:9$"($@#%'B;6DD"#(
8/9%*?<CD:F=D?:AC%
Los constructores contenidos por la clase M#&<-0Q/55$& son:
!"M#&<-0Q/55$&2% <-#% ?<6% ;v Construye una cadena sin caracteres y con una capacidad
inicial de ?<6 caracteres (por defecto 16, si no se especifica otro valor).
!"M#&<-0Q/55$&2%M#&<-0%"%;v Construye una cadena con el valor ".
B/9%5?@;L;=8=;E<%@A%G8%=8@A<8%
Existen tres tipos de modificaciones que se pueden aplicar a la cadena.
Hay mtodos de insercin:
!"M#&<-0Q/55$&%<-"$&#2%<-#%<D%F()$+#%*%;v Desplaza los caracteres de la cadena e inserta la
cadena correspondiente al segundo parmetro (de cualquier tipo).
Pgina 107 de 189

!"M#&<-0Q/55$&% ',,$-.2% F()$+#% *% ;v Inserta al final de la cadena, la cadena

correspondiente al segundo parmetro (de cualquier tipo).
Hay mtodos de substitucin:
!"=*<.% "$#JI'&G#2% <-#% <D% +I'&% #*% ;v Cambia el carcter de la posicin < por #*. Si la
posicin supera la longitud de la cadena, se extiende rellenndose con caracteres
nulos.
!"M#&<-0Q/55$&% &$,?'+$2% <-#% <-<D% <-#% 5<-D% M#&<-0% "% ;v Reemplaza una subcadena de esta
cadena (de <-< a 5<-) por la cadena recibida por parmetro. No se debe confundir con
el mtodo &$,?'+$2; que incluye la clase M#&<-0.%
!"M#&<-0Q/55$&%&$=$&"$2;; Invierte la cadena (de izquierda a derecha).
Y mtodos de borrado:
!"M#&<-0Q/55$&%.$?$#$2%<-#%<-<D%<-#%5<-%;v Borra la subcadena entre el carcter <-< y el 5<-.
!"M#&<-0Q/55$&%.$?$#$JI'&G#2%<-#%<%;v Borra el carcter en la posicin <.
=/9%*8>8=;@8@%@A%G8%=8@A<8%
El buffer de un objeto M#&<-0Q/55$& tiene una +','+<.'. que es la longitud de la cadena
que puede almacenar sin tener que asignar ms espacio. El buffer crece
automticamente a medida que se aaden caracteres, pero resulta ms eficiente
especificar el tamao del buffer de una sola vez:
!"<-#%+','+<#H2;v Devuelve la capacidad actual del buffer.
!"=*<.%$-"/&$J','+<#H2%<-#%<%;v. Garantiza que la capacidad del buffer es al menos <.
!"=*<.%"$#:$-0#I2%<-#%<%;v Establece la longitud de esta cadena a <.%
@/9%'gD:8==;E<%@A%@8D?C%
Para obtener un objeto M#&<-0 a partir de un objeto M#&<-0Q/55$&, debe invocarse el
mtodo #*M#&<-02;, comn a ambas clases.
Se debe tener en cuenta que no hay mtodos M#&<-0Q/55$& para eliminar una parte de un
buffer. Para resolver este problema, debe crearse un vector de caracteres a partir del
buffer, y construir un nuevo buffer con el contenido restante. Para esto se usa el mtodo
0$#JI'&"2;, comn con la clase M#&<-0.
>*("C"78:?$(>"(6$?(>"(<9>"'9$(
8/9%'KAH>G?%@A%*8@A<8%S;K8%Y@A%G8%=G8CA%7D:;<V9%
En el siguiente ejemplo se muestra la utilizacin de los principales mtodos de la clase
M#&<-0:
public static void main( String s[] ){
String cad = new String("Cadena Fija");
System.out.println("Ejemplo de String: "+cad+"");
//Mtodos comunes a StringBuffer
System.out.println("Su longitud es: "+cad.length());
Pgina 108 de 189

System.out.println("Su tercer caracter es: "+cad.charAt(3));

System.out.print("Su subcadena del 3 al 6 es:");
System.out.println( cad.substring(2,6) );
char[] vectorcad = cad.toCharArray();
System.out.println("Creado un vector, de elemento 3: ");
System.out.print( vectorcad[2] );
// Bsqueda en cadenas
String subcad=new String("ena");
System.out.print("La subcadena '"+subcad+"'");
System.out.print(" aparece en la posicion: ");
System.out.println( cad.indexOf(subcad) );
// Comparaciones
String cadcomp=new String("CADENA Fija");
System.out.print("La cadena '"+cadcomp+"'");
if ( cad.compareTo(cadcomp) == 0 )
System.out.println(" ES igual 'Sensitive'");
else
System.out.println(" NO es igual 'Sensitive'");
System.out.print("La cadena '"+cadcomp+"'");
if ( cad.equalsIgnoreCase(cadcomp) )
System.out.println(" ES igual 'Insensitive'");
else
System.out.println(" NO = 'Insensitive'");
// Derivacin
System.out.print("Cadena derivada en minusculas: ");
System.out.println( cad.toLowerCase() );
}
Lo que muestra por pantalla:
Ejemplo de String: 'Cadena Fija'
Su longitud es: 11
Su tercer caracter es: e
Su subcadena del 3 al 6 es: dena
Creado un vector, de elemento 3: d
La subcadena 'ena' aparece en la posicion: 3
La cadena 'CADENA Fija' NO es igual 'Sensitive'
La cadena 'CADENA Fija' ES igual 'Insensitive'
Cadena derivada en minusculas: cadena fija
Pgina 109 de 189

B/9%'KAH>G?%@A%*8@A<8%.8:;8BGA%Y@A%G8%=G8CA%7D:;<V6FLLA:9%
En el siguiente ejemplo se muestra la utilizacin de los principales mtodos de la clase
M#&<-0Q/55$&:
public static void main( String s[] ){
StringBuffer cad = new StringBuffer("Cadena Variable");
System.out.println("Ejemplo de StringBuffer: "+cad+"");
// Modificacin de la cadena
cad.delete( 0, 6 );
System.out.println("Borrados 6 primeros caracteres: "+cad);
cad.replace( cad.length()-3, cad.length(), "da" );
System.out.println("Sutituidos ultimos caracteres: "+cad);
cad.append(" Cadena");
System.out.println("Apendizada con 'Cadena': "+cad);
// Gestin de su capacidad
System.out.println("Tiene capacidad de: "+cad.capacity());
cad.ensureCapacity( 32 );
System.out.println("Capacidad sobre 32:"+cad.capacity());
System.out.println("");
}
Lo que muestra por pantalla:
Ejemplo de StringBuffer: 'Cadena Variable'
Borrados 6 primeros caracteres: Variable
Sutituidos ultimos caracteres: Variada
Apendizada con 'Cadena': Variada Cadena
Tiene capacidad de: 31
Capacidad sobre 32: 64
Pgina 110 de 189

(((/Q/%')12$&$M7$,(&$%
9*(%'@#?>6<<%&'
Normalmente, cuando se codifica un programa, se hace con la intencin de que ese
programa pueda interactuar con los usuarios del mismo, es decir, que el usuario pueda
pedirle que realice cosas y pueda suministrarle datos con los que se quiere que haga
algo. Una vez introducidos los datos y las rdenes, se espera que el programa manipule
de alguna forma esos datos para proporcionarnos una respuesta a lo solicitado.
Adems, en muchas ocasiones interesa que el programa guarde los datos que se le han
introducido, de forma que si el programa termina los datos no se pierdan y puedan ser
recuperados en una sesin posterior. La forma ms normal de hacer esto es mediante la
utilizacin de ficheros que se guardarn en un dispositivo de memoria no voltil
(normalmente un disco).
A todas estas operaciones, que constituyen un flujo de informacin del programa con el
exterior, se les conoce como !-#&'.'aM'?<.' (!aM;.
Existen dos tipos de E/S; la !aM%$"#4-.'& que se realiza con el terminal del usuario y la
!aM%'%#&'=B"%.$%5<+I$&*, en la que se trabaja con ficheros de disco.
Todas las operaciones de E/S en Java vienen proporcionadas por el paquete estndar de
la API de Java denominado )'='A<* que incorpora interfaces, clases y excepciones para
acceder a todo tipo de ficheros. En este tutorial slo se van a dar algunas pinceladas de
la potencia de este paquete.
;*("'@#9>9S$9:%>9("$@A'>9#(
Aqu slo trataremos la entrada/salida que se comunica con el usuario a travs de la
pantalla o de la ventana del terminal.
Si creamos una ',,?$# no se utilizarn normalmente estas funciones, ya que su resultado
se mostrar en la ventana del terminal y no en la ventana de la ',,?$#. La ventana de la
',,?$#%es una ventana grfica y para poder realizar una entrada o salida a travs de ella
ser necesario utilizar el AWT.
El acceso a la entrada y salida estndar es controlado por tres objetos que se crean
automticamente al iniciar la aplicacin: MH"#$6A<-, MH"#$6A*/# y MH"#$6A$&&%
8/9%7UCDAH/;<%
Este objeto implementa la entrada estndar (normalmente el teclado). Los mtodos que
nos proporciona para controlar la entrada son:
!"&$'.2;\ Devuelve el carcter que se ha introducido por el teclado leyndolo del
buffer de entrada y lo elimina del buffer para que en la siguiente lectura sea ledo el
siguiente carcter. Si no se ha introducido ningn carcter por el teclado devuelve el
valor -1.%
!""P<,2-;\ Ignora los - caracteres siguientes de la entrada.
Pgina 111 de 189

B/9%7UCDAH/?FD%
Este objeto implementa la salida estndar. Los mtodos que nos proporciona para
controlar la salida son:
!",&<-#2';\ Imprime ' en la salida, donde ' puede ser cualquier tipo bsico Java ya que
Java hace su conversin automtica a cadena. %
!",&<-#?-2';\ Es idntico a ,&<-#2'; salvo que con ,&<-#?-2; se imprime un salto de lnea
al final de la impresin de '.
=/9%7UCDAH/A::%
Este objeto implementa la salida en caso de error. Normalmente esta salida es la
pantalla o la ventana del terminal como con MH"#$6A*/#, pero puede ser interesante
redirigirlo, por ejemplo hacia un fichero, para diferenciar claramente ambos tipos de
salidas.
Las funciones que ofrece este objeto son idnticas a las proporcionadas por MH"#$6A*/#.
@/%'KAH>G?%
A continuacin vemos un ejemplo del uso de estas funciones que acepta texto hasta que
se pulsa el retorno de carro e informa del nmero de caracteres introducidos.
import java.io.*;
class CuentaCaracteres {
public static void main(String args[]) throws IOException {
int contador=0;
while(System.in.read()!=\n)
contador++;
System.out.println(); // Retorno de carro "gratuito"
System.out.println("Tecleados "+contador+" caracteres.");
}
}
<*("'@#9>9S$9:%>9(8?#(D%<M"#?(
8/9%1;>?C%@A%L;=[A:?C%
En Java es posible utilizar dos tipos de ficheros (de texto o binarios) y dos tipos de
acceso a los ficheros (secuencial o aleatorio).
Los ficheros de texto estn compuestos de caracteres legibles, mientras que los binarios
pueden almacenar cualquier tipo de datos (<-#, 5?*'#, (**?$'-DAAA).
Una lectura secuencial implica tener que acceder a un elemento antes de acceder al
siguiente, es decir, de una manera lineal (sin saltos). Sin embargo los ficheros de acceso
aleatorio permiten acceder a sus datos de una forma aleatoria, esto es indicando una
determinada posicin desde la que leer/escribir.
Pgina 112 de 189

B/9%*G8CAC%8%ACDF@;8:%
En el paquete )'='A<* existen varias clases de las cuales podemos crear instancias de
clases para tratar todo tipo de ficheros.
En este tutorial slo vamos a trata las tres principales:
!"x<?$F/#,/#M#&$'6: Fichero de salida de texto. Representa ficheros de texto para
escritura a los que se accede de forma secuencial.
!"x<?$O-,/#M#&$'6: Fichero de entrada de texto. Representa ficheros de texto de slo
lectura a los que se accede de forma secuencial.
!"d'-.*6G++$""x<?$: Fichero de entrada o salida binario con acceso aleatorio. Es la
base para crear los objetos de tipo fichero de acceso aleatorio. Estos ficheros
permiten multitud de operaciones; saltar hacia delante y hacia atrs para leer la
informacin que necesitemos en cada momento, e incluso leer o escribir partes del
fichero sin necesidad de cerrarlo y volverlo a abrir en un modo distinto.
=/9%!A<A:8G;@8@AC%
Para tratar con un fichero siempre hay que actuar de la misma manera:
1. Se abre el fichero.
Para ello hay que crear un objeto de la clase correspondiente al tipo de fichero que
vamos a manejar, y el tipo de acceso que vamos a utilizar:
TipoDeFichero obj = new TipoDeFichero( ruta );
Donde &/#' es la ruta de disco en que se encuentra el fichero o un descriptor de fichero
vlido.
Este formato es vlido, excepto para los objetos de la clase d'-.*6G++$""x<?$ (acceso
aleatorio), para los que se ha de instanciar de la siguiente forma:
RandomAccessFile obj = new RandomAccessFile( ruta, modo );
Donde 6*.* es una cadena de texto que indica el modo en que se desea abrir el fichero;
"r" para slo lectura o "rw" para lectura y escritura.
2. Se utiliza el fichero.
Para ello cada clase presenta diferentes mtodos de acceso para escribir o leer en el
fichero.
3. Gestin de excepciones (opcional, pero recomendada)
Se puede observar que todos los mtodos que utilicen clases de este paquete deben tener
en su definicin una clusula #I&*N"%OF!g+$,#<*-. Los mtodos de estas clases pueden
lanzar excepciones de esta clase (o sus hijas) en el transcurso de su ejecucin, y dichas
excepciones deben de ser capturadas y debidamente gestionadas para evitar problemas.
4. Se cierra el fichero y se destruye el objeto.
Para cerrar un fichero lo que hay que hacer es destruir el objeto. Esto se puede realizar
de dos formas, dejando que sea el recolector de basura de Java el que lo destruya
cuando no lo necesite (no se recomienda) o destruyendo el objeto explcitamente
mediante el uso del procedimiento c?*"$2; del objeto:
obj.close()
Pgina 113 de 189

@/9%,8%=G8CA%S;GA3FD>FD7D:A8H%
Mediante los objetos de esta clase escribimos en ficheros de texto de forma secuencial.
Presenta el mtodo N&<#$2; para la escritura en el fichero. Presenta varios formatos:
!"<-#%N&<#$2%<-#%+%;\ Escribe el carcter en el fichero.%
!"<-#%N&<#$2%(H#$%'oq%;\ Escribe el contenido del vector en el fichero.
!"<-#%N&<#$2%(H#$%'oqD%<-#%*55D%<-#%?$-%;\ Escribe ?$- caracteres del vector ' en el fichero,
comenzando desde la posicin *55.
El siguiente ejemplo crea el fichero de texto "a+'&#'A#g#" a partir de un texto que se le
introduce por teclado:
import java.io.*;
class CreaCarta {
public static void main(String args[]) throws IOException{
int c;
FileOutputStream f=new FileOutputStream("/carta.txt");
while( ( c=System.in.read() ) != -1 )
f.write( (char)c );
f.close();
}
}
A/9%,8%=G8CA%S;GA(<>FD7D:A8H%
Mediante los objetos de esta clase leemos de ficheros de texto de forma secuencial.
Presenta el mtodo &$'.2; para la lectura del fichero. Este mtodo se puede invocar de
varias formas.
!"<-#%&$'.2;\ Devuelve el siguiente carcter del fichero.%
!"<-#%&$'.2%(H#$%'oq%;\ Llena el vector ' con los caracteres ledos del fichero. Devuelve
la longitud del vector que se ha llenado si se realiz con xito o 1 si no haba
suficientes caracteres en el fichero para llenar el vector.
!"<-#%&$'.2%(H#$%'oqD%<-#%*55D%<-#%?$-%;\ Lee ?$- caracteres del fichero, insertndolos en el
vector '.
Todos ellos devuelven -1 si se ha llegado al final del fichero (momento de cerrarle).
El siguiente ejemplo muestra el fichero de texto "a+'&#'A#g#" en pantalla:
import java.io.*;
class MuestraCarta {
int c;
FileInputStream f=new FileInputStream("/carta.txt");
while( ( c=f.read() ) != -1 )
System.out.print( (char)c );
Pgina 114 de 189

f.close();
}
}
L/9%,8%=G8CA%28<@?H$==ACCS;GA%
Mediante los objetos de esta clase utilizamos ficheros binarios mediante un acceso
aleatorio, tanto para lectura como para escritura. En estos ficheros hay un ndice que nos
dice en qu posicin del fichero nos encontramos, y con el que se puede trabajar para
posicionarse en el fichero.
Mtodos de desplazamiento
Cuenta con una serie de funciones para realizar el desplazamiento del puntero del
fichero. Hay que tener en cuenta que cualquier lectura o escritura de datos se realizar a
partir de la posicin actual del puntero del fichero.
!"?*-0%0$#x<?$E*<-#$&2;vDevuelve la posicin actual del puntero del fichero.%
!"=*<.%"$$P2%?*-0%?%;v Coloca el puntero del fichero en la posicin indicada por ?. Un
fichero siempre empieza en la posicin 0.%
!"<-#%"P<,QH#$"2%<-#%-%;v Intenta saltar - bytes desde la posicin actual.
!"?*-0%?$-0#I2;v Devuelve la longitud del fichero.
!"=*<.%"$#:$-0#I2%?*-0%?;v Establece a ? el tamao de este fichero.%
!"x<?$R$"+&<,#*&%0$#xR2;v%Devuelve el descriptor de este fichero.%
Mtodos de escritura
La escritura del fichero se realiza con una funcin que depende el tipo de datos que se
desee escribir.
!"=*<.%N&<#$2%(H#$%(oqD%<-#%<-<D%<-#%?$-%;v Escribe ?$- caracteres del vector (.%
!"=*<.%N&<#$2%<-#%<%;v Escribe la parte baja de < (un byte) en el flujo.%
!"=*<.%N&<#$Q**?$'-2%(**?$'-%(%;v Escribe el boolean ( como un byte.%
!"=*<.%N&<#$QH#$2%<-#%<%;v Escribe < como un byte.%
!"=*<.%N&<#$QH#$"2%M#&<-0%"%;v Escribe la cadena s tratada como bytes, no caracteres.%
!"=*<.%N&<#$JI'&2%<-#%<%;v Escribe <%como 1 byte.%
!"=*<.%N&<#$JI'&"2%M#&<-0%"%;v Escribe la cadena ".%
!"=*<.%N&<#$R*/(?$2%.*/(?$%.%;; Convierte . a ?*-0 y le escribe como 8 bytes.%
!"=*<.%N&<#$x?*'#2%5?*'#%5%;v Convierte 5 a entero y le escribe como 4 bytes.%
!"=*<.%N&<#$O-#2%<-#%<%;; Escribe < como 4 bytes.%
!"=*<.%N&<#$:*-02%?*-0%=%;v Escribe = como 8 bytes.%
!"=*<.%N&<#$MI*&#2%<-#%<%;v Escribe <%como 2 bytes.%
!"=*<.%N&<#$Y8x2%M#&<-0%"%;v Escribe la cadena " utilizando la codificacin UTF-8.%
Los mtodos que escriben nmeros de ms de un byte escriben el primero su parte alta.
Pgina 115 de 189

Mtodos de lectura
La lectura del fichero se realiza con una funcin que depende del tipo de datos que
queremos leer.
!"(**?$'-%&$'.Q**?$'-2;v%Lee un byte y devuelve 5'?"$ si vale 0 o #&/$ sino.%
!"(H#$%&$'.QH#$2;v Lee y devuelve un byte.%
!"+I'&%&$'.JI'&2;v Lee y devuelve un caracter.%
!".*/(?$%&$'.R*/(?$2;v Lee 8 bytes, y devuelve un .*/(?$.%
!"5?*'#%&$'.x?*'#2;v Lee 4 bytes, y devuelve un 5?*'#.%
!"=*<.%&$'.x/??H2%(H#$%(oq%;v Lee bytes del fichero y los almacena en un vector (.%
!"=*<.%&$'.x/??H2%(H#$%(oqD%<-#%<-<D%<-#%?$-%;v Lee ?$- bytes del fichero y los almacena
en un vector (.%
!"<-#%&$'.O-#2;v Lee 4 bytes, y devuelve un <-#.%
!"?*-0%&$'.:*-02;v Lee 8 bytes, y devuelve un ?*-0.%
!""I*&#%&$'.MI*v Lee 2 bytes, y devuelve un "I*&#.%
!"<-#%&$'.Y-"<0-$.QH#$2;v Lee 1 byte, y devuelve un valor de 0 a 255.%
!"<-#%&$'.Y-"<0-$.MI*v%Lee 2 bytes, y devuelve un valor de 0 a 65535.%
!"M#&<-0%&$'.Y8x2;v Lee una cadena codificada con el formato UTF-8.%
!"<-#%"P<,QH#$"2<-#%-;v Salta - bytes del fichero.%
Si no es posible la lectura devuelven WT.
Ejemplo
Vamos a crear un pequeo programa que cree y acceda a un fichero binario, mediante
acceso aleatorio.
El siguiente ejemplo crear un fichero binario que contiene los 100 primeros nmeros (en
orden):
// Crea un fichero binario con los 100 primeros numeros
static void creaFichBin( String ruta ) throws IOException {
RandomAccessFile f=new RandomAccessFile(ruta,"rw"); // E/S
for ( int i=1; i <= 100 ; i++ )
{
try{
f.writeByte( i );
} catch( IOException e){
// Gestion de excepcion de ejemplo
break; // No se puede seguir escribiendo
}
f.close();
}
Pgina 116 de 189

El siguiente mtodo accede al elemento +/'? de un fichero binario, imprimiendo la

longitud del fichero, el elemento +/'? y su 10 veces siguiente elemento:
static void imprimeEltoN(String ruta, long cual)
throws IOException{
RandomAccessFile f=new RandomAccessFile(ruta,"r"); // E/
System.out.print( "El fichero " + ruta );

System.out.println( " ocupa " + f.length() + " bytes." );
f.seek( cual-1 ); // Me posiciono (-1 porque empieza en 0)

System.out.print(" En la posicion " + f.getFilePointer() );
System.out.println(" esta el numero " + f.readByte() );
f.skipBytes( 9 ); // Salto 9 => Elemento 10 mas alla

System.out.print(" 10 elementos ms all, esta el ");
System.out.println( f.readByte() );
f.close();
}
Si incluimos ambos mtodos en una clase, y les llamamos con el siguiente programa
principal (6'<-2;):
String ruta="numeros.dat"; // Fichero
creaFichBin( ruta ); // Se crea
imprimeEltoN( ruta, 14 ); // Accedo al elemento 14.
}
Obtendremos la siguiente salida:
El fichero numeros.dat ocupa 100 bytes.
En la posicion 13 esta el numero 14
10 elementos ms all, esta el 24
Pgina 117 de 189

@"79(%!*(;%:%?@"<9$(B#AD%<9$(
Pgina 118 de 189

(./0/%,37%4$j"'1'7%!2nS(*37%&'%,$7%-S*%
9*(%'@#?>6<<%&'(
Las JFC (Java Foundation Classes) son parte de la API de Java compuesto por clases
que sirven para crear interfaces grficas visuales para las aplicaciones y ',,?$#" de Java.
As como Sun presenta estas JFC, Microsoft ha desarrollado otro paquete propio con el
nombre de AFD (Application Foundation Classes).
Las JFC contienen dos paquetes grficos: AWT y Swing.
!"AWT presenta componentes pesados, que en cada plataforma slo pueden tener una
representacin determinada. Est disponible desde la versin 1.1 del JDK como
)'='A'N#.
!"Swing presenta componentes ligeros, que pueden tomar diferente aspecto y
comportamiento pues lo toman de una biblioteca de clases. Est disponible desde la
versin 1.2 del JDK como )'='gA"N<-0 aunque antes se podan encontrar versiones
previas como +*6A"/-A)'='A o como )'='A'N#A"N<-0A
AWT se estudia con ms detenimiento en el apartado ZO[A_AGL8Z de este tutorial,
mientras que Swing se estudia en el apartado ZO[AÀMN<-0Z de este tutorial.
;*(7?>":?(>"("!"'@?$(
Tanto AWT como Swing tienen en comn un sistema para gestionar los eventos que se
producen al interactuar con el usuario de la interfaz grfica; su 6*.$?*%.$%$=$-#*".
El funcionamiento del modelo de eventos se basa en la gestin de excepciones.
Para cada objeto que represente una interfaz grfica, se pueden definir objetos "oyentes"
(:<"#$-$&), que esperen a que suceda un determinado evento sobre la interfaz. Por
ejemplo se puede crear un objeto oyente que est a la espera de que el usuario pulse
sobre un botn de la interfaz, y si esto sucede, l es avisado, ejecutando determinada
accin.
La clase base para todos estos eventos que se pueden lanzar es la clase GL8!=$-#
(perteneciente al paquete )'='A'N#).
El modelo de eventos de AWT depende del paquete )'='A'N#A$=$-#, que en Swing se
ampla con el paquete )'='gA"N<-0A$=$-#.
Existen dos tipos bsicos de eventos:
!"Fsicos: Corresponden a un evento hardware claramente identificable. Ej: se ha
pulsado una tecla (S$HM#&*P$!=$-#).
!"Semnticos: Se componen de un conjunto de eventos fsicos, que sucedidos en un
determinado orden tienen un significado ms abstracto: El usuario ha elegido un
elemento de una lista desplegable (O#$6!=$-#).
Pgina 119 de 189

<*($6;89G6"@"$(>"(9P@(
A continuacin se enumeran los paquetes que componen las JFC, as como su
funcionalidad, ordenados por orden de antigedad. Esto es importante, porque debe de
tenerse en cuenta si se va a utilizar para crear ',,?$#", ya que normalmente los
navegadores no soportan la ltima versin de la API de Java en su propia mquina
virtual.
Si queremos que nuestra ',,?$# se vea igual en varios navegadores, deberemos de tener
en cuenta qu paquetes podemos utilizar y cules no, comprobando la versin de Java
que soportan los navegadores que nos interesen.
8/9%&AC@A%G8%TA:C;E<%0/i%
!")'='A'N#: Contiene todas las clases bsicas de AWT para crear interfaces e imprimir
grficos e imgenes, as como la clase base para los eventos en componentes:
GL8!=$-#.
!")'='A'N#A<6'0$: Para crear y modificar imgenes. Utiliza productores de imgenes,
filtros y "consumidores de imgenes". Permite renderizar una imagen mientras est
siendo generada.
B/9%&AC@A%G8%TA:C;E<%0/0%
!")'='A'N#A.'#'#&'-"5$&: Transferencia de datos entre aplicaciones. Permite definir
clases "transferibles" entre aplicaciones, y da soporte al mecanismo del portapapeles
(copiar y pegar).
!")'='A'N#A$=$-#: Modelo de eventos de AWT. Contiene eventos, oyentes y
adaptadores a oyentes.
=/9%&AC@A%G8%TA:C;E<%0/O%
!")'='A'N#A+*?*&: Utilizacin de colores. Contiene la implementacin de una paleta de
colores basada en la especificada por el ICC (Consorcio Internacional de Color).
!")'='A'N#A.-.: Operaciones de arrastrar y soltar.
!")'='A'N#A5*-#: Todo lo referente a las fuentes de texto. Soporta fuentes del tipo True
Type, Type 1, Type 1 Multiple Master, y OpenType.
!")'='A'N#A0$*6\% Aporta clases de Java 2D, para crear objetos en 2 dimensiones,
utilizando geometra plana (elipses, curvas, reas...).
!")'='A'N#A<6: Para utilizar smbolos Japoneses, Chinos o Coreanos.
!")'='A'N#A<6'0$A&$-.$&'(?$: Para producir imgenes que sean <-.$,$-.<$-#$"% .$%
&$.$&<-0 (animacin).
!")'='A'N#A,&<-#: Para imprimir documentos. Incorpora capacidad para gestionar
diversos tipos de documentos, formatos de pgina e interactuar con el usuario para
controlar la impresin de trabajos.
Pgina 120 de 189

>*($6;89G6"@"$(>"($P%'B(
A continuacin se enumeran los paquetes que componen Swing, as como su
funcionalidad:
!")'='gA"N<-0: Tiene los componentes bsicos para crear componentes ligeros Swing.
!")'='gA"N<-0A(*&.$&: Para dibujar bordes personalizados en los componentes Swing.
!")'='gA"N<-0A+*?*&+I**"$&: Para utilizar el componente @J*?*&JI**"$&.
!")'='gA"N<-0A$=$-#: Eventos lanzados por componentes Swing, as como oyentes para
dichos eventos. Extiende los que se encuentran en el paquete AWT )'='A'N#A$=$-#.
!")'='gA"N<-0A5<?$+I**"$&: Para utilizar el componente @x<?$JI**"$&.
!")'='gA"N<-0A,?'5: Permite a Swing utilizar mltiples representaciones. Se utiliza por
aquellos desarrolladores que no pueden crear un nuevo aspecto de interfaz, basado
en los que Swing ya incorpora (como Basic o Metal).
!")'='gA"N<-0A,?'5A('"<+: Objetos que utilizan interfaces de aspecto "Basic". Este
aspecto es el que presentan por defecto los componentes Swing. En este paquete se
encuentran gestores de impresin, eventos, oyentes y adaptadores. Se puede crear un
aspecto personalizado de interfaz utilizando este paquete.
!")'='gA"N<-0A,?'5A6$#'?: Objetos que utilizan interfaces de aspecto "Metal".
!")'='gA"N<-0A,?'5A6/?#<: Permite a los usuarios combinar aspectos de interfaz, entre
auxiliares y los que existen por defecto.
!")'='gA"N<-0A#$g#: Para manejar componentes de texto (modificables o no). Soporta
sintaxis resaltada, edicin, estilos...
!")'='gA"N<-0A#$g#AI#6?: Contiene la clase 789:!.<#*&S<#, basada en la versin 3.2 de
la especificacin HTML, y clases para crear editores de texto HTML
!")'='gA"N<-0A#$g#AI#6?A,'&"$&: Contiene analizadores de texto HTML.
!")'='gA"N<-0A#$g#A&#5: Contiene la clase d8x!.<#*&S<# para crear editores de
documentos en formato RTF (Rich-Text-Format).
!")'='gA"N<-0A#&$$: Para personalizar la forma en que son utilizados los rboles
generados por la clase )'='A'N#A"N<-0A@8&$$.%
!")'='gA"N<-0A/-.*: Permite realizar operaciones de .$"I'+$&a&$I'+$& en las
aplicaciones que cree el usuario.
Pgina 121 de 189

(./O/%$o1%Y$BCD:8=D%o;<@?^;<V%1??G\;D9%
9*(%'@#?>6<<%&'(
AWT es un conjunto de herramientas GUI (Interfaz Grfica con el Usuario) diseadas
para trabajar con mltiples plataformas.
Este paquete viene incluido en la API de Java como )'='A'N# ya desde su primera
versin, con lo que las interfaces generadas con esta biblioteca funcionan en todos los
entornos Java disponibles (incluyendo navegadores, lo que les hace especialmente
eficientes para la creacin de ',,?$#" Java).
En el apartado "[OAÀ%!)$6,?*%.$%+&$'+<>-%.$%/-'%',,?$#" se muestra un breve ejemplo
de cmo utilizar las clases del AWT para crear una ',,?$# y una aplicacin de Java.
La siguiente figura muestra la jerarqua de clases para las principales clases de AWT:
O6'0$-%\%@$&'&3/1'%.$%?'"%+?'"$"%.$%GL8%
En este apartado vamos a estudiar algunas de las clases ms importantes del AWT, as
como su funcionalidad.
;*(<?78?'"'@(
Esta clase representa a cualquier objeto que puede ser parte de una interfaz grfica de
usuario. Es la clase padre de muchas de las clases del AWT.
Su propsito principal es representar algo que tiene una posicin y un tamao, que
puede ser dibujado en la pantalla y que pueda recibir eventos de entrada (que responda a
las interacciones con el usuario).
La clase J*6,*-$-# presenta diversos mtodos, organizados para cubrir varios
propsitos.
A continuacin se explican algunos de ellos.
Pgina 122 de 189

8/9%18H8k?%U%>?C;=;E<%@AG%=?H>?<A<DA%
!"R<6$-"<*-%0$#M<C$2;v Devuelve la anchura y altura del componente como un objeto
de la clase R<6$-"<*-, que tiene como campos: N<.#I (anchura) y I$<0#I (altura).
!"=*<.%"$#M<C$2<-#%'-+I*D%<-#%?'&0*;v Establece la anchura y altura del componente.
!"R<6$-"<*-% 0$#E&$5$&&$.M<C$2;v Devuelve el tamao que este componente debera
tener.
!"=*<.%"$#E&$5$&&$.M<C$2;v Establece el tamao que este componente debera tener.
!"R<6$-"<*-% 0$#9<-<6/6M<C$2;v Devuelve el tamao mnimo que este componente
debera tener.
!"=*<.% "$#9<-<6/6M<C$2<-#% '-+I*D% <-#% ?'&0*;v Establece el tamao mnimo que este
componente debera tener.
!"d$+#'-0?$% 0$#Q*/-."2;v Devuelve las coordenadas de este componente como un
objeto de la clase d$+#'-0?$, que tiene como campos: gD%HD%N<.#I%H%I$<0#I.
!"=*<.%"$#Q*/-."2<-#%gD%<-#%HD%<-#%'-+I*D%<-#%?'&0*;v Establece las coordenadas de este
componente.
B/9%$==;?<AC%C?B:A%AG%=?H>?<A<DA%
!"(**?$'-%0$#!-'(?$.2;v Comprueba si el componente est o no activo.%
!"=*<.%"$#!-'(?$.2(**?$'-;v Establece el componente a activo o inactivo.%
!"(**?$'-%0$#[<"<(?$2;v%Comprueba si el componente est o no visible.%
!"=*<.%"$#[<"<(?$2(**?$'-;v%Establece si el componente est visible o invisible.%
!"=*<.%,'<-#2X&',I<+"%0;v Indica al AWT que ha de dibujar el componente 0.
!"=*<.%&$,'<-#2;v Indica al AWT que ha de volver a dibujar el componente.
!"=*<.% /,.'#$2X&',I<+"% 0;v Es llamado por AWT cuando se invoca el mtodo
&$,'<-#2;. Por defecto llama a ,'<-#2;.%
=/9%'TA<D?C%@A%;<DA:8==;E<%=?<%AG%FCF8:;?%
A su vez hay tres tipos de mtodos, para la gestin de eventos mediante el nuevo
modelo de eventos de AWT (desde la versin 1.1).
Hay tres tipos de mtodos:
!"=*<.% '..f8<,*f:<"#$-$&2f8<,*f:<"#$-$&% ?;v Aade un oyente a la espera de algn
tipo de eventos sobre este componente.
!"=*<.%&$6*=$f8<,*f:<"#$-$&2f8<,*f:<"#$-$&%?;v Elimina algn oyente que estaba a la
espera de algn tipo de eventos sobre este componente.
!"=*<.% ,&*+$""f8<,*f!=$-#2f8<,*f!=$-#% $;v Procesa eventos del tipo _8<,*f!=$-#
envindolos a cualquier objeto _8<,*f:<"#$-$& que estuviera escuchando.
En estos mtodos f8<,*f puede ser cualquiera de los siguientes:
J*6,*-$-#D%x*+/", O-,/#9$#I*., S$H, 9*/"$, 9*/"$9*#<*-.
Pgina 123 de 189

<*(<?'@9%'"#(
La clase J*-#'<-$& sabe cmo mostrar componentes embebidos (que a su vez pueden
ser instancias de la clase J*-#'<-$&).
Algunos de los mtodos de la clase J*-#'<-$& son:
!"J*6,*-$-#%'..2J*6,*-$-#%+;v Aade un componente al contenedor.
!"=*<.%,&<-#2X&',I<+"%0;v Imprime el contenedor.
!"=*<.%,&<-#J*6,*-$-#"2X&',I<+"%0;v Imprime cada uno de los componentes de este
contenedor.
!":'H*/#9'-'0$&% 0$#:'H*/#2;v% Devuelve el gestor de impresin (:'H*/#9'-'0$&)
asociado a este contenedor, que es el responsable de colocar los componentes dentro
del contenedor.%
!"=*<.% "$#:'H*/#2:'H*/#9'-'0$&% T;v Establece un gestor de impresin para este
componente.
Estos objetos J*-#'<-$& tienen un :'H*/#9'-'0$& asociado que define la manera en
que van a posicionarse los objetos componentes en su interior.
>*(B"$@?#"$(>"(%78#"$%&'(
:'H*/#9'-'0$& y :'H*/#9'-'0$&_ son dos interfaces encargadas de la representacin
y posicionamiento en pantalla de componentes AWT.
De estas interfaces se proporcionan cinco implementaciones en AWT. Cada una de ellas
reparte los objetos de una forma particular:
!"Q*&.$&:'H*/#: En cinco lugares: Norte, Sur, Este, Oeste y Centro (]*&#ID% M*/#ID%
!'"#D%L$"# y J$-#$&).
!"J'&.:'H*/#: Permite gestionar varios componentes de los que slo uno se visualiza
a la vez, permaneciendo los dems invisibles debajo.
!"x?*N:'H*/#: De izquierda a derecha horizontalmente en cada lnea. Cuando
sobrepasan una lnea se comienza a la izquierda de la siguiente.
!"X&<.:'H*/#: En una tabla en la que todas las casillas tienen el mismo tamao.
!"X&<.Q'0:'H*/#: En una tabla, pero las casillas no tienen que tener el mismo tamao.
"*(?@#9$(<:9$"$(
Por supuesto AWT no se limita a estas clases. Dentro de esta biblioteca podemos
encontrar multitud de clases prefabricadas para facilitar el diseo grfico.
A continuacin explicamos algunas de ellas.
8/9%*G8CAC%=?<DA<A@?:8C%Y[;K8C%@A%*?<D8;<A:%
!"E'-$?: Permite hacer una presentacin ms avanzada que J*-#'<-$& mediante la
combinacin con subpaneles o subclases para crear contenedores personalizados. La
clase G,,?$# que sirve para crear ',,?$#" Java, hereda de esta clase E'-$?.
Pgina 124 de 189

!"M+&*??E'-$: Una barra de desplazamiento, horizontal o vertical.

!"L<-.*N: Una ventana sin borde.
!"x&'6$: Una ventana que no tiene borde. Puede tener asociado un objeto 9$-/('&
(una barra de herramientas o barra de men personalizada).
!"R<'?*0: Una ventana usada para crear dilogos. Tiene la capacidad de ser 6*.'? con
lo que slo este contenedor recibira entradas del usuario.
!"x<?$.<'?*0: Un dilogo que usa el selector de archivos nativo del sistema operativo.
B/9%*G8CAC%=?H>?<A<DAC%Y[;K8C%@;:A=D8C%@A%*?H>?<A<D9%
!"Q/##*-: Un botn grfico para el que se puede definir una accin que suceder
cuando se presione el botn.
!"J'-='": Permite pintar o capturar eventos del usuario. Se puede usar para crear
grficos o como clase base para crear una jerarqua de componentes personalizados.
!"JI$+P(*g: Soporta dos estados: *- y *55. Se pueden asociar acciones que se ejecuten
(#&<00$&") cuando el estado cambie.
!"JI*<+$: Men desplegable de opciones.
!":'($?: Cadena de etiqueta en una localizacin dada.
!":<"#: Una lista desplegable de cadenas.
!"M+&*??('&: Desplegable de objetos J'-='".
!"8$g#J*6,*-$-#: Cualquier componente que permita editar cadenas de texto.Tiene
dos clases hijas:
!"8$g#x<$?.: Componente de texto consistente en una lnea que puede ser usada
para construir formularios.
!"8$g#G&$': Componente para edicin de texto de tamao variable.
D*("!"'@?$(>"(9P@(
AWT tiene sus propios eventos, que se explican a continuacin.
8/9%'TA<D?C%LJC;=?C%
Son todos hijos del evento J*6,*-$-#!=$-#, que indica algn cambio en un objeto
J*6,*-$-#:
!"O-,/#!=$-#: Se ha producido una entrada del usuario. Tiene como eventos hijos
S$H!=$-# (pulsacin de una tecla) y 9*/"$!=$-# (accin sobre el ratn).
!"x*+/"!=$-#: Avisa al programa de que el componente ha ganado o perdido la
'#$-+<>- (enfoque) del usuario. Esto se deduce de la actividad del usuario (ratn y
teclado).
!"L<-.*N!=$-#: Avisa al programa de que el usuario ha utilizado uno de los controles
de ventana a nivel del sistema operativo, como los controles de minimizar o cerrar.
!"J*-#'<-$&!=$-#: Se enva cuando se aaden o eliminan componentes a un
contenedor.
Pgina 125 de 189

!"E'<-#!=$-#: Evento especial que seala que el sistema operativo quiere dibujar de
nuevo una parte de la interfaz. Un componente debe sobreescribir el mtodo ,'<-#2;
o el mtodo /,.'#$2; para gestionar este evento.
B/9%'TA<D?C%CAHR<D;=?C%
Son todos hijos del evento GL8!=$-#, que es el evento base de la jerarqua de eventos:
!"G+#<*-!=$-#: Avisa al programa de acciones especficas de componentes como las
pulsaciones de botones.
!"G.)/"#6$-#$!=$-#: Comunica que una barra de desplazamiento ha sido ajustada.
!"O#$6!=$-#: Avisa al programa cuando el usuario interacciona con una eleccin, una
lista o una casilla de verificacin.
!"8$g#!=$-#: Avisa cuando un usuario cambia texto en un componente
8$g#J*6,*-$-#D 8$g#G&$' o 8$g#x<$?..
!"O-,/#9$#I*.!=$-#: Avisa que un texto que est siendo creado utilizando un mtodo
de entrada est cambiando (se ha escrito algo ms...).
!"O-=*+'#<*-!=$-#: Este evento ejecuta el mtodo &/-2; en una clase d/--'(?$ cuando
es tratado por el #I&$'. del despachador (.<",'#+I$&) de AWT.
Pgina 126 de 189

(./Q/%7o()!%
9*(%'@#?>6<<%&'(
El paquete Swing es el nuevo paquete grfico que ha aparecido en la versin 1.2 de
Java. Est compuesto por un amplio conjunto de componentes de interfaces de usuario
que funcionen en el mayor nmero posible de plataformas.
Cada uno de los componentes de este paquete puede presentar diversos aspectos y
comportamientos en funcin de una biblioteca de clases. En la versin 1.0 de Swing,
que corresponde a la distribuida en la versin 1.2 de la API de Java se incluyen tres
bibliotecas de aspecto y comportamiento para Swing:
!"6$#'?A)'&: Aspecto y comportamiento independiente de la plataforma.
!"6*#<5A)'&: Basado en la interfaz Sun Motif.
!"N<-.*N"A)'&: Muy similar a las interfaces Microsoft Windows 95.
La siguiente imagen muestra una aplicacin de ejemplo (adjunta al JDK 1.2) que
muestra las diferentes interfaces para una misma aplicacin segn se utilice una u otra
biblioteca:
O6'0$-%V\%R<5$&$-#$"%'",$+#*"%.$%/-'%<-#$&5'C%MN<-0%
Es la nueva clase denominada Y<9'-'0$& la que se encarga del aspecto y
comportamiento de una aplicacin Swing en un entorno de ejecucin.
En el apartado "[OAÀ%!)$6,?*%.$%+&$'+<>-%.$%/-'%',,?$#" se muestra un breve ejemplo
de cmo utilizar las clases de Swing para crear una aplicacin utilizando Swing.
;*('6"!9$(<9#9<@"#=$@%<9$(
La arquitectura Swing presenta una serie de ventajas respecto a su antecedente AWT:
!"Amplia variedad de componentes: En general las clases que comiencen por "J" son
componentes que se pueden aadir a la aplicacin. Por ejemplo: @Q/##*-.
Pgina 127 de 189

!"Aspecto modificable (?**P% '-.% 5$$?): Se puede personalizar el aspecto de las

interfaces o utilizar varios aspectos que existen por defecto (Metal Max, Basic
Motif, Window Win32).
!"Arquitectura Modelo-Vista-Controlador: Esta arquitectura da lugar a todo un
enfoque de desarrollo muy arraigado en los entornos grficos de usuario realizados
con tcnicas orientadas a objetos. Cada componente tiene asociado una clase de
modelo de datos y una interfaz que utiliza. Se puede crear un modelo de datos
personalizado para cada componente, con slo heredar de la clase 9*.$?.
!"Gestin mejorada de la entrada del usuario: Se pueden gestionar combinaciones de
teclas en un objeto S$HM#&*P$ y registrarlo como componente. El evento se activar
cuando se pulse dicha combinacin si est siendo utilizado el componente, la
ventana en que se encuentra o algn hijo del componente.
!"Objetos de accin ('+#<*-%*()$+#"): Estos objetos cuando estn activados ($-'(?$.)
controlan las acciones de varios objetos componentes de la interfaz. Son hijos de
G+#<*-:<"#$-$&A
!"Contenedores anidados: Cualquier componente puede estar anidado en otro. Por
ejemplo, un grfico se puede anidar en una lista.
!"Escritorios virtuales: Se pueden crear escritorios virtuales o "interfaz de mltiples
documentos" mediante las clases @R$"P#*,E'-$ y @O-#$&-'?x&'6$.
!"Bordes complejos: Los componentes pueden presentar nuevos tipos de bordes.
Adems el usuario puede crear tipos de bordes personalizados.
!"Dilogos personalizados: Se pueden crear multitud de formas de mensajes y
opciones de dilogo con el usuario, mediante la clase @F,#<*-E'-$.
!"Clases para dilogos habituales: Se puede utilizar @x<?$JI**"$& para elegir un
fichero, y @J*?*&JI**"$& para elegir un color.
!"Componentes para tablas y rboles de datos: Mediante las clases @8'(?$ y @8&$$.
!"Potentes manipuladores de texto: Adems de campos y reas de texto, se presentan
campos de sintaxis oculta @E'""N*&., y texto con mltiples fuentes @8$g#E'-$.
Adems hay paquetes para utilizar ficheros en formato HTML o RTF.
!"Capacidad para "deshacer": En gran variedad de situaciones se pueden deshacer las
modificaciones que se realizaron.
!"Soporte a la accesibilidad: Se facilita la generacin de interfaces que ayuden a la
accesibilidad de discapacitados, por ejemplo en Q&'<??$.
<*(8#%'<%89:"$(<:9$"$(
Las clases de Swing se parecen mucho a las de AWT.
Todas las clases explicadas en el apartado "IV.2 AWT" de este tutorial tienen una nueva
versin en Swing con el prefijo @. As la clase E'-$? de AWT tiene una clase @E'-$? en
Swing. Esto se cumple para todas las clases menos para JI*<+$D%J'-='"D%x<?$R<'?0*0 y
M+&*??E'-$.
De hecho todas las clases componentes de Swing (clases hijas de @J*6,*-$-#), son
hijas de la clase J*6,*-$-# de AWT.
Pgina 128 de 189

!"Q/##*-X&*/,: Muestra una lista de elementos (@d'.<*Q/##*-) con solo uno

seleccionable. Cada elemento tiene un crculo, que en caso del elemento
seleccionado contendr un "punto".
!"@8*00?$Q/##*-: Es como un botn normal, pero al ser pinchado por el usuario queda
activado.
!"@E&*0&$""Q'&: Representa una barra de estado de progreso, mediante la que
habitualmente se muestra el desarrollo de un proceso en desarrollo (ejemplo: la
instalacin de una aplicacin).
!"@8'(($.E'-$: Es una ventana con solapas (la que utiliza Windows). Este
componente haba sido muy solicitado.
!"@G,,?$#: Aunque ya exista una clase G,,?$# en AWT, esta nueva versin es
necesaria para crear ',,?$#" Java que utilicen interfaces Swing.
Por supuesto Swing no se limita a estas clases, sino que posee muchas ms con diversas
funcionalidades. Para estudiarlas consulte la documentacin del JDK 1.2 de Java.
>*('6"!?$(B"$@?#"$(>"(%78#"$%&'(
Swing incorpora nuevos gestores de impresin, ampliando los cinco que AWT
incorporaba. Entre ellos conviene destacar los siguientes:
!"Q*g:'H*/#: Es similar al x?*N:'H*/# de AWT, con la diferencia de que con l se
pueden especificar los ejes (x o y). Viene incorporada en el componente Q*g, pero
est disponible como una opcin en otros componentes.
!"F=$&?'H:'H*/#: Todos los componentes se aaden encima de cada componente
previo.
!"M,&<-0:'H*/#: El espacio se asigna en funcin de una serie de restricciones
asociadas con cada componente.
!"M+&*??E'-$:'H*/#: Incorporado en el componente M+&*??E'-$A
!"[<$N,*&#:'H*/#: Incorporado en el componente [<$N,*&#A
"*(C#??@89'"(
La clase @d**#E'-$ permite colocar contenido de las ',,?$#" creadas con la clase
@G,,?$# en un determinado plano de impresin (capa).
Por orden de cercana al usuario, estas capas son:
!"0?'""E'-$: Una capa que abarca toda la parte visible (por defecto no es visible).
!"?'H$&$.E'-$: Una subclase de @J*6,*-$-# diseada para contener cuadros de
dilogo, mens emergentes y otros componentes que deben aparecer flotando entre
el usuario y el contenido.
!"6$-/('&: Una capa opcional, que si aparece estar anclada en la parte superior.
!"+*-#$-E'-$: La capa en que se dibujar la mayor parte del contenido.
As pues cada vez que se vayan a aadir componentes a una ',,?$# de clase @G,,?$#,
debe aadirse a uno de estas capas. Por ejemplo:
laJApplet.getContentPane().add( unComponente );
Pgina 129 de 189

D*('6"!?$("!"'@?$(>"($P%'B(
Swing incorpora su nuevo conjunto de eventos para sus componentes.
8/9%'TA<D?C%LJC;=?C%
Slo aparecen dos nuevos eventos fsicos, descendientes de O-,/#!=$-#:
!"9$-/S$H!=$-#: Un men de rbol ha recibido un evento de S$H!=$-# (accin sobre
el ratn).
!"9$-/R&'09*/"$!=$-#: Un men de rbol ha recibido un evento de 9*/"$!=$-#
(pulsacin de una tecla).
B/9%'TA<D?C%CAHR<D;=?C%
Son todos hijos del evento de AWT GL8!=$-#, que es el evento base de la jerarqua de
eventos:
!"G-+$"#*&!=$-#: Antecesor aadido desplazado o eliminado.
!"J'&$#!=$-#: El signo de intercalacin del texto ha cambiado.
!"JI'-0$!=$-#: Un componente ha sufrido un cambio de estado.
!"R*+/6$-#!=$-#: Un documento ha sufrido un cambio de estado.
!"7H,$&?<-P!=$-#: Algo relacionado con un vnculo hipermedia ha cambiado.
!"O-#$&-'?x&'6$!=$-#: Un GL8!=$-# que aade soporte para objetos @O-#$&-'?x&'6$A
!":<"#R'#'!=$-#: El contenido de una lista ha cambiado o se ha aadido o eliminado
un intervalo.
!":<"#M$?$+#<*-!=$-#: La seleccin de una lista ha cambiado.
!"9$-/!=$-#: Un elemento de men ha sido seleccionado o mostrado o bien no
seleccionado o cancelado.
!"E*,/,9$-/!=$-#: Algo ha cambiado en @E*,/,9$-/.
!"8'(?$J*?/6-9*.$?!=$-#: El modelo para una columna de tabla ha cambiando.
!"8'(?$9*.$?!=$-#: El modelo de una tabla ha cambiado.
!"8&$$!g,'-"<*-!=$-#: El nodo de un rbol se ha extendido o se ha colapsado.
!"8&$$9*.$?!=$-#: El modelo de un rbol ha cambiado.
!"8&$$M$?$+#<*-!=$-#: La seleccin de un rbol ha cambiado de estado.
!"Y-.*'(?$!.<#!=$-#: Ha ocurrido una operacin que no se puede realizar.
B*(":(89@#&'(>"(>%$"I?(7?>":?T!%$@9T<?'@#?:9>?#(
Muchos de los componentes Swing estn basados en un patrn de diseo denominado
"Modelo-Vista-Controlador".
El concepto de este patrn de diseo se basa en tres elementos:
!"Modelo: Almacena el estado interno en un conjunto de clases.
!"Vista: Muestra la informacin del modelo
Pgina 130 de 189

!"Controlador: Cambia la informacin del modelo (delegado).

No es menester de este tutorial explicar todo el funcionamiento de este nuevo diseo,
pero si se quiere profundizar en l consulte h7UOWPSe,3FFFi.
Pgina 131 de 189

@"79(!*(C9!9("(%'@"#'"@(
Pgina 132 de 189

./0%-$.$%'%()1'2)'1%
9*(%'@#?>6<<%&'(
Una de las grandes potencias del lenguaje de programacin Java es la total portabilidad
de sus programas gracias a su afamada mquina virtual. Esto adquiere una
importancia an mayor en Internet donde existen tipos de computadoras muy dispares.
Las siguientes bibliotecas de la API de Java contienen una serie de clases que son
interesantes de cara a la creacin de aplicaciones que trabajen en red. Las ms
importantes son:
!")'='A',,?$#: Da soporte a las applets.
!")'='A-$#: Clases para redes. Dan acceso a TCP/IP, "*+P$#" y URLs.
Conviene destacar la existencia de otras bibliotecas ms complejas, orientadas tambin
a la programacin en red, que aunque no sern estudiadas en este tutorial, s conviene
tener presente su existencia:
!")'='A"3?: Paquete que contiene el JDBC, para conexin de programas Java con
Bases de datos.
!")'='A&6<: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e
incluso enviar objetos como parmetros de un objeto a otro.
!"*&0A*60AJFdQG: Facilita la posibilidad de utilizar OMG CORBA, para la conexin
entre objetos distribuidos, aunque estn codificados en distintos lenguajes.
!"*&0A*6(AJ*"]'6<-0 : Da servicio al IDL de Java, similar al RMI pero en CORBA.
Una de las caractersticas de Java que lo hacen especialmente interesante para Internet
es que sus programas objeto (cdigos de byte) son verificables para poder detectar
posibles virus en sus contenidos. Estos programas J>.<0*"% .$% (H#$ no necesitan ser
recompilados, y una vez verificados (pues Java trabaja con nombres no con
direcciones), se transforman en direcciones fsicas de la mquina destino.
O6'0$-%U\%!)$+/+<>-%.$%/-%+>.<0*%.$%(H#$%
Esta forma de trabajar cuida la seguridad sin un grave perjuicio de la eficiencia. Un
programa en Java es slo unas 20 veces ms lento que uno programado en C, cifra
Pgina 133 de 189

aceptable para la mayora de las tareas, y suponiendo que no se utilice un compilador

JIT.
;*(":(89G6"@"(C9!9*'"@(
Java ofrece un conjunto de clases que permiten utilizar los URLs (Y-<5*&6% d$"*/&+$%
:*+'#*&"). Un URL es una direccin electrnica que permite encontrar una informacin
en Internet especificando:
!"El nombre del protocolo que permitir leer la informacin. Por ejemplo 788E.
!"El nombre del servidor que proporciona la informacin. Por ejemplo "/-"<#$A/-+A$./
o bien una direccin IP directamente.
!"El nombre del fichero en el servidor. Por ejemplo a@'='5'3a@'='5'3AI#6.
<*(D6@6#?(>":(C9!9("'(%'@"#'"@(
Java es seguramente el lenguaje con ms futuro en cuanto a la programacin para
Internet.
De hecho, podra evolucionar hasta el punto de que el navegador no interprete las
applets de Java, sino que l sea un conjunto de applets que se descarguen de Internet
segn se vayan necesitando. As es que en todo momento podramos estar ejecutando la
ltima versin del navegador.
Incluso siendo un poco ms futuristas, podramos plantearnos conectarnos a servidores
que nos cobraran por el uso de sus programas (hojas de clculo, procesadores de
texto...) en funcin del tiempo de uso, trabajando siempre con la ltima versin del
mismo, en lugar de invertir nuestro dinero en actualizaciones.
Pgina 134 de 189

./O%,37%73*p'17%')%-$.$%
9*(D6'>97"'@?$(
Los "*+P$#" son un sistema de comunicacin entre procesos de diferentes mquinas de
una red. Ms exactamente, un "*+P$# es un punto de comunicacin por el cual un
proceso puede emitir o recibir informacin.
Fueron popularizados por Q$&+P?$H% M*5#N'&$% R<"#&<(/#<*-, de la universidad
norteamericana de Berkley. Los "*+P$#" han de ser capaces de utilizar el protocolo de
streams TCP (Transfer Contro Protocol) y el de datagramas UDP (User Datagram
Protocol).
Utilizan una serie de primitivas para establecer el punto de comunicacin, para
conectarse a una mquina remota en un determinado puerto que est disponibleD% para
escuchar en l, para leer o escribir y publicar informacin en l, y finalmente para
desconectarse.
Con todas primitivas se puede crear un sistema de dilogo muy completo.
O6'0$-%Tz\%x/-+<*-'6<$-#*%.$%/-'%+*-$g<>-%"*+P$#%
Para ms informacin vase h.RllX^Ne,3FFDi.
Pgina 135 de 189

;*("C"78:?(>"(6$?(
Para comprender el funcionamiento de los "*+P$#" no hay nada mejor que estudiar un
ejemplo. El que a continuacin se presenta establece un pequeo dilogo entre un
programa servidor y sus clientes, que intercambiarn cadenas de informacin.
8/9%4:?V:8H8%*G;A<DA%
El programa cliente se conecta a un servidor indicando el nombre de la mquina y el
nmero puerto (tipo de servicio que solicita) en el que el servidor est instalado.
Una vez conectado, lee una cadena del servidor y la escribe en la pantalla:
import java.io.*;
import java.net.*;
class Cliente {
static final String HOST = "localhost";
static final int PUERTO=5000;
public Cliente( ) {
try{
Socket skCliente = new Socket( HOST , Puerto );
InputStream aux = skCliente.getInputStream();
DataInputStream flujo = new DataInputStream( aux );
System.out.println( flujo.readUTF() );
skCliente.close();
System.out.println( e.getMessage() );
}
}
public static void main( String[] arg ) {
new Cliente();
}
}
En primer lugar se crea el "*+P$# denominado "PJ?<$-#$, al que se le especifican el
nombre de I*"# (7FM8) y el nmero de puerto (EFd8) en este ejemplo constantes.
Luego se asocia el flujo de datos de dicho "*+P$# (obtenido mediante 0$#O-,/#M#&$'6;),
que es asociado a un flujo (5?/)*) R'#'O-,/#M#&$'6 de lectura secuencial. De dicho flujo
capturamos una cadena ( &$'.Y8x2;%), y la imprimimos por pantalla (MH"#$6A*/#).
El "*+P$# se cierra, una vez finalizadas las operaciones, mediante el mtodo +?*"$2;.
Debe observarse que se realiza una gestin de excepcin para capturar los posibles
fallos tanto de los flujos de datos como del "*+P$#.
Pgina 136 de 189

B/9%4:?V:8H8%7A:T;@?:%
El programa servidor se instala en un puerto determinado, a la espera de conexiones, a
las que tratar mediante un segundo "*+P$#.
Cada vez que se presenta un cliente, le saluda con una frase "Hola cliente N".
Este servidor slo atender hasta tres clientes, y despus finalizar su ejecucin, pero es
habitual utilizar bucles infinitos ( NI<?$2#&/$; ) en los servidores, para que atiendan
llamadas continuamente.
Tras atender cuatro clientes, el servidor deja de ofrecer su servicio:
import java.io.* ;
import java.net.* ;
class Servidor {
static final int PUERTO=5000;
public Servidor( ) {
try {
ServerSocket skServidor = new ServerSocket( PUERTO );
System.out.println("Escucho el puerto " + PUERTO );
for ( int numCli = 0; numCli < 3; numCli++; ) {
Socket skCliente = skServidor.accept(); // Crea objeto
System.out.println("Sirvo al cliente " + numCli);
OutputStream aux = skCliente.getOutputStream();
DataOutputStream flujo= new DataOutputStream( aux );
flujo.writeUTF( "Hola cliente " + numCli );
skCliente.close();
} // Cierra while
System.out.println("Demasiados clientes por hoy");
System.out.println( e.getMessage() );
}
}
public static void main( String[] arg ) {
new Servidor();
}
}
Utiliza un objeto de la clase M$&=$&M*+P$#% ("PM$&=<.*&), que sirve para esperar las
conexiones en un puerto determinado (EY!d8F), y un objeto de la clase M*+P$#
("PJ?<$-#$;%que sirve para gestionar una conexin con cada cliente.
Pgina 137 de 189

Mediante un bucle 5*& y la variable -/6J?< se restringe el nmero de clientes a tres, con
lo que cada vez que en el puerto de este servidor aparezca un cliente, se atiende y se
incrementa el contador.
Para atender a los clientes se utiliza la primitiva '++$,#2; de la clase M$&=$&M*+P$#, que
es una rutina que crea un nuevo M*+P$# ("PJ?<$-#$) para atender a un cliente que se ha
conectado a ese servidor.
Se asocia al "*+P$# creado ("PJ?<$-#$) un flujo (5?/)*;% de salida R'#'F/#,/#M#&$'6 de
escritura secuencial, en el que se escribe el mensaje a enviar al cliente.
El tratamiento de las excepciones es muy reducido en nuestro ejemplo, tan solo se
captura e imprime el mensaje que incluye la excepcin mediante 0$#9$""'0$2;.
=/9%'KA=F=;E<%
Aunque la ejecucin de los "*+P$#" est diseada para trabajar con ordenadores en red,
en sistemas operativos multitarea (por ejemplo Windows y UNIX) se puede probar el
correcto funcionamiento de un programa de "*+P$#" en una misma mquina.
Para ellos se ha de colocar el servidor en una ventana, obteniendo lo siguiente:
>java Servidor
Escucho el puerto 5000
En otra ventana se lanza varias veces el programa cliente, obteniendo:
>java Cliente
Hola cliente 1
>java Cliente
Hola cliente 2
>java Cliente
Hola cliente 3
>java Cliente
connection refused: no further information
Mientras tanto en la ventana del servidor se ha impreso:
Sirvo al cliente 1
Sirvo al cliente 2
Sirvo al cliente 3
Demasiados clientes por hoy
Cuando se lanza el cuarto de cliente, el servidor ya ha cortado la conexin, con lo que se
lanza una excepcin.
Obsrvese que tanto el cliente como el servidor pueden leer o escribir del "*+P$#. Los
mecanismos de comunicacin pueden ser refinados cambiando la implementacin de los
"*+P$#", mediante la utilizacin de las clases abstractas que el paquete )'='A-$# provee.
Pgina 138 de 189

@"79(!%E(988:"@$(C9!9(
Pgina 139 de 189

.(/0/%()123&"**(+)%$%,$7%$44,'17%
9*(%'@#?>6<<%&'(
Las ',,?$#" (miniaplicacin) son programas escritos en Java que sirven para dar vida
a las pginas Web (interaccin en tiempo real, inclusin de animaciones, sonidos...), de
ah su potencia.
Las ',,?$#" son programas que se incluyen en las pginas Web. Las ',,?$#"% "on
ejecutadas en la mquina cliente, con lo que no existen ralentizaciones por la saturacin
del mdem o del ancho de banda. Permiten cargar a travs de la red una aplicacin
portable que se ejecuta en el navegador. Para que esto ocurra tan slo hace falta que el
navegador sea capaz de interpretar Java.
A las pginas que contienen ',,?$#" se las denomina pginas @'='Ê*N$&$.. Las ',,?$#"
pueden ser visualizadas con la herramienta ',,?$#=<$N$&, incluido en el JDK de Java.
Las ',,?$#" no son exactamente aplicaciones Java, ya que presentan las siguientes
diferencias respecto a las aplicaciones normales Java:
Se cargan mediante un navegador, no siendo lanzados por el intrprete Java.
Son cargados a travs de la red por medio de pginas HTML y no residen en el disco
duro de la mquina que los ejecuta.
Poseen un ciclo de vida diferente; mientras que una aplicacin se lanza una vez, una
',,?$# se arranca (inicia) cada vez que el usuario recarga la pgina en la que se
encuentra la ',,?$#.
Tienen menos derechos que una aplicacin clsica, por razones de seguridad. De modo
predeterminado en el puesto que los ejecuta no pueden ni leer ni escribir ficheros, ni
lanzar programas, ni cargar DLLs. Slo pueden comunicarse con el servidor Web en
que se encuentra la pgina Web que las contiene.
;*(<?'$%>"#9<%?'"$($?;#"(:9($"B6#%>9>("'(:9$(988:"@$(
Como ya se ha dicho las applets tienen una serie de restricciones de programacin que
las hacen "seguras".
Estas restricciones de seguridad son especialmente importantes, ya que evitarn que se
cargue por error una ',,?$# que destruya datos de la mquina, que obtenga informacin
restringida, o que produzca otros daos inesperados.
Las ',,?$#" no dejan de ser ejecutables que funcionan dentro de una aplicacin, como
puede ser un visualizador de pginas Web ((&*N"$&). Este ejecutable puede obtenerse
de una red, lo que significa que hay cdigo posiblemente no fiable que se ejecuta dentro
de la aplicacin.
Java tiene muchas salvaguardas de seguridad que minimizan el riesgo de la ejecucin de
applets, pero estas salvaguardas tambin limitan a los programadores de ',,?$#" en su
capacidad de programacin.
El modelo de seguridad para las ',,?$#" en Java trata una ',,?$# como cdigo no fiable
ejecutndose dentro de un entorno fiable. Por ejemplo, cuando un usuario instala una
copia de un navegador Web en una mquina se est fiando de que su cdigo ser
Pgina 140 de 189

funcional en el entorno. Normalmente los usuarios tienen cuidado de qu instalan

cuando proviene de una red. Una ',,?$#, por el contrario, se carga desde la red sin
ninguna comprobacin de su fiabilidad.
El lenguaje Java y las ',,?$#" son escritos para que eviten las ',,?$#" no fiables.
Estas salvaguardas son implementadas para verificar que los cdigos de byte de las
clases de los applets, no rompen las reglas bsicas del lenguaje ni las restricciones de
acceso en tiempo de ejecucin. Slo cuando estas restricciones son satisfechas se le
permite a la ',,?$# ejecutar su cdigo. Cuando se ejecuta, se le marca para sealar que
se encuentra dentro del intrprete. Esta marca permite a las clases de tiempo de
ejecucin determinar cundo a una fraccin del cdigo se le permite invocar a cierto
mtodo. Por ejemplo, una ',,?$# est restringida en los I*"#" en los que se puede abrir
una conexin de red o en un conjunto de URLs a las que puede acceder.
En su conjunto estas restricciones constituyen una poltica de seguridad. En el futuro,
Java tendr polticas ms ricas, incluyendo algunas que usen encriptacin y
autentificacin para permitir a las ',,?$#" una mayor capacidad.
La actual poltica de seguridad afecta a los recursos que una ',,?$# puede usar, cuyos
principales puntos son:
!"Los accesos que pueden realizar las ',,?$#" a los ficheros son restringidos. En
particular escribir en ficheros y/o leerles no ser una capacidad estndar que se
pueda realizar en los navegadores que soporten ',,?$#" de Java.
!"Las conexiones de red sern restringidas a conectar solo con el I*"# del que proviene
la ',,?$#.
!"Una ',,?$# no es capaz de usar ningn mtodo que pueda resultar en una ejecucin
arbitraria, cdigo no revisado o ambos. Esto incluye mtodos que ejecuten
programas arbitrarios (mtodos nativos) as como la carga de bibliotecas dinmicas.
Se anticipa en cualquier caso que en el futuro los modelos de seguridad permitirn a las
',,?$#" autentificadas superar estas restricciones.
Pgina 141 de 189

.(/O/%,$%*,$7'%$44,'1%
9*($%@69<%&'(>"(:9(<:9$"(988:"@("'(:9(98%(>"(C9!9(
La clase G,,?$# Java, de la cual han de heredar todos los programas Java que vayan a
actuar como ',,?$#", es la nica clase que contiene el paquete )'='A',,?$# de la API de
Java.
Esta clase hereda de F()$+# (como todas las clases Java), pero adems hereda de
J*6,*-$-# y J*-#'<-$&, que son dos clases del paquete grfico AWT. Esto ya perfila
las posibilidades grficas de este tipo de aplicaciones Java.
;*(7H@?>?$(>":(<%<:?(>"(!%>9(
Como ya se ha indicado una ',,?$# no tiene un ciclo de vida tan "sencillo" como el de
una aplicacin, que simplemente se ejecuta hasta que finaliza su mtodo 6'<-2;.
La siguiente figura modeliza el ciclo de vida de una ',,?$#:
O6'0$-%TT\%J<+?*%.$%=<.'%.$%/-'%',,?$#%
Cada crculo representa una fase en el ciclo de vida de la ',,?$#. Las flechas representan
transiciones y el texto representa la accin que causa la transicin. Cada fase est
marcada con una invocacin a un mtodo de la ',,?$#:
!"=*<.% <-<#2;v Es invocado cuando se carga la ',,?$#. Aqu se suelen introducir las
iniciaciones que la ',,?$# necesite.
!"=*<.% "#'vEs invocado cuando la ',,?$#, despus de haber sido cargada, ha sido
parada (cambio de pgina Web, minimizacin del navegador,...), y de nuevo
activada (vuelta a la pgina, restauracin del navegador,...). Se informa a la ',,?$#
de que tiene que empezar su funcionamiento.
!"=*<.%"#*,2;v%Es invocado para informar a la ',,?$# de que debe de parar su ejecucin.
As una ',,?$# que utilice #I&$'.", debera detenerlos en el cdigo de este mtodo.
!"=*<.%.$"#&*H2;vEs invocado para informar a la ',,?$# de que su espacio est siendo
solicitado por el sistema, es decir el usuario abandona el navegador. La ',,?$# debe
de aprovechar este momento para liberar o destruir los recursos que est utilizando.
Pgina 142 de 189

!"=*<.%,'<-#2;v%Es invocado cada vez que hay que el navegador redibuja la ',,?$#.
Al crear una ',,?$# no es necesario implementar todos estos mtodos. De hecho habr
',,?$#" que no los necesiten.
Cuando un navegador carga una pgina Web que contiene una ',,?$#, suele mostrar en
su parte inferior un mensaje como:
initializing... starting...
Esto indica que la ',,?$#, se est cargando:
1. Una instancia de la clase ',,?$# es creada.
2. La ',,?$# es iniciada, mediante su mtodo <-<#2;.
3. La ',,?$# empieza a ejecutarse, mediante su mtodo "#'.
Cuando el usuario se encuentra con una pgina Web, que contiene una ',,?$# y salta a
otra pgina, entonces la ',,?$# se detiene invocando a su mtodo "#*,2;. Si el usuario
retorna a la pgina donde reside la ',,?$#, sta vuelve a ejecutarse nuevamente
invocando a su mtodo "#'.
Cuando el usuario sale del navegador la ',,?$# tiene un tiempo para finalizar su
ejecucin y hacer una limpieza final, mediante el mtodo .$"#&*H2;.
<*(:9(<:9$"(6#:(
Un URL (Uniform Resource Locator) es una direccin de Internet. Cada recurso
(fichero, pgina Web, imagen...) tiene uno propio. En Java existe una clase denominada
Yd: que modeliza esta clase de objetos.
La clase Yd: pertenece al paquete )'='A-$#, y tiene una cierta importancia en el
desarrollo de las ',,?$#", puesto que muchos de los mtodos de la clase G,,?$# la
utilizan para acceder a determinado recurso de Internet o para identificarse.%
Podemos especificar un URL de manera absoluta:
URL URLabsoluto = new URL(http://www.host.com/dir/fich.htm);
O bien podemos especificar un Yd: de manera relativa:
URL URLhost = new URL(http://www.Javasoft.com/);
URL URLrelativo = new URL( URLhost, dir/fich.htm);
Ambos ejemplos corresponderan al URL "I##,\aaNNNAI*"#A+*6a.<&a5<+IAI#6".
>*(%'<:6$%&'(>"(:9(988:"@("'(6'9(8AB%'9(P";(
Para incluir una ',,?$# en una pgina Web, una vez compilada la ',,?$#, debe incluirse
entre el cdigo HTML de la pgina Web una etiqueta iGEE:!8c, que como mnimo
ha de presentar los siguientes tres parmetros:
!"+*.$: Especifica el URL del fichero de clase Java (*.class) que contiene la ',,?$#.
!"width: Especifica la anchura inicial de la ',,?$# (en ,<g$?").
!"I$<0#I: Especifica la altura inicial de la ',,?$# (en ,<g$?").
Adems, de la etiqueta inicial, una ',,?$# puede tener parmetros que se especificarn
mediante etiquetas iEGdG9c, que como mnimo han de presentar dos parmetros:
Pgina 143 de 189

!"-'6$: Indica el nombre del parmetro de la ',,?$# al que esta etiqueta hace
referencia.
!"='?/$: Establece este valor al parmetro indicado en -'6$ de la misma etiqueta.
As un ejemplo de esto sera:
<applet code="AppletDiagonal.class" width=200 height=200>
<param name=Parametro1 value=Valor1>
<param name=Parametro2 value=Valor2>
</applet>
En este ejemplo la ',,?$# puede entender los parmetro E'&'6$#&*T y E'&'6$#&*_,
mediante los mtodos que se describen en el siguiente apartado, y obtendra ['?*&T y
['?*&_ respectivamente.
Se observa que adems de la etiqueta i',,?$#c en el cdigo HTML tambin aparece
una etiqueta ia',,?$#c. Esto sucede porque HTML es un lenguaje pareado, en el que
casi todas las etiquetas de inicio de elemento (i$#<3c) tienen una etiqueta de fin
(ia$#<3c).
"*(?;@"'<%&'(>"(:?$(89#A7"@#?$(>"(:9(988:"@(
Cuando se incluye una ',,?$# en una pgina Web ha de hacerse mediante la etiqueta
HTML i',,?$#c. Las etiquetas HTML permiten utilizar parmetros, y la etiqueta
i',,?$#c hace lo propio, permitiendo a la ',,?$# recibir parmetros de ejecucin, tal y
como una aplicacin los recibe en el parmetro " (un vector de cadenas) de su mtodo
6'<-2M#&<-0oq%";A
Los siguientes mtodos se utilizan para extraer informacin de los parmetros que
recibi la ',,?$# cuando fue llamada desde el cdigo HTML:
!"Yd:%0$#R*+/6$-#Q'"$2;v Devuelve el URL del documento que contiene la ',,?$#.
!"Yd:%0$#J*.$Q'"$2;v Devuelve el URL de la ',,?$#.
!"M#&<-0% 0$#E'&'6$#$&2M#&<-0% -'6$;v Devuelve el valor de un parmetro (etiquetas
i,'&'6c) que aparezca en el documento HTML.
Si por ejemplo se llamase a una ',,?$#, con el cdigo HTML:
<applet code=AppletParam.class width=50 height=50>
<param name=Color value=red>
</applet>
Una llamada en esta ',,?$# al mtodo 0$#E'&'6$#$&2J*?*&; devolver &$..
D*(?;@"'<%&'(>"(%'D?#79<%&'($?;#"(6'9(988:"@(
Algunos mtodos de la ',,?$# se utilizan para comunicar informacin o mostrar
mensajes en la pantalla referentes a la ',,?$#:
!"(**?$'-%<"G+#<=$2;v Comprueba si la ',,?$# est activa.
!"=*<.%"I*NM#'#/"2M#&<-0%"#'#/";v Muestra una cadena del estado en la pantalla.
Pgina 144 de 189

!"M#&<-0% 0$#G,,?$#O-5*2;; Devuelve informacin relativa a la ',,?$# como el autor,

Copyright o versin.
!"M#&<-0o%qo%q%0$#E'&'6$#$&O-5*2;v Devuelve un vector que describe algn parmetro
especfico de la ',,?$#. Cada elemento en el vector es un vector de tres cadenas que
tienen la forma: {nombre, tipo, comentario}.
Un ejemplo de como definir este mtodo para una ',,?$# que permita un solo
parmetro, color, sera:
public String[][] getParameterInfo() {
String info[][] = { {Color,String,foreground color} };
return info;
}
B*(79'%86:9<%&'(>":("'@?#'?(>"(6'9(988:"@(
Algunas applets pueden afectar al entorno en que estn ejecutndose. Para ello se
utilizan los mtodos:
!"G,,?$#J*-#$g#% 0$#G,,?$#J*-#$g#2;v Devuelve un G,,?$#J*-#$g#, que permite a la
',,?$# afectar a su entorno de ejecucin.
!"=*<.%&$"<C$2%<-#%'-+I*D%<-#%?'&0*;v Solicita que se modifique el tamao de la ',,?$#.
Tambin permite recibir un nico parmetro R<6$-"<*-.%
!":*+'?$%0$#:*+'?$2;v Devuelve el :*+'?$ de la ',,?$# si fue establecido.
!"=*<.%"$#M#/(2%G,,?$#M#/(%"%;v Establece el "#/( de esta ',,?$#.%
M*($?8?#@"(76:@%7">%9(
La clase G,,?$# tambin incluye mtodos para trabajar con imgenes y ficheros de
sonido de Internet mediante la utilizacin de URLs. Para ello implementa los mtodos:
!"O6'0$% 0$#O6'0$2Yd:% /D% M#&<-0% ";v Obtiene una imagen de un URL / que ser
absoluto si no se especifica una ruta relativa ".
!"G/.<*J?<,%0$#G/.<*J?<,2Yd:%/D%M#&<-0%";v Obtiene un clip de sonido de un URL /
que ser absoluto si no se especifica una ruta relativa ".
!"=*<.%,?'H2Yd:%/&TD%M#&<-0%-'6$;v Ejecuta directamente un fichero de sonido de un
URL / que ser absoluto si no se especifica una ruta relativa ".
!""#'#<+% '/.<*J?<,% -$NG/.<*J?<,2Yd:% /;v% Obtiene un nuevo fichero de sonido del
URL /.
Mediante el uso adecuado de varios de estos mtodos se pueden combinar sonidos e
imgenes para conseguir efectos espectaculares.
Pgina 145 de 189

.(/Q/%'-'54,3%&'%*3)712"**(+)%&'%")$%$44,'1%
9*(<&>%B?(
Para crear una ',,?$# normalmente ser necesario importar al menos las bibliotecas
)'='A'N#An y la )'='A',,?$#An.
La clase que represente a la ',,?$# se ha de declarar como una subclase de la clase
G,,?$#, para poder sobreescribir los mtodos de la clase G,,?$#.
Siempre conviene sobreescribir al menos el mtodo ,'<-#2; que ser llamado por los
navegadores que soporten ',,?$#" para mostrarles por pantalla.
Vamos a construir una ',,?$# denominada G,,?$#R<'0*-'? que simplemente dibuje una
lnea diagonal. Un posible cdigo para esta ',,?$# sera:
import java.awt.*;
import java.applet.*;
public class AppletDiagonal extends Applet {
public void paint(Graphics g) {
g.setColor( Color.red );
g.drawLine(0, 0, getWidth(), getHeight() );
}
}
Pasemos a comentar el funcionamiento de este cdigo:
!"El mtodo ,'<-#2; recibe un objeto de la clase X&',I<+". La clase X&',I<+", incluida
en el AWT, contiene mtodos para mostrar varios tipos de grficos.
!"Mediante el mtodo "$#J*?*&2; de la clase X&',I<+" se establece el color de primer
plano a rojo, que es uno de los colores predefinidos de la clase J*?*&.
!"Por ltimo, mediante .&'N:<-$2;% se dibuja una lnea dadas las coordenadas de su
esquina superior izquierda y de la inferior derecha. En este caso se indican la
esquina superior izquierda de la ',,?$# mediante las coordenadas (zDz), y la esquina
inferior derecha se obtiene mediante dos mtodos de la clase R<6$-"<*- (
0$#L<.#I2;D%0$#7$<0I#2;%).
;*("C"<6<%&'(
Para ejecutar la ',,?$#, una vez compilado el fichero, se introduce la llamada a la ',,?$#
en una pgina Web (por ejemplo G,,?$#R<'0*-'?AI#6), introduciendo entre su cdigo
HTML lo siguiente:
<applet code="AppletDiagonal.class" width=200 height=200>
</applet>
Pgina 146 de 189

Cuando se cargue esta pgina Web en un navegador compatible con Java o mediante el
visualizador de ',,?$#"%que viene con el JDK (',,?$#=<$N$&) se ver algo como:
O6'0$-%T_\%G,,?$#%Lnea%
Se podra dibujar un rectngulo con cambiar la lnea de cdigo de .&'N:<-$2;%por otra
que llamase al mtodo .&'Nd$+#2;:
g.drawRect(10, 10, r.width 20, r.height 20);
<*(<#"9<%&'(>"(988:"@$(7A$(9!9'K9>9$(
La creacin de ',,?$#" complejos, escapa a las intenciones de este tutorial, con lo que
no se va a presentar el cdigo fuente de ms ',,?$#".
El dominio de la biblioteca AWT es una condicin imprescindible para la creacin de
',,?$#" de ms calidad y vistosidad.
Por ltimo recordar que con el JDK se incluyen unas cuantas ',,?$#" que pueden servir
para el estudio de las mismas, puesto que se incluye su cdigo fuente.
Para ms informacin consulte h]PS,;Ull,^N,PX2e,3FF9i.
>*(<#"9<%&'(>"(6'9(98:%<9<%&'(G6"(6@%:%<"(:9(988:"@(U9P@V(
Se va a utilizar AWT para crear una aplicacin que de un resultado igual que la
ejecucin de la Z',,?$#%:1-$'Z. Ser una aplicacin que crear un x&'6$ de AWT para
incluir en su interior la ',,?$# que ya fue creada.
De hecho el 6'<-2; de la aplicacin lo nico que har ser crear un objeto de este tipo
(indicndole altura y anchura, como hacamos en la ',,?$# mediante los parmetros de
la etiqueta HTML).
El cdigo fuente de la aplicacin sera el siguiente:
import java.awt.*;
import java.awt.event.*;
class FrameLinea extends Frame {

private AppletDiagonal unaApplet; // Se mostrar
Pgina 147 de 189

public static void main( String[] s ) {

new FrameLinea( 200, 230 );
}
public FrameLinea( int ancho, int largo ) {
super(); // Constructor de Component
// Se aade un oyente que cerrara la aplicacin
addWindowListener( new OyenteLinea() );
// Se crea una applet de diagonal
unaApplet=new AppletDiagonal();
unaApplet.init();
unaApplet.start();
// Se mete la applet en frame
add( unaApplet );
setSize(ancho,largo); // ajusta frame
setVisible(true); // muestra frame
}
// Clase anidada
class OyenteLinea extends WindowAdapter {
// Sobreescribo el mtodo de "cuando se cierra ventana"
public void windowClosing(WindowEvent e) {
unaApplet.stop();
unaApplet.destroy();
System.exit(0);
}
}
}
Vamos a crear un x&'6$ en el que vamos a incluir la ',,?$# /-'G,,?$# que ser de la
clase G,,?$#R<'0*-'?, creada anteriormente.
La aplicacin lo que hace es crear un oyente de la clase creada FH$-#$:<-$', que ser el
encargado de capturar el evento de cerrar la ventana del x&'6$.
En el constructor se inicia la ',,?$# (<-<#2; y "#') y se aade al x&'6$% mediante el
mtodo '..2; de la clase J*-#'<-$& (x&'6$ es hija de J*-#'<-$&).
Por ltimo se establece el tamao del x&'6$ (recibido por parmetro) mediante "$#M<C$2;
y por ltimo se muestra el x&'6$ que ya tiene en su interior la ',,?$# ("$#[<"<(?$2;).
Cuando se cierra la ventana, el FH$-#$:<-$' se encarga de cerrar la ',,?$#D mediante
"#*,2; y .$"#&*H2;D y de finalizar la aplicacin mediante MH"#$6A$g<#2;.
Pgina 148 de 189

"*(<#"9<%&'(>"(6'9(98:%<9<%&'(G6"(6@%:%<"(:9(988:"@(U$P%'BV(
Esta misma aplicacin se puede crear utilizando Swing con solo cambiar las siguientes
cosas:
1. Se ha de incluir la biblioteca de Swing:
import javax.swing.*;
2. Se han de cambiar los nombres de la clase x&'6$ de AWT por la clase @x&'6$ de
Swing.
3. Se crea un +*-#$-#E'-$ mediante un objeto @E'-$?, justo antes de llamar al oyente:
setContentPane( new JPanel() );
4. Para aadir la ',,?$# se ha de aadir al +*-#$-#E'-$:
getContentPane().add( unaApplet );
Pgina 149 de 189

.(/X/%'-'54,37%&'%$44,'17%
En este apartado se comentan una serie de ',,?$#" que pueden servir tanto para
demostrar las posibilidades de estos programas, como para clasificarles por los
siguientes gneros:
!"Instantneas: Muestran una secuencia de imgenes.
!"Animacin y Sonidos: Mezclan imgenes con sonidos.
!"Grficos Interactivos: Permiten la interaccin del usuario con las imgenes,
mediante respuestas a las acciones del ratn sobre la imagen.
!"Trucos de Texto: Permiten animar texto dndole vida.
!"Financias y Negocios: Algunos nos permiten mostrar diagramas de barras, y otros
elementos ilustrativos de este gnero.
!"Demos, Juegos y Educacionales: Muy especializados, permiten al usuario
interactuar consiguiendo cotas fascinantes de diversin.
A continuacin veremos un ejemplo de cada grupo que sea lo ms significativo posible,
es decir, que resalte las caractersticas de ese grupo y las diferencias con el resto de los
grupos.
En cada uno de ellos se ha incluido una descripcin de lo que hace la ',,?$#, los
parmetros que soporta, y un ejemplo del cdigo HTML que habra que insertar en una
pgina Web para incluir la ',,?$# en dicha pgina.
9*(%'$@9'@A'"9$E(W@67;:%'B(>6N"X(
O6'0$-%T`\%G,,?$#%O-"#'-#4-$'%8/6(?<-0%R/P$%
8/9%&AC=:;>=;E<%
Se trata de una ',,?$# en la que R/P$D la mascota de Java, da volteretas en la pgina
correspondiente. La animacin consta de 17 secuencias.
B/9%48:RHAD:?C%
!"6'gN<.#I: Anchura mxima de la imagen durante la animacin.
!"-<60": Nmero de marcos o secuencias en la animacin.
!"*55"$#: Desplazamiento horizontal entre la primera y la ltima secuencia de la
animacin.
!"<60: URL del directorio donde se encuentran almacenadas las diferentes secuencias
de la animacin: T1.gif, T2.gif...
Pgina 150 de 189

=/9%'KAH>G?%
<applet code=TumbleItem.class width=600 height=95>
<param name=maxwidth value=120>
<param name=nimgs value=16>
<param name=offset value=-57>
<param name=img value=tumble>
</applet>
;*(9'%79<%&'(L($?'%>?E(W9'%79@?#X(
O6'0$-%Tw\%G,,?$#%.$%G-<6'+<>-%H%"*-<.*%G-<6'#*&%
8/9%&AC=:;>=;E<%
Esta ',,?$# permite crear una animacin con sonido.
Se puede especificar el orden de las secuencias, si la animacin se repite, la pista de
sonido, otros sonidos para determinadas secuencias, el espacio de tiempo entre
secuencias, una imagen por defecto mientras se est iniciando la ',,?$#, la posicin
exacta en la que se quiere que aparezca cada secuencia...
Haciendo un +?<+ con el ratn sobre la ',,?$# se detiene la animacin. Haciendo otro
contina la ejecucin.
B/9%48:RHAD:?C%
!"<6'0$"*/&+$: URL del directorio que contiene las imgenes de la animacin:
T1.gif...
!""#'&#/,: URL de la imagen que aparecer por defecto mientras se cargan el resto de
las secuencias.
!"('+P0&*/-.: URL de la imagen de fondo.
!""#'&#<6'0$: ndice de la primera secuencia.
!"$-.<6'0$: ndice de la ltima secuencia de la animacin.
!",'/"$": Lista de las pausas en milisegundos. Permite especificar una pausa
especfica para cada secuencia. Cada nmero se separa mediante el carcter |.
!"&$,$'#: Indicador de repeticin. Se una para repetir la secuencia de animaciones. Su
valor por defecto es #&/$.
!",*"<#<*-": Coordenadas de la posicin de cada marco o secuencia (x@y). Permite
mover la animacin alrededor. Cada par de coordenadas se separa por el carcter |.
!"<6'0$": ndices de las imgenes. Permite repetir las imgenes de la animacin. Cada
nmero se encuentra separado por el carcter |.
Pgina 151 de 189

!""*/-."*/&+$: URL del directorio que contiene los archivos de sonido.

!""*/-.#&'+P: URL del archivo de sonido que suena de fondo.
!""*/-.": Lista de URLs de archivos de sonido para cada secuencia de la ',,?$#. Se
encuentran separados por el carcter |.
=/9%'KAH>G?%
<applet code=Animator.class width=64 height=64>
<param name=imagesource value=tower>
<param name=endimage value=2>
<param name=soundsource value=audio>
<param name=soundtrack value=spacemusic.au>
<param name=sounds value=1.au|2.au>
<param name=pause value=200>
</applet>
<*(B#AD%<?$(%'@"#9<@%!?$E(W:%'N(;6@@?'X(
O6'0$-%Ty\%G,,?$#%.$%0&45<+*"%<-#$&'+#<=*"%:<-P%Q/##*-%
8/9%&AC=:;>=;E<%
Esta ',,?$# permite colocar un botn en una pgina Web. Cuando se pulse el botn
aparecer una nueva pgina, o se reproducir un determinado archivo de sonido,...
B/9%48:RHAD:?C%
!"I&$5: URL del documento o archivo al que hay que llamar cuando un usuario pulsa
el botn. Este URL tambin puede hacer referencia a una posicin concreta de la
pgina actual.
!""-.: URL del archivo de sonido que se va a reproducir cuando se pulse el botn.
=/9%'KAH>G?%
<applet code=LinkButton.Java width=100 height=30>
<param name=lbl value=Java>
<param name=href value=http://www.Javasoft.com/>
Pgina 152 de 189

<param name=snd value=computer.au>

</applet>
>*(@#6<?$(>"(@"O@?E(W'"#!?6$(@"O@X(
O6'0$-%T|\%G,,?$#%.$%#$g#*%'-<6'.*%]$&=*/"%8$g#%
8/9%&AC=:;>=;E<%
Esta ',,?$# muestra una lnea de texto en la que las letras, aleatoriamente, se estn
desplazando de tal forma que se superponen con las letras contiguas.
Es algo muy sencillo pero, por otra parte, muy llamativo.
B/9%48:RHAD:?C%
!"#$g#: El texto (slo una lnea) que se mostrar en la ',,?$#.
=/9%'KAH>G?%
<applet code=NervousText.class width=200 height=50>
<param name=text value=hello World!>
</applet>
@/9%)?D8C%
Se necesitar establecer bien la anchura de la ',,?$# para que quepa toda la lnea.
Puede servir para una firma en los mensajes de correo electrnico o de noticias, pero no
podr verse si el navegador no soporta Java.
"*(D%'9'<%9$(L('"B?<%?$E(W;9#(<M9#@X(
O6'0$-%T\%G,,?$#%.$%5<-'-+<'"%H%-$0*+<*"%Q'&%JI'&#%
Pgina 153 de 189

8/9%&AC=:;>=;E<%
Esta ',,?$# muestra un grfico de barras basado en los parmetros que recibe.
B/9%48:RHAD:?C%
!"#<#?$: Ttulo del grfico. Aparecer debajo de las grficas.
!"+*?/6": Nmero de columnas (barras) en el grfico.
!"*&<$-#'#<*-: Posicin de las barras: horizontales o verticales.
!""+'?$: Escala de representacin (en pixels por unidad de barra).
!"+i]cf"#H?$: Textura de las barras: lisas o rayadas.
!"+i]cf='?/$: Unidades de medida: dlares, das...
!"+i]cf?'($?: Etiqueta de la barra: dinero, tiempo...
!"+i]cf+*?*&: Color de la barra: verde, azul, rosa, naranja, magenta ,amarillo...
=/9%'KAH>G?%
<applet code=Chart.class width=251 height=125>
<param name=title value=Performance>
<param name=columns value=4>
<param name=orientation value=horizontal>
<param name=scale value=5>
<param name=c1_style value=striped>
<param name=c1 value=10>
<param name=c1_color value=blue>
<param name=c1_label value=Q1>
<param name=c2_color value=green>
<param name=c2_style value=solid>
<param name=c3_style value=striped>
<param name=c3_color value=magenta>
<param name=c4_color value=yellow>
<param name=c4_style value=solid>
Pgina 154 de 189

@/9%)?D8C%
Si se modifica la orientacin (ponindola en vertical) habr que escoger una anchura y
altura adecuadas para que todo el grfico quepa dentro de la zona reservada para la
',,?$#.
El usuario no puede interactuar con el grfico. Slo se muestra en pantalla.
D*(C6"B?$(L(">6<9<%?'9:"$E(WB#98M(:9L?6@X(
O6'0$-%TV\%G,,?$#%.$%)/$0*"%H%$./+'+<*-'?$"%X&',I%:'H*/#%
8/9%&AC=:;>=;E<%
Es una ',,?$# que despliega un grafo, consistente en un conjunto de nodos y arcos.
Se pueden definir los nodos que se van a usar as como la longitud ptima de los arcos.
El grafo est construido mediante un algoritmo heurstico.
B/9%48:RHAD:?C%
!"+$-#$&: Nodo central del grafo (en color rojo) que se sita en el centro de la pantalla.
!"Los nodos se crean cuando se necesitan.
!"$.0$": Arcos del grafo. Este parmetro consiste en una lista (separada por comas),
de arcos. Cada arco se define mediante un par de nodos entre las etiquetas *&<0$-^
.$"#<-*a?*-0<#/., donde la longitud del arco (?*-0<#/.) es opcionalA
=/9%'KAH>G?%
<applet code="Graph.class" width=400 height=400>
<param name=edges value="joe-food, joe-dog, joe-tea,
joe-cat, joe-table, table-plate/50, plate-food/30,
food-mouse/100, food-dog/100, mouse-cat/150, tab1e-cup/30,
Pgina 155 de 189

cup-tea/30, dog-cat/80, cup-spoon/50, plate-fork,

dog-fleal, dog-f1ea2, f1ea1-f1ea2/20, p1ate-knive>
<param name=center value="joe">
</applet>
@/9%)?D8C%
El usuario puede recoger nodos y distorsionar el grafo para acelerar el proceso del
esquema.
Pgina 156 de 189

98H'>%<"$(
Pgina 157 de 189

$4q)&(*'%(/%',%-&p%Y-8T8%&ATAG?>HA<D%p;D9%
9*(%'@#?>6<<%&'(
JDK es el acrnimo de "Java Development Kit", es decir Kit de desarrollo de Java. Se
puede definir como un conjunto de herramientas, utilidades, documentacin y ejemplos
para desarrollar aplicaciones Java.
Para la realizacin de este tutorial se ha trabajado con la versin 1.2.0 del JDK.
;*(<?78?'"'@"$(>":(C>N(
8/9%(<D:?@F==;E<%
JDK consta de una serie de aplicaciones y componentes, para realizar cada una de las
tareas de las que es capaz de encargarse
A continuacin se explican ms en profundidad cada uno de ellos, as como su sintaxis,
indicando entre corchetes aquellos elementos que sean opcionales.
Se observar que todos los programas permiten la inclusin de una serie de opciones
sobre su ejecucin antes del primer argumento. Estas opciones se indican precedidas de
un menos(-):
programa -opcion1 -opcion2 Parametro1
Todas las opciones que los ejecutables del JDK presentan se muestran llamando al
programa sin parmetros o con las opciones ^s%o Î$?,:
programa
programa -help
programa -?
B/9%(<DZ:>:ADA%A<%D;AH>?%@A%AKA=F=;E<%Y-2'9%
Permite la ejecucin de los programas Java (*.class) no grficos (aplicaciones).
La sintaxis para su utilizacin es la siguiente:
java [Opciones] ClaseAEjecutar [Argumentos]
!"F,+<*-$": Especifica opciones relacionadas con la forma en que el intrprete Java
ejecuta el programa.
!"J?'"$G!)$+/#'&: Especifica el nombre de la clase cuyo mtodo 6'<-2; se desea
ejecutar como programa. Si la clase reside en un paquete se deber especificar su
ruta mediante en forma ,'3/$#$A"/(,'3/$#$A+?'"$f'f$)$+/#'&.
!"G&0/6$-#*": Especifica los argumentos que se recibirn en el parmetro " del
mtodo 6'<-2M#&<-0%";, por si el programa necesita de parmetros de ejecucin. Si
por ejemplo el programa realiza el filtrado de un archivo, probablemente nos
interese recibir como argumento la ruta del fichero a filtrar, y una ruta destino.
Pgina 158 de 189

=9/%*?H>;G8@?:%
Se utiliza para compilar archivos de cdigo fuente Java (habitualmente *.java), en
archivos de clases Java ejecutables (*.class). Se crea un archivo de clase para cada clase
definida en un archivo fuente.
Este compilador es una utilidad en lnea de comandos con la siguiente sintaxis:
javac [Opciones] ArchivoACompilar
!"F,+<*-$": Especifica opciones de cmo el compilador ha de crear las clases
ejecutables.
!"G&+I<=*GJ*6,<?'&: Especifica la ruta del archivo fuente a compilar, normalmente
una fichero con extensin ZA)'='Z.
@/9%.;CF8G;N8@?:%@A%8>>GADC%
Es una herramienta que sirve como campo de pruebas de applets, visualizando cmo se
mostraran en un navegador, en lugar de tener que esperar.
Al ser activado desde una lnea de rdenes abre una ventana en la que muestra el
contenido de la ',,?$#.
Se activa con la sintaxis:
appletviewer [Opciones] Applet
!"F,+<*-$": Especifica cmo ejecutar la applet Java.
!"G,,?$#: Indica un URL o una ruta de disco que contiene una pgina HTML con una
applet Java empotrada.
A/9%&A>F:8@?:%
Es una utilidad de lnea de comandos que permite depurar aplicaciones Java.
No es un entorno de caractersticas visuales, pero permite encontrar y eliminar los
errores de los programas Java con mucha exactitud. Es parecido en su funcionamiento al
depurador 0.( que se incluye con las distribuciones del compilador 0++a0KK para
C/C++.
Se activa con la sintaxis:
jdb [Opciones]
!"F,+<*-$": Se utiliza para especificar ajustes diferentes dentro de una sesin de
depuracin.
L/9%&ACA<C8HBG8@?:%@A%8:=[;T?%@A%=G8CA%
Se utiliza para desensamblar un archivo de clase. Su salida por defecto, muestra los
atributos y mtodos pblicos de la clase desensamblada, pero con la opcin ^+ tambin
desensambla los cdigos de byte, mostrndolos por pantalla. Es til cuando no se tiene
el cdigo fuente de una clase de la que se quisiera saber cmo fue codificada.
La sintaxis es la siguiente:
javap [Opciones] [NombresClases]
!"F,+<*-$": Especifica la forma en la que se han de desensamblar las clases.
Pgina 159 de 189

!"]*6(&$"J?'"$: Especifica la ruta de las clases a desensamblar, separadas por

espacios.
V/9%!A<A:8@?:%@A%=8BA=A:8%U%8:=[;T?%@A%8>Z<@;=A%
Se utiliza para generar archivos fuentes y cabeceras C para implementar mtodos Java
en C (+>.<0*%-'#<=*). Esto se consigue mediante la generacin de una estructura C cuya
distribucin coincide con la de la correspondiente clase Java.
El generador de cabeceras )'='I, crea los ficheros de cabecera C/C++ para implementar
en esos lenguajes los mtodos nativos que presente un programa Java.
La sintaxis es la siguiente:
javah [Opciones] NombreClase
!"]*6(&$J?'"$: Nombre de la clase desde la cul se van a generar archivos fuente C.
!"F,+<*-$": Forma en la que se generarn los archivos fuente
[/9%!A<A:8@?:%@A%@?=FHA<D8=;E<%
Es una herramienta til para la generacin de documentacin API directamente desde el
cdigo fuente Java. Genera pginas HTML basadas en las declaraciones y comentarios
)'='.*+, con el formato ann%+*6$-#'&<*"%na:
/** Comentarios sobre la clase
@autor: Ignacio Cruzado
*/
class MiClase {
};
La documentacin que genera es del mismo estilo que la documentacin que se obtiene
con el JDK.
Las etiquetas, que se indican con una arroba (), aparecern resaltadas en la
documentacin generada.
Su sintaxis es:
javadoc Opciones NombreArchivo
!"F,+<*-$s: Opciones sobre qu documentacin ha de ser generada.
!"]*6(&$G&+I<=*: Paquete o archivo de cdigo fuente Java, del que generar
documentacin.
;/9%$>>GADC%@A%@AH?CD:8=;E<%
El JDK incluye una serie de applets de demostracin, con su cdigo fuente al completo.
K/9%*E@;V?%LFA<DA%@A%G8%$4(%
El cdigo fuente de la API se instala de forma automtica, cuando se descomprime el
JDK, aunque permanece en formato comprimido en un archivo llamado ""+&AC<,"
localizado en el directorio Java que se cre durante la instalacin.
Pgina 160 de 189

<*(6$?(>":(C>N(
Ya se han visto las diferentes partes de que est compuesto el JDK, pero para el
desarrollo de una aplicacin final Java (ya sea una aplicacin o una ',,?$#), deberemos
utilizar las diferentes herramientas que nos proporciona el JDK en un orden
determinado.
En el siguiente diagrama podemos ver la sucesin de pasos para generar un programa
final Java:
Edicin del fuente:

Editor de Textos
(edit, vi, notepad)
Codigo Fuente Java Documentacin Documentacin HTML

MiClase.java automtica: sobre MiClase
javadoc
Compilacin:
javac MiClase
Ficheros de cabecera
Codebyte Java: Insercin de mtodos C/C++
MiClase.class nativos: fichero.h
javah
Ejecucin del
programa:
java MiClase
Salida del
programa
Ejecucin del applet:

appletviewer MiClase
Pgina Web con applet

Editor de Textos incrustado:
(edit, vi, notepad) Pagina.html
O6'0$-%TU\%Y#<?<C'+<>-%.$?%@RS%
Pgina 161 de 189

>*(?;@"'<%&'("(%'$@9:9<%&'(>":(C>N(
El JDK se puede obtener de las pginas de Sun (I##,\aa)'='A"/-A+*6), y existen
versiones disponibles para varias plataformas entre las que se encuentran:
!"Microsoft Windows 95 y NT 4.0
!"Sun Solaris 2.4 SPARC o 2.5 al 2.6 sobre x86 o SPARC.
!"IBM AIX, OS/400 y OS/390
!"Linux
Si su sistema operativo no ha sido enumerado, por favor consulte a su fabricante, pues
Sun tiene previsto desarrollar su JDK para ms plataformas.
La instalacin es diferente para cada sistema operativo, pero en general muy sencilla. Se
recomienda observar y establecer los valores de las variables de entorno:
!"EG87: Variable de entorno que indica desde qu ruta (adems del directorio actual)
se pueden ejecutar los programas
!"J:GMMEG87: Indica al compilador Java en qu rutas se encuentran los ficheros de
clase.
"*('?!">9>"$("'(:9(!"#$%&'(4*)(>":(C>N(UC9!9()V(
La aparicin de la versin 1.2 del JDK (diciembre de 1997) significa un salto
importante en las capacidades de Java, hasta tal punto que comercialmente se conoce a
esta evolucin como "Java 2".
8/9%*G8CAC%
Se ampla el paquete de clases de JFC(Java Foundation Classes) pasando de 23 a 70
clases. Aparecen nuevos paquetes de la API Java:
!"MN<-0: Nuevo paquete de grficos.
!"@'='%_R: Ampliacin de AWT.
!"@'='%J*??$+#<*-": Incluye nuevas clases que representan estructuras de datos clsicas
de la programacin: [$+#*&D%G&&'H:<"#D%G&&'HM$#D%8&$$9',...
B/9%'L;=;A<DA%AKA=F=;E<%
!"Compatible con programas realizados en otras versiones, tanto en cdigo como en
ejecucin.
!"Compilador ms estricto y que genera un cdigo ms optimizado.
!"Entorno de ejecucin ms rpido y estable (mquina virtual), prximo a la velocidad
de ejecucin de C++, especialmente utilizando los nuevos compiladores Just In
Time (JIT), incorporados en las nuevas JRE, que compilan las clases para las
plataformas locales, aumentando su velocidad de ejecucin.
!"Mejora en la gestin de la seguridad: Control de acceso basado en el plan de accin,
soporte para certificados X509v3 y nuevas herramientas y certificados de seguridad.
!"Mejor tratamiento de sonido.
Pgina 162 de 189

!"Ms velocidad de las clases que utilizan RMI.

!"Y por supuesto se solventan errores de versiones pasadas.
=/9%-8T86A8<C%
!"@'='%E?/0^<-: Permite que las applets y los JavaBeans de una red utilicen el JRE 1.2,
en vez de la mquina virtual del navegador en que se muestren.
!"Se permite a los JavaBeans interactuar con applets y se les da un mejor soporte en
tiempo de diseo y en tiempo de ejecucin.
!"Los JavaBeans se pueden incluir unos en otros.
@/9%3D:?C%
!"OR:% 2O-#$&5'+$% R$5<-<#<*-% :'-0/'0$;: Para interactuar con CORBA de una forma
simple y prctica se utiliza Java.
!"@J!% 2@'='% J&<,#*0&',IH% !g#$-"<*-";: Se ofrecen mejores posibilidades para el
tratamiento seguro de la informacin.
!"d9O%2d$6*#$%9$#I*.%O-=*+'#<*-;: Permite realizar acciones sobre objetos remotos,
incluso mediante SSL (Security Socket Layer) un conocido sistema de seguridad de
comunicacin.
!"Tecnologa de ayuda.
!"Mejor soporte de '&&'"#&'&%H%"*?#'&.
!"Otros servicios varios.
A/9%3BCA:T8=;?<AC%
Aunque no existen incompatibilidades importantes, s que se pueden observar que
algunas cosas que en otras versiones no funcionaban bien o se permitan ahora se
desaprueban. Entre otros conviene destacar:
!"No se pueden declarar mtodos abstractos como -'#<=$, ,&<='#$, 5<-'?%ni%"H-+&*-C$..
!"No se recomienda la utilizacin de 5<-'?<C$tu en la gestin de excepciones.
!"El paquete MN<-0 en algunas versiones intermedias apareca colgando de
+*6A"/-A)'='An o de )'='A'N#A"N<-0An y ahora pasa a ser )'='gA"N<-0An.
Pgina 163 de 189

$4q)&(*'%((a%P'22$5(')1$7%&'%&'7$223,,3%
9*(8#?B#979$(>"('9!"B9<%&'(
8/9%(<D:?@F==;E<%
Las applets Java no seran de mucha utilidad sin programas de navegacin compatibles
con Java. Por lo tanto, para que Java funcione necesita de estos programas de
navegacin, que afortunadamente se han comprometido a apoyarlo.
B/9%)ADC=8>A%)8T;V8D?:%
Es un programa de navegacin con apoyo completo a Java. Adems del simple apoyo al
lenguaje y sistema de tiempo de ejecucin, tambin ha ayudado en el desarrollo de
@'='M+&<,#, que es un lenguaje de comandos basado en objetos Java. El objetivo de
@'='M+&<,# es permitir el desarrollo rpido de aplicaciones distribuidas cliente servidor.
Para ms informacin consultar http://home.es.netscape.com/
=/9%5;=:?C?LD%(<DA:<AD%'g>G?:A:%
Microsoft tard un poco en desarrollar una herramienta para Java: Internet Explorer.
Est estrechamente ligado al sistema operativo Microsoft Windows 95, y est
completamente integrado en la versin Windows 98 del mismo.
Para ms informacin consultar http://www.microsoft.com/
@/9%P?D-8T8%
Es el contendiente de Sun. Se dise inicialmente como un experimento en el desarrollo
del programa de navegacin de Java. Se ha convertido en un prometedor modelo de lo
que depara el futuro para los programas de navegacin de la Web. Ser el programa de
navegacin existente ms compatible con Java. Constituye un til campo de pruebas
para los programadores de Java.
Es capaz de gestionar e interactuar de forma dinmica con nuevos tipos de objeto y
protocolos Internet.
Para ms informacin consultar http://www.sun.com/
A/9%7>UVG8CC%5?C8;=%
Fue el primer navegador de Internet, y ya est disponible con apoyo a Java.
Para ms informacin consultar http://www.spyglass.com/
;*("'@?#'?$(>"(>"$9##?::?(
8/9%(<D:?@F==;E<%
Los desarrolladores se han acostumbrado a las herramientas grficas de programacin, y
aunque el JDK es suficiente para desarrollar Java, se han creado muchos entornos de
desarrollo (OR!") para este lenguaje.
Pgina 164 de 189

La mayor parte de los participantes en el negocio de herramientas de programacin han

anunciado algn tipo de entorno de desarrollo para Java. Parte de ese apoyo ha llegado
en forma de mdulos adicionales para productos ya existentes, mientras que otra parte
consistir en productos totalmente nuevos.
En este apartado se comentan algunos de los ms valorados, y se indican otros por si el
lector desea buscar algo con unas caractersticas muy especficas.
B/9%.;CF8G%*8LZ%@A%7UH8<DA=%
La empresa Symantec, dura competidora en los IDE de Java ofrece el entorno visual de
desarrollo Java Visual Caf, que ya goza de una gran reputacin entre los
desarrolladores de Java.
Integra de forma transparente las herramientas del JDK, presentndolas en formato
grfico.
Las principales funciones que soporta son las siguientes:
!"Editor de programacin grfica: Posee todas las caractersticas de un moderno editor
de programacin: sintaxis a todo color, resaltado de palabras clave, lenguaje macro
integrado para ampliar el editor...
!"Editor de clases y jerarquas: Navega con rapidez a travs del cdigo Java,
permitiendo trabajar directamente con clases o miembros de clases en lugar de
archivos individuales; este editor localiza el cdigo fuente correspondiente y lo
carga. Adems gestiona y visualiza las relaciones lgicas entre clases.
!"Depurador grfico: Gran ventaja sobre el ).( que es modo lnea.
!"Gestor de proyectos: Permite organizar proyectos Java con mayor efectividad.
Soporta proyectos dentro de proyectos, por lo que puede mantenerse al da con
bibliotecas anidadas y dependencias de proyectos.
!"Asistentes: Para creacin de eventos, bases de datos, applets...
Para ms informacin, consultar http://cafe.symantec.com/
=/9%.;CF8G%-WW%@A%5;=:?C?LD%
Es la nueva herramienta de Microsoft para desarrollar Java en sus sistemas operativos
Microsoft Windows. Se encuentra incluido en el paquete de desarrollo 9<+&*"*5#%[<"/'?%
M#/.<*, y es directo heredero del tan extendido 9<+&*"*5#%[<"/'?%JKK.
Presenta el serio problema de que no respeta las especificaciones de clases de Sun, lo
que ha llevado a ambas compaas a juicio; en lugar de utilizar las clases del JFC,
Microsoft se ha inventado un nuevo paquete WFC(Windows Foundation Classes), para
el desarrollo en la plataforma Windows, rompiendo la portabilidad.
Para ms informacin consultar http://www.microsoft.com/
@/9%-6F;G@A:%@A%6?:G8<@%
La empresa Q*&?'-. es la desarrolladora de populares entornos de desarrollo de C++ y
Delphi para Windows. Borland ha optado por desarrollar un producto totalmente nuevo
para los desarrolladores de Java; @Q/<?.$&.
Pgina 165 de 189

@Q/<?.$& ha sido desarrollado totalmente en Java, lo que permite a Borland salir del
mercado del PC y comercializar @Q/<?.$& en todas las plataformas soportadas por Java.
Presenta gran conectividad con las bases de datos, soportando incluso CORBA. Tiene
un programa de desarrollo de JavaBeans con ms de 200 prediseados.
Realmente es un producto muy completo de desarrollo de Java, y se distribuye en dos
versiones (standard y Cliente/Servidor).
Para ms informacin, consltese http://www.borland.com/jbuilder/
A/9%-8T8%7DF@;?%@A%7F<%
Entorno muy intuitivo y prctico, en el que casi la mayora de las tareas se realizan
mediante el ratn. Es muy fcil crear aplicaciones sencillas con este IDE, pero se
necesita tener una versin del JDK previamente, y tiene unos requisitos hardware
bastante altos.
Para ms informacin consltese http://www.sun.com/
L/9%.;CF8G$VA%L?:%-8T8%@A%(65%
Es una RAD (d',<.%G<..$.%R$"<0-), que aunque tiene muchas de las caractersticas del
Visual Caf, con una interfaz un poco ms limpia. Permite disear la interfaz de la
aplicacin o ',,?$#, y definiendo el sistema de eventos, la herramienta puede crear
cdigo Java.
Es muy sencillo de manejar y uno de los ms potentes del mercado.
Para ms informacin, consltese http://www.ibm.com/ad/vajava/
V/9%`%HF=[?C%HRC///%
Los IDE estn en continuo desarrollo, y seguro que tras la finalizacin de este tutorial
ya han aparecido muchos ms en el mercado.
Algunos de ellos son:
!"%LMGaEOOSLO8MG87GTOLdGOXU: Entorno de desarrollo Java para Macintosh, basado en
J*.$N'&&<*&%JKK. http://www.metrowerks.com/
!".LEUTGO8MG8"ETVOEK8$HTGKKSFGHRG: Entorno de desarrollo Java para Power Macintosh.
http://www.natural.com/page/products/roaster/
!"%LUDL8MG8'SKSRLH83OEJQSRU: Conjunto de herramientas de desarrollo J*"6*%con dos
bibliotecas propias. http://www.sgi.com/products/cosmo/
!"'VJGO%GMG8 MG8 *UWDGTOS]: Un producto a bajo precio, con algunos tutoriales.
http://www.asymetrix.com/sales/
!";EZE8 7EXGO: Sencillo entorno de desarrollo que funciona bajo Windows 95/NT,
creado por Heechang Choi. http://net.info.samsung.com.kr/~hcchoi/Javamaker.html
!"&M8 MG8 'LbT8 *U8 $T8 3GTU: Editor muy potente para Windows, aunque flojo en otros
aspectos. http://www.ozwmail.com.au/~saig
!"7LIL8 MG8 0GHVDPOE8 'LbTdEOG: Entorno visual para crear applets, fcil de usar.
http://www.PenumbraSoftware.com
Pgina 166 de 189

!";EDPE8 MG8 *SD,GRQ: Constructor grfico de applets, con mucha documentacin.

http://www.aimtech.com/prodjahome.html
La informacin de este apartado ha sido extrada de h.UfUe, 3FFDie h7UOWPSe, 3FFFi y
h1UXXRe,3FF@i.
Se recomienda al lector que busque en Internet en las direcciones:
!"http://www.developer.com/news/userchice/n_userframe.html: Lista de los entornos
de desarrollo preferidos por los desarrolladores de Java.
!"http://www.yahoo.com/Business_and_Economy/Companies/Computes/Software/PR
ogramming_Tools/Languages/Java: Lista de ltimas herramientas Java.
<*(;%;:%?@"<9$(>"(8#?B#979<%&'(
Java est orientado a objetos, por lo que es importante no ignorar el potencial de volver
a utilizar objetos Java. De hecho ya estn apareciendo algunas bibliotecas comerciales
de objetos Java.
!"Por ejemplo, la empresa Dimensin X cuenta con tres bibliotecas de clases Java:
!"Ice: Paquete de representacin de grficos tridimensionales.
!"Liquid Reality: Kit de herramientas VRML.
!"JACK: Herramienta para crear applets Java a travs de una interfaz sencilla.
Pgina 167 de 189

$4q)&(*'%(((a%5q13&37%)$1(.37%-$.$%Y-)(9%
9*(%'@#?>6<<%&'(
Aunque la potencia de la API de Java es ms que suficiente para casi todo tipo de
aplicaciones, algunas de ellas necesitan utilizar la potencia especfica de una plataforma
en concreto, por ejemplo para conseguir un poco ms de velocidad y eficiencia.
Java permite incorporar en sus programas fragmentos de +>.<0*%-'#<=* es decir, cdigo
compilado para una determinada plataforma, generalmente escrito en C/C++. As se
puede utilizar cdigo especfico de una plataforma, bibliotecas ya escritas...
Para ello Java cuenta con el JNI (@'='%]'#<=$%O-=*+'#<*-). Hay que tener en cuenta que
una aplicacin que utilice este tipo de mtodos estar violando las directrices de
seguridad de la mquina virtual Java, motivo por el que no se permite incluir mtodos
nativos en ',,?$#" de Java.
Para agregar mtodos nativos Java a una clase de Java han de seguirse los siguiente
pasos:
1. Escritura del programa Java, invocando mtodos nativos como -'#<=$.
2. Compilacin del programa Java.
3. Creacin de un archivo de cabecera nativo (AI)
4. Escritura de los mtodos nativos.
5. Creacin de una biblioteca con esos mtodos nativos.
6. Ejecucin del programa Java.
;*("C"78:?(>"(6$?(>"(7H@?>?$('9@%!?$(
Para mostrar cmo utilizar los mtodos nativos, vamos a crear un pequeo programa,
escrito con mtodos nativos, que lo nico que hace es imprimir Z7*?'%9/-.*rrrZ. Para
ello vamos a utilizar el JDK y un compilador de C.
Se advierte al lector que no se deje engaar por la simpleza del ejemplo que se va a
desarrollar, porque la potencia del JNI va mucho ms all de lo que estas lneas dejan
entrever. Para ms informacin consulte h7UOWPSe,3FFFi.
8/9%'C=:;DF:8%@AG%>:?V:8H8%-8T8%
Escribimos el programa Java en un fichero denominado 7*?']'#<=*A)'='.
El cdigo Java que vamos a utilizar ser:
puclic class HolaNativo{
public native void diHola();
static {
System.loadLibrary("LibHola");
}
Pgina 168 de 189

new HolaNativo().diHola();
}
}
El mtodo nativo .<7*?'2; no tiene cuerpo porque ser aadido mediante una biblioteca
nativa denominada :<(7*?'. Dicha biblioteca nativa es cargada mediante la sentencia
?*'.:<(&'&H2;, sentencia que ha sido incluida como "#'#<+ para que sea ejecutada cada
vez que se cree una instancia (objeto) de esta clase.
El programa principal tan slo instancia un objeto de esta clase y utiliza el mtodo
nativo que imprime la cadena de Z7*?'%9/-.*rrrZ.
B/9%*?H>;G8=;E<%@AG%>:?V:8H8%-8T8%
Ahora ya es posible compilar la clase Java 7*?']'#<=* que fue creada mediante la
sentencia (utilizando el JDK):
javac HolaNativo.java
=/9%*:A8=;E<%@A%F<%L;=[A:?%@A%=8BA=A:8%<8D;T?%Y/[9%
Un fichero de cabecera nativo es un fichero que habitualmente tiene la extensin ZAIZ.
En un fichero de este tipo se definen en C/C++ las interfaces pblicas (clases, mtodos
o funciones, variables globales, constantes...).
La herramienta )'='I incluida en el JDK es capaz de crear automticamente un fichero
de cabecera para mtodos nativos Java, con slo invocarla indicando el nombre de la
clase de la que extraer las cabeceras nativas:
javah HolaNativo
Esta operacin crea un fichero 7*?']'#<=*AI que ser til para crear los mtodos
nativos. Hay dos lneas importantes dentro de este fichero:
#include <jni.h>
JNIEXPORT void JNICALL Java_HolaNativo_diHola(JNIEnv*,jobject);
La primera lnea importa una biblioteca JNI que valdr a C/C++ para saber cmo crear
los mtodos nativos.
La segunda lnea corresponde al mtodo nativo que definimos.
Los mtodos nativos suelen denominarse siempre como Java_Paquete_Clase_Metodo()
aunque en este caso al no haber paquete esta parte se ha omitido.
As mismo los mtodos nativos reciben como parmetros @]O!-=n y )*()$+#% que
permitirn al mtodo nativo comunicarse con su entorno.
@/9%'C=:;DF:8%@A%G?C%HZD?@?C%<8D;T?C%
Se ha de crear un fichero fuente nativo, en el que se defina el cuerpo de la funcin que
actuar como mtodo nativo. Este fichero lo denominaremos 7*?']'#<=*A+:
#include <jni.h>
#include "HolaNativo.h"
#include <stdio.h>
Pgina 169 de 189

JNIEXPORT void JNICALL Java_HolaNativo_DiHola( JNIEnv* e,

jobject o ){
printf("Hola Mundo!!!\n");
}
En este programa se incluyen tres bibliotecas: La de JNI ()-<AI), el fichero de cabecera
ya creado (7*?']'#<=*AI) y una biblioteca de C para imprimir ("#.<*AI).
Ser puede observar que el cuerpo del mtodo nativo lo que hace es invocar a la funcin
de C ,&<-#52; que imprimir por pantalla la cadena Z7*?'%9/-.*rrrZ.
A/9%*:A8=;E<%@A%F<8%B;BG;?DA=8%=?<%AC?C%HZD?@?C%<8D;T?C%
Cada compilador de C o C++ tiene su propia herramienta para crear bibliotecas
compartidas (DLL en Windows o SO en UNIX).
Para crear la biblioteca se ha de compilar el fichero fuente nativo, y luego crear la
biblioteca compartida mediante el programa correspondiente a su compilador.
Para esto cada compilador tiene su propia sintaxis, con lo que se tendr que consultar la
documentacin del compilador en lo referente a la creacin de bibliotecas. En cualquier
caso algunos ejemplos de compilacin en bibliotecas son:
Para el GCC de Solaris:
cc -G HolaNativo.c -o libHola.so
Para Microsoft Visual C++ para Windows:
cl -LD HolaNativo.c -Fe libHola.dll
En cualquier caso asegrese que la biblioteca creada tiene el mismo nombre con que se
la invoca desde el archivo de clase Java en el mtodo ?*'.:<(&'&H2;.
L/9%'KA=F=;E<%@AG%>:?V:8H8%-8T8%
Para ejecutar este programa, debe invocarse:
java HolaNativo
Con lo que se muestra por pantalla:
Hola Mundo
Se puede observar que la forma de creacin, compilacin y ejecucin de la clase Java es
igual que la utilizada para crear una aplicacin Java normal, solo que al incluir mtodos
nativos, han de crearse bibliotecas y ficheros de cabecera antes de ejecutar el programa.
Pgina 170 de 189

$4q)&(*'%(.a%!"#$%&'%2'S'2')*($%&'%*WW%$%-$.$%
9*(%'@#?>6<<%&'(
La sintaxis de Java resulta muy familiar a los programadores de C++, debido
mayoritariamente a que Java proviene de C++. Sin embargo Java pretende mejorar a
C++ en muchos aspectos (sobre todo en los aspectos orientados a objeto del lenguaje),
aunque prohibe muchas de las tareas por las que C++ fue tan extendido.
Se observa que las diferencias han sido diseadas como mejoras del lenguaje, ya que
uno de los aspectos ms criticado (y defendido) de C++ es su capacidad para hacer
cosas no orientadas a objetos, as como acceder a los recursos de las mquinas (lo que
le permita atacar sistemas, siendo uno de los lenguajes ms difundidos entre los
programadores de virus).
En este apndice pretendemos mostrar aquellas diferencias significativas, para que los
programadores familiarizados con C++ puedan programar en Java, conociendo sus
posibilidades y limitaciones.
;*(>%D"#"'<%9$($%'@A@%<9$(
8/9%'GAHA<D?C%C;H;G8:AC%
"MU, T^, LRLXRUN^QPM, K_Pok^N^MZ: Como no existen macros como b<-+?/.$, se utiliza
<6,*&#.
)_ÔPTUO,T^,jÔ^SQRP: La herencia en Java se especifica con la palabra clave $g#$-.",
en lugar del operador :: de C++.
'USMNPSN^M/,En lugar de +*-"# de C++ las variables constantes se declaran como "#'#<+%
5<-'?.
B/9%'GAHA<D?C%AIF;T8GA<DAC%
7R^`LOUM, ^MNgNRQUM: No es necesaria declaracin previa (fuera de las clases) de los
miembros estticos ("#'#<+).
7qNUTUM,RSXRS^: En Java no existen (hay que incluir el cuerpo de los mtodos junto a su
definicin), aunque los compiladores Java suelen intentar expandir en lnea (a modo de
los mtodos inline) los mtodos declarados como 5<-'?.
7qNUTUM, ]RONkPX^M: Todos los mtodos no estticos ("#'#<+) se consideran =<&#/'? en
Java.
?UOVPOT: No existe en Java. Simplemente se llama el mtodo, y el compilador se
encarga de buscarlo.
'XPM^M,PSRTPTPM: Aunque Java no permite anidar clases, s que se puede modelizar este
concepto mediante los paquetes Java y la composicin.
&U, ^rRMN^S, sP`RWUMs, KbOSGHMZ: Es su lugar se considera amigas a todas las clases y
elementos que componen un paquete.
Pgina 171 de 189

=/9%'GAHA<D?C%8k8@;@?C%
'U`^SNPORUM: Java soporta los dos tipos de comentarios de C++, e incorpora un tercero,
con la sintaxis ann%+*6$-#'&<*%na, para la documentacin automtica.
)_ÔPTUO,ttt,: Java aade este operador para desplazamientos a la derecha con signo.
(SRQRPQRnS: Todos las variables de tipo simple y las referencias a objeto se inician a un
valor 0 (o equivalente), y -/?? para las referencias a objeto.
.^lÔ^SQRP, UVJGO: En Java "/,$& hace referencia a la superclase (clase padre) de la
clase actual. Dicha clase slo puede ser una, porque Java solo soporta herencia simple.
@/9%'GAHA<D?C%CF>:;H;@?C%
FLTL: No existe en Java, aunque con (&$'P y +*-#<-/$, combinados con etiquetas de
bloque, se puede suplir.
'USTRQRUS^M: Deben utilizarse expresiones booleanas y nunca nmeros.
*OWk`^SNUM,_UO,T^l^QNU: Java no los soporta.
<*(>%D"#"'<%9$(>"(>%$"I?(
8/9%1;>?C%@A%@8D?C%
4R_UM, MR`_X^M: Soporta los mismos que C++, aadiendo (**?$'- (#&/$a5'?"$), y
ampliando el tipo +I'&, para soportar caracteres Unicode de 16 bits.
-kSNÔUM: En Java no hay punteros, permitiendo as programacin segura. En su lugar
se crean las referencias a objeto, que pueden ser reasignadas (como si fueran un puntero
a objeto de C++).
$^QNUO^M: Son objetos de slo lectura, con un mtodo ?$-0#I2; para averiguar su
longitud, y que lanzan una excepcin si se intenta acceder a un elemento fuera del
vector.
'XPM^M: Todo debe de estar includo en clases; no existen enumeraciones ($-/6) ni
registros ("#&/+#).
%X^`^SNUM, WXULPX^M: No existen variables o funciones globales, aunque se puede
utilizar "#'#<+ para simularlas.
B/9%&;CAk?%@A%G8C%=G8CAC%
'kÔ_U,T^,XUM,`qNUTUM: Todos los cuerpos de las clases han de estar codificados en las
definiciones de las clases. No se pueden separa como se hace en C++ mediante ficheros
de cabecera (ZAIZ).
'USMNOkQNUO^M: Aunque existen constructores, como en C++, no existen constructores
copia, puesto que los argumentos son pasados por referencia.
+^MNOkQNUO^M: No existen destructores en Java, ya que tiene recoleccin automtica de
basura, aunque en su lugar se pueden escribir mtodos 5<-'?<C$2;, que sern ejecutados
cuando el recolector de basura de Java destruya el objeto.
Pgina 172 de 189

IOLUX, T^, jÔ^SQRP: En Java todas las clases se relacionan en un nico rbol de
herencia, en cuya cspide se encuentra la clase F()$+#, con lo que todas las clases
heredan de ella. En C++ sin embargo se pueden declarar clases que no tengan padre.
;Ô^SQRP,SU,O^MNORQNR]P/ Al heredar, no se puede reducir las ocultaciones del padre: En
C++ s se podra ampliar la visibilidad de uno de los elementos heredados. En todo caso
s se puede restringir.
;Ô^SQRP,MR`_X^,T^,QXPM^M: No existe la herencia mltiple de clases. An as se puede
implementar una herencia mltiple utilizando interfaces, dado que ellas s la soportan.
!ULO^QPOWP,T^,`qNUTUM: Es exactamente igual que la de C++.
!ULO^QPOWP, T^, U_ÔPTUO^M: No existe. En los objetos M#&<-0 el operador + y += se
permiten para la comparacin de cadenas.
=/9%)FAT?C%@;CAk?C%
-XPSNRXXPM, KTGDJKETGUZ: En Java no se soportan plantillas p clases genricas de C++,
aunque existen una serie de clases en la API de Java que tratan objetos genricos (clase
F()$+#) como [$+#*& o M#'+P.
(SNÔlPQ^M, KSHTGObERGZ: Que son unas especies de +?'"$"% '("#&'+#'" con 6B#*.*"%
'("#&'+#*", y que permiten herencia mltiple, utilizando la palabra reservada
<6,?$6$-#".
+RlÔ^SN^,W^MNRnS,T^,^rQ^_QRUS^M: Todas las excepciones de Java heredan de la clase
8I&*N'(?$, que las dota de una interfaz comn.
>*(>%D"#"'<%9$(>"("C"<6<%&'(
8/9%$C>A=D?C%H?@;L;=8@?Ca%
'PT^SPM: Las cadenas entrecomilladas se convierten en objetos M#&<-0, no en vectores
estticos de caracteres.
(SMNPSQRPQRnS: Los objetos se crean en el montculo (-$N) y nunca en la pila (6'??*+), y
los tipos simples no permiten -$N (excepto los vectores de tipos simples, iguales que los
de C++).
(SNqO_O^N^: Los intrpretes Java son unas 20 veces ms lentos que los de C, aunque esta
diferencia se est reduciendo con lo compiladores JIT(Just In Time) para Java que estn
apareciendo en el mercado.
#RLXRUN^QPM, ^MNgSTPO: En C++ exista casi una biblioteca por plataforma (si exista)
para hacer cosas como: Trabajo en red, conexin a bases de datos, uso de mltiples
hilos de control, uso de objetos distribudos o compresin. Java incorpora bibliotecas
estndar multiplataforma para todas estas tareas en su API.
%rQ^_QRUS^M,_UO,lPXXUM,T^,T^MQOR_NUO^M: Java lanza excepciones cuando hay errores en
el acceso a un descriptor, permitiendo al programador gestionar dichos fallos, y
recuperar al programa de ellos.
6^MNRnS,T^,ÔOUO^M,PX,QU`_RXPO: Adems comprobar el lanzamiento de excepciones en
tiempo de compilacin, comprueba el cumplimiento del lanzamiento de excepciones por
los mtodos sobreescritos.
Pgina 173 de 189

B/9%$C>A=D?C%AG;H;<8@?Ca%
-O^_OUQ^MPTUO: Java no tiene preprocesador, por lo que las macros (b<-+?/.$D%
b.$5<-$DAAA) no existen.
*QQ^MU, TRO^QNU, PX, jPOTVPO^: En Java est restringido, aunque para eso permite la
utilizacin de 6B#*.*"% -'#<=*", escritos para la plataforma (normalmente C/C++). En
cualquier caso las ',,?$#" no pueden utilizar estos 6B#*.*"%-'#<=*", slo las aplicaciones
Java pueden hacerlo.
=/9%$C>A=D?C%;<D:?@F=;@?C%
7kXNR_X^M, jRXUM, T^, QUSNOUX, KDVKTSTQOGETSHFZ: Java permite la utilizacin de mltiples
hilos de control y la ejecucin en paralelo (y sincronizada) de mltiples tareas, mediante
la clase 8I&$'..
*__X^NM, 8P]P: Este tipo de aplicaciones son seguras, distribubles por Internet y
ejecutables por los navegadores, aunque tienen restricciones (como la escritura en
disco).
%rNOPQQRnS, PkNU`gNRQP, T^, TUQk`^SNPQRnS: Un nuevo tipo de comentario
(ann+*6f.*+na) permite a los programadores extraer de manera automtica comentarios
de sus fuentes, generando automticamente documentacin estandarizada.
8P]P#^PSM: Mediante esta biblioteca se permite crear elementos visuales
multiplataforma, algo impensable en C++.
Pgina 174 de 189

$4q)&(*'%.a%!"#$%&'%2'S'2')*($%&',%,')!"$-'%-$.$%
9*(D6'>97"'@?$(
Palabras reservadas (funcionales):
'("#'+#% (**?$'-% (&$'P% (H#$% +'"$%
+'#+I% +I'&% +?'""% +*-#<-/$% .$5'/?#%
.*% .*/(?$% $?"$% $g#$-."% 5'?"$%
5<-'?% 5<-'??H% 5?*'#% 5*&% <5%
<6,?$6$-#"% <6,*&#% <-"#'-+$*5% <-#% <-#$&5'+$%
?*-0% -'#<=$% -$N% -/??% ,'+P'0$%
,&<='#$% ,&*#$+#$.% ,/(?<+% &$#/&-% "I*&#%
"#'#<+% "/,$&% "N<#+I% "H-+&*-<+$.% #I<"%
#I&*N% #I&*N"% #&'-"<$-#% #&H% =*<.%
=*?'#<?$% NI<?$% % % %
Tipos de comentarios:
/*comentario*/ // Hasta fin de lnea //* javadoc */
Bloques de cdigo:
{ // conjunto de sentencias
}
Separadores Java:
{ } , : ;
Propuestas de estilo de nombres de identificadores:
Las clases: J?'"$ o 9<J?'"$.
Los mtodos: 6$#*.*2; o 6$#*.*:'&0*2;A%
Las variables: '?#/&' o '?#/&'9$.<'.
Las constantes: JF]M8G8! o JF]M8G]8!f:GdXG.
Los paquetes: )'='A,'3/$#$A"/(,'3/$#$.
;*(@%8?$(>"(>9@?$(
4R_U, LpN^M, 4R_U,+PNUM, .PSWU,K_UMRNR]UZ, 0RNÔPX,
(H#$% 1 Entero 127 14
"I*&#%% 2 Entero 32767 14
<-#% 4 Entero 2.147.483.647 14
?*-0% 8 Entero 9.233e15 14
5?*'#% 4 Coma flotante 1.4e-45 a 3.4e38 36,6
.*/(?$% 8 Coma flotante 4.9e-324 a 1.7e308 3,14e2
+I'&% 2 Caracter Unicode a o \064
(**?$'-% 1 Booleano #&/$ o 5'?"$ #&/$ o 5'?"$
Vectores:
int vectorNumeros[]=new int[numero];
Pgina 175 de 189

Cadenas Constates:
String nombreBonito = Amelia;
Cadenas Variables:
StringBuffer cadenaVariable = Cambiante;
<*(?8"#9>?#"$(
Operadores Unarios:
)_ÔPTUO,, +^MQOR_QRnS,K_O^lRfPZ, )_ÔPTUO, +^MQOR_QRnS,K_O^,U,_UMlRfPZ,
+ Convierte el operador a <-# ++ Incrementa operador
- Niega aritmticamente oper. -- Decrementa operador
Operadores aritmticos (binarios):
)_ÔPTUO, "MU, *NPfU, +^MQOR_QRnS,
K% *,T%K%*,_% op1 += op2 Suma op1 y op2
^% *,T%^%*,_% op1 -= op2 Resta op2 de op1
n% *,T%n%*,_% op1 *= op2 Multiplica op1 por op2
a% *,T%a%*,_% op1 /= op2 Divide op1 por op2
k% *,T%k%*,_% op1 %= op2 Resto de op1 / op2
Operadores de comparacin (binarios):
)_ÔPTUO, "MU, +^]k^X]^,]ÔTPTÔU,MR,
> 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
mm% *,T%mm%*,_% AND, condicionalmente evala op2
m% *,T%m%*,_% AND, siempre evala op1 y op2
pp% *,T%pp%*,_% OR, condicionalmente evala op2
p% *,T%p%*,_% OR, siempre evala op1 y op2
r% r%*,% op es falso
Operadores de bit (binarios):
cc% *,T%cc%*,_% Desplaza los bits de op1 a la derecha op2 veces
ii% *,T%ii%*,_% Desplaza los bits de op1 a la izquierda op2 veces
ccc% *,T%ccc%*,_% Desplaza los bits de op1 a la derecha op2 veces (sin signo)
m% *,T%m%*,_% AND
p% *,T%p%*,_% OR
h% *,T%h%*,_% "XOR"
l% l*,_% Complemento
Operador terciario:
expresion ? sentencia_si : sentencia_si_no
Precedencia de operadores:
4R_U,T^,U_ÔPTUO^M, )_ÔPTUO^M,T^,^MN^,NR_U,
Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creacin o conversin new (tipo) expr
Pgina 176 de 189

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 = += -= *= /= %= &= ^= |= <<= = =
>*("$@#6<@6#9$(>"(<?'@#?:(
Toma de decisin (<5^$?"$ y "N<#+I):
if ( condicin ) {
Bloque de cdigo a ejecutar si la condicin es cierta
}
else {
Bloque de cdigo a ejecutar si no
}
switch ( expresionMultivalor ) {
default : conjuntoDeSentencias; break;
}
Bucles iterativos (NI<?$, .*^NI<?$, 5*&):
while ( expresinBooleana ) {
sentencias;
};
do {
sentencias;
} while ( expresinBooleana );
for(inicio; condicion_continuacion; sentencia_actualizacion) {
sentencias;
}
Sentencias de saltos:
etiquetaSentencia: sentenciaEtiquetada
break nombreEtiqueta; // Sale del ltimo bucle
continue; // Hace otra pasada al ltimo bucle
Pgina 177 de 189

return valor; // Sale del mtodo devolviendo &'()*
"*(<:9$"$(
Definicin de clase:
acceso class NombreDeClase herencia{
acceso tipo nombreAtributo1;
NombreDeClase{ // Constructor
}
// . . .
finalize { //Recogida de basura
}
acceso tipo_devuelto nombreMtodo1( parmetros ) {
cuerpo_del_mtodo1;
}
}
Tipos de acceso de las clases:
!"5<-'?: Sin subclases
!"'("#&'+#: Clase abstracta, luego no se permiten instancias de esta clase.
!",/(?<+: Accesible desde fuera de su paquete
Herencia:
!"$g#$-.": Clase padre. La clase F()$+# es superclase de todas las clases Java (raz del
rbol de herencia).
!"<6,?$6$-#": Interfaces padres, separadas por comas; O-#$&5'+$TD%O-#$&5'+$_.
class MiClase extends SuPadre implements Interface0,Interface1;
D*(9@#%;6@?$(
Acceso (igual que para mtodos):
!",/(?<+: Los miembros declarados ,/(?<+ son accesibles en cualquier lugar en que sea
accesible la clase, y son heredados por las subclases.
!",&<='#$: Los miembros declarados ,&<='#$ son accesibles slo en la propia clase.
!",&*#$+#$.: Los miembros declarados ,&*#$+#$. son accesibles slo para sus
subclases
Composicin:
class claseCompuesta {
claseComponente referenciaAObjetoComponente.
}
Pgina 178 de 189

B*(7H@?>?$(
Referencias vlidas en los mtodos:
!"#I<": Referencia al objeto actual.
!""/,$&: Referencia a la clase padre en el rbol de herencia.
Modificadores permitidos:
!"Acceso: ,/(?<+ ,&<='#$ o ,&*#$+#$.. Igual que para los atributos.
!"'("#&'+#: Mtodo abstractos, sin cuerpo. Slo se permiten en clases abstractas.
!"5<-'?: No se puede sobreescribir el mtodo.
!""#'#<+: Mtodo de la clase (no de los objetos).
!"-'#<=$: Mtodo implementado con mtodos nativos (especficos de una plataforma).
!""H-+I&*-<C$.: Solamente permite un hilo de ejecucin.
Sobrecarga del mtodo: Varias implementaciones en funcin de los parmetros.
Sobreescritura del mtodo: Un cuerpo en cada nivel de herencia.
M*(?;C"@?$(
Instanciacin:
NombreDeClase referenciaAObjeto = new NombreDeClase();
Acceso al objeto:
referenciaAObjeto.mtodo( parmetros );
referenciaAObjeto.atributo;
Destruccin: Cuando la referencia a objeto sale de mbito en el programa.
%*(%'@"#D9<"$(
Declaracin de una interfaz:
interface MiInterfaz {
int CONSTANTE = 100;
int metodoAbstracto( int p ); // Por definir
}
Implementacin de interfaces:
class ImplementaInterfaz implements MiInterfaz{
int m=CONSTANTE;
int metodoAbstracto( int p ){ return ( p*m ); }
}
Herencia mltiple entre interfaces:
interface InterfazMultiple extends Interfaz0,Interfaz1;
Clases de envoltura de tipos simples:
Pgina 179 de 189

'XPM^M,T^,^S]UXNkOP,T^,NR_UM,MR`_X^M,
R*/(?$% .*/(?$%
x?*'#% 5?*'#%
O-#$0$&% <-#D%"I*&#D%(H#$%
:*-0% ?*-0%
JI'&'+#$&% +I'&%
Q**?$'-% (**?$'-%
C*(89G6"@"$(
Creacin de un paquete (primera sentencia de un fichero fuente):
package NombrePaquete;
Importacin de un paquete o parte de l:
import Paquete.Subpaquete1.Subpaquete2.Clase1;
Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento
Visibilidad en los paquetes:
!RNkPQRnS,T^X,^X^`^SNU, JOSZETG8 JLO8MGbGRTL8 JOLTGRTGM8 JVPKSR8
%S,XP,`RM`P,QXPM^, S S S S
%S,kSP,QXPM^,
No S S S
^S,^X,`RMÙ,_Pok^N^,
%S,kSP,QXPM^,jRfP,
No No S S
^S,UNOU,_Pok^N^,
%S,kSP,QXPM^,SU,jRfP,
No No No S
^S,UNOU,_Pok^N^,
N*("O<"8<%?'"$(
Tipos de excepciones:
!"!&&*&: Excepciones que indican problemas muy graves, que suelen ser
irrecuperables y no deben casi nunca ser capturadas.
!"!g+$,#<*-: Excepciones no definitivas, pero que se detectan fuera del tiempo de
ejecucin.
!"d/-#<6$!g+$,#<*-: Excepciones que se dan durante la ejecucin del programa.
Lanzamiento de una excepcin:
metodoLanzador() throws MiException{
throw MiException:
}
Tratamiento de una excepcin:
try {
// Cdigo posiblemente problematico
Pgina 180 de 189

} catch( tipo_de_excepcion e) {
// Cdigo para solucionar la excepcion e
} catch( tipo_de_excepcion_mas_general e)
// Cdigo para solucionar la excepcion e
} finally {
// Se ejecutara tras try o catch
}
:*(@M#"9>$(
Creacin:
!"Para crear un #I&$'., se ha de implementar una clase, extendiendo la clase base
d/--'(?$, y crear un objeto de la clase 8I&$'..
!"Este objeto representar un nuevo hilo de control, que ser accionado cuando
invoquemos al mtodo "#' del #I&$'..
!"En ese momento este hilo se activar, ejecutando (si el planificador de hilos
considera que es el momento), el mtodo &/-2; de la clase en que todo esto suceda.
Sincronizacin de procesos:
!"Durante la ejecucin de un programa, muchas veces varios procesos han de realizar
tareas de una forma sincronizada, actuando en un determinado orden.
!"Para ello se han de declarar mtodos como "H-+&*-<C$.A%
!"Mediante la utilizacin de excepciones, y de las funciones N'<#2; y -*#<5<H2;,
respectivamente esperarn a que otro proceso acabe antes de continuar su ejecucin.
Pgina 181 de 189

B:?$9#%?(
*LMNOPQN, JRSTUVRSW, 4UUXYRN, K*J4Z.- Biblioteca de mdulos pera representar
interfaces grficos provisto por Sun en la API de Java.
*T`RSRMNOPTUO,T^,!^WkORTPT.- Parte de la mquina virtual Java responsable de velar
por el cumplimiento de las polticas y reglas de seguridad.
I`LRNU.- Parte de un programa en el que es vlida una referencia a una variable.
*`ÔRQPS, !NPSTPOT, 'UT^, lUO, (SlUO`PNRUS, (SNÔQjPSW^, K*!'((Z.- Sistema de
codificacin que convierte caracteres a nmeros en el rango de 0 a 127. Es una parte del
cdigo ANSI que se ampla hasta los 257 caracteres.
*SgXRMRM.- Proceso de conocer los requerimientos de software que tienen el cliente y el
usuario final.
*-(.- Application Programming Interface.
*_XRQPQRnS.- Programa informtico, que se ejecuta sin necesidad de otro programa
*__X^N.- Programa informtico que se ejecuta necesitando de otro programa,
normalmente un navegador.
*__XRQPNRUS, -OUWOP``RSW, (SNÔlPQ^, K*-(Z.- Conjunto de paquetes y clases Java,
incluidos en el JDK que utilizan los programadores Java para realizar sus aplicaciones.
IOLUX.- Estructura de datos, grafo no cclico, con forma de rbol (nodos padres e hijos).
*OWk`^SNUM.- Parmetros.
*OOPp.- Vector.
*!'((.- American Standard Code for Information Interchange.
*J4.- Abstract Windowing Toolkit.
#+[.- Beans Developer Kit.
#^PSM,+^]^XU_Ô,[RN,K#+[Z.- Conjunto de herramientas para desarrollar @'='Q$'-".
#RN.u Unidad mnima de informacin digital que puede tomar los valores lgicos de z o
de T.
#XUok^.u Cdigo localizado entre corchetes.
#UUX^PS.- Tipo de datos bi-estado, que puede tomar valor de cierto (#&/$) o falso (5'?"$).
#pN^.- Secuencia de 8 bits.
'PT^SP.- Secuencia de caracteres.
'POgQNÔ.- Smbolo que representa informacin, o la codificacin en una computadora.
Normalmente letras de alfabeto, nmeros o signos ASCII.
'POWPTUO,T^,QXPM^M.- Parte del JRE de Java responsable de encontrar archivos de clase
y cargarlos en la mquina virtual Java.
'PMNRSW.- Moldeado.%
'6(.- Common Gateway Interfaz.
Pgina 182 de 189

'XPM^.- Unidad fundamental de programacin en Java, que sirve como plantilla para la
creacin de objetos. Una clase define datos y mtodos y es la unidad de organizacin
bsica de un programa Java.
'U`ÙS, 6PN^VPp, (SNÔlPv, K'6(Z.- Es un lenguaje de programacin que permite
dotar a las pginas Web de interactividad, construyendo una pgina Web
correspondiente a un enlace de hipertexto en el mismo momento en que se hace "clic"
sobre el enlace. Los "+&<,#% +0< pueden estar escritos en cualquier lenguaje de
programacin.
'U`ÙS, )Lf^QN, .ôk^M^N, #OUYÔ, *OQjRN^QNkO^, K').#*Z.- Estndar para la
conexin entre objetos distribuidos, aunque est codificados en distintos lenguajes.
'U`_RXPTUO.- Programa de software que traduce cdigo fuente en un lenguaje de
programacin legible por una persona a cdigo mquina interpretable por un ordenador.
'USMNPSN^.- Valor utilizado en un programa de computadoras con la garanta de no
cambiar en tiempo de ejecucin. La garanta es a menudo reforzada por el compilador.
En Java las constantes se declaran como "#'#<+%5<-'?.
'USMNOkQNUO.u Mtodo que tiene el mismo nombre que la clase que inicia. Toma cero o
ms parmetros y proporciona unos datos u operaciones iniciales dentro de una clase,
que no se pueden expresar como una simple asignacin.
'USN^S^TUO.u En diseo de interfaces de usuario, es un objeto que contiene los
componentes (como botones, barras de deslizamiento y campos de texto).
'US]ÔMRnS T^, NR_UM, T^, TPNUM.- Modificacin de una expresin de un tipo de datos a
otro.
').#*.- Common Object Requeset Broker Architecture.
%SNÔU.- Un nmero entero, sin parte decimal, positivo o negativo.
%MNOkQNkOP,T^,TPNUM.- Una construccin de software (en memoria o en disco duro) que
contiene datos y las relaciones lgicas entre ellos.%
%]^SNU.- Un mensaje que significa n incidente importante, normalmente desde fuera del
entorno de software.
%rQ^_QRnS.- Un evento que ocurre durante la ejecucin de un programa que interrumpe
el flujo normal de las instrucciones.
?XkfU.- Stream.
6OP_jRQPX,"MÔ,(SN^lPQ^,K6"(Z.- Interfaz grfica de usuario.
;POTVPO^.- El aspecto fsico de un sistema de computadora, como el procesador, disco
duro e impresora.
;Ô^SQRP,`wXNR_X^.- La prctica (permitida en lenguajes como C++ pero no en Java) de
derivar una clase de ms de una +?'"$%('"$A%
;Ô^SQRP.- Mecanismo encargado de relacionar clases entre s de una manera
jerrquica. En Java, slo existe herencia simple.
;RXU.- 8I&$'.A%
;470, K;p_Ô4^rN, 7POYk_, 0PSWkPf^Z.- Lenguaje que se utiliza para crear pginas
Web. Los programas de navegacin de la Web muestran estas pginas de acuerdo con
un esquema de representacin definido por el programa de navegacin.
Pgina 183 de 189

(+%.- Integral Development Environment.

(+0.- Java Interface Definition Language.
(SW^SRÔcP, T^X, MUlNVPO^.- Rama de la ingeniera concerniente con el anlisis, diseo,
implementacin, prueba, y mantenimiento de programas de computadoras.
(SMNPSQRP.- Objeto de software construido desde una clase. Por ejemplo, puede tener
una clase avin, pero una flota de quince instancias de avin.
(SN^WOPX,+^]^XU_`^SN,%S]ROU`^SN,K(+%Z.- Una herramienta de desarrollo visual en la
que un programa puede ser construido, ejecutado y depurado.
(SNÔLXUokÛ.- Condicin en la que dos o ms entidades de software se bloquean
mutuamente, cada una esperando los recursos que est utilizando la otra.
(SNÔlPQ^, +^lRSRNRUS, 0PSWkPW^, K(+0Z.- Herramienta mediante la cual los objetos
pueden invocar mtodos de otros objetos que se encuentren en mquinas remotas,
mediante CORBA.
(SNÔlPv,WOglRQP,T^,kMkPORU,K6"(Z.- Una interfaz entre la mquina y el hombre como el
Windows de Microsoft, el Mac OS, o el Sistema X Windows, que depende de pantallas
de alta resolucin, un recurso grfico de puntero como un ratn y una coleccin de
controles en pantalla (denominados Widgets) que el usuario puede manejar
directamente.
(SNÔlPv2u, Mecanismo Java para decirle al compilador que un conjunto de mtodos
sern definidos en futuras clases. (Esas clases estarn definidas para implementar la
interfaz).%
8P]P, :+.- Paquete que permite a los desarrolladores incorporar texto, imgenes y
grficos en dos dimensiones de gran calidad.
8P]P, <+.- Conjunto de clases para crear aplicaciones y applets con elementos en tres
dimensiones. Es parte del JMF.
8P]P,+PNP#PM^,'USS^QNR]RNp,K8+#'Z.- Lenguaje estndar de Java para interactuar con
bases de datos, similar al SQL. Es independiente no slo de la plataforma sino tambin
de la base de datos con que interacte. Desde la versin 1.2 del JDK se permite
interactuar con ODBC.
8P]P,+^]^XU_Ô,'USS^QNRUS,K8+'Z.- Conexin de desarrollo en la que se publican las
versiones beta de las bibliotecas de Java que se estn desarrollando.
8P]P, ?UkSTPNRUS, 'XPMM^M, K8?'Z.- Conjunto de componentes y caractersticas para
construir programas con interfaces grficas.
8P]P, 7^TRP, ?OP`^VUOY, K87?Z.- Protocolo de transmisin de datos para la
reproduccin multimedia (vdeo y sonido).
8P]P, &PNR]^, (S]UQPNRUS, K8&(Z.- Capacidad de Java para ejecutar cdigo nativo, es
decir, cdigo compilado al lenguaje mquina de un determinado ordenador. Permite a la
Mquina Virtual Java (JVM) interactuar con programas o bibliotecas escritos en otros
lenguajes (C/C++, ensamblador...). No se puede utilizar en applets, pues viola las
directrices de seguridad.
8P]P,.kSNR`^,%S]ROUS`^SN,K8.%Z.- Software suministrado por Sun que permite a los
programas de Java ejecutarse en una mquina de usuario. El JRE incluye la Mquina
Virtual Java (JVM).%
Pgina 184 de 189

8.%.- Java Runtime Environment.

8$7.- Java Virtual Machine.
8P]P,$RONkPX,7PQjRS^,K8$7Z.- El intrprete de Java que ejecuta los cdigos de byte en
una plataforma particular.%
8P]P#^PSM.- Paquete que permite escribir componentes software Java, que se puedan
incorporar grficamente a otros componentes.
8+#'.- Java DataBase Connectivity.
8+'.- Java Developer Connection.
8?'.- Java Foundation Classes.
87?.- Java Media Framewok
8&(.- Java Native Invocation.
8$7.- Java Virtual Machine.
0XP`PTP,_UO,O^lÔ^SQRP.- Una forma de transferir parmetros a una subrutina en la que
se pasa un puntero o referencia a un elemento, de esta forma, la subrutina puede leer y
cambiar el valor del elemento referenciado.
0XP`PTP,_UO,]PXUO.- Una forma de transferir parmetros a una subrutina en la que se
pasa la copia del elemento; las modificaciones de la copia no afectan al elemento
original.
7qNUTU.- Conjunto de sentencias que operan sobre los datos de la clase para manipular
su estado.
7RSRP_XRQPQRnS.- G,,?$#.
7UT^XU.- En diseo orientado a objetos, una representacin del mundo real en unas
abstracciones de software denominadas clases y la relacin entre ellas.
7UXT^PTU.- Suplantacin del tipo de un objeto o variable por otro nuevo tipo.
7kXNR_OUQ^MU.- En sistemas operativos, la habilidad de efectuar dos o ms programas
independientes, comnmente en un procesador solo (a travs de 9/?#<#'&$').%
&P]^WPTUO, J^L.- Software que permite al usuario conectarse a un servidor de Web
utilizando Hypertext Transfer Protocol (HTTP). Microsoft Internet Explorer, Netscape
Navigator, HotJava de Sun, son populares navegadores de Web.
&P]^WPTUO.- Navegador Web.
HVKK.- Valor de Java que significa ='+1*.
)Lf^QN,+PNP#PM^,'US^QNR]RNp,K)+#'Z. Lenguaje estndar de Microsoft; que utiliza un
driver del fabricante de una base de datos, para interactuar con ella, ms orientado a
C/C++ que a Java.
)+#'.- Object DataBase Conectivity.
-Pok^N^.- Nombre de Java para una biblioteca de clases.
-POg`^NOUM,lUO`PX^M.- Nombres utilizados dentro de una subrutina por sus parmetros.%
-POg`^NOUM2u,Valores u objetos pasados entre una subrutina y la rutina de llamada.%
Pgina 185 de 189

-XkWuRS2u,Un programa de una plataforma especfica diseado para ser llamado por un
navegador Web. Utilizado con frecuencia para mostrar informacin que el mismo
navegador no puede mostrar.
-UXRlUOlRMÙ.- En diseo orientado a objetos, la habilidad de utilizar una clase derivada
en lugar de su clase base. Por ejemplo, un programador puede escribir un mtodo
$g,&$"'&"$2; para la clase Mamfero. Un Perro, una Vaca y un Gato se derivan de
Mamfero, y todos pueden $g,&$"'&"$2;, aunque sus voces sean bastantes diferentes.
-OUQ^MU.- Instancia de un programa ejecutable. Por ejemplo, si inicia dos copias de un
intrprete de Java, tiene dos procesos de la mquina virtual de Java ejecutndose en su
computadora.
!^kTUQnTRWU.- Documentacin de diseo que describe el trabajo de un programa en
ingls estructurado (o en otro lenguaje) en lugar de un lenguaje de computadora.
.^QUX^QNUO, T^, LPMkOP.- En Java, el mecanismo por el cual se recobra y libera la
memoria asociada con objetos no utilizados.
.^ÙN^, 7^NjUT, (S]UQPNRUS, K.7(Z.- Herramienta que incorpora mtodos Java ara
localizar objetos remotos, comunicarse con ellos e incluso enviar objetos como
parmetros de un objeto a otro.
.7(.- Remote Method Invocation.
!^QkO^,!UQY^NM,0PpÔ,K!!0Z.- Sistema para la creacin de conexiones seguras en red.
!Ô]X^NM.- Mdulos que permiten sustituir o utilizar el lenguaje Java en lugar de
programas CGI.
!j^XX.- Intrprete de rdenes de un sistema operativo.
!RMN^`P, U_ÔPNR]U.- Software responsable de asignar a los usuarios los recursos de
sistemas de computadoras (incluyendo procesos). UNIX, Windows, NT y Mac OS, son
ejemplos de sistemas operativos.
!G0.^%Structured Query Language.
!!0.- Secure Sockets Layer.
%MNgNRQU.- En diseo orientado a objetos, representa la pertenencia a la clase, en vez de a
una instancia. Es un espacio compartido por todas las instancias de una clase.
!NO^P`.- Flujo de datos. Por ejemplo las entradas y salidas de un programa.
!NORSW.- Objeto Java estandarizado en el lenguaje, que representa una cadena de
caracteres.
!NOkQNkO^T, GkÔp, 0PSWkPW^, K!G0Z.- Lenguaje para realizar consultas a Bases de
Datos relacionales.
!kLQXPM^.- Clase descendiente de otra clase de la que hereda mtodos y variables.
!k_ÔQXPM^.- Clase de la cual heredan sus mtodos y variables otras clases denominadas
subclases.
!VRSW.u,Paquete que permite incorporar elementos grficos en las aplicaciones, de una
manera ms potente que con el AWT. Aparece en la versin 1.2 del JDK. Es no de los
componentes que estn incluidos en las Java Fundation Classes, o JFC.
4jO^PT.- Un "proceso ligero" que puede ser arrancado y utilizado ms rpidamente que
por un 5*&P o ",'N-A%[B'"$ tambin: 5*&PD%",'N-%H%E&*+$"*A%
Pgina 186 de 189

4R^`_U,T^,]RTP.- El nmero de lneas sobre las que una variable es activa, esto es, el
nmero de lneas entre la primera y la ltima referencia a la variable.
4R_U, _OR`RNR]U.- En Java, un tipo de dato que no es un objeto. Los tipos primitivos
incluyen caracteres, enteros, nmero de coma flotante y booleanos.%
"70.- Unified Modeling Language.
"SRQUT^.- Conjunto de caracteres de 16 bits, en lugar de los 8 que soportaba ASCII. As
se pueden representar la mayor parte de los lenguajes del mundo.
"SRlR^T, 7UT^XRSW, 0PSWkPW^, K"70Z.- Notacin estndar de facto utilizada en el
anlisis y diseo orientado a objetos, basado en el trabajo de Grady Booch, James
Rumbaugh, e Ivar Jacobson.
$^QNUO.- Estructura de datos que coloca un tipo de datos en celdas continuas.
$ÔRlRQPTUO,T^,QnTRWU,T^,LpN^.- Rutinas en la mquina virtual de Java, que aseguran
que las instrucciones en el archivo de clase no violan ciertas restricciones de seguridad.
Pgina 187 de 189

;%;:%?B#9D=9(
Se ha dividido este apartado en diversos puntos, intentando explicar qu referencias
bibliogrficas han sido utilizadas en mayor o menor medida para realizar este tutorial.
En cada resea bibliogrfica se indican el nmero de pginas que tiene, y un comentario
personal indicando su utilidad para una mayor profundizacin en Java.
9*(;%;:%?B#9D=9(<?'$6:@9>9(89#9(:9(9<@69:(!"#$%&'E
#" h*OSUXT,p,6UMXRSWe,3FF@i,[^S,*OSUXT,p,8P`^M,6UMXRSW2,*TTRMUSuJ^MX^pH+UÙ2
"!?% ?$-0/')$% .$% E&*0&'6'+<>-% @'='. Wesley Iberoamericana. 1997. 334 pginas.
(9/H%(4"<+*D%$"+&<#*%,*&%$?%.$"'&&*??'.*&%.$?%?$-0/')$).,
#" h%QY^Xe,3FF@i,#OkQ^,%QY^X. "7'-."%^*-%@'='%M$6<-'&". Presindent MindView Inc.
1997. 577 pginas. (8/#*&<'?%+*6,?$#*%$-%O-0?B"%$-%5*&6'#*%ERx).
#" h6POQcP, ^N, PX2e, 3FFFi2, 8P]RÔ, 6POQRg, T^, 8PXnSe, 8UMq, (WSPQRU, .UTOcWk^ve, (mRWU,
7RSWUe, *RNUO, (`Pve, *XlUSMU, #OPvgX^ve, *XLÔNU, 0POvPLPXe, 8^MwM, 'PXX^fP, p, 8US,
6POQcP. ZG,&$-.'% @'='% +*6*% "<% $"#/=<$&'% $-% ,&<6$&*Z. Universidad de Navarra.
1999. 140 pginas. (8/#*&<'?% 6/H% (4"<+*D% $-% $?% 3/$% "$% #&'#'% ?'% ,*#$-+<'% .$% @'='D%
,$&*%"<-%,&*5/-.<C'&%$-%-<-0e-%#$6'%$-%,'&#<+/?'&).,
#" h6POQcPe, 3FF@i, ?OPSQRMQU, 8UMq, 6POQcP, -^mPX]U2 "G,/-#$"% .$% #$*&1'% .$% ?'%
'"<0-'#/&'% E&*0&'6'+<>-% G='-C'.'% .$?% #$&+$&% +/&"*% .$% O-0$-<$&1'% 8B+-<+'% $-%
O-5*&64#<+'%.$%X$"#<>-". Universidad de Burgos. 1997. 216 pginas. (J*6$-#'-%?'%
#$*&1'%.$%?'%,&*0&'6'+<>-%*&<$-#'+<>-%'?%*()$#*A%7'-%"<.*%&$"/6<.*"%,'&'%.'&%/-'%
=<"<>-%.$%?'%,&*0&'6'+<>-%*&<$-#'.'%'%*()$#*%$-%$?%','&#'.*%OAT).
#" h8UjSMUSe,3FF9i,8^ll,8UjSMUS. "J*.<-0%M#'-.'&."%5*&%JD%JKKD%'-.%@'='". Vision
2000 CCS Package and Application Team. 1996. 14 pginas. (C*-"$)*"% ,'&'% $?%
5*&6'#*%.$%?*"%5/$-#$"%@'='D%J%H%JKK).
#" h7UOWPSe, 3FFFi, 7RY^, 7UOWPS( "R$"+/(&$% @'='% TA_". Prentice Hall. 1999. 675
pginas. (M<-%./.'%6/H%<-#$&$"'-#$D%"*(&$%#*.*%,*&%"/%'+#/'?<.'.%'?%#&'#'&%+*-%@'='%
_D%H%,*&%"/%$g#$-"<>-%'?%#&'#'&%#*.'"%?'"%(<(?<*#$+'"%.$%@'=').,
#" h&PkWjNUSe,3FF9i,-PNORQY,&PkWjNUS. Z9'-/'?%.$%@'='Z. Mc. Graw Hill 1996. 395
pginas. (O-#&*./+$%#*.*"%?*"%'",$+#*"%.$%?'%,&*0&'6'+<>-%(4"<+'%$-%@'=').,
#" h.UfUe,3FFDi,(WSPQRU,.UfU,?OPRX^. "J*6,'&'#<='%.$%I$&&'6<$-#'"%@'='". Artculo
de la revista Solo Programadores n49. Tower. Octubre 1998. (J*6,'&'% y% OR!"%
@'=').
#" h!PSve, 3FFDi, 8P]RÔ, !PSv, *XP`RXXU.
"]*=$.'.$"% H% +'6(<*"% +*-% @'='% _". Artculo
de la revista Solo Programadores n55. Tower. Marzo 1999. (Q/$-%&$"/6$-%.$%?*"%
+'6(<*"%3/$%I'-%"/&0<.*%$-%$?%@RS%TA_).,
#" h!kSe, 3FFDi, !kS, 7RQOUMpMN^`M, (SQ2 "@RS% TA_% R*+/6$-#'#<*-Z. www.sun.com.
1997. (R*+/6$-#'+<>-%.$%?'%GEO%.$%@'='%.$?%@RS).,
#" h]PS,;Ull,^N,PX2e,3FF9i,*ONjkO,]PS,;Ulle,!P`R,!jPRUR,p,)OQP,!NPOLkQY. Z7**P$.%
*-%@'='Z. Addison-Weslet. 1996. 28*.*%?*%3/$%I'+$%5'?#'%"'($&%,'&'%+&$'&%',,?$#"D%
+*-%6/+I*"%$)$6,?*"A%!-%<-0?B";.
Pgina 188 de 189

#" h1UXXRe, 3FF@i, *STO^V, 1UXXR.":'% (<(?<'% .$% @'='". Anaya multimedia. 1997. 814
pginas. (J*6,?$#*%$-%?*%'%3/$%(<(?<*#$+'"%.$?%@RS%TAT%"$%&$5<$&$).,
;*(;%;:%?B#9D=9(9>%<%?'9:(?(<%@9>9("'(:9(9<@69:(!"#$%&'E(
#" h-RPNNRSR,^N, PX2e, 3FF9i, 7PORU, 62, -RPNNRSRe, 8UMq, *2, 'PX]Uu7PSvPSUe, 8UPokcS,
'Ô]ÔP, p, 0kRM, ?ÔSgST^v. "G-4?<"<"% H% .<"$*% .$#'??'.*% .$% G,?<+'+<*-$"%
<-5*&64#<+'"%.$%0$"#<>-". Ra-Ma. 1996.,
#" h.P`LPkWj,^N,PX2e,3FFDi 82,.P`LPkWj,82e,72,#XPjPe,J2,-O^`ÔXPSRe,?2,%TTp,p,
J2, 0UO^SM^S. "9*.$?'.*% H% R<"$*% F&<$-#'.*"% '% F()$#*"A% 9$#*.*?*01'% F98".
Prentice Hall, 2 reimpresin. 1998.,
#" h.PNRUSPXe,
3FF@i, .PNRUSPX, !UlNVPO^, 'UO_UOPNRUS. "8I$% Y-<5<$.% 9*.$?<-0%
:'-0/'0$%R*+/6$-#'#<*-%M$#%TAT". www.rational.com. Septiembre de 1997.,
#" h.RllX^Ne, 3FFDi, 8^PSu7POR^, .RllX^N, "J*6/-<+'+<*-$"% $-% Y]O{". McGraw Hill.
1998.
<*(;%;:%?B#9D=9(9>%<%?'9:(G6"($"(6@%:%K&("'(:9(!"#$%&'(4*+(
#" h'UONqM, ^N, PX2e3FF9i, 8UMq, 0kRM, 'UONqMe, &kORP, 6USvgX^ve, $ROWRSRP, -qO^ve, -PokR,
$RXX^SP,p,*SP,.UMP,?O^RO^. "@'='D%$?%?$-0/')$%.$%,&*0&'6'+<>-%.$%O-#$&-$#Z. Data
Becker 1996.
#" h'k^SQPe, 3FF9i, -^TOU, 7PSk^X, 'k^SQP, 8R`qS^v2, E&*0&'6'+<>-% $-% @'='% ,'&'%
O-#$&-$#. Anaya Multimedia. 1996.
#" h'k^SQPe, 3FF@i, -^TOU, 7PSk^X, 'k^SQP, 8R`qS^ve2, "E&*0&'6'+<>-% $-% @'='".
Ediciones Anaya Multimedia. 1997.
#" h?OP`RmgSe, 3FF@i, 8UMq, 7PSk^X, ?OP`RmgS, 4UOO^M. "9'-/'?% O6,&$"+<-.<(?$% .$%
@'='". Ediciones Anaya Multimedia. 1997.
#" h0PXPSRe,3FF@i, !kX^R`PS, x!P`x, 0PXPSR. "@'='D% (<(?<*#$+'% .$?% ,&*0&'6'.*&".
Ediciones McGraw Hill. 1997.
#" h?OUklê, 3FF@i, *WkMNcS, ?OUkl^. 8/#*&<'?% .$% @'='. Facultad de Informtica de
Sevilla. 1997. http://www.fie.us.es/info/internet/JAVA/.
>*(>%#"<<%?'"$(>"(%'@"#H$(
Se recomienda suscribirse a la lista de correo de Sun sobre Java, cuya direccin es:
javanews@US.IBM.COM
Pgina 189 de 189

Guia de Iniciación en Java

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Guia de Iniciación en Java

Diunggah oleh

Hak Cipta:

Format Tersedia

Gua de iniciacin al lenguaje Java.

Versin 2.0. Octubre de 1999

A. Fundamentos ............................................................................................................................... 135

F. Atributos ...................................................................................................................................... 178

Direccin electrnica del proyecto: qjava@ubu.es

Burgos, 5 de Octubre de 1998

En un tercer apndice ZG,B-.<+$%OOO\%9B#*.*"%]'#<=*"Z se explica mediante un ejemplo

Clase Hija1 Clase Hija2

Clase Nieta1 Clase Nieta2 Clase Nieta3

Para ms informacin sobre el modelo de objetos en la programacin avanzada, y las

Se utiliza el operador -$N para asignar un espacio de memoria a un objeto en el

3. Enorme diversidad de controladores electrnicos. Los dispositivos electrnicos se

De este modo se pueden utilizar dichas primitivas para cualquier operacin de

!"El cdigo no produce desbordamiento de operandos en la pila.

Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.

String nombreBonito = Amelia;

Supongamos que un programa debe realizar diferentes acciones dependiendo de si el

// Sentencias para tratar el carcter c

estamos en bucles anidados. Si dicha etiqueta no es indicada, se presupone que nos

void inicia( int paramX, int paramY ) {

MiPunto( int paraX, int paraY ) {

Clase Hija1 Clase Hija2

static void metodoStatic() {

System.out.println(En el metodo abstracto de claseB);

Esta forma de ,*?<6*&5<"6*%.<-46<+*%$-%#<$6,*%.$%$)$+/+<>- es uno de los mecanismos

super( x, y ); // Aqu se llama al constructor de MiPunto

Clases de Exception RuntimeException Clases de Error

!"M#&<-0%0$#9$""'0$2;v Devuelve la cadena de error del objeto.

Lanzadora lanza = new Lanzadora();

!"O??$0'?8I&$'.M#'#$!g+$,#<*-: Un thread no estaba en el estado adecuado.

Para la colisin de nombres en mtodos:

As una clase dentro de un "/(,'3/$#$ como E'3/$#$AM/(,'3/$#$A+?'"$ estar

class Productor implements Runnable {

class Consumidor implements Runnable {

while ( true ) // Bucle infinito

public static void main( String args[] ) {

Desde aqu se recomienda el uso de una metodologa orientada a objeto para el

Pgina 100 de 189

Pgina 101 de 189

Pgina 102 de 189

Pgina 103 de 189

Pgina 104 de 189

Pgina 105 de 189

Las funciones de comparacin son las siguientes:

Pgina 106 de 189

Pgina 107 de 189

!"M#&<-0Q/55$&% ',,$-.2% F()$+#% *% ;v Inserta al final de la cadena, la cadena

Pgina 108 de 189

System.out.println("Su tercer caracter es: "+cad.charAt(3));

Pgina 109 de 189

Pgina 110 de 189

Pgina 111 de 189

Pgina 112 de 189

Pgina 113 de 189

Pgina 114 de 189

Pgina 115 de 189

Pgina 116 de 189

El siguiente mtodo accede al elemento +/'? de un fichero binario, imprimiendo la

RandomAccessFile f=new RandomAccessFile(ruta,"r"); // E/

System.out.print( "El fichero " + ruta );

f.seek( cual-1 ); // Me posiciono (-1 porque empieza en 0)

f.skipBytes( 9 ); // Salto 9 => Elemento 10 mas alla

Pgina 117 de 189

Pgina 118 de 189

En un tercer apndice ZG,B-.<+$%OOO\%9B#."%]'#<=*"Z se explica mediante un ejemplo

Esta forma de ,?<6&5<"6%.<-46<+%$-%#<$6,*%.$%$)$+/+<>- es uno de los mecanismos

!"Q/##-X&/,: Muestra una lista de elementos (@d'.<Q/##-) con solo uno

!""/-."/&+$: URL del directorio que contiene los archivos de sonido.