Tutorial Java ST

Tutorial Java
Contents
Leccin: Lenguaje bsico .......................................................................................................... 8
Variables .................................................................................................................................. 8
Operadores.............................................................................................................................. 8
Expresiones, declaraciones y bloques ................................................................................ 8
Instrucciones de flujo de control........................................................................................... 8
Variables ...................................................................................................................................... 8
Nomenclatura ........................................................................................................................ 10
Tipos de datos primitivos......................................................................................................... 10
Valores por defecto .............................................................................................................. 12
Literales .............................................................................................................................. 13
Usando caracteres de subrayado en literales de valores numricos........................... 15
Arreglos ...................................................................................................................................... 16
Declarar una Variable para hacer referencia a un Arreglo ............................................ 18
Crear, inicializar y acceder a una arreglo ......................................................................... 19
Copia de Arrays .................................................................................................................... 20
Manipulacin de arreglos .................................................................................................... 21
Resumen de Variables ............................................................................................................ 22
Preguntas: Variables ................................................................................................................ 22
Operadores................................................................................................................................ 22
Asignacin, aritmtica y operadores unarios ....................................................................... 24
El operador de asignacin Simple ..................................................................................... 24
Los operadores aritmticos................................................................................................. 24
Los operadores unarios ....................................................................................................... 25
Operadores de igualdad y relacionales ............................................................................ 27
Los operadores condicionales ............................................................................................ 28
El operador de comparacin de tipo instanceof .............................................................. 29
Operadores Bitwise y Bit Shift ................................................................................................ 30
Resumen de operadores ......................................................................................................... 30
Operador de asignacin simple.......................................................................................... 30
Operadores aritmticos ....................................................................................................... 30
Operadores unarios ............................................................................................................. 31
Igualdad y operadores relacionales ................................................................................... 31
Operadores condicionales .................................................................................................. 31
Operador de comparacin de tipo ..................................................................................... 31
Operadores Bitwise bit a bit y Bit Shift (mover bits) ........................................................ 31
Preguntas y ejercicios: operadores ....................................................................................... 31

Preguntas............................................................................................................................... 31
Ejercicios................................................................................................................................ 32
Expresiones, instrucciones y bloques ................................................................................... 33
Expresiones ........................................................................................................................... 33
Instrucciones o sentencias .................................................................................................. 34
Bloques .................................................................................................................................. 34
Preguntas y ejercicios: expresiones, instrucciones y bloques .......................................... 35
Preguntas............................................................................................................................... 35
Ejercicios................................................................................................................................ 35
Instrucciones de control de flujo............................................................................................. 35
Las instrucciones if-then e if-then-else.................................................................................. 36
La instruccin if-then ...................................................................................................... 36
La instruccin if-then-else .......................................................................................... 37
La instruccin switch ............................................................................................................ 38
El uso de Strings en la instruccin switch ..................................................................... 41
Las instrucciones while y do-while ................................................................................. 43
La instruccin for .................................................................................................................... 44
Instrucciones de ramificacin ................................................................................................. 46
La instruccin break ........................................................................................................... 46
La instruccin continue .................................................................................................... 48
La instruccin return......................................................................................................... 49
Resumen de las instrucciones de flujo de Control .............................................................. 50
Preguntas y ejercicios: Control de flujo ................................................................................. 50
Preguntas............................................................................................................................... 50
Ejercicios................................................................................................................................ 50
Leccin: Clases y objetos ....................................................................................................... 52
Clases..................................................................................................................................... 52
Objetos ................................................................................................................................... 52
Ms tipos ................................................................................................................................ 52
Clases anidadas ................................................................................................................... 52
Tipos de enumeracin ......................................................................................................... 52
Clases......................................................................................................................................... 52
Declarar Clases ........................................................................................................................ 54
Declarar las Variables miembro ............................................................................................. 55
Modificadores de acceso..................................................................................................... 55
Tipos ....................................................................................................................................... 56
Nombres de variables .......................................................................................................... 56
Definir Mtodos ......................................................................................................................... 57
Nombrando un mtodo ........................................................................................................ 57
Sobrecarga de mtodos ...................................................................................................... 58
Proporcionar constructores para tus clases ......................................................................... 58
Pasar informacin a un mtodo o a un Constructor ........................................................... 59
Tipos de parmetros ............................................................................................................ 60
Nmero arbitrario de argumentos ...................................................................................... 60
Nombres de parmetros ...................................................................................................... 61
Pasando argumentos de tipo de datos primitivo ............................................................. 62
Pasando argumentos de tipo de datos de referencia ..................................................... 62
Objetos ....................................................................................................................................... 63
Creacin de objetos ................................................................................................................. 64
Declarar una Variable para hacer referencia a un objeto .............................................. 64
Crear instancias de una clase ............................................................................................ 65
Inicializar un objeto............................................................................................................... 65
Uso de objetos .......................................................................................................................... 67
Referenciando a los campos de un objeto ....................................................................... 67
Llamar los mtodos de un objeto ....................................................................................... 68
El recolector de basura ........................................................................................................ 69
Ms sobre clases ...................................................................................................................... 70
Devuelve un valor desde un mtodo ..................................................................................... 70
Devolviendo una clase o una interfaz ............................................................................... 71
Usando la palabra clave this................................................................................................... 72
Usando this con un campo .............................................................................................. 72
Usando this con un Constructor ..................................................................................... 72
Controlar el acceso a los miembros de una clase............................................................... 73
Entendiendo a los miembros de la clase .............................................................................. 74
Variables de clase ................................................................................................................ 75
Mtodos de la clase ............................................................................................................. 76
Constantes............................................................................................................................. 76
La clase de Bicycle .......................................................................................................... 77
Inicializar campos ..................................................................................................................... 78
Bloques de inicializacin esttica ...................................................................................... 78
Inicializar miembros de instancia ....................................................................................... 79
Resumen de crear y utilizar clases y objetos ....................................................................... 79

Preguntas y ejercicios: clases ................................................................................................ 80
Preguntas............................................................................................................................... 80
Ejercicios................................................................................................................................ 81
Preguntas y ejercicios: objetos............................................................................................... 81
Preguntas............................................................................................................................... 81
Ejercicios................................................................................................................................ 82
Clases anidadas ....................................................................................................................... 82
Por qu utilizar clases anidadas? .................................................................................... 82
Clases anidadas estticas .................................................................................................. 83
Clases internas ..................................................................................................................... 83
Sombreado ............................................................................................................................ 84
Ejemplo de la clase interna ................................................................................................. 84
Clases locales y annimas.................................................................................................. 86
Modificadores ........................................................................................................................ 86
Clases locales ........................................................................................................................... 86
Declarar clases locales ........................................................................................................ 86
Acceso a miembros de una clase envolvente.................................................................. 88
Clases de sombreado y locales ..................................................................................... 89
Las clases locales son similares a las clases internas ................................................... 89
Clases de annimas................................................................................................................. 90
Declarar clases annimas ................................................................................................... 90
Sintaxis de clases annimas .............................................................................................. 91
Acceder a las Variables locales del mbito envolvente y declarando y acceder a los
miembros de la clase annima........................................................................................... 91
Ejemplos de clases de annimos ...................................................................................... 92
Cundo utilizar clases anidadas, Local clases, clases de annimas y expresiones
Lambda ...................................................................................................................................... 94
Preguntas............................................................................................................................... 95
Ejercicios................................................................................................................................ 95
Las respuestas a las preguntas y ejercicios: clases anidadas .......................................... 96
Preguntas............................................................................................................................... 96
Ejercicio.................................................................................................................................. 97
Tipos enumerados .................................................................................................................... 97
Leccin: anotaciones ............................................................................................................. 101
Conceptos bsicos de anotaciones ................................................................................. 101
El formato de una anotacin ......................................................................................... 101

Donde pueden ser utilizadas las anotaciones ........................................................... 102
Declarar un tipo de anotacin ....................................................................................... 102
Tipos de anotacin predefinidos ...................................................................................... 104
Tipos de anotacin utilizados por el lenguaje Java................................................... 104
Anotaciones que se aplican a otras anotaciones ...................................................... 105
Preguntas y ejercicios: anotaciones ................................................................................ 106
Preguntas......................................................................................................................... 106
Leccin: Interfaces y herencia .............................................................................................. 106
Interfaces ............................................................................................................................. 106
Herencia ............................................................................................................................... 106
Interfaces ................................................................................................................................. 107
Interfaces en Java .............................................................................................................. 107
Interfaces como APIs ......................................................................................................... 108
Definir una interfaz ............................................................................................................. 108
El cuerpo de la interfaz ...................................................................................................... 109
Implementar una interfaz....................................................................................................... 109
Una interfaz de muestra, Relatable ................................................................................. 109
Implementa la interfaz Relatable...................................................................................... 110
Usando una interfaz como un tipo ....................................................................................... 111
Evolucin de las Interfaces ................................................................................................... 112
Mtodos por defecto .............................................................................................................. 112
Extender Interfaces que contienen mtodos por defecto............................................. 115
Mtodos estticos............................................................................................................... 116
Integracin de mtodos por defecto en bibliotecas existentes ................................... 117
Resumen de Interfaces ......................................................................................................... 121
Preguntas y ejercicios: Interfaces ........................................................................................ 121
Preguntas............................................................................................................................. 121
Ejercicios.............................................................................................................................. 121
Herencia ................................................................................................................................... 122
La jerarqua de clases de la plataforma Java ................................................................ 122
Un ejemplo de herencia..................................................................................................... 123
Lo que se puede hacer en una subclase ........................................................................ 124
Miembros privados en una superclase ........................................................................... 124
Casting de Objetos ............................................................................................................. 124
Herencia mltiple de estado, la implementacin y el tipo ................................................ 125
Sobreescribir y ocultar mtodos....................................................................................... 126

Mtodos de instancia ..................................................................................................... 126
Mtodos estticos........................................................................................................... 126
Mtodos de interfaz ........................................................................................................ 127
Modificadores .................................................................................................................. 129
Resumen .......................................................................................................................... 129
Polimorfismo............................................................................................................................ 130
Ocultar campos ....................................................................................................................... 132
Usando la palabra clave super ............................................................................................. 132
Acceso a miembros de la superclase.............................................................................. 132
Los constructores de la subclase ..................................................................................... 133
Objeto como una superclase ................................................................................................ 134
El mtodo clone() ............................................................................................................... 134
El mtodo equals() ............................................................................................................. 135
El mtodo finalize()............................................................................................................. 136
El mtodo getClass() ......................................................................................................... 136
El mtodo hashCode() ....................................................................................................... 136
El mtodo toString() ........................................................................................................... 136
Escribir clases y mtodos finales ......................................................................................... 137
Clases y mtodos abstractos................................................................................................ 137
Las clases abstractas en comparacin con las Interfaces........................................... 138
Un ejemplo de clase abstracta ......................................................................................... 139
Cuando una clase abstracta implementa una interfaz ................................................. 140
Miembros de la clase ......................................................................................................... 140
Resumen de la herencia ....................................................................................................... 140
Preguntas y ejercicios: herencia .......................................................................................... 140
Preguntas............................................................................................................................. 140
Leccin: Nmeros y cadenas ............................................................................................... 141
Nmeros............................................................................................................................... 141
Strings .................................................................................................................................. 141
Nmeros................................................................................................................................... 141
Las clases de nmeros .......................................................................................................... 142
Formato de impresin numrica .......................................................................................... 144
Los mtodos printf y formato ............................................................................................ 144
Un ejemplo........................................................................................................................... 145
La clase DecimalFormat .................................................................................................... 146
Ms all de la aritmtica bsica ........................................................................................... 147

Constantes y mtodos bsicos ........................................................................................ 148
Mtodos de funciones logartmicos y exponenciales ................................................... 149
Mtodos de funciones trigonomtricos ........................................................................... 150
Nmeros aleatorios ............................................................................................................ 152
Resumen de nmeros ........................................................................................................... 152
Caracteres ............................................................................................................................... 152
Secuencias de escape....................................................................................................... 154
Strings ...................................................................................................................................... 154
Creacin de strings ............................................................................................................ 154
Longitud de cadena ............................................................................................................ 155
Concatenacin de cadenas .............................................................................................. 156
Creacin de cadenas de formato ..................................................................................... 157
Conversin entre nmeros y cadenas ................................................................................ 157
Conversin de cadenas a nmeros ................................................................................. 157
Convertir nmeros en cadenas ........................................................................................ 158
Manipulacin de caracteres de una cadena ...................................................................... 159
Caracteres y subcadenas ndice ...................................................................................... 159
Otros mtodos para manipular cadenas ......................................................................... 160
La bsqueda de caracteres y subseries de caracteres en una cadena .................... 160
Sustitucin de caracteres y subseries de caracteres en una cadena ........................ 161
Un ejemplo........................................................................................................................... 162
Comparacin de cadenas y porciones de cadenas .......................................................... 163
La clase StringBuilder ............................................................................................................ 165
Longitud y capacidad ......................................................................................................... 165
Operaciones de StringBuilder ........................................................................................... 166
Un ejemplo........................................................................................................................... 167
Resumen de caracteres y cadenas ..................................................................................... 169
Autoboxing y Unboxing .......................................................................................................... 169
Leccin: Lenguaje bsico

Variables
Ya has aprendido que objetos almacenan su estado en los campos. Sin embargo, el lenguaje de
programacin Java tambin utiliza el trmino "variable". Esta seccin analiza esta relacin, ms
las variables y sus reglas de nomenclatura y convenciones, los tipos de datos bsicos (tipos
primitivos, matrices y cadenas de caracteres), los valores por defecto y literales.
Operadores
Esta seccin describe los operadores del lenguaje de programacin Java. Primero presenta los
operadores ms comnmente utilizados, y por ltimo los operadores menos utilizados. Cada
discusin incluye ejemplos de cdigo que se pueden compilar y ejecutar.
Expresiones, declaraciones y bloques

Los operadores pueden utilizarse en la construccin de expresiones, que computan los valores;
las expresiones son los componentes bsicos de las instrucciones; las instrucciones pueden
agruparse en bloques. Esta seccin analiza expresiones, instrucciones y los bloques usando el
cdigo de ejemplo que ya has visto.
Instrucciones de flujo de control

Esta seccin describe las sentencias de los flujos de control soportados por el lenguaje de
programacin Java. Cubre la toma de decisiones, bucles y ramificaciones de sentencias que
permiten a sus programas ejecutar condicionalmente bloques particulares de cdigo.
Variables
Como has aprendido en la leccin anterior, un objeto almacena su estado en campos.
int cadence = 0;
int speed = 0;
int gear = 1;
Ya hemos presentado a los campos, pero probablemente tiene todava un par de preguntas, tales
como:
Cules son las reglas y convenciones para nombrar un campo?

Adems de int, qu otros tipos de datos existen?
Los campos se tienen que inicializar cuando se declaran?
A los campos se les asigna un valor predeterminado si no se inicializan explcitamente?
Exploraremos las respuestas a estas preguntas en esta leccin, pero antes de hacerlo, hay algunas
distinciones tcnicas de las que primero debes ser consciente.
En el lenguaje de programacin Java, se usan ambos trminos "campo" y "variable";
Esto es una fuente comn de confusin entre los nuevos desarrolladores, ya que ambas parecen a
menudo referirse a lo mismo.
El lenguaje de programacin Java define los siguientes tipos de variables:
Variables de Clase (campos estticos)

Una variable de clase es cualquier campo declarado con el modificador static;
Esto indica al compilador que hay exactamente una copia de esta variable en
existencia, sin importar cuntas veces la clase ha creado una instancia.
Un campo define el nmero de marchas para una clase particular de bicicleta que podra
ser marcado como static ya que conceptualmente el mismo nmero de marchas se
aplicar a todas las instancias.
El cdigo static int numGears = 6; creara un campo esttico. Adems, la palabra
clave final podra aadirse para indicar que el nmero de marchas nunca cambiar.
Variables de Instancia (campos no-estticos)

Tcnicamente hablando, los objetos almacenan sus Estados individuales en "campos no
estticos", es decir, los campos se declararan sin la palabra clave static.
Los campos no estticos son tambin conocidos como las variables de instancia porque
sus valores son nicos para cada instancia de una clase (para cada objeto, en otras
palabras); el currentSpeed de una bicicleta es independiente de la currentSpeed de
otra.
Variables Locales
Similar a cmo un objeto almacena su estado en los campos, un mtodo almacenar
temporalmente el estado en las variables locales.
La sintaxis para declarar una variable local es similar a declarar un campo (por ejemplo,
int count = 0;).
No hay ninguna clave especial designando una variable como local; la determinacin
proviene totalmente de la situacin en la que se declara la variable est entre la apertura
y cierre de llaves de un mtodo.
Por lo tanto, las variables locales slo son visibles para los mtodos en los que se
declaran; No son accesibles desde el resto de la clase.
Parmetros
Ya has visto ejemplos de parmetros tanto en el mtodo main de la aplicacin "Hello
World!" y en la clase Bicycle.
Recordemos que la firma para el mtodo main es public static void
main(String[] args).
Aqu, la variable args es el parmetro de este mtodo. Lo importante a recordar es que
los parmetros siempre son clasificados como "variables" no como "campos".
Esto se aplica a otras construcciones de parmetros aceptados tambin (como
constructores y los controladores de excepciones) que aprender ms adelante en el
tutorial.
Una vez dicho esto, el resto de este tutorial utiliza las siguientes directrices generales cuando se
habla de campos y variables:
Si estamos hablando de "campos en general" (excluyendo las variables locales y los parmetros),
podemos decir simplemente "campos".
Si la discusin se aplica a "todas las anteriores", podemos decir simplemente "variables".
Si el contexto pide una distincin, usaremos trminos especficos (campo esttico, variables locales,
etc.) segn corresponda. Ocasionalmente tambin puede ver el trmino "miembro" usado tambin.
Los tipos de campos, mtodos y tipos anidados se denominan colectivamente miembros.
Nomenclatura
Cada lenguaje de programacin tiene su propio conjunto de reglas y convenciones para las clases
de nombres que puedes usar, y el lenguaje de programacin Java no es diferente.
Las reglas y convenciones para nombrar sus variables pueden resumirse como sigue:
Los nombres de variables distinguen maysculas de minsculas. El nombre de una

variable puede ser cualquier identificador legal una secuencia de longitud ilimitada de
Unicode de letras y dgitos, comenzando con una letra, el signo de dlar "$" o el carcter
subrayado "_". La Convencin, sin embargo, es siempre comenzar sus nombres de
variables con una letra, no "$" o "_". Adems, el carcter de signo de dlar, por
Convencin, nunca se utiliza en absoluto. Usted puede encontrar algunas situaciones
donde se generan automticamente nombres que contienen el signo de dlar, pero sus
nombres de variable siempre deben evitar usarlo. Un convenio similar existe para el
carcter de subrayado; Aunque es tcnicamente legal para comenzar un nombre de la
variable con '_', se desaconseja esta prctica. El espacio en blanco no est permitido.
Los caracteres posteriores pueden ser Letras, nmeros, signos de dlar, o caracteres
resaltados. La convencin (y el sentido comn) se aplican a esta regla tambin. Al elegir
un nombre para sus variables, utilice palabras completas en lugar de abreviaturas
crpticas. Hacerlo asi har su cdigo fcil de leer y comprender. En muchos casos tambin
har su cdigo auto-documentado; los campos denominados cadence, speed y gear,
por ejemplo, son mucho ms intuitivos que versiones abreviadas, como s, c y g. Tambin
tenga en cuenta que el nombre que usted elige no debe ser una palabra clave o palabra
reservada.
Si el nombre que usted elige consta de una nica palabra, escriba esa palabra en
letras minsculas. Si consta de ms de una palabra, la primera letra de cada palabra
subsiguiente ser mayscula. Los nombres gearRatio y currentGear son los
principales ejemplos de esta Convencin. Si la variable almacena un valor constante,
tales como static final int NUM_GEARS = 6, la Convencin cambia
ligeramente, cada letra ser mayscula y se separa las palabras posteriores con el
carcter de subrayado. Por Convencin, el carcter de subrayado nunca se utiliza en otros
lugares.
Tipos de datos primitivos

El lenguaje de programacin Java es estticamente-tipado, lo que significa que:
todas las variables primero deben ser declaradas antes de que puedan ser utilizadas.
Esto implica declarar el tipo de la variable y el nombre, como ya lo has visto:
int gear = 1;
As dice el programa que un campo llamado "gear" existe, contiene datos numricos y tiene un valor
inicial de "1". El tipo de dato de una variable determina los valores que puede contener, adems de
las operaciones que pueden realizarse con l. Adems de int, el lenguaje de programacin Java
soporta otros siete tipos de datos primitivos.
Un tipo primitivo est predefinido por el lenguaje y es nombrado por una palabra
clave reservada.
Los valores primitivos no comparten el estado con otros valores primitivos. Los ocho tipos de datos
primitivos soportados por el lenguaje Java de programacin son:
byte: el tipo de dato byte de 8-bit es un entero con signo en complemento a dos (0 para
positivo y 1 para negativo).
o
o
Tiene un valor mnimo de -128 y un valor mximo de 127 (inclusivo).

til para guardar memoria en grandes arreglos, donde importa el ahorro de
memoria.
Pueden tambin ser utilizados en lugar de int donde sus lmites ayudan a clarificar el
cdigo; el hecho de que el rango de una variable es limitado puede servir como una forma
de documentacin.
short: el tipo de dato short es de 16-bit es un entero con signo en complemento a dos.
o
o
Tiene un valor mnimo de -32,768 y un valor mximo de 32,767 (inclusivo).

Puede utilizar un short para guardar memoria en arreglos grandes, en situaciones
donde realmente importa el ahorro de memoria.
int: por defecto, el tipo de datos int es de 32-bit es un entero con signo en complemento a
dos,
o
Tiene un valor mnimo de -231 y un valor mximo de 231-1.

Utilice la clase Integer para utilizar el tipo de datos int como un entero sin signo.
En Java SE 8 y versiones posteriores, puede utilizar el tipo de datos int para representar
un entero sin signo de 32 bits, que tiene un valor mnimo de 0 y un valor mximo de 232-1.
Consulte la seccin el nmero de clases para obtener ms informacin. Mtodos estticos
como compareUnsigned, divideUnsigned etc. se han aadido a la clase Integer
para apoyar las operaciones aritmticas de nmeros enteros sin signo.
long: el tipo de datos long es de 64-bit complemento a dos con cualquier otro.
o
o
La firma de long tiene un valor mnimo de -263 y un valor mximo de 263-1.

Utilice este tipo de datos cuando se necesita un rango de valores ms amplio que
las ofrecidas por int.
En Java SE 8 y versiones posteriores, puede utilizar el tipo de datos long para representar
64 bits sin signo, que tiene un valor mnimo de 0 y un valor mximo de 264-1.
La clase Long tambin contiene mtodos como compareUnsigned, divideUnsigned
etc. para apoyar operaciones aritmticas de long sin signo.
float: el tipo de datos float es un punto flotante de precisin simple de 32 bits del
estandar IEEE 754 (Instituto de Ingeniera Elctrica y Electrnica para aritmtica en coma
flotante). Su rango de valores est fuera del alcance de esta discusin, pero se especifica
en la seccin tipos de coma flotante, formatos y valores de la Java Language Specification.
Como con las recomendaciones de byte y short,
o
o
o
Use un float (en vez de double) si necesita guardar memoria en grandes

conjuntos de nmeros de punto flotante.
Este tipo de datos no debe utilizarse para valores precisos, como moneda.
Para eso, usted necesitar utilizar la clase java.math.BigDecimal en su lugar.
Numbers and Strings cubre BigDecimal y otras clases tiles proporcionados por
la plataforma Java.
doble: el tipo de datos double es un punto flotante de precisin doble de 64 bits IEEE 754.
Su rango de valores est fuera del alcance de esta discusin, pero se especifica en la
seccin tipos de coma flotante, formatos y valores de la especificacin del lenguaje Java.
o
o
Para valores decimales, este tipo de datos es generalmente la opcin

predeterminada.
Este tipo de datos no debe utilizarse para valores precisos, como moneda.
booleano: el tipo de datos boolean tiene slo dos valores posibles: true y false.
o
o
Utilice este tipo de datos para indicadores simples que siguen condiciones
del tipo verdadero o falso.
Este tipo de datos representa un bit de informacin, pero su "tamao" no es
algo que se define con precisin.
char: el tipo de datos char es un solo carcter Unicode de 16 bits.
Tiene un valor mnimo de '\u0000' (o 0) y un valor mximo de '\uffff' (o

65.535 inclusivo).
Adems de los ocho tipos de datos primitivos mencionados anteriormente, el lenguaje de

programacin Java tambin proporciona un apoyo especial para cadenas de caracteres mediante
la clase java.lang.String .
Encerrando tu cadena de caracteres entre comillas dobles crear automticamente un nuevo
objeto String; por ejemplo,
String s = "this is a string";.

Los objetos String son inmutables, que significa que una vez creado, no se pueden cambiar sus
valores.
La clase String no es tcnicamente un tipo de datos primitivo, pero teniendo en cuenta el apoyo
especial dado por el lenguaje, probablemente tendern a pensar en l como tal. Usted aprender
ms acerca de la clase String en Objetos de datos simples.
Valores por defecto
No siempre es necesario asignar un valor cuando se declara un campo.
Los campos que son declarados pero no inicializados establecern una moratoria razonable por el
compilador.
En trminos generales, por defecto ser cero o null, dependiendo del tipo de datos.
Confiar en estos valores por defecto, sin embargo, se considera generalmente mal estilo de
programacin.
La siguiente tabla resume los valores por defecto para los tipos de datos anteriores.
Tipo de datos
Valor por defecto (de campos)
Byte
short
int
long
0L
float
0.0F
double
0.0d
Char
'\u0000'
String (o cualquier objeto) null

Boolean
false
Las variables locales son ligeramente diferentes;

El compilador nunca asigna un valor predeterminado a una variable local sin inicializar. Si no puede
inicializar la variable local donde se declara, asegrese de asignarle un valor antes de intentar
usarla.
El acceso a una variable local sin inicializar producir un error en tiempo de compilacin.
Literales
Usted puede haber notado que no se utiliza la palabra clave new al inicializar una variable de un tipo
primitivo.
Los tipos primitivos son tipos de datos especiales incorporados en el lenguaje;

No son objetos creados de una clase.
Una literal es la representacin de cdigo fuente de un valor fijo; los literales estn
representados directamente en el cdigo sin necesidad de cmputo.
Como se muestra a continuacin, es posible asignar un literal a una variable de un tipo primitivo:
boolean result = true;

char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;
Literales enteros
Un literal entero es de tipo long si termina con la letra L o l; de lo contrario es de tipo int.
Se recomienda utilizar la letra mayscula L porque la minscula letra l es difcil distinguir el dgito 1.
Los valores de los tipos integrales byte, short, int y long pueden crearse desde
literales int.
Los valores de tipo long que exceden el rango de int pueden crearse de literales de
long.
Los literales enteros pueden ser expresados por estos sistemas de numeracin:
Decimales: Base 10, cuyas cifras consta de los nmeros 0 a 9; Este es el sistema de
numeracin que utiliza todos los das.
Hexadecimal: Base 16, cuyos dgitos consisten en los nmeros 0 a 9 y las letras A F
Binario: Base 2, cuyas cifras se compone de los nmeros 0 y 1 (puede crear literales
binarios en Java SE 7 y versiones posteriores)
Para la programacin de propsito general, es probable que el sistema de numeracin nico que
nunca usar es el sistema decimal. Sin embargo,
Si usted necesita usar otro sistema de numeracin, el ejemplo siguiente muestra la sintaxis correcta.
El prefijo 0x indica hexadecimal y 0b binario:
// The number 26, in decimal

int decVal = 26;
// The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;
Literales de coma flotante
Un literal de coma flotante es de tipo float si termina con la letra F o f; de lo contrario su

tipo es double y opcionalmente puede terminar con la letra D o d.
Los tipos de punto flotante (float y double) tambin puede expresarse utilizando E o e (para la
notacin cientfica), F o f (literal float de 32 bits) y D o d (64 bits double literal; esta es la opcin
predeterminada y por Convencin se omite).
double d1 = 123.4;
// mismo valor que d1, pero en notacin cientfica
double d2 = 1.234e2;
float f1 = 123.4f;
Carcteres y literales String
Los literales de tipo char y String pueden contener cualquier carcter Unicode (UTF-16).
Si tu editor y sistema de archivos lo permiten, se pueden utilizar tales caracteres directamente en el

cdigo. Si no, puede utilizar un "escape Unicode" como '\u0108' (mayuscula C con acento
circunflejo), o "S\u00ED Se\u00F1or" (S Seor en Espaol).
Utilice siempre 'comillas simples' para literales char y "comillas dobles" para literales de
String.
Las secuencias de escape Unicode pueden utilizarse en cualquier parte en el programa (como en
los nombres de campo, por ejemplo), no slo en literales char o String.
El lenguaje de programacin Java tambin soporta algunas secuencias de escape especial para
literales char y String:
\b (retroceso)
\t (tab),
\n (avance de lnea),
\f (forma de alimentacin),
\r (retorno de carro),
\" (comilla doble),
\' (comilla simple) y
\\ (barra invertida).
Tambin hay una literal especial null que puede utilizarse como un valor para cualquier tipo de
referencia.
null puede asignarse a cualquier variable, excepto las variables de tipos primitivos.
Es poco lo que puede hacer con un valor null ms all de pruebas de su presencia. Por lo tanto,
null es a menudo utilizado en programas como marcador para indicar que un objeto no
est disponible.
Finalmente, tambin hay un tipo especial de literal llamada
Una clase literal, se forma al tomar un nombre de tipo y anexar (.class);
Por ejemplo, String.class. Esto se refiere al objeto (de tipo Class) que representa el tipo de s
mismo.
Usando caracteres de subrayado en literales de valores numricos

En Java SE 7 y versiones posteriores, cualquier nmero de caracteres de subrayado (_) puede
aparecer en cualquier parte entre los dgitos en un literal numrico.
Esta caracteristica le permite separar grupos de dgitos en literales numricos, que pueden
mejorar la legibilidad del cdigo.
Por ejemplo, si su cdigo contiene nmeros con muchos dgitos, usars un carcter de subrayado
para separar dgitos en grupos de tres, similar a cmo usaras un signo de puntuacin como una
coma o un espacio, como un separador.
El siguiente ejemplo muestra otras maneras en que puede utilizar el carcter de subrayado en
literales de valores numricos:
long creditCardNumber = 1234_5678_9012_3456L;

long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;
Usted puede colocar subrayados slo entre los dgitos;
No puede colocar subrayado en los siguientes lugares:
Al principio o al final de un nmero

Adyacente a un punto decimal en un literal de coma flotante
Antes de un sufijo F o L
En las posiciones donde se espera una cadena de dgitos
Los siguientes ejemplos demuestran las colocaciones de subrayado vlido y no vlido (que
destacan) en literales de valores numricos:
// Invalido: no se puede poner subrayado

// adyacente a un punto decimal
float pi1 = 3_.1415F;
// adyacente a un punto decimal
float pi2 = 3._1415F;
// antes de un sufijo L
long socialSecurityNumber1 = 999_99_9999_L;
// OK (literal decimal)
int x1 = 5_2;
// Al final de una literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;
// en el prefijo 0x
int x4 = 0_x52;
// en el comienzo de un nmero
int x5 = 0x_52;
// OK (literal hexadecimal)
int x6 = 0x5_2;
// al final del numero
int x7 = 0x52_;
Arreglos
Un arreglo es un objeto contenedor que contiene un nmero fijo de valores de un solo tipo.
La longitud de un arreglo se establece cuando se crea el arreglo.
Despus de la creacin, su longitud es fija.
Usted ya ha visto un ejemplo de arreglo, en el mtodo main de la aplicacin "Hello World!". Esta
seccin analiza detalladamente los arreglos.
Una arreglo de 10 elementos.
Cada item de un arreglo se llama un elemento, y cada a elemento se accede por su ndice
numrico.
Como se muestra en la ilustracin anterior, la numeracin comienza con 0. El noveno elemento, por
ejemplo, sera por lo tanto para acceder al ndice 8.
El siguiente programa, ArrayDemo, crea un arreglo de enteros, pone algunos valores del
arreglo e imprime cada valor en salida estndar.
class ArrayDemo {
public static void main(String[] args) {
// declara una arreglo de enteros
int[] anArray;
// asigna memoria para 10 nmeros enteros
anArray = new int[10];
// inicializa primer elemento
anArray[0] = 100;
// inicializa segundo elemento
anArray[1] = 200;
// y as sucesivamente
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index
+ anArray[0]);
+ anArray[1]);
+ anArray[2]);
+ anArray[3]);
+ anArray[4]);
+ anArray[5]);
+ anArray[6]);
+ anArray[7]);
+ anArray[8]);
+ anArray[9]);
}
}
La salida de este programa es:
Element
Element
Element
Element
Element
Element
Element
Element
Element
Element
at
at
at
at
at
at
at
at
at
at
index
index
index
index
index
index
index
index
index
index
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
100
200
300
400
500
600
700
800
900
1000
0: "
1: "
2: "
3: "
4: "
5: "
6: "
7: "
8: "
9: "
En una situacin de programacin del mundo real, es probable que utilice una de las construcciones
de bucle soportados para iterar a travs de cada elemento de la matriz, en lugar de escribir cada
lnea individual como en el ejemplo anterior.
Sin embargo, el ejemplo ilustra claramente la sintaxis de la matriz. Usted aprender acerca de las
diferentes construcciones de bucles (for, while, y do-while) en la seccin de Control de flujo .
Declarar una Variable para hacer referencia a un Arreglo

El programa anterior declara un arreglo (llamada anArray) con la siguiente lnea de cdigo:
// declara un arreglo de enteros

int[] anArray;
Al igual que las declaraciones de variables de otros tipos,
una declaracin de arreglo tiene dos componentes: tipo de arreglo y el nombre del
arreglo.
Tipo de arreglo se escribe como type[], donde type es el tipo de datos de los elementos
contenidos;
los corchetes son smbolos especiales que indica que esta variable contiene un
arreglo.
El tamao del arreglo no es parte de este tipo (razn por la cual los corchetes estn vacos). El
nombre de un arreglo puede ser cualquier cosa que quieras, siempre que sigas las reglas y
convenciones como se discute en la seccin de nomenclatura . Al igual que con las variables de
otros tipos,
la declaracin en realidad no crea un arreglo; simplemente indica al compilador que esta

variable mantendr un arreglo del tipo especificado.
Del mismo modo, puede declarar arreglos de otros tipos:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Tambin puede colocar los parntesis despus del nombre de la matriz:
// esta forma se desaconseja

float anArrayOfFloats[];
Sin embargo, la convencin desalienta esta forma.
Los corchetes identifican el tipo de arreglo y deben aparecer con la designacin del
tipo.
Crear, inicializar y acceder a una arreglo
Otra forma de crear un array es con el operador new.
La siguiente instruccin en el programa ArrayDemo asigna un array con suficiente memoria para
10 elementos de tipo entero y asigna el arreglo a la variable anArray.
// crea un arreglo de enteros

anArray = new int[10];
Si falta esta instruccin, entonces el compilador imprime un error como el siguiente, y falla la
compilacin:
ArrayDemo.java:4: Variable anArray may not have been initialized.

Las siguientes lneas asignan valores a cada elemento de la matriz:
anArray[0] = 100; // inicializa el primer elemento

anArray[1] = 200; // inicializa el segundo elemento
anArray[2] = 300; // y as sucesivamente
A cada elemento del array se accede por su ndice numrico:
System.out.println("Element 1 at index 0: " + anArray[0]);

Como alternativa, puede utilizar la sintaxis de mtodo abreviado para crear e inicializar un
arreglo:
int[] anArray
100, 200,
400, 500,
700, 800,
};
= {
300,
600,
900, 1000
Aqu la longitud del arreglo se determina por el nmero de valores proporcionados entre
corchetes y separados por comas.
Tambin puede declarar un arreglo de arreglos (tambin conocido como un arreglo

multidimensional) mediante el uso de dos o ms conjuntos de corchetes, tales como
// arreglo multidimensional
String[][] names
Cada elemento, por lo tanto, debe accederse por el nmero correspondiente de los valores
del ndice.
En el lenguaje de programacin Java, un arreglo multidimensional es un arreglo cuyos
componentes son ellos mismos, los arreglos.
Esto es a diferencia de los arreglos en C o Fortran. Una consecuencia de esto es que las filas
pueden variar en longitud, como se muestra en el siguiente programa MultiDimArrayDemo :
class MultiDimArrayDemo {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}
Mr. Smith
Ms. Jones
Finalmente, usted puede utilizar la propiedad incorporada length para determinar el tamao de
cualquier arreglo. El cdigo siguiente imprime el tamao de la matriz a la salida estndar:
// para determinar el tamao del arreglo

System.out.println(anArray.length);
Copia de Arrays
La clase System tiene un mtodo arraycopy que puede utilizar para eficientar
copiar datos desde un arreglo a otro:
// obj origen, posicin inicial del obj origen,

// obj destino, posicin inicial del obj destino,
// numero de elementos a copiar
public static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
Los dos argumentos Object especifican el arreglo a copiar y el arreglo al que se copiara. Los tres
argumentos int especifican la posicin de partida en el arreglo de origen, la posicin de partida en
el arreglo de destino y el nmero de elementos del arreglo para copiar.
El siguiente programa, ArrayCopyDemo, declara un array de elementos char, deletrea la palabra
"descafeinado". Se utiliza el mtodo System.arraycopy para copiar un subsecuencia de
componentes del arreglo en un segundo arreglo:
class ArrayCopyDemo {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}
caffein
Manipulacin de arreglos
Los arreglos son un concepto potente y til usado en programacin.
Java SE proporciona mtodos para realizar algunas de las manipulaciones ms comunes

relacionadas con arreglos. Por ejemplo, el ejemplo ArrayCopyDemo utiliza el mtodo
arraycopy de la clase de System en lugar de recorrer manualmente los elementos del arreglo
origen y colocar cada uno en el arreglo de destino. Esto se lleva a cabo detrs de escena,
permitiendo a los desarrolladores usar una sola lnea de cdigo para llamar al mtodo.
Para su conveniencia, Java SE proporciona varios mtodos para realizar las manipulaciones de los
arreglos (tareas comunes, como copiar, clasificar y bsqueda de arreglos) en la clase
java.util.Arrays .
Por ejemplo, el ejemplo anterior puede modificarse para utilizar el mtodo copyOfRange de la
clase java.util.Arrays , como se puede ver en el ejemplo ArrayCopyOfDemo .
La diferencia es que mediante el mtodo copyOfRange no requiere crear el array de destino
antes de llamar al mtodo, porque el arreglo de destino es devuelto por el mtodo:
class ArrayCopyOfDemo {
char[] copyFrom = {'d', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd'};
char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);
System.out.println(new String(copyTo));
}
}
Como puede ver, la salida de este programa es el mismo (caffein), aunque requiere menos
lneas de cdigo.
Tenga en cuenta que el segundo parmetro del mtodo copyOfRange es el ndice inicial del rango
a ser copiado, inclusivo, mientras que el tercer parmetro es el ndice final del rango que se
copiar, exclusivamente. En este ejemplo, el rango a copiar no incluye el elemento del arreglo en el
ndice 9 (que contiene el carcter a).
Algunas otras operaciones tiles proporcionados por mtodos de la clase java.util.Arrays,
son:
Buscar en una matriz un valor especfico para obtener el ndice en el cual se coloca (el
mtodo binarySearch).
Comparar dos arreglos para determinar si son iguales o no (el mtodo equals).
Llenar una matriz para colocar un valor especfico en cada ndice (el mtodo fill).
Clasificar un arreglo en orden ascendente. Esto puede hacerse ya sea secuencialmente,
utilizando el mtodo de sort, o al mismo tiempo, usando el parallelSort mtodo
introducido en Java SE 8. La clasificacin paralela de grandes arreglos en sistemas
multiprocesador es ms rpido que la matriz secuencial de clasificacin.
Resumen de Variables
El lenguaje de programacin Java utiliza "variables" y "campos" como parte de su

terminologa.
Las variables de instancia (campos no estticos) son nicas para cada instancia de una
clase.
Las variables de clase (campos estticos) son campos declarados con el modificador
static; hay exactamente una copia de una variable de clase, sin importar cuntas veces
se ha creado una instancia de la clase.
Las variables locales almacenan temporalmente el estado dentro de un mtodo.
Los parmetros son variables que proporcionan informacin extra para un mtodo;
parmetros y variables locales siempre se clasifican como "variables" (no "campos").
Al nombrar sus campos o variables, hay reglas y convenciones que se deben (o debe)
seguir.
Los ocho tipos de datos primitivos son: byte, short, int, long, float, double, boolean y char.
La clase java.lang.String representa cadenas de caracteres.
El compilador asigna un valor razonable por defecto para los campos de los tipos
anteriores; para las variables locales, nunca se asigna un valor predeterminado.
Un literal es la representacin de cdigo fuente de un valor fijo.
Un arreglo es un objeto contenedor que contiene un nmero fijo de los valores de un solo
tipo.
La longitud de un arreglo se establece cuando se crea el arreglo. Despus de la creacin,
su longitud es fija.
Preguntas: Variables
1.
2.
3.
4.
5.
6.
7.
El trmino "variable de instancia" es otro nombre para ___.

El trmino "variable de clase" es otro nombre para ___.
Una variable local almacena el estado temporal; se declara dentro de un ___.
Una variable declarada dentro de la apertura y cierre de parntesis de la firma de un
mtodo se llama un ___.
Cules son los ocho tipos de datos primitivos, apoyados por el lenguaje de programacin
Java?
Cadenas de caracteres estn representadas por la clase ___.
Un ___ es un objeto contenedor que contiene un nmero fijo de los valores de un solo tipo.
Operadores
Ahora que ha aprendido a declarar e inicializar variables, probablemente quieras saber cmo hacer
algo con ellas. Aprender los operadores del lenguaje de programacin Java es un buen lugar para
empezar.
Los operadores son smbolos especiales que realizan operaciones concretas en uno,
dos o tres operandos y luego devuelven un resultado.
Mientras exploramos los operadores del lenguaje de programacin Java, puede ser til para usted
saber con anticipacin qu operadores tienen la mas alta precedencia. Los operadores en la tabla
siguiente se enumeran segn el orden de precedencia.
Cuanto ms cerca de la parte superior de la tabla un operador aparece, es ms alta su

procedencia.
Los operadores con mayor prioridad se evalan antes que los operadores con precedencia
relativamente menor.
Los operadores en la misma lnea tienen la misma precedencia.
Cuando los operadores de igual prioridad aparecen en la misma expresin, debe regir una regla de
cul se evala primero.
Los operadores binarios se evalan de izquierda a derecha;

Los operadores de asignacin se evalan de derecha a izquierda.
Precedencias de los operadores
Operadores
Precedencia
Postfix
expr++ expr--
Unario
++expr --expr +expr -expr ~ !
Multiplicativo
* / %
Aditivo
+ -
Shift (desplazar)
<< >> >>>
Relacionales
< > <= >= instanceof
Igualdad
== !=
bitwise AND
&
bitwise exclusive OR
bitwise inclusive OR
AND lgico
&&
OR lgica
||
ternario
? :
asignacin
= += -= *= /= %= &= ^= |= <<= >>= >>>=
En la programacin de propsito general, ciertos operadores tienden a aparecer con ms frecuencia

que otros; por ejemplo, el operador de asignacin "=" es mucho ms comn que el operador de
desplazamiento a la derecha sin signo ">>>". Con esto en mente, la siguiente discusin se centra
primero en los operadores que es ms probable que utilice en forma regular y termina enfocndose
en aquellas que son menos comunes. Cada discusin va acompaada de cdigo de ejemplo que se
puede compilar y ejecutar. Estudiar la salida en consola le ayudar a reforzar lo aprendido.
Asignacin, aritmtica y operadores unarios

El operador de asignacin Simple
Uno de los operadores ms comunes que te vas a encontrar es el operador de asignacin simple
"=". Viste a este operador en la clase de bicicleta; asigna el valor a su derecha con el operador
de la izquierda:
int cadence = 0;
int speed = 0;
int gear = 1;
Este operador puede usarse en objetos para asignar referencias a objetos, como se discute en
Crear objetos.
Los operadores aritmticos

El lenguaje de programacin Java proporciona operadores que realizan la adicin, sustraccin,
multiplicacin y divisin. Hay una buena posibilidad de que les reconocers por sus homlogos en
matemtica bsica. El nico smbolo que puede parecer nuevo para ti es "%", l cual divide un
operandor por otro y devuelve el resto como su resultado.
Operador
Descripcin
Operador aditivo (tambin utilizada para la concatenacin de cadenas)
Operador de resta
Operador de multiplicacin
Operador divisin
Operador del resto
El siguiente programa, ArithmeticDemo, prueba los operadores aritmticos.
class ArithmeticDemo {
public static void main (String[] args) {
int result = 1 + 2;
// el resultado es ahora 3
System.out.println("1 + 2 = " + result);
int original_result = result;
result = result - 1;
System.out.println(original_result + " - 1 = " + result);
original_result = result;
result = result * 2;
System.out.println(original_result + " * 2 = " + result);
result = result / 2;
System.out.println(original_result + " / 2 = " + result);
result = result + 8;
System.out.println(original_result + " + 8 = " + result);
result = result % 7;
System.out.println(original_result + " % 7 = " + result);
}
}
Este programa imprime lo siguiente:
1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3
Tambin puedes combinar los operadores aritmticos con el operador de asignacin simple
para crear asignaciones compuestas. Por ejemplo, x+=1; y x=x+1; ambos incrementan el valor
de x por 1.
El + operador puede utilizarse tambin para concatenar (unir) dos cadenas juntas, como se
muestra en el siguiente programa ConcatDemo :
class ConcatDemo {
public static void main(String[] args){
String firstString = "This is";
String secondString = " a concatenated string.";
String thirdString = firstString+secondString;
System.out.println(thirdString);
}
}
Al final de este programa, la variable thirdString contiene " This is a concatenated
string.", que queda impreso a la salida estndar.
Los operadores unarios

Los operadores unarios requieren slo uno de los operadores; realizan diversas operaciones como
un valor de incremento/decremento en uno, negar una expresin, o invertir el valor de tipo booleano.
Operador
Descripcin
operador aditivo unario ; indica el valor positivo (sin embargo, los nmeros son positivos
sin esto)
Menos; operador unario, niega una expresin
++
Operador de incremento; incrementa un valor de 1
--
Operador de decremento; disminuye un valor de 1
Operador complemento lgico; invierte el valor de tipo booleano
El siguiente programa, UnaryDemo, prueba los operadores unarios:
class UnaryDemo {
int result = +1;
System.out.println(result);
result--;
result++;
result = -result;
// el resultado es ahora -1
boolean success = false;
// false
System.out.println(success);
// true
System.out.println(!success);
}
}
Los operadores de incremento/decremento pueden aplicarse antes del (prefijo) o despus del
(posfijo) operador. En el cdigo result++; y ++result; ambos terminarn en que result se
incrementa en uno. La nica diferencia es que la versin prefija
(++result) evala sobre el valor incrementado,

(result++) se evala sobre el valor original.
Si slo est realizando un simple incremento/decremento, no importa qu versin elegir. Pero si

utiliza este operador en una parte de una expresin ms grande, elegir indistintamente puede hacer
una diferencia significativa.
El siguiente programa, PrePostDemo, ilustra el operador de incremento unario prefijo/postfijo:
class PrePostDemo {
int i = 3;
i++;
// imprime 4
System.out.println(i);
++i;
// imprime 5
// imprime 6
System.out.println(++i);
// imprime 6
System.out.println(i++);
// imprime 7
}
}
Operadores de igualdad y relacionales

Los operadores de igualdad y relacionales
determinan si uno de los operadores es mayor, menor, igual, o no es igual a otro

operador.
La mayora de estos operadores probablemente se ver familiar tambin. Tenga en mente que
debe utilizar "==", no "=", cuando se prueba si dos valores primitivos son iguales.
==
!=
>
>=
<
<=
igual
no es
mayor
mayor
menor
menor
a
igual a
que
o igual que
que
o igual que
El siguiente programa, ComparisonDemo, prueba los operadores de comparacin:
class ComparisonDemo {
int value1 = 1;
int value2 = 2;
if(value1 == value2)
System.out.println("value1 == value2");
if(value1 != value2)
System.out.println("value1 != value2");
if(value1 > value2)
System.out.println("value1 > value2");
if(value1 < value2)
System.out.println("value1 < value2");
if(value1 <= value2)
System.out.println("value1 <= value2");
}
}
Salida:
value1 != value2
value1 < value2
value1 <= value2
Los operadores condicionales

Los operadores && y || realizan operaciones Y-condicional e O-condicional en dos
expresiones boolean.
Estos operadores muestran un comportamiento "cortocircuito", que significa que se evala el
segundo operador slo si es necesario.
&& Condicional-AND
|| Condicional-OR
El siguiente programa, ConditionalDemo1, prueba estos operadores:
class ConditionalDemo1 {
int value1 = 1;
int value2 = 2;
if((value1 == 1) && (value2 == 2))
System.out.println("value1 is 1 AND value2 is 2");
if((value1 == 1) || (value2 == 1))
System.out.println("value1 is 1 OR value2 is 1");
}
}
Otro operador condicional es ?:, que puede ser considerado como abreviatura para una instruccin
if-then-else.
Este operador es tambin conocido como el operador ternario porque utiliza tres operandos.
En el siguiente ejemplo, este operador debe leerse como:
"Si someCondition es true, asigne el valor de value1 a result. De lo contrario, asigne el
valor de value2 a result."
El siguiente programa prueba el operador ?: en la ConditionalDemo2.
class ConditionalDemo2 {
int value1 = 1;
int value2 = 2;
int result;
boolean someCondition = true;
result = someCondition ? value1 : value2;
}
}
Porque someCondition es true, este programa imprime "1" en la pantalla.
Use este operador ?: en lugar de una instruccin if-then-else si hace el cdigo ms

legible;
Por ejemplo, cuando las expresiones son compactas y sin efectos secundarios (tales como las
asignaciones).
El operador de comparacin de tipo instanceof
El operador instanceof compara un objeto con un tipo especificado.

Se utiliza para comprobar si un objeto es una instancia de una clase, una instancia de una
subclase o una instancia de una clase que implementa una interfaz determinada.
El siguiente programa, InstanceofDemo, define una clase padre (llamado Parent), una interfaz
sencilla (llamado MyInterface) y una clase de hija (llamado Child) que hereda de los padres e
implementa la interfaz.
class InstanceofDemo {
Parent obj1 = new Parent();
Parent obj2 = new Child();
System.out.println("obj1 instanceof Parent: "
+ (obj1 instanceof Parent));
System.out.println("obj1 instanceof Child: "
+ (obj1 instanceof Child));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
System.out.println("obj2 instanceof Parent: "
+ (obj2 instanceof Parent));
System.out.println("obj2 instanceof Child: "
+ (obj2 instanceof Child));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}
Salida:
obj1
obj1
obj1
obj2
obj2
obj2
instanceof
instanceof
instanceof
instanceof
instanceof
instanceof
Parent: true
Child: false
MyInterface: false
Parent: true
Child: true
MyInterface: true
Cuando usa el operador instanceof , tenga en cuenta que null no es una instancia de nada.
Operadores Bitwise y Bit Shift

El lenguaje de programacin Java tambin proporciona operadores que realizan operaciones
bit a bit y de desplazamiento de bit en tipos integros.
Los operadores discutidos en esta seccin se utilizan poco. Por lo tanto, su cobertura es breve; la
intencin es simplemente hacerle consciente de que existen estos operadores.
El operador unario de complemento Bitwise "~" invierte un patrn de bits; se puede aplicar a
cualquiera de los tipos integros, haciendo todos los "0" a "1" y todos los "1" a "0".
Por ejemplo, un byte contiene 8 bits; aplicar este operador a un valor cuyo patrn es "00000000"
cambiara su patrn a "11111111".
El operador de desplazamiento a la izquierda con signo "<<" dezplaza el patrn de bit a la izquierda
y el operador de desplazamiento a la derecha con signo ">>" dezplaza el patrn de bit a la derecha.
El patrn de bits esta dado por el operando de la izquierda y el nmero de posiciones a desplazar
por el operando de la derecha. El operador de desplazamiento a la derecha sin signo ">>>" cambia
un cero en la posicin ms a la izquierda, mientras que la posicin ms a la izquierda despus de
">>" depende de la extensin del signo.
El operador Bitwise & realiza una operacin bitwise AND.
El operador Bitwise ^ realiza una operacin bitwise OR exclusiva.
El operador Bitwise | realiza una operacin bitwise OR inclusiva.
El siguiente programa, BitDemo, utiliza el operador bitwise AND para imprimir el nmero "2" en
salida estndar.
class BitDemo {
int bitmask = 0x000F;
int val = 0x2222;
// prints "2"
System.out.println(val & bitmask);
}
}
Resumen de operadores
La siguiente referencia rpida resume los operadores soportados por el lenguaje de programacin
Java.
Operador de asignacin simple

=
Operador de asignacin simple
Operadores aritmticos
+
Operador aditivo (tambien usado para la concatenacin de
String)
operador de resta
*
operador de multiplicacin
/
%
operador de Division
operador de resto
Operadores unarios
+
operador aditivo unario:indica el valor positivo

(sin embargo, los nmeros son positivos sin esto)
Menos; operador unario, niega una expresion
Operador de incremento; incrementa un valor de 1
Operador de decremento; disminuye un valor de 1
Operador complemento lgico; invierte el valor
de tipo booleano
++
-!
Igualdad y operadores relacionales

==
!=
>
>=
<
<=
Equal to
Not equal to
Greater than
Greater than or equal to
Less than
Less than or equal to
Operadores condicionales
&&
||
?:
Conditional-AND
Conditional-OR
Ternary (forma abreviada de
de la sentencia if-then-else)
Operador de comparacin de tipo

instanceof
Compara un objecto con

un tipo especificado
Operadores Bitwise bit a bit y Bit Shift (mover bits)

~
<<
>>
>>>
&
^
|
Unary bitwise complement

Signed left shift
Signed right shift
Unsigned right shift
Bitwise AND
Bitwise exclusive OR
Bitwise inclusive OR
Preguntas y ejercicios: operadores

Preguntas
1.
Considere el siguiente fragmento de cdigo.
arrayOfInts[j] > arrayOfInts[j+1]
Que operadores contiene el cdigo?

2.
int i = 10;
int n = i++%5;
a.
b.
3.
4.
5.
Cules son los valores de i y n despus de que se ejecuta el cdigo?

Cules son los valores finales de i y n si en lugar de utilizar el operador postfijo
de incremento (i++), utiliza la versin prefija (++i))?
Para invertir el valor de un boolean, que operador usaras?

Qu operador se utiliza para comparar dos valores, = o ==?
Explica el siguiente ejemplo de cdigo:
result = someCondition ? value1 : value2;
Ejercicios
1.
Cambiar el siguiente programa para utilizar asignaciones compuestas:
class ArithmeticDemo {
public static void main (String[] args){
int result = 1 + 2; // result is now 3
result = result - 1; // result is now 2
result = result * 2; // result is now 4
result = result / 2; // result is now 2
result = result + 8; // result is now 10
result = result % 7; // result is now 3
}
}
En el siguiente programa, explique por qu el valor "6" se imprime dos veces seguidas:
class PrePostDemo {
public static void main(String[]
int i = 3;
i++;
//
++i;
//
System.out.println(++i); //
System.out.println(i++); //
//
}
}
args){
"4"
"5"
"6"
"6"
"7"
Expresiones, instrucciones y bloques

Ahora que comprende las variables y los operadores, es tiempo de aprender acerca de las
expresiones, instrucciones y bloques.
Los operadores se utilizan en la construccin de expresiones, que computan los

valores; las expresiones son los componentes bsicos de las instrucciones; las
instrucciones pueden agruparse en bloques.
Expresiones
Una expresin es una construccin compuesta por variables, operadores y las invocaciones
de mtodo, que fueron construidas segn la sintaxis del lenguaje, se evala como un valor nico.
Ya hemos visto ejemplos de expresiones, ilustrados en negrita abajo:
int cadence = 0;
anArray[0] = 100;
int result = 1 + 2; // result is now 3
if (value1 == value2)
System.out.println("value1 == value2");
El tipo de datos del valor devuelto por una expresin depende de los elementos utilizados en
la expresin.
La expresin cadence = 0 devuelve un int porque el operador de asignacin devuelve un valor
del mismo tipo de datos que el de su operador de la izquierda; en este caso, cadence es un int.
Como se puede ver en las otras expresiones, una expresin puede devolver otros tipos de valores,
tales como boolean o String.
El lenguaje de programacin Java permite construir expresiones compuestas de varias expresiones
ms pequeas, siempre y cuando el tipo de datos requerido por una parte de la expresin coincide
con el tipo de datos del otro. Aqu hay un ejemplo de una expresin compuesta:
1 * 2 * 3
En este caso particular, el orden en el cual se evala la expresin es importante porque el resultado
de la multiplicacin es independiente del orden; el resultado es siempre el mismo, no importa en qu
orden se aplican las multiplicaciones. Sin embargo, esto no es cierto de todas las expresiones. Por
ejemplo, la siguiente expresin da resultados diferentes, dependiendo de si se realiza la adicin o la
operacin de divisin primero:
x + y / 100
// ambiguo
Puede especificar exactamente cmo una expresin sern evaluadas utilizando parntesis: (y). Por
ejemplo, para hacer la anterior expresin inequvoca, puede escribir lo siguiente:
(x + y) / 100
// no ambiguo, recomendado
Si usted no indica explcitamente el orden para las operaciones a realizar, el orden es determinado
por la precedencia asignada a los operadores en el uso dentro de la expresin. Los operadores que
tienen una mayor prioridad consiguen ser evaluados primero. Por ejemplo, el operador divisin tiene
una mayor prioridad que el operador de suma. Por lo tanto, los siguientes dos comandos son
equivalentes:
x + y / 100
x + (y / 100) // no ambiguo, recomendado
Al escribir expresiones compuestas, debe ser explcito e indicar entre parntesis que los operadores
deben ser evaluados primero. Esta prctica hace ms fcil leer y mantener el cdigo.
Instrucciones o sentencias
Las instrucciones son ms o menos equivalentes a las oraciones en lenguas naturales.
Una instruccin forma una unidad completa de ejecucin.
Los siguientes tipos de expresiones se pueden realizar en una instruccin por la expresin de un
punto y coma (terminacin;).
Expresiones de asignacin
Cualquier uso de ++ o -Invocaciones de mtodo
Expresiones de creacin de objeto
Tales instrucciones son llamadas instrucciones o sentencias de expresin. Estos son algunos
ejemplos de instrucciones de expresin.
// instruccin de asignacin
aValue = 8933.234;
// instruccin de incremento
aValue++;
// instruccin de invocacin de mtodo
System.out.println("Hello World!");
// instruccin de creacin de objeto
Bicycle myBike = new Bicycle();
Adems de las instrucciones de expresin, existen otros dos tipos de instrucciones:
1.
2.
declaracin de instrucciones e
instrucciones de control de flujo.
Una declaracin declara una variable. Ya has visto muchos ejemplos de instrucciones de
declaracin:
// instruccin de declaracin
double aValue = 8933.234;
Finalmente, las instrucciones o sentencias de control de flujo regulan el orden en que se
ejecutan las instrucciones.
Bloques
Un bloque es un grupo de cero o ms instrucciones entre corchetes y puede ser utilizado

en cualquier lugar que se permite una sola sentencia.
El ejemplo siguiente, BlockDemo, ilustra el uso de bloques:
class BlockDemo {
boolean condition = true;

if (condition) { // comienza el bloque 1
System.out.println("Condition is true.");
} // finaliza el bloque 1
else { // comienza el bloque 2
System.out.println("Condition is false.");
} // finaliza el bloque 2
}
}
Preguntas y ejercicios: expresiones, instrucciones y

bloques
Preguntas
1.
2.
3.
4.
Los operadores pueden utilizarse en la construccin de ___, que computan los valores.
Las expresiones son los componentes bsicos de ___.
Las instrucciones pueden agruparse en ___.
El siguiente fragmento de cdigo es un ejemplo de una expresin ___.
5. 1 * 2 * 3
6. Las instrucciones son ms o menos equivalentes a las oraciones en lenguas naturales, pero
en lugar de acabar con un punto, una instruccin termina con un ___.
7. Un bloque es un grupo de cero o ms instrucciones entre ___ y puede ser utilizado en
cualquier lugar que se permite una sola sentencia.
Ejercicios
Identifique los siguientes tipos de instrucciones de expresin:
aValue = 8933.234;
aValue++;
Bicycle myBike = new Bicycle();
Instrucciones de control de flujo

Las instrucciones dentro de los archivos fuente generalmente se ejecutan de arriba hacia abajo,
en el orden en que aparecen.
Sin embargo, en las instrucciones del control de flujo, la ruptura del flujo de ejecucin mediante el
empleo de toma de decisiones, bucles y ramificaciones, permite a su programa condicionar la
ejecucin de determinados bloques de cdigo.
Esta seccin describe las instrucciones para la toma de decisiones:
if-then
if-then-else
switch
Instrucciones de bucle:
for
while
do-while
Instrucciones de ramificacin:
break
continue
return
Las instrucciones if-then e if-then-else

La instruccin if-then
La instruccin if-then es la ms bsica de todas las instrucciones de control de flujo.
Le dice a su programa que ejecute una determinada seccin de cdigo slo si una
determinada prueba se evala como true.
Por ejemplo, la clase Bicycle podra permitir a los frenos disminuir la velocidad de la bicicleta
solamente si la bicicleta ya est en marcha. Una posible implementacin del mtodo applyBrakes
podra ser como sigue:
void applyBrakes() {
// la clusula "if": la bicicleta debe estar en movimiento
if (isMoving){
// la clusula "then": disminuir la velocidad actual
currentSpeed--;
}
}
Si esta prueba se evala como false (es decir, que la bicicleta no est en movimiento), el control
salta hasta el final de la instruccin if-then.
Adems, la apertura y cierre de llaves son opcionales, siempre que la clusula "then"
contenga solamente una instruccin:
// lo mismo que el anterior, pero sin llaves
if (isMoving)
currentSpeed--;
}
Decidir cundo omitir las llaves es una cuestin de gusto personal. Omitirlos puede hacer el cdigo
ms frgil. Si una segunda instruccin ms tarde se aade a la clusula "then", un error comn sera
olvidar aadir las llaves recin requeridas. El compilador no puede detectar este tipo de error;
slo obtendr resultados equivocados.
La instruccin if-then-else
La instruccin if-then-else proporciona un camino secundario a la ejecucin

cuando una clusula "if" se evala como false.
Puedes usar una instruccin if-then-else en el mtodo applyBrakes para tomar medidas si
se aplican los frenos cuando la bicicleta no est en movimiento. En este caso, la accin es
simplemente imprimir un mensaje de error indicando que ya se ha detenido la bicicleta.
if (isMoving) {
currentSpeed--;
} else {
System.err.println("The bicycle has already stopped!");
}
}
El siguiente programa, IfElseDemo, asigna una calificacin basada en el valor de una prueba: una
A para una calificacin de 90% o superior, una B por una puntuacin de 80% o superior y as
sucesivamente.
class IfElseDemo {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80)
grade = 'B';
grade = 'C';
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade =
{
{
{
" + grade);
}
}
La salida del programa es:
Grade = C
Usted puede haber notado que el valor de testscore puede satisfacer ms de una expresin en
la declaracin compuesta: 76 >= 70 y 76 >= 60. Sin embargo, una vez que se satisface una
condicin, se ejecutan las instrucciones apropiadas (grade = 'C';) y no se evalan las
condiciones restantes.
La instruccin switch
A diferencia de las instrucciones if-then e if-then-else,
La instruccin switch puede tener un nmero de posibles rutas de ejecucin.

Un switch trabaja con byte, short, char y tipos de datos primitivos int.
Tambin funciona con tipos enumerados (discutido en Tipos Enum), la clase String y algunas
clases especiales que contienen ciertos tipos primitivos: Character, Byte, Short e Integer
(discutido en nmeros y cadenas).
La sentencia break lo lleva a la siguiente sentencia ejecutable fuera del bloque en el que se ubica.
El ejemplo de cdigo siguiente, SwitchDemo, declara un int llamado month cuyo valor
representa un mes. El cdigo muestra el nombre del mes, basndose en el valor del month,
mediante la instruccin switch.
public class SwitchDemo {

int month = 8;
String monthString;
switch (month) {
case 1: monthString
break;
case 2: monthString
break;
case 3: monthString
break;
case 4: monthString
break;
case 5: monthString
break;
case 6: monthString
break;
case 7: monthString
break;
case 8: monthString
break;
case 9: monthString
break;
case 10: monthString
break;
= "January";
= "February";
= "March";
= "April";
= "May";
= "June";
= "July";
= "August";
= "September";
= "October";
case 11: monthString = "November";

break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
En este caso, August se imprime a la salida estndar.
El cuerpo de una instruccin switch es conocido como bloque del switch.
Una instruccin en el bloque del switch puede etiquetarse con una o ms etiquetas de case o
default.
La instruccin switch evala la expresin, luego ejecuta todas las instrucciones que le
siguen a la correspondiente etiqueta case.
Tambin se puede mostrar el nombre del mes con declaraciones if-then-else :
int month = 8;
if (month == 1) {
System.out.println("January");
} else if (month == 2) {
System.out.println("February");
}
... // y asi
Decidir si utilizar la instruccin if-then-else o una instruccin switch se basa en la legibilidad
y la expresin que est probando la instruccin.
Una instruccin if-then-else puede probar expresiones basadas en rangos de

valores o condiciones.
Una declaracin switch prueba expresiones basadas solamente en un nico nmero
entero, valor enumerado u objeto String.
Otro punto de inters es la instruccin break.
Cada instruccin break termina la instruccin switch en la que se encuentra.
El Flujo de control contina con la primera instruccin que sigue en el bloque switch. Las
instrucciones de break son necesarias porque sin ellas, las instrucciones dentro del bloque
switch fracasan: todas las instrucciones despus de la correspondiente etiqueta del case son
ejecutadas en secuencia, independientemente de la expresin de etiquetas posteriores case, hasta
que se encuentre una instruccin break.
El programa SwitchDemoFallThrough muestra las instrucciones en un bloque switch que
fracasan. El programa muestra el mes correspondiente al nmero entero month y los meses que
siguen en el ao:
public class SwitchDemoFallThrough {

java.util.ArrayList<String> futureMonths =
new java.util.ArrayList<String>();
int month = 8;
switch (month) {
case 1: futureMonths.add("January");
case 2: futureMonths.add("February");
case 3: futureMonths.add("March");
case 4: futureMonths.add("April");
case 5: futureMonths.add("May");
case 6: futureMonths.add("June");
case 7: futureMonths.add("July");
case 8: futureMonths.add("August");
case 9: futureMonths.add("September");
case 10: futureMonths.add("October");
case 11: futureMonths.add("November");
case 12: futureMonths.add("December");
break;
default: break;
}
if (futureMonths.isEmpty()) {
System.out.println("Invalid month number");
} else {
for (String monthName : futureMonths) {
System.out.println(monthName);
}
}
}
}
Esta es la salida del cdigo:
August
September
October
November
December
Tcnicamente, el break final no es necesario porque el flujo cae fuera de la declaracin switch.
Es recomendable utilizar un break para que modificar el cdigo sea ms fcil y menos propenso a
errores.
La seccin default se encarga de todos los valores que no son explcitamente

manejados por una de las secciones del case.
SwitchDemo2, el siguiente ejemplo de cdigo muestra cmo una declaracin puede tener
varias etiquetas de case.
El ejemplo de cdigo calcula el nmero de das en un mes determinado:
class SwitchDemo2 {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1: case 3: case 5:
case 7: case 8: case 10:
case 12:
numDays = 31;
break;
case 4: case 6:
case 9: case 11:
numDays = 30;
break;
case 2:
if (((year % 4 == 0) &&
!(year % 100 == 0))
|| (year % 400 == 0))
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = "
+ numDays);
}
}
Esta es la salida del cdigo:
Number of Days = 29
El uso de Strings en la instruccin switch

En Java SE 7 y versiones posteriores, puede utilizar un objeto String en la expresin de la
instruccin switch.
El ejemplo de cdigo siguiente, StringSwitchDemo, muestra el nmero del mes basndose en
el valor de la String denominada month:
public class StringSwitchDemo {

public static int getMonthNumber(String month) {
int monthNumber = 0;
if (month == null) {
return monthNumber;
}
// toLowerCase convierte en minuscula
switch (month.toLowerCase()) {
case "january":
monthNumber = 1;
break;
case "february":
monthNumber =
break;
case "march":
monthNumber =
break;
case "april":
monthNumber =
break;
case "may":
monthNumber =
break;
case "june":
monthNumber =
break;
case "july":
monthNumber =
break;
case "august":
monthNumber =
break;
case "september":
monthNumber =
break;
case "october":
monthNumber =
break;
case "november":
monthNumber =
break;
case "december":
monthNumber =
break;
default:
monthNumber =
break;
2;
3;
4;
5;
6;
7;
8;
9;
10;
11;
12;
0;
}
return monthNumber;
}
String month = "August";
int returnedMonthNumber =
StringSwitchDemo.getMonthNumber(month);
if (returnedMonthNumber == 0) {
System.out.println("Invalid month");
} else {
System.out.println(returnedMonthNumber);
}
}
}
La salida de este cdigo es 8.
La String en la expresin switch se compara con las expresiones asociadas con la etiqueta de
cada case como si se utilizara el mtodo String.equals. A fin de que el ejemplo
StringSwitchDemo acepte cualquier mes independientemente del caso, month se convierte en

minscula (con el mtodo toLowerCase) y todas las cadenas asociadas con el case son
etiquetas en minsculas.
Nota: este ejemplo comprueba si la expresin en la instruccin switch es null. Asegrese de
que la expresin en cualquier instruccin switch no es null para impedir que una
NullPointerException sea lanzada.
Las instrucciones while y do-while
La instruccin ciclica while continuamente ejecuta un bloque de instrucciones

mientras una condicin particular es true.
Su sintaxis puede expresarse como:
while (expresin) {
instruccin(es)
}
La instruccin while evala la expresin, que debe devolver un valor boolean.

Si la expresin se evala como true, la instruccin while ejecuta la instruccin(es) en el
bloque de while.
La instruccin while contina probando la expresin y ejecutando su bloque hasta que la
expresin se evala como false.
Se logra mediante la instruccin while imprimir los valores del 1 al 10 como en el siguiente
programa WhileDemo:
class WhileDemo {
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
Puede implementar un bucle infinito mediante la instruccin while como sigue:
while (true){
// aqui va tu codigo
}
El lenguaje de programacin Java tambin proporciona una instruccin do-while, que puede
expresarse de la siguiente manera:
do {
instruccin(es) // las instrucciones se ejecutan al menos una vez
} while (expresin);
La diferencia entre do-while y while es que do-while evala su expresin en la

parte inferior del bucle en lugar de la parte superior. Por lo tanto, las instrucciones dentro
del bloque do siempre se ejecutan al menos una vez.
Como se muestra en el siguiente programa DoWhileDemo:
class DoWhileDemo {
int count = 1;
do {
System.out.println("Count is: " + count);
count++;
} while (count < 11);
}
}
La instruccin for
La instruccin cclica for proporciona una forma compacta para iterar sobre un
rango de valores.
Los programadores a menudo se refieren a l como el "for loop" debido a la forma en la cual el
bucle se repite hasta que se satisface una condicin particular.
La forma general de la instruccin for puede expresarse de la siguiente manera:
for (inicializacin; terminacin; incremento) {

instruccin(es)
}
Cuando use esta versin de la instruccin for, tenga en cuenta que:
La expresin inicializacin, inicializa el bucle; se ejecuta una vez, cuando comienza el

bucle.
Cuando la expresin terminacin se evala como false, finaliza el bucle.
La expresin de incremento se invoca despus de cada iteracin a travs del bucle; es
perfectamente aceptable para esta expresin incrementar o disminuir un valor.
El siguiente programa, ForDemo, utiliza la forma general de la instruccin for para imprimir los
nmeros del 1 al 10 a la salida estndar:
class ForDemo {
for(int i = 1; i < 11; i++){
System.out.println("Count is: " + i);
}
}
}
Count is: 1
Count
Count
Count
Count
Count
Count
Count
Count
Count
is:
is:
is:
is:
is:
is:
is:
is:
is:
2
3
4
5
6
7
8
9
10
Observe cmo el cdigo declara una variable dentro de la expresin de inicializacin.

El alcance de esta variable se extiende desde su declaracin hasta el final del bloque regido por la
instruccin for, as que puede ser utilizado en las expresiones de terminacin y de incremento.
Si la variable que controla una instruccin for no es necesaria fuera del bucle, es mejor declarar la
variable en la expresin de inicializacin.
Los nombres i, j y k se utilizan para el control de los bucles for; declarndolos dentro de
la expresin de inicializacin limita su vida til y reduce errores.
Las tres expresiones del bucle for son opcionales; se puede crear un bucle infinito de la
siguiente manera:
// loop infinito
for ( ; ; ) {
// your code goes here
}
La instruccin for tambin tiene otra forma diseada por iteracin a travs de colecciones y
arreglos de esta forma se refiere a veces como
Instruccin for mejorado y puede ser utilizada para hacer los bucles ms compactos y
fciles de leer.
for (parametro : nombrearreglo) {

instruccin(es)
}
Para demostrarlo, considere la siguiente matriz, que contiene los nmeros del 1 al 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};

El siguiente programa, EnhancedForDemo, utiliza el bucle for mejorado a travs de la matriz:
class EnhancedForDemo {
int[] numbers =
{1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}
En este ejemplo, la variable item retiene el valor actual de la matriz de nmeros.

La salida de este programa es la misma que antes:
Count
Count
Count
Count
Count
Count
Count
Count
Count
Count
is:
is:
is:
is:
is:
is:
is:
is:
is:
is:
1
2
3
4
5
6
7
8
9
10
Se recomienda utilizar este forma de instruccin for en vez de la forma general siempre
que sea posible.
Instrucciones de ramificacin
La instruccin break
La instruccin break tiene dos formas: con etiqueta y sin etiqueta.
Viste la forma sin etiqueta en la discusin anterior de la instruccin switch. Tambin puede utilizar
una etiqueta break para terminar un bucle for, while, o do-while, como se muestra en el
siguiente programa BreakDemo:
class BreakDemo {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " +
i);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
Este programa busca el nmero 12 en una matriz.

La instruccin break, que se muestra en negrita, finaliza el bucle for cuando se encuentra
ese valor.
Luego el flujo de control se transfiere despus del bucle for. La salida de este programa es:
Found 12 at index 4
Una instruccin break sin etiqueta termina las instrucciones switch, for, while, o dowhile mas internas.
Un break con etiqueta termina una instruccin externa.
El siguiente programa, BreakWithLabelDemo, es similar al programa anterior, pero utiliza

bucles for anidados para buscar un valor en una matriz bidimensional.
Cuando el valor se encuentra, un break con etiqueta finaliza el bucle for externo
(etiquetado como " search "):
class BreakWithLabelDemo {
int[][] arrayOfInts = {
{ 32, 87, 3, 589 },
{ 12, 1076, 2000, 8 },
{ 622, 127, 77, 955 }
};
int searchfor = 12;
int i;
int j = 0;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at " + i + ",
" + j);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
sta es la salida del programa.
Found 12 at 1, 0
La instruccin break termina la instruccin etiquetada; No transfiere el flujo de control a la

etiqueta.
El Flujo se transfiere a la instruccin que sigue inmediatamente a la instruccin con etiqueta
(finalizada).
La instruccin continue
La instruccin continue salta la iteracin actual de un bucle for, while, o dowhile.
La forma sin etiqueta salta al final del cuerpo del bucle ms interno y evala la expresin boolean
que controla el bucle.
El siguiente programa, ContinueDemo, pasa a travs de una String, contando las ocurrencias
de la letra "p". Si el carcter actual no es una p, la declaracin continue omite el resto del bucle y
procede al siguiente carcter. Si es una "p", el programa incrementa el contador de letra.
class ContinueDemo {
String searchMe = "peter piper picked a " + "peck of pickled
peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {
// interesado solo en p's
if (searchMe.charAt(i) != 'p')
continue;
// procesa p's
numPs++;
}
System.out.println("Found " + numPs + " p's in the string.");
}
}
Aqu est la salida de este programa:
Found 9 p's in the string.

Para ver este efecto con ms claridad, intente quitar la declaracin continue y vuelva a compilar.
Cuando se ejecuta el programa otra vez, la cuenta ser incorrecta, diciendo que ha encontrado 35 p
en lugar de 9.
Una instruccin con etiqueta continue salta la iteracin actual de un bucle externo marcado con
la etiqueta dada.
El siguiente programa de ejemplo, ContinueWithLabelDemo, utiliza bucles anidados para
buscar una subcadena dentro de otra cadena.
Se necesitan dos bucles anidados:
uno para iterar sobre la subcadena

uno para iterar sobre la cadena en donde vamos a buscar.
El siguiente programa, ContinueWithLabelDemo, usa la forma etiquetada de continue para

saltar una iteracin en el bucle externo.
class ContinueWithLabelDemo {
String searchMe = "Look for a substring in me";
String substring = "sub";
int max = searchMe.length() substring.length();
test:
for (int i = 0; i <= max; i++) {
int n = substring.length();
int j = i;
int k = 0;
while (n-- != 0) {
if (searchMe.charAt(j++) != substring.charAt(k++)) {
continue test;
}
}
foundIt = true;
break test;
}
System.out.println(foundIt ? "Found it" : "Didn't find it");
}
}
Aqu est la salida de este programa.
Found it
La instruccin return
La ltima de las instrucciones de ramificacin es la instruccin return.
La instruccin return sale por el mtodo actual, y el flujo de control regresa a donde se
invoc el mtodo.
La instruccin return tiene dos formas:
una que devuelve un valor

otra que no devuelve.
Para devolver un valor, simplemente ponga el valor (o una expresin que calcula el valor)
despus de la palabra clave return.
return ++count;
El tipo de datos del valor devuelto debe coincidir con el tipo devuelto por el mtodo declarado.
Cuando un mtodo es declarado void, este utiliza la forma de return que no devuelve un valor.
return;
La leccin de clases y objetos cubrir todo lo que necesitas saber sobre mtodos de escritura.
Resumen de las instrucciones de flujo de Control

La instruccin if-then es la ms bsica de todas las instrucciones de flujo de control. Le dice al
programa que ejecute una determinada seccin de cdigo slo si una prueba en particular se evala
como true.
La instruccin if-then-else proporciona un camino secundario a la ejecucin cuando una
clusula "si" se evala como false.
A diferencia de if-then y if-then-else la instruccin switch se permite para cualquier
nmero de rutas de ejecucin posible.
La instruccin while y do-while continuamente ejecutan un bloque de sentencias mientras una
condicin particular es true.
La diferencia entre do-while y while es que do-while evala su expresin en la parte inferior
del bucle en lugar de la parte superior. Por lo tanto, las declaraciones dentro del bloque do siempre
se ejecutan al menos una vez.
La instruccin for proporciona una forma compacta para iterar sobre un rango de valores. Tiene
dos formas, una de las cuales fue diseada para crear bucles a travs de las colecciones y los
arreglos.
Preguntas y ejercicios: Control de flujo

Preguntas
1.
2.
3.
4.
5.
La ms bsica instruccin de los flujos de control soportado por el lenguaje de

programacin Java es la instruccin de ___.
La instruccin de ___ permite cualquier nmero de rutas de ejecucin posible.
La instruccin de ___ es similar a la instruccin while, pero evala su expresin en la ___
del bucle.
Cmo se escribe un bucle infinito mediante la instruccin for?
Cmo se escribe un bucle infinito mediante la instruccin while?
Ejercicios
1.
if (aNumber >= 0)
if (aNumber == 0)
System.out.println("first string");
else System.out.println("second string");
System.out.println("third string");
a.
Qu salida crees que el cdigo producir si aNumber es 3?
b.
c.
d.
Practicas.
Escribe un programa de prueba que contenga el fragmento de cdigo anterior;

hacer aNumber 3. Cul es la salida del programa? Es lo que has predicho?
Explicar por qu la salida es lo que es; en otras palabras, cul es el flujo de
control para el fragmento de cdigo?
Usando slo espacios y saltos de lnea, reformatear el fragmento de cdigo para
que el flujo de control sea fcil de entender.
Utilice llaves, { y }, para clarificar el cdigo.
Leccin: Clases y objetos

Con el conocimiento que ahora tiene de los fundamentos del lenguaje de programacin Java, puede
aprender a escribir sus propias clases. En esta leccin, encontrar informacin sobre cmo definir
sus propias clases, incluyendo declarar miembros, variables, mtodos y constructores.
Aprender a utilizar las clases para crear objetos y cmo utilizar los objetos que crea.
Esta leccin cubre tambin clases anidadas dentro de otras clases y enumeraciones.
Clases
Esta seccin le muestra la anatoma de una clase y cmo declarar campos, mtodos y
constructores.
Objetos
Esta seccin cubre la creacin y uso de objetos. Usted aprender a crear una instancia de un
objeto y, una vez instanciado, cmo se utiliza el operador dot para acceder a las variables de
instancia y mtodos del objeto.
Ms tipos
Esta seccin cubre ms aspectos de las clases que dependen del uso de referencias a objetos y
sobre el operador dot que has aprendido en la seccin anterior: devolver valores desde los
mtodos, la palabra clave this, clase vs. miembros de instancia y control de acceso.
Clases anidadas
Clases anidadas estticas annimas internas, clases, clases locales estn cubiertas. Tambin hay
una discusin sobre cundo utilizar este enfoque.
Tipos de enumeracin
Esta seccin cubre las enumeraciones, clases especializadas que le permiten definir y utilizar
conjuntos de constantes.
Clases
La introduccin a los conceptos de orientacin a objetos en la leccin titulada Conceptos de
programacin orientada a objetos utiliza una clase de bicicleta como ejemplo, con bicicletas de
carreras, bicicletas de montaa y bicicletas tndem como subclases.
Aqu est el cdigo del ejemplo para una posible implementacin de una clase de Bicycle,
para darle una visin general de una declaracin de clase.
Las secciones posteriores de esta leccin retroceden y explican las declaraciones de clase paso a
paso. Por el momento, no se preocupe por los detalles.
public class Bicycle {

// la clase Bicycle tiene
// tres campos
public int cadence;

public int gear;
public int speed;
// un constructor
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
// cuatro mtodos
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
}
Una declaracin de clase para una clase de MountainBike que es una subclase de la
Bicycle podra verse as:
public class MountainBike extends Bicycle {

// la subclase MountainBike tiene
// un campo
public int seatHeight;
// un constructor
public MountainBike(int startHeight, int startCadence,
int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
// un mtodo
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
MountainBike hereda todos los campos y mtodos de Bicycle y agrega el campo
seatHeight y un mtodo para configurarlo (las bicicletas de montaa tienen asientos que se
pueden mover hacia arriba y hacia abajo segn la demanda de terreno).
Declarar Clases
Has visto clases definidas de la siguiente manera:
class MyClass {
// declaraciones de mtodos,
// campos y constructores
}
Esto es una declaracin de clase.
El cuerpo de la clase (el rea entre las llaves) contiene todo el cdigo que se proporciona para
el ciclo de vida de los objetos creados de la clase:
constructores para inicializar nuevos objetos,

las declaraciones de los campos que proporcionan el estado de la clase y de sus
objetos, y
mtodos para implementar el comportamiento de la clase y de sus objetos.
La declaracin de clase anterior es mnima. Contiene slo aquellos componentes de una declaracin
de clase que se requieren.
Puede proporcionar ms informacin acerca de la clase, como el
nombre de su superclase,
si implementa cualquier interface
y as sucesivamente, en el inicio de la declaracin de clase.

Por ejemplo,
class MyClass extends MySuperClass implements YourInterface {

// declaraciones de mtodos,
// campos y constructores
}
significa que MyClass es una subclase de MySuperClass y que implementa la interfaz
YourInterface .
Tambin puede agregar modificadores como pblico o privado al principio as que puedes
ver que la primera lnea de una declaracin de clase puede ser bastante complicada.
Los modificadores pblico y privada, que determinan qu otras clases pueden acceder
MyClass, se discuten ms adelante en esta leccin.
La leccin de las interfaces y la herencia le explicarn cmo y por qu utilizara las palabras clave
extends e implements en una declaracin de clase. Por el momento no necesitas preocuparte
por estas complicaciones adicionales.
En general, las declaraciones de clase pueden incluir estos componentes:
1.
2.
Modificadores como public, private y otros que encontrar ms adelante.

El nombre de clase, con la letra inicial mayuscula por la Convencin.
3.
4.
5.
El nombre de las clases padres (superclase), si es el caso, va precedido por la palabra

clave extends. Una clase (subclase) puede solamente extender de un padre.
Una lista separada por comas de interfaces implementadas por la clase, si los hubiere,
precedido por la palabra clave implements. Una clase puede implementar ms de una
interfaz.
El cuerpo de la clase, rodeado de llaves, { }.
Declarar las Variables miembro

Existen varios tipos de variables:
Las variables miembro en una clase se denominan campos.

Las variables en un mtodo o bloque de cdigo, se denominan variables locales.
Las variables en las declaraciones de mtodos se denominan parmetros.
La clase Bicycle utiliza las siguientes lneas de cdigo para definir sus campos:
public int cadence;

public int gear;
public int speed;
Las declaraciones de campos se componen de tres componentes, en orden:
1.
2.
3.
Cero o ms modificadores, como public o private.

El tipo del campo.
El nombre del campo.
Los campos de Bicycle se denominan cadence, gear y speed y son todos datos de tipo
integer (int).
La palabra clave public identifica estos campos como miembros pblicos, accesibles por
cualquier objeto que pueda acceder a la clase.
Modificadores de acceso
El primer modificador (extremo izquierdo) utilizado le permite controlar qu otras clases tienen
acceso a un campo miembro.
Por el momento, considere slo public y private. Otros modificadores de acceso se discutirn
ms adelante.
modificador public el campo es accesible desde todas las clases.

modificador private el campo es accesible solamente dentro de su propia clase.
En el espritu de encapsulacin, es comn hacer los campos privados. Esto significa que slo se
puede acceder directamente desde la clase Bicycle. Sin embargo, s todava necesitamos
acceso a estos valores:
puede acceder indirectamente mediante la adicin de mtodos pblicos que

obtengan los valores de los campos para nosotros:

private int cadence;
private int gear;
private int speed;
gear = startGear;
speed = startSpeed;
}
public int getCadence() {
return cadence;
}
cadence = newValue;
}
public int getGear() {
return gear;
}
gear = newValue;
}
public int getSpeed() {
return speed;
}
speed -= decrement;
}
speed += increment;
}
}
Tipos
Todas las variables deben tener un tipo.
Puede utilizar los tipos primitivos como int, float, boolean, etc.
puede utilizar los tipos de referencia, tales como cadenas, arreglos u objetos.
Nombres de variables
Todas las variables, ya sean campos, variables locales o parmetros, siguen las mismas reglas de
nomenclatura y convenciones que se cubrieron en la leccin de lenguaje bsico, Variables
Nomenclatura.
En esta leccin, tenga en cuenta de que las mismas reglas de nomenclatura y convenciones se
utilizan en los nombres de mtodos y clases, excepto que
debe escribirse con mayscula la primera letra de un nombre de clase, y

la primera (o nica) palabra en un nombre de mtodo debe ser un verbo.
Definir Mtodos
Aqu est un ejemplo tpico de una declaracin de mtodo:
public double calculateAnswer(double wingSpan, int numberOfEngines,

double length, double grossTons) {
// hacer el clculo aqu
}
Los nicos elementos necesarios de una declaracin de mtodo son
el tipo de retorno del mtodo,

nombre,
un par de parntesis () y
un cuerpo entre llaves, {}.
Ms generalmente, las declaraciones de mtodos tienen seis componentes, en orden:

1.
2.
3.
4.
5.
6.
Modificadores como public, private y otros que aprenders ms adelante.

El tipo de retorno: el tipo de dato del valor devuelto por el mtodo, o void si el mtodo no
devuelve un valor.
El nombre del mtodo las reglas para nombres de campo se aplican a los nombres de
los mtodos tambin, pero la convencin es un poco diferente.
La lista de parmetros entre parntesis una lista delimitada por comas de parmetros
de entrada, precedidos por sus tipos de datos, encerrado entre parntesis, (). Si no hay
parmetros, debe utilizar parntesis vacos.
Una lista de excepciones, que se discutir ms adelante.
El cuerpo del mtodo, encerrado entre llaves el cdigo del mtodo, incluyendo la
declaracin de variables locales, van aqu.
Los modificadores, tipos de retorno y los parmetros sern discutidos ms adelante en esta leccin.
Las excepciones son discutidas en una leccin posterior.
Definicin: Dos de los componentes de una declaracin de mtodo comprenden la firma del
mtodo el nombre del mtodo y los tipos de parmetro.
La firma del mtodo declarado anteriormente es:
calculateAnswer(double, int, double, double)
Nombrando un mtodo
Aunque un nombre de mtodo puede ser cualquier identificador legal, las convenciones de cdigo
restringen los nombres de mtodos. Por Convencin, los nombres de mtodos deben ser un
verbo en minscula o un nombre de varias palabras que comiencen con un verbo en
minsculas, seguido de adjetivos, sustantivos, etc. En los nombres de varias palabras, la
primera letra de cada segunda y siguientes palabras debe escribirse con mayscula. Estos
son algunos ejemplos:
run
runFast
getBackground
getFinalData
compareTo
setX
isEmpty
Tpicamente, un mtodo tiene un nombre nico en su clase. Sin embargo, un mtodo podra
tener el mismo nombre que otros mtodos debido a la sobrecarga de mtodo.
Sobrecarga de mtodos
El lenguaje de programacin Java soporta Mtodos de Sobrecarga y Java puede distinguir entre
los mtodos con diferentes firmas de mtodos. Esto significa que los mtodos dentro de una
clase pueden tener el mismo nombre si tienen listas de parmetros diferentes (hay algunos
requisitos a esto que sern discutidos en la leccin titulada "Interfaces y herencia").
Supongamos que tiene una clase que puede utilizar la caligrafa para dibujar distintos tipos de datos
(cadenas, enteros y as sucesivamente) y que contiene un mtodo para la elaboracin de cada tipo
de datos. Es incmodo usar un nombre nuevo para cada mtodo por ejemplo, drawString,
drawInteger, drawFloaty as sucesivamente. En el lenguaje de programacin Java, usted
puede utilizar el mismo nombre para todos los mtodos de dibujo pero pase una lista de argumentos
diferentes para cada mtodo. Por lo tanto, la clase de dibujo de datos podra declarar cuatro
mtodos denominados draw, cada uno de ellos tiene una lista de parmetros diferentes.
public class DataArtist {

...
public void draw(String
...
}
public void draw(int i)
...
}
public void draw(double
...
}
public void draw(int i,
...
}
}
s) {
{
f) {
double f) {
Los mtodos sobrecargados se diferencian por la cantidad y el tipo de los argumentos que se
pasan al mtodo. En el cdigo de muestra, draw(String s) y draw(int i) son mtodos
distintos y nicos porque requieren diferentes tipos de argumentos.
No se puede declarar ms de un mtodo con el mismo nombre y el mismo nmero y tipo de
argumentos, ya que el compilador no puede distinguirlos.
El compilador no considera el tipo de retorno al diferenciar los mtodos, por lo que no puede
declarar dos mtodos con la misma firma, incluso si tienen un tipo de retorno diferente.
Nota: Los Mtodos sobrecargados deben ser usados con moderacin, ya que pueden hacer el
cdigo mucho menos legible.
Proporcionar constructores para tus clases
Una clase contiene constructores que se invocan para crear objetos desde la clase modelo o
plantilla. Las declaraciones de los constructores parecen declaraciones de mtodos excepto
que utilizan el nombre de la clase y no tienen tipo de retorno. Por ejemplo, Bicycle tiene un
constructor:

gear = startGear;
speed = startSpeed;
}
Para crear un nuevo objeto Bicycle llamado myBike, se llama a un constructor por el
operador new:
Bicycle myBike = new Bicycle(30, 0, 8);

new Bicycle(30, 0, 8) crea el espacio en la memoria para el objeto e inicializa sus
campos.
Aunque Bicycle solamente tiene un constructor, podra tener otros, incluyendo a un constructor
sin argumentos:
public Bicycle() {
gear = 1;
cadence = 10;
speed = 0;
}
Bicycle yourBike = new Bicycle(); invoca el constructor sin-argumentos para crear
un nuevo objeto Bicycle llamado yourBike.
Ambos constructores se pueden haber declarado en Bicycle porque tienen listas de argumentos
diferentes. Como con los mtodos, la plataforma Java distingue los constructores sobre la base
de la cantidad de argumentos en la lista y sus tipos. No puedes escribir dos constructores que
tienen el mismo nmero y tipo de argumentos para la misma clase, porque la plataforma no sera
capaz de distinguirlos. Si lo hace, provoca un error en tiempo de compilacin.
No tiene que proporcionar ningun constructor para la clase, pero debe tener cuidado al
hacerlo. El compilador proporciona automticamente un constructor por default sinargumentos, para cualquier clase sin constructores. Este constructor predeterminado llamar
al constructor sin-argumentos de la superclase. En esta situacin, el compilador se quejar si la
superclase no tiene un constructor sin-argumentos por lo que debe comprobar que lo tiene. Si tu
clase no tiene una superclase explcita, entonces tiene una superclase implcita del Object, que
tiene un constructor sin-argumentos
Usted puede utilizar un constructor de la superclase. La clase MountainBike al principio de
esta leccin as lo hizo. Esto se discutir ms adelante, en la leccin de las interfaces y la herencia.
Usted puede utilizar modificadores de acceso en la declaracin de un constructor para
controlar qu otras clases pueden llamar al constructor.
Nota: Si otra clase no puede llamar al constructor de MyClass, no puede crear directamente
objetos MyClass.
Pasar informacin a un mtodo o a un Constructor
La declaracin de un mtodo o un constructor declara el nmero y el tipo de los argumentos

para el mtodo o constructor. Por ejemplo, el siguiente es un mtodo que calcula los pagos
mensuales para un prstamo hipotecario, basado en la cantidad de prstamo, la tasa de inters, la
duracin del prstamo (el nmero de perodos) y el valor futuro del prstamo:
public double computePayment(

double loanAmt,
double rate,
double futureValue,
int numPeriods) {
double interest = rate / 100.0;
double partial1 = Math.pow((1 + interest),
- numPeriods);
double denominator = (1 - partial1) / interest;
double answer = (-loanAmt / denominator)
- ((futureValue * partial1) / denominator);
return answer;
}
Este mtodo tiene cuatro parmetros: el monto del prstamo, la tasa de inters, el valor futuro y el
nmero de perodos. Los tres primeros son nmeros de punto flotante de precisin doble, y la cuarta
es un entero. Los parmetros se utilizan en el cuerpo del mtodo y en tiempo de ejecucin
tomarn los valores de los argumentos que se pasaron dentro.
Nota: Los parmetros se refieren a la lista de variables en una declaracin de mtodo. Los
argumentos son los valores reales que se pasan cuando se invoca el mtodo. Cuando se
invoca un mtodo, los argumentos utilizados deben coincidir con los parmetros de la
declaracin de tipo y orden.
Tipos de parmetros
Puede utilizar cualquier tipo de dato para un parmetro de un mtodo o un constructor. Esto
incluye tipos de datos primitivos, como doubles, floats, e integers, como viste en el mtodo
computePayment y tipos de datos de referencia, tales como objetos y arreglos.
Aqu hay un ejemplo de un mtodo que acepta un arreglo como argumento. En este ejemplo, el
mtodo crea un objeto nuevo Polygon y lo Inicializa desde un arreglo de objetos Point
(asuma que Point es una clase que representa una coordenada x, y):
public Polygon polygonFrom(Point[] corners) {

// el cuerpo del mtodo va aqui
}
Nota: Si quieres pasar un mtodo dentro de un mtodo, utilice una expresin lambda o un
mtodo de Referencia.
Nmero arbitrario de argumentos

Puede utilizar un constructor denominado varargs para pasar un nmero arbitrario de valores
a un mtodo. Usas varargs cuando no sabes cuantos de un tipo determinado de argumento
se pasarn al mtodo. Es un atajo para crear una matriz manualmente (del mtodo anterior podra
haber utilizado varargs en lugar de una matriz).
Para usar varargs, sigues el tipo del ltimo parmetro con puntos suspensivos (tres puntos,...), y
luego un espacio, y el nombre del parmetro. Entonces puede llamarse al mtodo con cualquier
cantidad de ese parmetro, incluyendo ninguno.
public Polygon polygonFrom(Point... corners) {

int numberOfSides = corners.length;
double squareOfSide1, lengthOfSide1;
squareOfSide1 = (corners[1].x - corners[0].x)
* (corners[1].x - corners[0].x)
+ (corners[1].y - corners[0].y)
* (corners[1].y - corners[0].y);
lengthOfSide1 = Math.sqrt(squareOfSide1);
// ms codigo del cuerpo del mtodo que sigue creando y
// retornando un polygon que conecta los Points
}
Puedes ver que, dentro del mtodo, corners es tratado como una matriz. Puede llamar al mtodo
con una matriz o con una serie de argumentos. El cdigo en el cuerpo del mtodo tratar el
parmetro como un arreglo en cualquiera de los casos.
Comnmente se ver varargs con los mtodos de impresin; por ejemplo, este mtodo printf :
public PrintStream printf(String format, Object... args)

le permite imprimir un nmero arbitrario de objetos. Puede ser llamado as:
System.out.printf("%s: %d, %s%n", name, idnum, address);

o como esta
System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone,

email);
o con todava un nmero diferente de argumentos.
Nombres de parmetros
Cuando se declara un parmetro a un mtodo o un constructor, proporcionas un nombre
para ese parmetro. Este nombre se utiliza en el cuerpo del mtodo para referirse al
argumento que se pasa dentro.
El nombre de un parmetro debe ser nico en su mbito de aplicacin. No puede ser el mismo
que el nombre de otro parmetro para el mismo mtodo o constructor, y no puede ser el nombre de
una variable local dentro del mtodo o constructor.
Un parmetro puede tener el mismo nombre que uno de los campos de la clase. Si este es el
caso, se dice del parmetro que sombrea al campo. Sombrear los campos puede dificultar leer su
cdigo y convencionalmente se utiliza solo dentro de los constructores y mtodos que fijan un
campo particular. Por ejemplo, considere la siguiente clase Circle y su mtodo setOrigin :
public class Circle {

private int x, y, radius;
public void setOrigin(int x, int y) {
...
}
}
La clase Circle tiene tres campos: x, y y radius. El mtodo setOrigin tiene dos parmetros,
cada uno de ellos tiene el mismo nombre como uno de los campos. Cada parmetro del mtodo
sombrea el campo que comparte su nombre. As que usar los nombres simples x o y dentro
del cuerpo del mtodo hace referencia al parmetro, no al campo. Para acceder al campo, debe
utilizar un nombre cualificado. Esto ser discutido ms adelante en esta leccin en la seccin
titulada "Usando la palabra clave this.
Pasando argumentos de tipo de datos primitivo

Los argumentos primitivos, como un int o double, se pasan a los mtodos por valor. Esto
significa que cualquier cambio en los valores de los parmetros existe slo en el mbito del
mtodo. Cuando el mtodo devuelve, los parmetros se han ido y cualquier cambio en ellos se
pierde. Aqu est un ejemplo:
public class PassPrimitiveByValue {

int x = 3;
// invoca el passMethod() con
// x como argumento
passMethod(x);
// imprime x para ver si este
// valor ha cambiado
System.out.println("Despues de invocar el passMethod, x = " +
x);
}
// cambia el parametro en passMethod()
public static void passMethod(int p) {
p = 10;
}
}
Cuando se ejecuta este programa, la salida es:
Despues de invocar el passMethod, x = 3
Pasando argumentos de tipo de datos de referencia

Los parmetros de tipo de datos de referencia, tales como objetos, tambin se pasan a los mtodos
por valor. Esto significa que cuando el mtodo devuelve, la referencia pasada dentro todava
hace referencia al mismo objeto que antes. Sin embargo, los valores de los campos del
objeto se pueden cambiar en el mtodo, si tienen el nivel de acceso adecuado.
Por ejemplo, considere un mtodo en una clase arbitraria que mueve objetos Circle:
public void moveCircle(Circle circle, int deltaX, int deltaY) {

// cdigo para mover el origen del crculo para x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);
// cdigo para asignar una nueva referencia al crculo
circle = new Circle(0, 0);
}
Deja que el mtodo se invoque con estos argumentos:
moveCircle(myCircle, 23, 56)
Dentro del mtodo, circle inicialmente se refiere a myCircle. El mtodo cambia las
coordenadas x y y del objeto de esas referencias circle (es decir, myCircle) por 23 y 56,
respectivamente. Estos cambios se mantendrn cuando el mtodo devuelve. Entonces circle es
asignado a una referencia a un objeto nuevo Circle con x = y = 0. Esta reasignacin no tiene
ninguna permanencia, sin embargo, debido a que la referencia fue pasada por su valor y no se
puede cambiar. Dentro del mtodo, el objeto apuntado por circle ha cambiado, pero, cuando el
mtodo devuelve, myCircle todava hace referencia al mismo objeto Circle como antes de que
se llamar al mtodo.
Objetos
Un tpico programa Java crea muchos objetos, que como ya sabes, interactan mediante la
invocacin de mtodos. A travs de estas interacciones del objeto, un programa puede realizar
diversas tareas, como implementar un GUI, ejecutar una animacin, o enviar y recibir informacin
sobre una red. Una vez que un objeto ha completado el trabajo para el cual fue creado, sus
recursos son reciclados para su uso por otros objetos.
Aqu est un pequeo programa, llamado CreateObjectDemo, que crea tres objetos: un objeto
Point y dos objetos Rectangle. Usted necesitar los tres archivos fuente completos para
compilar este programa.
public class CreateObjectDemo {

// Declarar y crear un objeto punto y dos objetos rectngulo.
Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);
// muestra la anchura, altura y rea de rectOne
System.out.println("Width of rectOne: " + rectOne.width);
System.out.println("Height of rectOne: " + rectOne.height);
System.out.println("Area of rectOne: " + rectOne.getArea());
// fija la posicin de rectTwo
rectTwo.origin = originOne;
// muestra la posicin de rectTwo
System.out.println("X Position of rectTwo: " +
rectTwo.origin.x);
System.out.println("Y Position of rectTwo: " +
rectTwo.origin.y);
// mueve a rectTwo y muestra su nueva posicin
rectTwo.move(40, 72);
System.out.println("X Position of rectTwo: " +
rectTwo.origin.x);
System.out.println("Y Position of rectTwo: " +
rectTwo.origin.y);
}
}
Este programa crea, manipula y muestra informacin acerca de diversos objetos. Aqu est la salida:
Width of rectOne: 100
Height of rectOne: 200

Area of rectOne: 20000
X Position of rectTwo:
Y Position of rectTwo:
X Position of rectTwo:
Y Position of rectTwo:
23
94
40
72
Las siguientes tres secciones utilizan el ejemplo anterior para describir el ciclo de vida de un objeto
dentro de un programa. De ellos, aprender cmo escribir cdigo que crea y utiliza los objetos en
sus propios programas. Tambin aprenders cmo el sistema limpia despus un objeto cuando su
vida ha terminado.
Creacin de objetos
Como ya sabes, una clase proporciona el plan de accin para los objetos; crea un objeto de
una clase. Cada una de las siguientes instrucciones extradas del programa CreateObjectDemo
crea un objeto y lo asigna a una variable:

La primera lnea crea un objeto de la clase Point, y la segunda y tercera lnea crean cada una un
objeto de la clase Rectangle.
Cada una de estas instrucciones consta de tres partes (explicadas en detalle ms abajo):
1.
2.
3.
Instruccin: el cdigo en negrita son todas las declaraciones de variables que asocian un
nombre de variable a un tipo de objeto.
Instanciacin o creacin de instancias: la palabra clave new es un operador de Java que
crea el objeto.
Inicializacin: el nuevo operador es seguido por una llamada a un constructor, que
inicializa el objeto nuevo.
Declarar una Variable para hacer referencia a un objeto

Previamente, aprendi que para declarar una variable, escribe el tipo y el nombre:
type name;
Esto notifica al compilador que usar nombre para referirse a datos cuyo tipo es de un tipo de valor.
Con una variable primitiva, esta instruccin tambin reserva la cantidad adecuada de memoria
para la variable.
Tambin puede declarar una variable de referencia en su propia lnea. Por ejemplo:
Point originOne;
Si se declara originOne as, su valor ser indeterminado hasta que un objeto es creado y
asignado a l. Simplemente declarar una variable de referencia no crea un objeto. Por eso,
tienes que utilizar el operador new, tal como se describe en la seccin siguiente. Debe asignar
un objeto a originOne antes de usarlo en su cdigo. De lo contrario, obtendr un error del
compilador.
Una variable en este estado, que actualmente hace referencia a ningn objeto, se puede ilustrar
como sigue (nombre de la variable, originOne, adems de una referencia apuntando a la nada):
Crear instancias de una clase

El operador new crea una instancia de una clase por la asignacin de memoria para un nuevo
objeto y devuelve una referencia de esa memoria. El operador new tambin invoca el
constructor del objeto.
Nota: La frase "crear instancias de una clase" significa lo mismo que "creando un objeto". Cuando
crea un objeto, crear una "instancia" de una clase, por lo tanto es el "ejemplar" de una clase.
El operador new requiere un solo argumento postfijo: una llamada a un constructor. El nombre
del constructor proporciona el nombre de la clase a instanciar.
El operador new devuelve una referencia al objeto creado. Esta referencia es asignada a una
variable del tipo adecuado, como:

La referencia devuelta por el operador new no tiene que ser asignado a una variable. Tambin
puede utilizarse directamente en una expresin. Por ejemplo:
int height = new Rectangle().height;

Esta declaracin se discutir en la prxima seccin.
Inicializar un objeto
Aqu est el cdigo para la clase Point:
public class Point {

public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}
Esta clase contiene un nico constructor. Puedes reconocer un constructor porque su
instruccin utiliza el mismo nombre que la clase y no tiene ningn tipo de retorno. El
constructor de la clase Point toma dos argumentos enteros, declarado por el cdigo (int a,
int b). La siguiente instruccin proporciona 23 y 94 como valores para esos argumentos:

El resultado de la ejecucin de esta instruccin puede ser ilustrado en la figura siguiente:
Aqu est el cdigo de la clase Rectangle, que contiene cuatro constructores:
public class Rectangle {

public int width = 0;
public int height = 0;
public Point origin;
// cuatro constructores
public Rectangle() {
origin = new Point(0, 0);
}
public Rectangle(Point p) {
origin = p;
}
public Rectangle(int w, int h) {
width = w;
height = h;
}
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// un mtodo para mover el rectangulo
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// un mtodo para computar el rea de un rectangulo
public int getArea() {
return width * height;
}
}
Cada constructor permite ofrecer valores iniciales para el origen del rectngulo, anchura y altura,
usando ambos tipos primitivos y de referencia. Si una clase tiene varios constructores, deben
tener diferentes firmas. El compilador de Java distingue los constructores basados en el
nmero y el tipo de los argumentos. Cuando el compilador de Java se encuentra con el siguiente
cdigo, sabe llamar al constructor de la clase Rectangle que es el que requiere un argumento
point seguido de dos argumentos enteros:

Esto llama al constructor de Rectangle que inicializa origin a originOne. Adems, el
constructor establece el ancho (width), la altura (height) de 200 y 100. Ahora hay dos
referencias al mismo objeto Point un objeto puede tener mltiples referencias a ella, como
se muestra en la siguiente figura:
La siguiente lnea de cdigo llama al constructor de Rectangle que requiere dos argumentos
enteros, que proporcionan los valores iniciales para la anchura y altura. Si revisas el cdigo en
el constructor, ver que crea un nuevo objeto point cuyo x y valores y se inicializan con 0:

El constructor de rectngulo utilizado en la instruccin siguiente no toma ningn argumento,
as que se llama un constructor sin argumentos:
Rectangle rect = new Rectangle();

Todas las clases tienen al menos un constructor. Si una clase no declara explcitamente
alguno, el compilador de Java proporciona automticamente un constructor sin-argumentos,
llamado constructor por default. Este constructor por default llama al constructor sinargumentos de la clase padre, o el constructor de Object si la clase no tiene ningn otro
padre. Si los padres no tienen ningn constructor (Object tiene uno), el compilador rechazar el
programa.
Uso de objetos
Una vez que haya creado un objeto, probablemente quieras usarlo para algo. Puede necesitar
usar el valor de uno de sus campos, cambiar uno de sus campos o llamar a uno de sus
mtodos para realizar una accin.
Referenciando a los campos de un objeto

A los campos del objeto se accede por su nombre. Debe utilizar un nombre que no sea ambiguo.
Usted puede utilizar un nombre simple para un campo dentro de su propia clase. Por ejemplo,
podemos agregar una instruccin dentro de la clase Rectangle que imprime la width (ancho) y la
height (altura):
System.out.println("Width and height are: " + width + ", " + height);

En este caso, width y height son nombres simples.
El cdigo que est fuera de la clase del objeto debe utilizar una referencia de objeto o expresin,
seguido por el operador punto (.), seguido por un nombre de campo simple, como en:
objectReference.fieldName
Por ejemplo, el cdigo de la clase CreateObjectDemo est fuera del cdigo de la clase
Rectangle. As que para hacer referencia a los campos de origin, width, y height
dentro del objeto Rectangle llamado rectOne, la clase CreateObjectDemo debe usar los
nombres rectOne.origin, rectOne.widthy rectOne.height, respectivamente. El
programa utiliza dos de estos nombres para mostrar la width y la height de rectOne:
System.out.println("Width of rectOne: " + rectOne.width);

System.out.println("Height of rectOne: " + rectOne.height);
Intentar utilizar los nombres simples width y height del cdigo en la clase
CreateObjectDemo no tiene sentido esos campos existen solamente dentro de un objeto
y resulta en un error del compilador.
Ms tarde, el programa utiliza cdigo similar para mostrar informacin sobre rectTwo. Los objetos
del mismo tipo tienen su propia copia de los mismos campos de instancia. De este modo,
cada objeto rectangle tiene campos llamados origin, width y height. Cuando usted
accede a un campo de instancia a travs de una referencia al objeto, se refiere al campo del
objeto particular. Los dos objetos rectOne y rectTwo en el programa de CreateObjectDemo
tienen diferentes campos de origin, width y height.
Para acceder a un campo, puede utilizar una referencia con nombre a un objeto, como en los
ejemplos anteriores, o se puede utilizar cualquier expresin que devuelve una referencia al
objeto. Recordemos que el operador new devuelve una referencia a un objeto. As que se
puede utilizar el valor devuelto por new para acceder a los campos de un objeto nuevo:
int height = new Rectangle().height;

Esta instruccin crea un nuevo objeto rectngulo e inmediatamente obtiene su altura. En
esencia, la instruccin determina la altura por defecto de un rectngulo. Tenga en cuenta que
despus de que esta instruccin ha sido ejecutada, el programa ya no tiene una referencia al
rectngulo creado, debido a que el programa no almacena la referencia en ninguna parte.
El objeto no tiene referencia y sus recursos son libres para ser reciclados por la Mquina Virtual de
Java.
Llamar los mtodos de un objeto

Tambin puede utilizar una referencia de objeto para invocar el mtodo de un objeto. Anexe el
nombre simple del mtodo a la referencia del objeto, con un operador punto intermedio (.). Adems,
proporcione, dentro de parntesis, cualquier argumento al mtodo. Si el mtodo no requiere ningn
argumento, utilice parntesis vacos.
objectReference.methodName(argumentList);
o:
objectReference.methodName();
La clase rectngulo tiene dos mtodos: getArea() para calcular el rea del rectngulo y
move() para cambiar el origen del rectngulo. Aqu est el cdigo CreateObjectDemo que
invoca estos dos mtodos:
System.out.println("Area of rectOne: " + rectOne.getArea());

...
rectTwo.move(40, 72);
La primera declaracin invoca el mtodo getArea() de rectOne y muestra los resultados. La
segunda lnea mueve rectTwo porque el mtodo move() asigna nuevos valores del objeto
origin.x y origin.y.
Como con campos de instancia, objectReference debe ser una referencia a un objeto. Puede
utilizar un nombre de variable, pero tambin se puede utilizar cualquier expresin que
devuelve una referencia al objeto. El operador new devuelve una referencia al objeto, as que
puede usar el valor devuelto de new para invocar mtodos de un objeto nuevo:
new Rectangle(100, 50).getArea()

La expresin new Rectangle(100, 50) devuelve una referencia al objeto que se refiere al
objeto Rectangle. Como se muestra, puede utilizar la notacin de punto para invocar el mtodo
getArea() de new Rectangle para calcular el rea del nuevo rectngulo.
Algunos mtodos, como getArea(), devuelven un valor. Para los mtodos que devuelven un
valor, puede utilizar la invocacin del mtodo en las expresiones. Usted puede asignar el
valor devuelto por el mtodo a una variable, usarlo para tomar decisiones o para controlar un
bucle. Este cdigo asigna el valor devuelto por el mtodo getArea() a la variable
areaOfRectangle:
int areaOfRectangle = new Rectangle(100, 50).getArea();

Recuerda, invocar un mtodo en un objeto particular es lo mismo que enviar un mensaje a
ese objeto. En este caso, el objeto que getArea() invoca en el rectngulo es devuelto por el
constructor.
El recolector de basura
Algunos lenguajes orientados a objetos requieren que usted haga un seguimiento de todos los
objetos que crea y que explcitamente los destruya cuando ya no son necesarios. La Gestin de
memoria manual o explcita es tedioso y propenso a errores. La plataforma Java te permite crear
tantos objetos como t quieras (limitado, por supuesto, por lo que pueda manejar tu sistema) y no
debes preocuparte por destruirlos. El entorno de ejecucin de Java (JRE) elimina objetos
cuando determina que ya no se estn utilizando. Este proceso se denomina recoleccin de
basura.
Un objeto es elegible para la recoleccin de basura cuando no existen ms referencias a ese
objeto. Las referencias que se llevan a cabo en una variable generalmente se cayeron cuando la
variable sale del mbito. O, usted puede tirar explcitamente una referencia a un objeto
estableciendo la variable en el valor especial null. Recuerde que un programa puede tener
mltiples referencias al mismo objeto; todas las referencias a un objeto deben dejarse caer antes
de que el objeto sea elegible para la recoleccin de basura.
El entorno de ejecucin Java tiene un recolector de basura que peridicamente libera la
memoria utilizada por los objetos a los que ya no se hace referencia. El recolector de basura
hace su trabajo automticamente cuando determina que es el momento adecuado.
Ms sobre clases
Esta seccin cubre ms aspectos de las clases que dependen del uso de referencias a objetos y el
operador dot que has aprendido en las secciones anteriores sobre los objetos:
Devolver valores desde mtodos.

La palabra clave this.
Clase vs. miembros de instancia.
Control de acceso.
Devuelve un valor desde un mtodo

Un mtodo devuelve al cdigo que lo invoca cuando se
completan todas las instrucciones en el mtodo,

alcanza una instruccin return , o
lanza o emite una excepcin (cubierta ms adelante),
lo que ocurra primero.

Puedes declarar un tipo de retorno de un mtodo en su declaracin de mtodo. Dentro del
cuerpo del mtodo, utilice la instruccin return para devolver el valor.
Cualquier mtodo declarado void no devuelve un valor. No necesita contener una
instruccin return, pero puede hacerlo. En tal caso, una instruccin return puede utilizarse
para ramificar de un bloque de control de flujo y salir del mtodo, y simplemente se utiliza como
este:
return;
Si usted intenta devolver un valor de un mtodo que es declarado void, obtendr un error del
compilador.
Cualquier mtodo que no sea declarado void debe contener una instruccin return con un valor
de retorno correspondiente, as:
return returnValue;
El tipo de dato del valor devuelto debe coincidir con el tipo de retorno declarado del mtodo;
No se puede devolver un valor entero de un mtodo declarado para devolver un valor booleano.
El mtodo getArea() de la clase Rectangle que se discuti en las secciones sobre objetos
devuelve un entero:
// un mtodo para calcular el rea del rectngulo

}
Este mtodo devuelve el nmero entero que la expresin width*height evala.
El mtodo getArea devuelve un tipo primitivo. Un mtodo tambin puede devolver un tipo de
referencia. Por ejemplo, en un programa para manipular objetos de Bicycle, tenemos un mtodo
como este:
public Bicycle seeWhosFastest(Bicycle myBike, Bicycle yourBike,

Environment env) {
Bicycle fastest;
// cdigo para calcular qu moto es
// ms rpida, dado el engranaje de cada bicicleta
// y la cadencia y dado el
// medio ambiente (terreno y viento)
return fastest;
}
Devolviendo una clase o una interfaz

Si esta seccin te confunde, saltala y regresa despus de haber terminado la leccin de interfaces y
herencia.
Cuando un mtodo utiliza un nombre de clase como su tipo de retorno, tales como
whosFastest , la clase del tipo de objeto devuelto debe ser una subclase de, o la clase
exacta de, el tipo de valor devuelto. Supongamos que usted tiene una jerarqua de clases en la
que ImaginaryNumber es una subclase de java.lang.Number, que a su vez es una subclase
del Object, como se ilustra en la figura siguiente.
La jerarqua de clases para ImaginaryNumber

Ahora, supongamos que tiene un mtodo declarado para devolver un Number:
public Number returnANumber() {

...
}
El mtodo returnANumber puede devolver un ImaginaryNumber pero no un Object.
ImaginaryNumber es un Number porque es una subclase del Number. Sin embargo, un
Object no es necesariamente un Number podra ser una String u otro tipo.
Se puede reemplazar un mtodo y definirlo para devolver una subclase del mtodo original,
as:
public ImaginaryNumber returnANumber() {

...
}
Esta tcnica, llamada tipo covariante de retorno, significa que el tipo de valor devuelto puede
variar en la misma direccin que la subclase.
Nota: Tambin puede utilizar nombres de interfaces como tipos de retorno. En este caso, el
objeto devuelto debe implementar la interfaz especificada.
Usando la palabra clave this

Dentro de un mtodo de instancia o un constructor, this es una referencia al objeto actual el
objeto cuyo mtodo o constructor se esta llamando. Puede referirse a cualquier miembro del
objeto actual desde dentro de un mtodo de instancia o un constructor utilizando this.
Usando this con un campo

La razn ms comn para el uso de la palabra clave this es porque un campo es sombreado
por un parmetro de mtodo o constructor.
Por ejemplo, la clase Point fue escrita as

public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}
Pero podra haber sido escrito as:

public int x = 0;
public int y = 0;
//constructor
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
Cada argumento del constructor sombrea uno de los campos del objeto dentro del constructor x
es una copia local del primer argumento del constructor. Para hacer referencia al campo Point x,
el constructor debe utilizar this.x.
Usando this con un Constructor

Desde dentro de un constructor, tambin puede utilizar la palabra clave this para llamar a
otro constructor en la misma clase. As, se le llama una invocacin explcita del constructor.
Aqu tiene otra clase de Rectangle, con una implementacin diferente de la de la seccin de
objetos .
public class Rectangle {

private int x, y;
private int width, height;
public Rectangle() {
this(0, 0, 1, 1);
}
public Rectangle(int width, int height) {
this(0, 0, width, height);
}
public Rectangle(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
...
}
Esta clase contiene un conjunto de constructores. Cada constructor inicializa todas o algunas de
las variables miembro del rectngulo. Los constructores proporcionan un valor por defecto
para cualquier variable miembro cuyo valor inicial no es proporcionado por un argumento.
Por ejemplo, el constructor sin-argumentos crea un Rectangle de 1 x 1 en las coordenadas 0,0. El
constructor de dos-argumentos llama al constructor de cuatro-argumentos, pasando el ancho y alto
pero siempre utilizando las coordenadas 0,0. Como antes, el compilador determina qu constructor
llamar, basado en el nmero y el tipo de argumentos.
Si se presenta, la invocacin de un constructor debe ser la primera lnea en el constructor.
Controlar el acceso a los miembros de una clase

Los modificadores de nivel de acceso determinan si otras clases pueden utilizar un campo
particular o invocar un mtodo en particular. Existen dos niveles de control de acceso:
En el nivel superior public o package-private (sin modificador explcito).

En el nivel de miembro public, private, protected o package-private (sin
modificador explcito).
Puede declarar una clase con el modificador public, en el caso de que la clase sea visible
para todas las clases de cualquier parte. Si una clase no tiene ningn modificador (es por
defecto, y se conoce como paquete privado), que es visible solamente dentro de su propio
paquete (los paquetes son nombres de grupos de clases relacionadas usted aprender acerca
de ellos en una leccin posterior.)
En el nivel de miembro, tambin puede utilizar el modificador public o sin modificadores
(paquete privado) as como con clases de nivel superior y con el mismo significado. Para los
miembros, hay dos modificadores de acceso adicional: private y protected. El modificador
private especifica que slo se puede acceder al miembro de su propia clase. El modificador
protected especfica que el miembro slo puede accederse desde dentro de su propio
paquete (como con paquete privado) y, adems, por una subclase de la clase en otro paquete.
La siguiente tabla muestra el acceso a los miembros permitidos por cada modificador.
Niveles de acceso
Modificador
Clase Paquete Subclase Mundo
public
protected
sin modificador Y
private
La primera columna de datos indica si la clase tiene acceso a los miembros definidos por el nivel de
acceso. Como puedes ver, una clase siempre tiene acceso a sus propios miembros. La segunda
columna indica si las clases en el mismo paquete que la clase (independientemente de su

paternidad) tienen acceso al miembro. La tercera columna indica si las subclases de la clase
declarada fuera de este paquete tienen acceso al miembro. La cuarta columna indica si todas las
clases tienen acceso a los miembros.
Los niveles de acceso afectan de dos maneras. En primer lugar, cuando utilizas las clases que
vienen de otra fuente, como las clases en la plataforma Java, los niveles de acceso determinan
que miembros de las clases pueden usar sus propias clases. En segundo lugar, cuando
escribes una clase, tienes que decidir qu nivel de acceso deben tener todas las variables
miembro y cada mtodo en su clase.
Vamos a ver una coleccin de clases y ver cmo afectan los niveles de acceso a la visibilidad. La
siguiente figura muestra las cuatro clases en este ejemplo y cmo se relacionan.
Clases y paquetes del ejemplo para ilustrar los niveles de acceso

La siguiente tabla muestra donde los miembros de la clase Alfa son accesibles para cada uno
de los modificadores de acceso que se pueden aplicar a ellos.
Visibilidad
Modificador
Alfa Beta Alphasub Gamma
public
protected
sin modificadores Y
private
Tips para escoger un nivel de acceso:

Si otros programadores utilizan su clase, usted quiere asegurarse de que no pueden ocurrir errores
por el uso indebido. Los niveles de acceso pueden ayudarle a hacerlo.
Use el nivel de acceso ms restrictivo que tenga sentido para un determinado miembro.
Use private a menos que tenga una buena razn para no hacerlo.
Evite los campos public excepto para las constantes. (Muchos de los ejemplos en el
tutorial usan los campos pblicos. Esto puede ayudar a ilustrar algunos puntos de forma
concisa, pero no se recomienda para el cdigo de produccin.) Los campos pblicos
tienden a vincularte a una implementacin en particular y limitar la flexibilidad de modificar
su cdigo.
Entendiendo a los miembros de la clase

En esta seccin, discutimos el uso de la palabra clave static para crear campos y mtodos
que pertenecen a la clase, en lugar de a una instancia de la clase.
Variables de clase
Cuando se crea una serie de objetos desde la misma clase plantilla, cada uno tiene sus
propias copias diferentes de las variables de instancia. En el caso de la clase de Bicycle, las
variables de instancia son cadence, gear y speed. Cada objeto Bicycle tiene sus propios
valores de estas variables, almacenadas en localizaciones de memoria diferentes.
A veces, quieres tener variables que son comunes a todos los objetos. Esto se logra con el
modificador static. Los Campos que tienen el modificador static en su declaracin se
denominan campos estticos o variables de clase. Estn asociados con la clase, en lugar de
cualquier objeto. Cada instancia de la clase comparte una variable de clase, que se encuentra
en una posicin fija en la memoria. Cualquier objeto puede cambiar el valor de una variable
de clase, pero tambin se pueden manipular variables de clase sin crear una instancia de la
clase.
Por ejemplo, supongamos que desea crear un nmero de objetos de Bicycle y asignar a cada uno
un nmero de serie, empezando por 1 para el primer objeto. Este nmero de identificacin es nico
para cada objeto y por lo tanto es una variable de instancia. Al mismo tiempo, necesitas un campo
para hacer un seguimiento de cuntos objetos de Bicycle han sido creados para que sepas qu
ID se le asignar al siguiente. Un campo no est relacionado a ningn objeto individual, sino a
la clase como un todo. Para ello es necesario una variable de clase, numberOfBicycles, como
sigue:

private int gear;
private int speed;
// aadir una variable de instancia para el ID del objeto
private int id;
// aadir una variable de clase para el
// nmero de objetos de Bicycle instanciados
private static int numberOfBicycles = 0;
...
}
Las variables de clase estn referenciadas por el nombre de la clase misma, como en
Bicycle.numberOfBicycles
Esto pone de manifiesto que son variables de clase.
Nota: Tambin puede hacer referencia a campos estticos con una referencia a un objeto como
myBike.numberOfBicycles
Pero esto es desalentado porque no deja en claro que son variables de clase.
Puede utilizar el constructor de Bicycle para establecer la variable de instancia de id e

incrementar la variable de clase numberOfBicycles :

private
private
private
private
int
int
int
int
cadence;
gear;
speed;
id;

public Bicycle(int startCadence, int startSpeed, int startGear){
gear = startGear;
speed = startSpeed;
// nmero de incrementos de Bicicletas
// y asignar el nmero de identificacin
id = ++numberOfBicycles;
}
// nuevo mtodo para devolver la variable de instancia ID
public int getID() {
return id;
}
...
}
Mtodos de la clase
El lenguaje de programacin Java soporta mtodos estticos, as como con las variables estticas.
Los mtodos estticos, que tienen el modificador static en sus declaraciones, deben ser
invocados con el nombre de clase, sin la necesidad de crear una instancia de la clase, como
en
ClassName.methodName(args)
Nota: Tambin puede hacer referencia a mtodos estticos con referencia a un objeto como
instanceName.methodName(args)
Pero esto es desalentado porque no deja en claro que son mtodos de la clase.
Un uso comn de mtodos estticos es para acceder a los campos estticos. Por ejemplo,
nosotros podramos aadir un mtodo esttico a la clase de Bicycle para acceder al campo
esttico de numberOfBicycles :
public static int getNumberOfBicycles() {

return numberOfBicycles;
}
No todas las combinaciones de mtodos y variables de instancia y clase estn permitidas:
Mtodos de instancia pueden acceder a las variables de instancia y mtodos de instancia

directamente.
Mtodos de instancia pueden acceder a variables de clase y mtodos de la clase
directamente.
Mtodos de la clase pueden acceder a variables de clase y mtodos de la clase
directamente.
Los mtodos de clase no pueden acceder a las variables de instancia o mtodos de
instancia directamente, -deben utilizar una referencia al objeto. Adems, los mtodos de
clase no pueden utilizar la palabra clave this ya que no hay ninguna instancia para this
y referirse a.
Constantes
El modificador static, en combinacin con el modificador final, tambin se utiliza para definir
constantes. El modificador final indica que no puede cambiar el valor de este campo.
Por ejemplo, la siguiente declaracin de variable define una constante llamada PI, cuyo valor es
una aproximacin de pi (la proporcin de la circunferencia de un crculo y su dimetro):
static final double PI = 3.141592653589793;

Las constantes definidas en esta forma no pueden ser reasignadas, y es un error en tiempo de
compilacin si su programa intenta hacerlo. Por Convencin, los nombres de valores constantes
se escriben en maysculas. Si el nombre est compuesto por ms de una palabra, las
palabras estn separadas por un guin bajo (_).
Nota: Si un tipo primitivo o una cadena se define como una constante y el valor es conocido en
tiempo de compilacin, el compilador sustituye el nombre de la constante en todas partes en el
cdigo con su valor. Esto se llama una constante de tiempo de compilacin. Si cambia el valor de la
constante en el mundo exterior (por ejemplo, si se est legislado que pi en realidad debera ser
3.975), tendr que volver a compilar las clases que utilizan esta constante para obtener el valor
actual.
La clase de Bicycle
Despus de todas las modificaciones realizadas en esta seccin, la clase Bicycle es ahora:

private int gear;
private int speed;
private int id;
public Bicycle(int startCadence,
int startSpeed,
int startGear){
gear = startGear;
speed = startSpeed;
id = ++numberOfBicycles;
}
public int getID() {
return id;
}
public static int getNumberOfBicycles() {
return numberOfBicycles;
}
public int getCadence(){
return cadence;
}
public void setCadence(int newValue){
cadence = newValue;
}
public int getGear(){

return gear;
}
public void setGear(int newValue){
gear = newValue;
}
public int getSpeed(){
return speed;
}
public void applyBrake(int decrement){
speed -= decrement;
}
public void speedUp(int increment){
speed += increment;
}
}
Inicializar campos
Como has visto, a menudo se puede proporcionar un valor inicial para un campo en su declaracin:
public class BedAndBreakfast {

// inicializar a 10
public static int capacity = 10;
// inicializar a false
private boolean full = false;
}
Esto funciona bien cuando el valor de inicializacin esta disponible y la inicializacin se puede poner
en una sola lnea. Sin embargo, esta forma de inicializacin tiene limitaciones debido a su
simplicidad. Si la inicializacin requiere un poco de lgica (por ejemplo, manejo de errores o un
bucle for para llenar una matriz compleja), la asignacin simple es insuficiente. Se puede inicializar
las variables de instancia en constructores, donde el manejo de errores o de otra lgica puede ser
utilizado. Para proporcionar la misma capacidad para variables de clase, el lenguaje de
programacin Java incluye bloques de inicializacin esttica.
Nota: No es necesario declarar campos al principio de la definicin de clase, aunque esta es

la prctica ms comn. Slo es necesario que sean declarados e inicializados antes de que
se utilicen.
Bloques de inicializacin esttica

Un bloque de inicializacin esttica es un bloque normal de cdigo encerrado entre llaves, { } y
precedido por la palabra clave static. Aqu est un ejemplo:
static {
// cualquier cdigo que se necesita para la inicializacin va aqu
}
Una clase puede tener cualquier nmero de bloques de inicializacin esttica, y pueden aparecer en
cualquier parte del cuerpo de la clase. El sistema runtime garantiza que la inicializacin esttica de
los bloques sean llamados en el orden en que aparecen en el cdigo fuente.
Hay una alternativa a los bloques estticos, se puede escribir un mtodo esttico privado:
class Whatever {
public static varType myVar = initializeClassVariable();
private static varType initializeClassVariable() {
// la inicializacin del cdigo va aqui
}
}
La ventaja de los mtodos estticos privados es que pueden ser reutilizados ms tarde si
tienes que reiniciar la variable de clase.
Inicializar miembros de instancia

Normalmente, pones cdigo para inicializar una variable de instancia en un constructor. Existen dos
alternativas al uso de un constructor para inicializar las variables de instancia: bloques
inicializadores y mtodos finales.
Los bloques inicializadores para variables de instancia se parecen a los bloques inicializadores
estticos, pero sin la palabra clave static:
{
// cualquier cdigo que se necesita para la inicializacin va aqu
}
El compilador de Java copia bloques de inicializacin en cada constructor. Por lo tanto, este
enfoque puede utilizarse para compartir un bloque de cdigo entre varios constructores.
Un mtodo final no puede invalidarse en una subclase. Esto se discute en la leccin sobre
interfaces y herencia. Aqu est un ejemplo del uso de un mtodo final para inicializar una variable
de instancia:
class Whatever {
private varType myVar = initializeInstanceVariable();
protected final varType initializeInstanceVariable() {
// la inicializacin del cdigo va aqui
}
}
Esto es especialmente til si las subclases querran volver a utilizar el mtodo de

inicializacin. El mtodo es final porque llamar a mtodos no-final durante la inicializacin de
la instancia puede causar problemas.
Resumen de crear y utilizar clases y objetos

Una declaracin de clase da nombre a la clase y encierra el cuerpo de la clase entre llaves. El
nombre de la clase puede estar precedido por modificadores. El cuerpo de clase contiene campos,
mtodos y constructores de la clase. Una clase utiliza campos que contienen informacin sobre el
estado y los mtodos para implementar el comportamiento. Los constructores que inicializan una
nueva instancia de una clase utilizan el nombre de la clase y lucen como mtodos sin un tipo de
retorno.
Controlas el acceso a clases y miembros de la misma manera: mediante el uso de un modificador de
acceso como el public en su declaracin.
Especifica una variable de clase o un mtodo de clase mediante el uso de la palabra clave static
en la declaracin del miembro. Un miembro que no est declarado como static implcitamente es
un miembro de instancia. Las variables de clase son compartidas por todas las instancias de una
clase y pueden accederse mediante el nombre de clase, as como una referencia a la instancia. Las
instancias de una clase obtienen su propia copia de cada variable de instancia, a las cuales debe
accederse a travs de una referencia a la instancia.
Se crea un objeto de una clase utilizando el operador new y un constructor. El nuevo operador
devuelve una referencia al objeto que fue creado. Puede asignar la referencia a una variable o
usarlo directamente.
Las variables y mtodos de instancia que son accesibles al cdigo fuera de la clase que se declaran
pueden ser referidos mediante el uso de un nombre cualificado. El nombre de una variable de
instancia se ve as:
objectReference.variableName
El nombre completo de un mtodo se ve as:
objectReference.methodName(argumentList)
o:
objectReference.methodName()
El recolector de basura limpia automticamente los objetos no utilizados. Un objeto no es utilizado si
el programa no mantiene ms referencias a l. Usted puede eliminar explcitamente una referencia
estableciendo la variable que contiene la referencia a null.
Preguntas y ejercicios: clases

Preguntas
1.
Considere la siguiente clase:
public class IdentifyMyParts {

public static int x = 7;
public int y = 3;
}
a.
b.
c.
Cules son las variables de clase?

Cules son las variables de instancia?
Cul es la salida del siguiente cdigo:
IdentifyMyParts a = new IdentifyMyParts();

IdentifyMyParts b = new IdentifyMyParts();
a.y = 5;
b.y = 6;
a.x = 1;
b.x = 2;
System.out.println("a.y = " + a.y);
System.out.println("b.y = " + b.y);

System.out.println("a.x = " + a.x);
System.out.println("b.x = " + b.x);
System.out.println("IdentifyMyParts.x = " +
IdentifyMyParts.x);
Ejercicios
1.
Escribir una clase cuyas instancias representan una sola carta de una baraja de cartas.
Jugar a las cartas tienen dos caractersticas distintivas: rango y palo. Asegrese de
mantener su solucin ya que se le pedir reescribirla en Enum Types.
Sugerencia:
Puede utilizar la instruccin assert para comprobar sus asignaciones. Escribe:
assert (boolean expression to test);

Si la expresin booleana es false, obtendr un mensaje de error. Por ejemplo,
assert toString(ACE) == "Ace";

debe devolver true, as que no habr ningn mensaje de error.
2.
3.
Escribir una clase cuyas instancias representan una baraja completa de cartas. Tambin
debe mantener esta solucin.
Escriba un pequeo programa para poner a prueba tus clases baraja y carta. El programa
puede ser tan simple como crear una baraja de cartas y que muestre sus cartas.
Preguntas y ejercicios: objetos

Preguntas
1.
Qu pasa con el siguiente programa?
public class SomethingIsWrong {

Rectangle myRect;
myRect.width = 40;
myRect.height = 50;
System.out.println("myRect's area is " + myRect.area());
}
}
2.
El cdigo siguiente crea una matriz y un objeto string. Cuntas referencias a esos objetos
existen despus de que el cdigo se ejecuta? Cualquier objeto es elegible para el
recolector de basura?
...
String[] students = new String[10];
String studentName = "Peter Parker";
students[0] = studentName;
studentName = null;
...
3.
Cmo destruye un programa un objeto que crea?
Ejercicios
1.
2.
Arregle el programa llamado SomethingIsWrong que se muestra en la pregunta 1.

Dada la siguiente clase, llamada NumberHolder, escriba algo de cdigo que cree una
instancia de la clase, inicialice sus dos variables miembro, y muestre el valor de cada
variable miembro.
public class NumberHolder {

public int anInt;
public float aFloat;
}
Clases anidadas
El lenguaje de programacin Java permite definir una clase dentro de otra clase. Dicha clase se
llama una clase anidada (nested class) y se muestra aqu:
class OuterClass {
...
class NestedClass {
...
}
}
Terminologa: Las clases anidadas se dividen en dos categoras: esttica y no esttica. Las clases
anidadas que se declaran static se denominan clases anidadas estticas. Clases anidadas no
estticas se denominan clases internas (inner classes).
class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}
Una clase anidada es un miembro de la clase a la que pertenece o que la envuelve. Las clases
anidadas no estticas (clases internas) tienen acceso a otros miembros de la clase a la que
pertenecen, aunque sean declaradas privadas. Las clases anidadas estticas no tienen
acceso a otros miembros de la clase a la que pertenecen. Como miembro de la OuterClass,
una clase anidada puede declararse private, public, protected o package private.
(Recordemos que las clases externas slo pueden ser declaradas public o package private.)
Por qu utilizar clases anidadas?

Razones convincentes para utilizar clases anidadas incluyen las siguientes:
Es una forma de agrupar lgicamente las clases que se utilizan solamente en un solo
lugar: Si una clase es til slo a otra clase, entonces es lgico incrustarla en esa clase y
mantener las dos juntas. La anidacin de tales "Clases ayudantes" hace su paquete ms
gil.
Aumenta la encapsulacin: considere dos clases de nivel superior, A y B, donde B

necesita acceso a los miembros de A que en caso contrario se declarara private.
Ocultando la clase B dentro de los miembros de la clase A, A puede ser declarada
private y B puede acceder a ellos. Adems, la propia B se puede esconder del mundo
exterior.
Puede generar cdigo ms legible y fcil de mantener: Anidar clases pequeas dentro
de clases de nivel superior coloca el cdigo ms cerca de donde se utiliza.
Clases anidadas estticas

Al igual que con los mtodos de clase y variables, una clase anidada esttica se asocia con
su clase externa. Y al igual que los mtodos estticos de clase, una clase anidada esttica no
puede referirse directamente a las variables de instancia o mtodos definidos en su clase
envolvente o a la que pertenece: puede usarlos slo a travs de una referencia de objeto.
Nota: Una clase anidada esttica interacta con los miembros de la instancia de la clase externa (y
otras clases) justo igual que con cualquier otra clase de nivel superior. En efecto, una clase anidada
esttica su comportamiento es como una clase de nivel superior que se ha anidado en otra clase de
nivel superior para conveniencia del empaquetado.
Las clases anidadas estticas son accedidas usando el nombre de clase a la que pertencece:
OuterClass.StaticNestedClass
Por ejemplo, para crear un objeto de la clase anidada esttica, use esta sintaxis:
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();
Clases internas
Como con mtodos y variables de instancia, una clase interna se asocia con una instancia de la
clase a la que pertenece y tiene acceso directo a los campos y mtodos del objeto. Tambin,
debido a que una clase interna esta asociada a una instancia, no se puede definir a cualquier
miembro esttico por s mismo.
Los objetos que son instancias de una clase interna existen dentro de una instancia de la clase
externa. Considere las siguientes clases:
class OuterClass {
...
class InnerClass {
...
}
}
Una instancia de InnerClass puede existir solamente dentro de una instancia de OuterClass y
tiene acceso directo a los campos y mtodos de su instancia envolvente.
Para crear una instancia de una clase interna, primero debe instanciar la clase externa. Luego,
crea el objeto interno dentro del objeto externo con esta sintaxis:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
Hay dos tipos especiales de clases internas: clases locales y annimas.
Sombreado
Si una declaracin de un tipo (por ejemplo, una variable de miembro o un nombre de parmetro) en
un mbito determinado (por ejemplo, una clase interna o una definicin de mtodo) tiene el mismo
nombre que otra declaracin en el mbito al que pertenece, entonces la declaracin sombrea la
declaracin del mbito envolvente. Usted no puede hacer referencia a una declaracin sombreada
solo por su nombre. El ejemplo siguiente, ShadowTest, lo demuestra:
public class ShadowTest {

public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " +
ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
La salida de este ejemplo es el siguiente:

x = 23
this.x = 1
ShadowTest.this.x = 0
Este ejemplo define tres variables denominadas x: la variable miembro de la clase ShadowTest, la
variable miembro de la clase interna FirstLevel y el parmetro en el mtodo
methodInFirstLevel. La variable x definido como un parmetro del mtodo
methodInFirstLevel sombrea la variable de la clase interna FirstLevel. En consecuencia,
cuando se utiliza la variable x en el mtodo methodInFirstLevel, se refiere al parmetro del
mtodo. Para hacer referencia a la variable miembro de la clase interna FirstLevel, utilice la
palabra clave this para representar el mbito al que pertenece:
System.out.println("this.x = " + this.x);
Se llama a las variables miembro encerradas en mbitos mayores por el nombre de clase a la
que pertenecen. Por ejemplo, la siguiente declaracin accede a la variable miembro de la clase
ShadowTest desde el mtodo methodInFirstLevel:
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
Ejemplo de la clase interna

Para ver una clase interna en uso, considere primero una matriz. En el ejemplo siguiente, se crea un
array, llenado con valores enteros y luego da salida a los valores de los ndices incluidos en la matriz
en orden ascendente.
En el ejemplo de DataStructure.java que sigue consiste en:
La clase externa DataStructure, que incluye un constructor para crear una instancia
de DataStructure que contiene un arreglo lleno de valores enteros consecutivos (0, 1,
2, 3 y as sucesivamente) y un mtodo que imprime los elementos del arreglo que tienen un
valor de ndice incluido.
La clase interna EvenIterator, que implementa la interfaz
DataStructureIterator, que se extiende de la interfaz de Iterator< Integer>.
Los Iteradores se utilizan para pasar a travs de una estructura de datos y suelen tener
mtodos de prueba para el ltimo elemento, recuperan el elemento actual y pasan al
siguiente elemento.
Un mtodo main que crea una instancia de un objeto DataStructure (ds), luego
invoca al mtodo printEven para imprimir los elementos del arreglo arrayOfInts con
los valores de ndice incluidos.
public class DataStructure {

// Crea un arreglo
private final static int SIZE = 15;
private int[] arrayOfInts = new int[SIZE];
public DataStructure() {
// llena la matriz con valores enteros ascendentes
for (int i = 0; i < SIZE; i++) {
arrayOfInts[i] = i;
}
}
public void printEven() {
// imprime los valores de los indices incluidos en el arreglo
DataStructureIterator iterator = this.new EvenIterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
}
interface DataStructureIterator extends
java.util.Iterator<Integer> { }
// la clase interna implementa la interfaz DataStructureIterator,
// que se extiende de la interfaz Iterator<Integer>
private class EvenIterator implements DataStructureIterator {
// inicia pasando a travs de la matriz desde el principio
private int nextIndex = 0;
public boolean hasNext() {
// Comprueba si el elemento actual es el ltimo de la
serie
return (nextIndex <= SIZE - 1);
}
public Integer next() {
// graba un valor de un indice incluido en el arreglo.
Integer retValue =
Integer.valueOf(arrayOfInts[nextIndex]);
// obten el siguiente elemento incluido
nextIndex += 2;
return retValue;
}
}
public static void main(String s[]) {
// llene el arreglo con los valores enteros e imprime solo
// los valores de los indices incluidos
DataStructure ds = new DataStructure();
ds.printEven();
}
}
La salida es:
0 2 4 6 8 10 12 14
Tenga en cuenta que la clase EvenIterator se refiere directamente a la variable de instancia
arrayOfInts del objeto DataStructure .
Puede utilizar clases internas para implementar clases auxiliares como se muestra en este ejemplo.
Para manejar los eventos de la interfaz de usuario, debes saber cmo utilizar clases internas,
porque el mecanismo de control de eventos hace uso extensivo de ellos.
Clases locales y annimas

Hay dos tipos adicionales de clases internas. Se puede declarar una clase interna dentro del
cuerpo de un mtodo. Estas clases son conocidas como clases locales. Tambin puede declarar
una clase interna dentro del cuerpo de un mtodo sin nombrar la clase. Estas clases son
conocidas como clases de annimas.
Modificadores
Se puede utilizar los mismos modificadores para las clases internas que utilizas para otros miembros
de la clase externa. Por ejemplo, puedes usar los especificadores de acceso private, public
y protected para restringir el acceso a las clases internas, al igual que las usarias para
restringir el acceso a otros miembros de clase.
Clases locales
Las Clases locales son definidos en un bloque, que es un grupo de cero o ms instrucciones entre
llaves. Normalmente encontrar clases locales definidas en el cuerpo de un mtodo.
Esta seccin abarca los siguientes temas:
Declarar clases locales

Acceso a miembros de una clase envolvente
o Sombreado y clases locales
Las clases locales son similares a las clases internas
Declarar clases locales
Puede definir una clase local dentro de cualquier bloque (vase expresiones, declaraciones y los
bloques para obtener ms informacin). Por ejemplo, puede definir una clase local en un cuerpo de
mtodo, un bucle for o una condicin if.
El ejemplo siguiente, LocalClassExample, valida dos nmeros de telfono. Define la clase local
PhoneNumber en el mtodo validatePhoneNumber:
public class LocalClassExample {

static String regularExpression = "[^0-9]";
public static void validatePhoneNumber(
String phoneNumber1, String phoneNumber2) {
final int numberLength = 10;
// Valid in JDK 8 and later:
// int numberLength = 10;
class PhoneNumber {
String formattedPhoneNumber = null;
PhoneNumber(String phoneNumber){
// numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
if (currentNumber.length() == numberLength)
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}
public String getNumber() {
return formattedPhoneNumber;
}
//
public void printOriginalNumbers() {
//
System.out.println("Original numbers are " +
phoneNumber1 +
//
" and " + phoneNumber2);
//
}
}
PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);
//
myNumber1.printOriginalNumbers();
if (myNumber1.getNumber() == null)
System.out.println("First number is invalid");
else
System.out.println("First number is " +
myNumber1.getNumber());
if (myNumber2.getNumber() == null)
System.out.println("Second number is invalid");
else
System.out.println("Second number is " +
myNumber2.getNumber());
}

validatePhoneNumber("123-456-7890", "456-7890");
}
}
En el ejemplo se valida un nmero de telfono quitando todos los caracteres del nmero de telfono
excepto los dgitos 0 a 9. Despus, comprueba si el nmero de telfono contiene exactamente diez
dgitos (la longitud de un nmero de telfono en Amrica del norte). Este ejemplo imprime lo
siguiente:
First number is 1234567890
Second number is invalid
Acceso a miembros de una clase envolvente

Una clase local tiene acceso a los miembros de su clase envolvente. En el ejemplo anterior, el
constructor PhoneNumber accede al miembro LocalClassExample.regularExpression.
Adems, una clase local tiene acceso a las variables locales. Sin embargo, una clase local slo
puede acceder a variables locales declaradas finales. Cuando una clase local tiene acceso a una
variable local o un parmetro del bloque envolvente, capta esa variable o parmetro. Por ejemplo, el
constructor PhoneNumber puede acceder a la variable local numberLength porque se declara
final; numberLength es una variable capturado.
Sin embargo, a partir de Java SE 8, una clase local puede acceder a las variables locales y
parmetros de la envolvente bloque que son definitivos o efectivamente final. Una variable o
parmetro cuyo valor no ha cambiado despus de que se inicialice es efectivamente final. Por
ejemplo, supongamos que la variable numberLength no est declarado el final, y agrega la
instruccin de asignacin resaltada en el constructor de PhoneNumber :
PhoneNumber(String phoneNumber) {
numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}
Debido a esta instruccin de asignacin, la variable numberLength ya no es con eficacia final.

Como resultado, el compilador de Java genera un mensaje de error similar a "las variables locales
que se hace referencia de una clase interna deben ser final o efectivamente final" donde la clase
interna PhoneNumber intenta acceder a la variable numberLength :
A partir de Java SE 8, si se declara la clase local en un mtodo, se pueden acceder a los

parmetros del mtodo. Por ejemplo, puede definir el siguiente mtodo en la clase de
PhoneNumber local:
public void printOriginalNumbers() {
System.out.println("Original numbers are " + phoneNumber1 +
" and " + phoneNumber2);
}
El mtodo printOriginalNumbers obtiene acceso a los parmetros phoneNumber1 y

phoneNumber2 del mtodo validatePhoneNumber.
Clases de sombreado y locales

Las declaraciones de un tipo (por ejemplo, una variable) en una clase local sombra declaraciones en
el mbito envolvente que tengan el mismo nombre. Para obtener ms informacin vea la sombra .
Las clases locales son similares a las clases internas

Clases locales son similares a las clases internas porque no pueden definir ni declarar a cualquier
miembros estticos. Clases locales de mtodos estticos, como la clase PhoneNumber, que se
define en el mtodo esttico validatePhoneNumber, slo pueden hacer referencia a los
miembros estticos de la clase envolvente. Por ejemplo, si no se define la variable miembro
regularExpression como esttico, entonces el compilador de Java genera un error similar a "no
esttico variable regularExpression no pueden ser referenciados desde un contexto esttico".
Clases locales son no esttico porque tienen acceso a los miembros de la instancia del bloque
envolvente. En consecuencia, no pueden contener ms clases de declaraciones estticas.
No puede declarar una interfaz dentro de un bloque; las interfaces son inherentemente estticas.
Por ejemplo, el siguiente fragmento de cdigo no compila porque la interfaz HelloThere se define
dentro del cuerpo del mtodo greetInEnglish:
public void greetInEnglish() {
interface HelloThere {
public void greet();
}
class EnglishHelloThere implements HelloThere {
public void greet() {
System.out.println("Hello " + name);
}
}
HelloThere myGreeting = new EnglishHelloThere();
myGreeting.greet();
}
No puede declarar inicializadores estticos o interfaces de miembro de una clase local. El siguiente
fragmento de cdigo no compila porque el mtodo EnglishGoodbye.sayGoodbye se declara
static. El compilador genera un error similar al "modificador 'static' slo est permitido en la
declaracin de variable constante" cuando se encuentra con esta definicin de mtodo:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static void sayGoodbye() {
System.out.println("Bye bye");
}
}
EnglishGoodbye.sayGoodbye();
}
Una clase local puede tener miembros estticos que son variables constantes. (Una variable
constante es una variable de tipo primitivo o tipo String que se declara final e inicializado con una
expresin constante de tiempo de compilacin. Una expresin constante de tiempo de compilacin
es normalmente una cadena o una expresin aritmtica que puede evaluarse en tiempo de
compilacin. Ver Miembros de la clase de comprensin para obtener ms informacin). El siguiente
fragmento de cdigo compila porque el miembro esttico EnglishGoodbye.farewell es una
variable constante:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static final String farewell = "Bye bye";
public void sayGoodbye() {
System.out.println(farewell);
}
}
EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
myEnglishGoodbye.sayGoodbye();
}
Clases de annimas
Annimas clases permiten hacer el cdigo ms conciso. Le permiten declarar y crear una
instancia de una clase al mismo tiempo. Son como las clases locales excepto que no tienen un
nombre. Usarlas, si es necesario utilizar una clase local solamente una vez.
Esta seccin abarca los siguientes temas:
Declarar clases annimas

Sintaxis de clases annimas
Acceder a las Variables locales del mbito envolvente y declarando y acceder a los
miembros de la clase annima
Ejemplos de clases de annimos
Declarar clases annimas

Mientras que las clases locales son declaraciones de clase, las clases annimas son expresiones, lo
que significa que la clase se define en otra expresin. El ejemplo siguiente,
HelloWorldAnonymousClasses, utiliza las clases annimas en las declaraciones de
inicializacin de las variables locales frenchGreeting y spanishGreeting, pero utiliza una
clase local para la inicializacin de la variable englishGreeting:
public class HelloWorldAnonymousClasses {

interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
class EnglishGreeting implements HelloWorld {
String name = "world";
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
greetSomeone("tout le monde");
}
name = someone;
System.out.println("Salut " + name);
}
};
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";

greetSomeone("mundo");
}
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
HelloWorldAnonymousClasses myApp =
new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
Sintaxis de clases annimas

Como se mencion anteriormente, una clase annima es una expresin. La sintaxis de la expresin
de una clase annima es como la invocacin de un constructor, excepto que no hay una definicin
de clase contenida en un bloque de cdigo.
Considere la instanciacin del objeto frenchGreeting :
HelloWorld frenchGreeting = new HelloWorld() {

String name = "tout le monde";
greetSomeone("tout le monde");
}
name = someone;
System.out.println("Salut " + name);
}
};
La expresin clase annima consiste en lo siguiente:
El new operador
El nombre de una interfaz para implementar o una clase para extender. En este ejemplo, la
clase annima est implementando la interfaz HelloWorld.
Parntesis que contienen los argumentos de un constructor, slo como una expresin de
creacin de instancia de clase normal. Nota: cuando se implementa una interfaz, no hay
ningn constructor, as que utiliza un par de parntesis, como en este ejemplo vaco.
Un cuerpo, que es un rgano de la declaracin de clase. Ms concretamente, en el cuerpo,
declaraciones de mtodos estn permitidas pero no son declaraciones.
Porque la definicin de una clase annima es una expresin, debe ser parte de una declaracin. En
este ejemplo, la expresin de la clase annima es parte de la declaracin que crea una instancia del
objeto frenchGreeting . (Esto explica por qu hay un punto y coma despus de la abrazadera
de cierre.)
Acceder a las Variables locales del mbito envolvente y declarando

y acceder a los miembros de la clase annima
Como local las clases, clases annimas pueden capturar variables; tienen el mismo acceso a las
variables locales del mbito envolvente:
Una clase annima tiene acceso a los miembros de su clase envolvente.

Una clase annima no puede acceder a variables locales en su mbito envolvente que no
son declaradas como final o final con eficacia.
Como una clase anidada, una declaracin de un tipo (por ejemplo, una variable) en una
clase annima ensombrece cualquier otra declaracin en el mbito envolvente que tiene el
mismo nombre. Para obtener ms informacin vea la sombra .
Las clases annimas tambin tienen las mismas restricciones que las clases locales con respecto a
sus miembros:
No puede declarar inicializadores estticos o interfaces de miembro de una clase annima.

Una clase annima puede tener miembros estticos que son variables constantes.
Tenga en cuenta que se puede declarar lo siguiente en clases annimas:
Campos
Mtodos adicionales (incluso si no implementan los mtodos del supertipo)
Inicializadores de instancia
Clases locales
Sin embargo, no puede declarar constructores en una clase annima.
Ejemplos de clases de annimos

Annimas clases a menudo se utilizan en aplicaciones de interfaz grfica de usuario.
Considere el ejemplo de JavaFX HelloWorld.java (de la seccin Hello World, JavaFX estilo de
Getting Started with JavaFX). Este ejemplo crea un marco que contiene un botn de decir ' Hola
mundo ' . La expresin clase annima se destaca:
import
import
import
import
import
import
javafx.event.ActionEvent;
javafx.event.EventHandler;
javafx.scene.Scene;
javafx.scene.control.Button;
javafx.scene.layout.StackPane;
javafx.stage.Stage;
public class HelloWorld extends Application {

launch(args);
}
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello World!");
Button btn = new Button();
btn.setText("Say 'Hello World'");
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
}
});
StackPane root = new StackPane();

root.getChildren().add(btn);
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
}
En este ejemplo, el mtodo de invocacin btn.setOnAction especifica lo que sucede cuando se
selecciona el botn de decir ' Hola mundo'. Este mtodo requiere un objeto de tipo
EventHandler<ActionEvent>. La interfaz de EventHandler<ActionEvent> contiene
solamente un mtodo, manejar. En lugar de aplicar este mtodo con una nueva clase, el ejemplo
utiliza una expresin de la clase annima. Observe que esta expresin es el argumento que se pasa
al mtodo btn.setOnAction.
Porque la interfaz EventHandler<ActionEvent> contiene solamente un mtodo, puede utilizar
una expresin lambda en lugar de una expresin de la clase annima. Consulte la seccin
Expresiones Lambda para obtener ms informacin.
Las clases annimas son ideales para implementar una interfaz que contiene dos o ms mtodos.
En el siguiente ejemplo de JavaFX es desde la seccin Personalizacin de controles de interfaz de
usuario. El cdigo resaltado crea un campo de texto que slo acepta valores numricos. Redefine la
implementacin predeterminada de la clase TextField con una clase annima reemplazando los
mtodos replaceText y replaceSelection heredados de la clase TextInputControl.
import
import
import
import
import
import
import
import
import
import
javafx.application.Application;
javafx.event.ActionEvent;
javafx.event.EventHandler;
javafx.geometry.Insets;
javafx.scene.Group;
javafx.scene.Scene;
javafx.scene.control.*;
javafx.scene.layout.GridPane;
javafx.scene.layout.HBox;
javafx.stage.Stage;
public class CustomTextFieldSample extends Application {

final static Label label = new Label();
@Override
public void start(Stage stage) {
Group root = new Group();
Scene scene = new Scene(root, 300, 150);
stage.setScene(scene);
stage.setTitle("Text Field Sample");
GridPane grid = new GridPane();
grid.setPadding(new Insets(10, 10, 10, 10));
grid.setVgap(5);
grid.setHgap(5);
scene.setRoot(grid);
final Label dollar = new Label("$");
GridPane.setConstraints(dollar, 0, 0);
grid.getChildren().add(dollar);
final TextField sum = new TextField() {
@Override
public void replaceText(int start, int end, String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceText(start, end, text);
}
label.setText("Enter a numeric value");
}
@Override
public void replaceSelection(String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceSelection(text);
}
}
};
sum.setPromptText("Enter the total");
sum.setPrefColumnCount(10);
GridPane.setConstraints(sum, 1, 0);
grid.getChildren().add(sum);
Button submit = new Button("Submit");
GridPane.setConstraints(submit, 2, 0);
grid.getChildren().add(submit);
submit.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent e) {
label.setText(null);
}
});
GridPane.setConstraints(label, 0, 1);
GridPane.setColumnSpan(label, 3);
grid.getChildren().add(label);
scene.setRoot(grid);
stage.show();
}
launch(args);
}
}
Cundo utilizar clases anidadas, Local clases, clases de

annimas y expresiones Lambda
Como se mencion en la seccin Clases anidadas, las clases anidadas permiten agrupar
lgicamente las clases que se utilizan solamente en un solo lugar, incrementar el uso de
encapsulacin y crear cdigo ms legible y fcil de mantener. Clases locales, clases annimas
y expresiones lambda tambin imparten estas ventajas; Sin embargo, se destinan a ser utilizados
para situaciones ms especficas:
Clase local: usarlo si usted necesita crear ms de una instancia de una clase, para acceder
a su constructor o introducir uno nuevo, llamar un tipo (, por ejemplo, es necesario invocar
mtodos adicionales ms adelante).
Clase annima: usarlo si necesita declarar campos o mtodos adicionales.
Clase anidada: usarlo si sus requerimientos son similares a los de una clase local, quieres
que sea el tipo ms ampliamente disponible, y no necesita acceso a variables locales o los
parmetros del mtodo.
o Utilice una clase anidada no esttico (o clase interna) si requiere acceso a campos
no pblicos y mtodos de una instancia envolvente. Utilice una clase anidada
esttica si no necesita este acceso.
Expresin lambda:
o Utilizar si usted encapsula una sola unidad de comportamiento que desea pasar a
otro cdigo. Por ejemplo, se usara una expresin lambda si quieres cierta accin
realizada en cada elemento de una coleccin, cuando se completa un proceso, o

cuando un proceso encuentra con un error.
Utilizarlo si necesitas un ejemplo simple de una interfaz funcional y no se aplica
ninguno de los anteriores criterios (por ejemplo, no necesitas un constructor, llamar
un tipo, campos o mtodos adicionales).
Preguntas y Ejercicios: Clases Anidadas

Preguntas
1.
El programa no compila Problem.java. Qu necesitas hacer para hacerlo compilar?

Por qu?
public class Problem {

String s;
static class Inner {
void testMethod() {
s = "Set from Inner";
}
}
}
2.
Utilice la documentacin de la API de Java para la clase de Box (en el paquete

javax.swing) para ayudar a contestar las siguientes preguntas.
a. Qu clase anidada esttica define Box?
b. Qu clase interna define Box?
c. Qu es la superclase de la clase interna de la Box?
d. Que de clases anidadas de la Boxse puede usar de cualquier clase?
e. Cmo se crea una instancia de clase de la Box Filler?
http://docs.oracle.com/javase/8/docs/api/javax/swing/Box.html
Ejercicios
1.
Compilar y ejecutar Class1. Cul es la salida?
public class Class1 {

protected InnerClass1 ic;
public Class1() {
ic = new InnerClass1();
}
public void displayStrings() {
System.out.println(ic.getString() + ".");
System.out.println(ic.getAnotherString() + ".");
}
static public void main(String[] args) {
Class1 c1 = new Class1();
c1.displayStrings();
}
protected class InnerClass1 {
public String getString() {
return "InnerClass1: getString invoked";
}
public String getAnotherString() {

return "InnerClass1: getAnotherString invoked";
}
}
}
Las respuestas a las preguntas y ejercicios: clases

anidadas
Preguntas
1.
Pregunta: el programa no compila Problem.java . Qu necesitas hacer para hacerlo

compilar? Por qu?
Respuesta: eliminar static frente a la declaracin de la clase Inner. Una clase esttica
interna no tiene acceso a los campos de instancia de la clase externa. Ver
ProblemSolved.java .
public class ProblemSolved {

String s;
class Inner {
void testMethod() {
s = "Set from Inner";
}
}
}
2.
Utilice la documentacin de la API de Java para la clase Box (en el paquete

javax.swing ) para ayudar a contestar las siguientes preguntas.
http://docs.oracle.com/javase/8/docs/api/javax/swing/Box.html
a.
Pregunta: Qu clase anidada esttica concepta Box ?

Respuesta: Box.Filler
b.
Pregunta: Qu clase interna concepta Box ?

Respuesta: Box.AccessibleBox
c.
Pregunta: Qu es la superclase de la clase interna de la Box?

Respuesta: [java.awt.]Container.AccessibleAWTContainer
d.
Pregunta: Cul de clases anidadas del Boxpuede utilizar de cualquier clase.

Respuesta: Box.Filler
e.
Pregunta: Cmo se crean una instancia de clase de la Box Filler ?
Respuesta: new Box.Filler(minDimension, prefDimension,
maxDimension)
Ejercicio
1.
Ejercicio: del archivo Class1.java. Compilar y ejecutar Class1. Cul es la salida?
public class Class1 {

protected InnerClass1 ic;
public Class1() {
ic = new InnerClass1();
}
public void displayStrings() {
System.out.println(ic.getString() + ".");
System.out.println(ic.getAnotherString() + ".");
}
Class1 c1 = new Class1();
c1.displayStrings();
}
protected class InnerClass1 {
public String getString() {
return "InnerClass1: getString invoked";
}
public String getAnotherString() {
return "InnerClass1: getAnotherString invoked";
}
}
}
Respuesta: InnerClass1: getString invoked.
InnerClass1: getAnotherString invoked.
Tipos enumerados
Un tipo enum es un tipo especial de datos que permite a una variable ser un conjunto
de constantes predefinidas. La variable debe ser igual a uno de los valores que han sido
predefinidos para ello. Los ejemplos ms comunes incluyen direcciones de la brjula
(valores de norte, sur, este y oeste) y los das de la semana.
Porque son constantes, son los nombres de los campos de un tipo enum en letras
maysculas.
En el lenguaje de programacin Java, definimos un tipo enum utilizando la palabra clave
enum . For example, especificara un tipo enum dias-de-la-semana como:
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
Usted debe usar los tipos enum cualquier momento en que necesite representar un
conjunto fijo de constantes. Eso incluye tipos enum naturales tales como los planetas de
nuestro sistema solar y los conjuntos de datos donde conoces a todos los valores posibles
en tiempo de compilacin, por ejemplo, las opciones de un men, parmetros de lnea de
comandos y as sucesivamente.
Aqu hay un cdigo se muestra cmo utilizar la enumeracin Day definida anteriormente:
public class EnumTest {

Day day;
public EnumTest(Day day) {
this.day = day;
}
public void tellItLikeItIs() {
switch (day) {
case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
case SATURDAY: case SUNDAY:
System.out.println("Weekends are best.");
break;
default:
System.out.println("Midweek days are soso.");
break;
}
}

EnumTest firstDay = new EnumTest(Day.MONDAY);
firstDay.tellItLikeItIs();
EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
thirdDay.tellItLikeItIs();
EnumTest fifthDay = new EnumTest(Day.FRIDAY);
fifthDay.tellItLikeItIs();
EnumTest sixthDay = new EnumTest(Day.SATURDAY);
sixthDay.tellItLikeItIs();
EnumTest seventhDay = new EnumTest(Day.SUNDAY);
seventhDay.tellItLikeItIs();
}
}
La salida es:
Mondays are bad.

Midweek days are so-so.
Fridays are better.
Weekends are best.
Weekends are best.
En lenguaje de programacin Java los tipos enum son mucho ms potentes que en sus
homlogos. La declaracin enum define una clase (llamada un tipo enum). El cuerpo de la
clase enum puede incluir mtodos y otros campos. El compilador aade automticamente
algunos mtodos especiales cuando se crea un enum. Por ejemplo, tienen un mtodo
esttico values que devuelve una matriz que contiene todos los valores de la
enumeracin en el orden en que se declararon. Este mtodo se utiliza comnmente en
combinacin con la para-cada construccin para iterar sobre los valores de un tipo enum.
Por ejemplo, este cdigo del ejemplo de la clase de Planet siguiente recorre en iteracin
todos los planetas del sistema solar.
for (Planet p : Planet.values()) {

System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}
Nota: Todas las enumeraciones implicit extienden java.lang.Enum. Porque slo

puede extenderse una clase uno de los padres (vase Declarando clases), Java el
lenguaje no soporta herencia mltiple del estado (vase herencia mltiple de estado,
implementacin y tipo), y por lo tanto no puede extender una enumeracin nada ms.
En el ejemplo siguiente, el Planet es un tipo enum representa los planetas del sistema
solar. Se definen con propiedades de radio y masa constante.
Cada constante de enumeracin se declara con valores para los parmetros de masa y el
radio. Estos valores se pasan al constructor cuando se crea la constante. Java exige las
constantes definirse en primer lugar, antes de cualquier campo o mtodos. Adems,
cuando hay campos y mtodos, la lista de constantes enum debe terminar con coma un
punto y.
Nota: El constructor de un tipo enum debe ser paquete privado o de acceso privado.
Crea automticamente las constantes definidas al principio del cuerpo enum. No se
puede invocar un constructor de enum.
Adems de sus propiedades y constructor, Planet tiene mtodos permiten recuperar la

gravedad superficial y el peso de un objeto en cada planeta. Aqu es un programa de
muestra lleva el peso de la tierra (en cualquier unidad) y calcula e imprime tu peso en todos
los planetas (en la misma unidad):
public enum
MERCURY
VENUS
EARTH
MARS
JUPITER
SATURN
URANUS
NEPTUNE
Planet {
(3.303e+23,
(4.869e+24,
(5.976e+24,
(6.421e+23,
(1.9e+27,
(5.688e+26,
(8.686e+25,
(1.024e+26,
2.4397e6),
6.0518e6),
6.37814e6),
3.3972e6),
7.1492e7),
6.0268e7),
2.5559e7),
2.4746e7);
private final double mass;

// in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
private double mass() { return mass; }
private double radius() { return radius; }
// universal gravitational constant (m3 kg-1 s-2)
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
if (args.length != 1) {
System.err.println("Usage: java Planet
<earth_weight>");
System.exit(-1);
}
double earthWeight = Double.parseDouble(args[0]);
double mass = earthWeight/EARTH.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}
}
2.
Si capacitar Planet.class desde la lnea de comandos con un argumento permiso

de 175, obtendr esta salida:
$ java Planet 175

Your weight on MERCURY is 66.107583
Your weight on VENUS is 158.374842
Your weight on EARTH is 175.000000
Your weight on MARS is 66.279007
Your weight on JUPITER is 442.847567
Your weight on SATURN is 186.552719
Your weight on URANUS is 158.397260
Your weight on NEPTUNE is 199.207413
Leccin: anotaciones
Anotaciones, una forma de metadatos, proporcionar datos sobre un programa que no es parte del
programa de s mismo. Anotaciones no tienen ningn efecto directo sobre el funcionamiento del
cdigo que anotan.
Anotaciones tienen un nmero de usos, entre ellos:
Informacin para el compilador anotaciones pueden utilizarse por el compilador para

detectar errores o suprimir advertencias.
Procesamiento de tiempo de compilacin y tiempo de implementacin herramientas
de Software pueden procesar informacin de anotacin para generar cdigo, archivos XML
y as sucesivamente.
Tiempo de ejecucin de procesamiento algunas anotaciones estn disponibles para
ser examinados en tiempo de ejecucin.
Esta leccin explica donde anotaciones pueden ser utilizadas, cmo aplicar las anotaciones, qu
tipo de anotacin predefinidos est disponible en la plataforma Java, Standard Edition (Java SE
API), cmo tipo annnotations puede utilizarse en conjuncin con sistemas de tipo enchufable para
escribir cdigo con verificacin de tipos ms fuerte y cmo implementar la repeticin anotaciones.
Conceptos bsicos de anotaciones

El formato de una anotacin
En su forma ms simple, una anotacin luce como el siguiente:
@Entity
La arroba carcter (@) indica al compilador que lo que sigue es una anotacin. En el ejemplo
siguiente, nombre de la anotacin es Override:
@Override
void mySuperMethod() { ... }
La anotacin puede incluir elementos, que puede ser llamado o no identificada, y hay valores para
los elementos:
@Author(
name = "Benjamin Franklin",
date = "3/27/2003"
)
class MyClass() { ... }
o
@SuppressWarnings(value = "unchecked")
void myMethod() { ... }
Si hay un elemento denominado value, entonces el nombre puede ser omitido, como en:
@SuppressWarnings("unchecked")
void myMethod() { ... }
Si la anotacin no tiene elementos, entonces los parntesis se pueden omitir, como se muestra en el
ejemplo anterior @Override .
Tambin es posible usar varias anotaciones en la misma declaracin:
@Author(name = "Jane Doe")

@EBook
class MyClass { ... }
Si las anotaciones tienen el mismo tipo, entonces esto se llama una anotacin de repeticin:
@Author(name = "Jane Doe")

@Author(name = "John Smith")
class MyClass { ... }
Repitiendo las anotaciones se admiten como del 8 Java SE suelte. Para ms informacin, vea
Repitiendo las anotaciones.
El tipo de anotacin puede ser uno de los tipos que se definen en los paquetes java.lang o
java.lang.annotation de la API de Java SE. En los ejemplos anteriores, Override y
SuppressWarnings son anotaciones Java predefinidas. Tambin es posible definir su propio tipo
de anotacin. Las anotaciones del Author y Ebook en el ejemplo anterior son tipos de anotacin
personalizadas.
Donde pueden ser utilizadas las anotaciones

Las Anotaciones pueden ser aplicadas a las declaraciones: las declaraciones de clases, campos,
mtodos y otros elementos del programa. Cuando se utiliza en una declaracin, cada anotacin a
menudo aparece, por Convencin, en su propia lnea.
A partir de la versin de Java SE 8, anotaciones pueden aplicarse tambin para el uso de tipos.
Estos son algunos ejemplos:
Expresin de creacin de la instancia de clase:
new @Interned MyObject();

Tipo cast:
myString = (@NonNull String) str;
clusula implements :
class UnmodifiableList<T> implements
@Readonly List<@Readonly T> { ... }
Declaracin de excepcin lanzada:
void monitorTemperature() throws
@Critical TemperatureException { ... }
Esta forma de anotacin se llama una anotacin de tipo. Para ms informacin, consulte tipo de
anotaciones y sistemas de tipo enchufable.
Declarar un tipo de anotacin

Muchas anotaciones reemplazar comentarios en cdigo.
Supongamos que un grupo de software comienza tradicionalmente el cuerpo de cada clase con
comentarios proporcionando informacin importante:
public class Generation3List extends Generation2List {

//
//
//
//
//
//
Author: John Doe

Date: 3/17/2002
Current revision: 6
Last modified: 4/12/2004
By: Jane Doe
Reviewers: Alice, Bill, Cindy
// class code goes here

}
Para agregar este mismo metadatos con una anotacin, primero es necesario definir el tipo de
anotacin. La sintaxis para hacer que esto es:
@interface ClassPreamble {
String author();
String date();
int currentRevision() default 1;
String lastModified() default "N/A";
String lastModifiedBy() default "N/A";
// Note use of array
String[] reviewers();
}
La definicin de tipo de anotacin es similar a una definicin de interfaz donde la palabra clave
interface est precedido por la arroba (@) (@ = AT, como en el tipo de anotacin). Tipos de
anotacin son una forma de interfaz, que sern cubiertos en una leccin posterior. Por el momento,
no necesitas comprender las interfaces.
El cuerpo de la definicin anterior anotacin contiene elementos de tipo anotacin declaraciones,
que parecen muchos mtodos. Tenga en cuenta que pueden definir valores por defecto opcional.
Despus se define el tipo de anotacin, puede utilizar las anotaciones de ese tipo, con los valores de
relleno, as:
@ClassPreamble (
author = "John Doe",
date = "3/17/2002",
currentRevision = 6,
lastModified = "4/12/2004",
lastModifiedBy = "Jane Doe",
// Note array notation
reviewers = {"Alice", "Bob", "Cindy"}
)
public class Generation3List extends Generation2List {
// class code goes here
}
Nota: Para ampliar la informacin en @ClassPreamble en la documentacin generada por
Javadoc, usted debe anotar la definicin de @ClassPreamble con la anotacin @Documented :
// import this to use @Documented

import java.lang.annotation.*;
@Documented
@interface ClassPreamble {
// Annotation element definitions

}
Tipos de anotacin predefinidos

Un conjunto de tipos de anotacin estn predefinidos en la API de Java SE. Algunos tipos de
anotacin son utilizados por el compilador de Java, y algunas se aplican a otras anotaciones.
Tipos de anotacin utilizados por el lenguaje Java

@Deprecated @Overridey @SuppressWarnings estn los tipos predefinidos anotacin
definidos en java.lang.
@Deprecated @Deprecated anotacin indica que el elemento de marcado es obsoleto y ya no
debe ser utilizado. El compilador genera una advertencia cada vez que un programa utiliza un
mtodo, clase o campo con la anotacin de @Deprecated . Cuando un elemento se considera
obsoleto, debe tambin ser document utilizando la etiqueta @deprecated Javadoc, como se
muestra en el ejemplo siguiente. El uso de la arroba (@) en ambos comentarios Javadoc y
anotaciones no es casual: se relacionan conceptualmente. Tambin, tenga en cuenta que la etiqueta
de Javadoc comienza con una minscula d y la anotacin se inicia con una mayscula D.
// Javadoc comment follows

/**
* @deprecated
* explanation of why it was deprecated
*/
@Deprecated
static void deprecatedMethod() { }
}
@Override @Override anotacin informa al compilador que el elemento est destinado a
reemplazar un elemento declarado en una superclase. Mtodos se discutirn en las Interfaces y
la herencia.
// mark method as a superclass method

// that has been overridden
@Override
int overriddenMethod() { }
Mientras que no es necesario usar esta anotacin cuando un mtodo, ayuda a evitar errores. Si un
mtodo marcado con @Override falla reemplazar correctamente un mtodo en uno de sus
superclases, el compilador genera un error.
@SuppressWarnings @SuppressWarnings anotacin indica al compilador que suprimir las
advertencias especficas que de lo contrario generara. En el ejemplo siguiente, se utiliza un mtodo
en desuso, y el compilador generalmente genera una advertencia. En este caso, sin embargo, la
anotacin causa la advertencia que se debe suprimir.
// use a deprecated method and tell

// compiler not to generate a warning
@SuppressWarnings("deprecation")
void useDeprecatedMethod() {
// deprecation warning
// - suppressed
objectOne.deprecatedMethod();
}
Cada advertencia del compilador pertenece a una categora. La especificacin del lenguaje Java
listas dos categoras: deprecation y unchecked. La advertencia unchecked puede ocurrir
cuando con cdigo legado escrito antes de la llegada de los genricos. Para suprimir varias
categoras de advertencias, utilice la siguiente sintaxis:
@SuppressWarnings({"unchecked", "deprecation"})
@SafeVarargs @SafeVarargs anotacin, cuando se aplica a un mtodo o constructor, afirma que
el cdigo no realizar operaciones potencialmente inseguras sobre su parmetro varargs . Cuando
se utiliza este tipo de anotacin, advertencias relativas al uso de varargs son suprimidas.
@FunctionalInterface Anotacin @FunctionalInterface , introducido en Java SE 8, indica
que la declaracin de tipo pretende ser una interfaz funcional, como se define en la especificacin
del lenguaje Java.
Anotaciones que se aplican a otras anotaciones

Las anotaciones que se aplican a otras anotaciones se llaman meta-anotaciones. Existen varios
tipos de meta-anotacin definidos en java.lang.annotation.
@Retention @Retention anotacin especifica cmo se almacena la anotacin marcada:
RetentionPolicy.SOURCE la anotacin marcada se conserva slo en el nivel de la

fuente y es ignorado por el compilador.
RetentionPolicy.CLASS la anotacin marcada es retenida por el compilador en
tiempo de compilacin, pero es ignorado por la Java Virtual Machine (JVM).
RetentionPolicy.RUNTIME la anotacin marcada es conservada por la JVM as que
puede ser utilizado por el entorno de ejecucin.
@Documented @Documented anotacin indica que cuando se usa la anotacin especifica

aquellos elementos deben ser documentados mediante la herramienta Javadoc. (De forma
predeterminada, las anotaciones no estn incluidas en Javadoc). Para obtener ms informacin,
consulte la pgina de herramientas de Javadoc.
@Target @Target anotacin marca otra anotacin para restringir qu tipo de elementos de Java la
anotacin se puede aplicar a. Una anotacin de destino especifica uno de los siguientes tipos de
elemento como su valor:
ElementType.ANNOTATION_TYPE puede ser aplicado a un tipo de anotacin.

ElementType.CONSTRUCTOR se puede aplicar a un constructor.
ElementType.FIELD puede aplicarse a un campo o propiedad.
ElementType.LOCAL_VARIABLE se puede aplicar a una variable local.
ElementType.METHOD puede aplicarse a una anotacin de nivel de mtodo.
ElementType.PACKAGE puede aplicarse a una declaracin de paquete.
ElementType.PARAMETER puede ser aplicado a los parmetros de un mtodo.
ElementType.TYPE se puede aplicar a cualquier elemento de una clase.
@Inherited @Inherited anotacin indica que el tipo de anotacin puede ser heredado de la
superclase. (Esto no es cierto por defecto). Cuando el usuario consulta el tipo de anotacin y la
clase no tiene anotacin para este tipo, se consulta a la superclase de la clase para el tipo de
anotacin. Esta anotacin se aplica slo a las declaraciones de clase.
@Repeatable Anotacin @Repeatable , introducido en Java SE 8, indica que la anotacin

marcada se puede aplicar ms de una vez para el mismo uso declaracin o tipo. Para ms
informacin, vea Repitiendo las anotaciones.
Preguntas y ejercicios: anotaciones

Preguntas
1.
Qu pasa con la siguiente interfaz?
public interface House {

@Deprecated
void open();
void openFrontDoor();
void openBackDoor();
}
2.
Considere esta implementacin de la interfaz de House, que se muestra en la pregunta 1.
public class MyHouse implements House {

public void open() {}
public void openFrontDoor() {}
public void openBackDoor() {}
}
Si se compila este programa, el compilador produce una advertencia porque open era
deprecated (en la interfaz). Qu puede hacer para deshacerse de esa advertencia?
3.
El siguiente cdigo se compilar sin errores? Por qu si o por qu no?
public @interface Meal { ... }

@Meal("breakfast", mainDish="cereal")
@Meal("lunch", mainDish="pizza")
@Meal("dinner", mainDish="salad")
public void evaluateDiet() { ... }
Leccin: Interfaces y herencia

Interfaces
Viste un ejemplo de la implementacin de una interfaz en la leccin anterior. Puedes leer ms sobre
interfaces aqu para qu son, por qu es posible que desee escribir una, y cmo escribir una.
Herencia
Esta seccin describe la manera en la que se puede derivar una clase de otra. Es decir, cmo
una subclase puede heredar campos y mtodos de una superclase. Usted aprender que todas
las clases se derivan de la clase Object, y cmo modificar los mtodos que una subclase hereda de
superclases. Esta seccin cubre tambin interfaces como clases abstractas.
Interfaces
Hay una serie de situaciones en ingeniera de software cuando es importante para los grupos
dispares de programadores acordar un "contrato" que detalle cmo interacta su software. Cada
grupo debe ser capaz de escribir su cdigo sin ningn conocimiento de cmo se escribe el
cdigo del otro grupo. En trminos generales, las interfaces son esos contratos.
Por ejemplo, imaginemos una sociedad futurista donde los coches robticos controlados por
computadora transportan pasajeros por las calles sin un operador humano. Fabricantes de
automviles escriben software (Java, por supuesto) que opera el automvil parar, arrancar,
acelerar, girar a la izquierda, y as sucesivamente. Otro grupo industrial, fabricantes del instrumento
electrnico de posicionamiento, sistemas informticos que reciben datos de posicin GPS (Global
Positioning System) y la transmisin inalmbrica de las condiciones del trfico, usan esa informacin
para conducir el coche.
Los fabricantes de automviles deben publicar una interfaz estndar de la industria que explica
en detalle qu mtodos pueden invocarse para mover el coche (cualquier coche, de cualquier
fabricante). Los fabricantes del posicionamiento pueden entonces escribir software que invoca los
mtodos descritos en la interfaz para dirigir el coche. Ninguno de los dos grupos industriales
necesita saber Cmo es que implementa el otro grupo el software. De hecho, cada grupo
considera su software altamente patentado y se reserva el derecho de modificarlo en cualquier
momento, siempre que continue adherido a la interfaz publicada.
Interfaces en Java
En el lenguaje de programacin Java, una interfaz es un tipo de referencia, similar a una clase,
que puede contener slo constantes, firmas de mtodos, mtodos por defecto, mtodos estticos y
tipos anidados. Los cuerpos de mtodo existen solamente para mtodos por defecto y mtodos
estticos. Las interfaces No pueden ser instanciadas slo pueden ser implementadas por las
clases o extendidas por otras interfaces. La Extensin se discute ms adelante en esta leccin.
Definir una interfaz es similar a la creacin de una nueva clase:
public interface OperateCar {

// declaraciones de constantes, si la hay
// firmas de mtodos
// una enumeracin con valores RIGHT, LEFT
int turn(Direction direction,
double radius,
double startSpeed,
double endSpeed);
int changeLanes(Direction direction,
double startSpeed,
double endSpeed);
int signalTurn(Direction direction,
boolean signalOn);
int getRadarFront(double distanceToCar,
double speedOfCar);
int getRadarRear(double distanceToCar,
double speedOfCar);
......
// ms firmas de mtodos
}
Tenga en cuenta que las firmas de los mtodos no tienen llaves y se terminan con un punto y
coma.
Para utilizar una interfaz, escriba una clase que implementa la interfaz. Cuando una clase
instanciable implementa una interfaz, proporciona un cuerpo de mtodo para cada uno de los
mtodos declarados en la interfaz. Por ejemplo,
public class OperateBMW760i implements OperateCar {

// las firmas del mtodo OperateCar, con la implementacin -// por ejemplo:
int signalTurn(Direction direction, boolean signalOn) {
// cdigo para encender la luz direccional IZQUIERDA del BMW
// cdigo para apagar la luz direccional IZQUIERDA del BMW
// cdigo para encender la luz direccional DERECHA del BMW
// cdigo para apagar la luz direccional DERECHA del BMW
}
// otros miembros, segn sea necesario -por ejemplo, las clases
// auxiliares no visibles a los clientes de la interfaz
}
En el ejemplo del coche robtico anterior, son los fabricantes de automviles quienes
implementarn la interfaz. La Implementacin de un Chevrolet ser sustancialmente diferente a la
de un Toyota, por supuesto, pero ambos fabricantes se adherirn a la misma interfaz. Los
fabricantes del posicionamiento, que son los clientes de la interfaz, basarn sus sistemas que
utilizan datos de GPS en la ubicacin del coche, mapas digitales y datos de trfico para conducir el
coche. Al hacerlo, el sistema de gua invocar los mtodos de interfaz: girar, cambiar de carril,
frenar, acelerar y as sucesivamente.
Interfaces como APIs

El ejemplo del Coche robtico muestra una interfaz que se utiliza como una Interfaz de
programacin de aplicaciones (API) estndar de la industria. Las APIs tambin son comunes en
los productos de software comercial. Por lo general, una empresa vende un paquete de software
que contiene mtodos complejos que otra empresa quiere utilizar en su propio producto de
software. Un ejemplo sera un conjunto de mtodos que se venden a las empresas para hacer
programas de grficos para el usuario final de procesamiento de imgenes digitales. La compaa
de procesamiento de imgenes escribe sus clases para implementar una interfaz, que hace
pblica a sus clientes. La empresa entonces invoca los mtodos con las firmas de
procesamiento de imgenes y devuelve los tipos definidos en la interfaz. Mientras que la API
de la compaa de procesamiento de imgenes se hace pblica (a sus clientes), su
implementacin de la API es mantenida como un secreto muy bien guardado, de hecho, puede
revisar la implementacin en una fecha posterior mientras contina implementando la interfaz
original en la que sus clientes han confiado.
Definir una interfaz

Una declaracin de interfaz consta de modificadores, la palabra clave interface, el nombre
de la interfaz, una lista separada por comas de interfaces padre (si corresponde) y el cuerpo
de la interfaz. Por ejemplo:
public interface GroupedInterface extends Interface1, Interface2,

Interface3 {
// declaraciones de constantes
// base de los logaritmos naturales
double E = 2.718282;
// firmas de mtodos
void doSomething (int i, double x);
int doSomethingElse(String s);
}
El especificador de acceso public indica que la interfaz se puede utilizar por cualquier clase
en cualquier paquete. Si no se especifica que la interfaz es pblica, su interfaz es accesible
slo para las clases definidas en el mismo paquete que la interfaz.
Una interfaz puede extender otras interfaces, as como una subclase de la clase o ampliar
otra clase. Sin embargo, considerando que una clase puede extender slo de otra clase, una
interfaz puede extender cualquier nmero de interfaces. La declaracin de interfaz incluye una
lista separada por comas de todas las interfaces que se extiende.
El cuerpo de la interfaz
El cuerpo de la interfaz puede contener mtodos abstractos, mtodos por defecto y mtodos
estticos. Un mtodo abstracto dentro de una interfaz es seguido por un punto y coma, pero sin
llaves (un mtodo abstracto no contiene una implementacin). Los Mtodos por defecto se definen
con el modificador default y los mtodos estticos con la palabra clave static. Todos los
mtodos abstractos, por defecto y estticos en una interfaz son implcitamente public, entonces
se puede omitir el modificador public.
Adems, una interfaz puede contener declaraciones de constantes. Todos los valores
constantes definidos en una interfaz son implcitamente public, static y final. Una vez
ms, se pueden omitir estos modificadores.
Implementar una interfaz

Para declarar una clase que implementa una interfaz, incluye una clusula implements en la
declaracin de clase. La clase puede implementar ms de una interfaz, as que la palabra clave
implements es seguida por una lista separada por comas de las interfaces implementadas por la
clase. Por Convencin, la clusula implements sigue a la clusula extends, si es que existe.
Una interfaz de muestra, Relatable

Considere una interfaz que define cmo comparar el tamao de los objetos.
public interface Relatable {

// este (objeto llamando isLargerThan)
// y otros deben ser instancias
// de los retornos de clase 1, 0, -1
// si este es mayor que,
// igual a, o menor que otro
public int isLargerThan(Relatable other);
}
Si quieres ser capaz de comparar el tamao de objetos similares, independientemente de lo que
son, la clase que instanca debera implementar Relatable.
Cualquier clase puede implementar Relatable si hay alguna forma de comparar el relativo
"tamao" de los objetos instanciados de la clase. Para strings, podra ser nmero de caracteres;
para libros, podra ser el nmero de pginas; para los estudiantes, puede ser peso; y as
sucesivamente. Para objetos planos geomtricos, el rea sera una buena opcin (vase la clase
RectanglePlus que sigue), mientras que volumen trabajara para objetos geomtricos
tridimensionales. Todas estas clases pueden implementar el mtodo isLargerThan().
Si sabes que una clase implementa Relatable, entonces usted sabe que puede comparar el
tamao de los objetos instanciados desde esa clase.
Implementa la interfaz Relatable

Aqu est la clase Rectangle que fue presentada en la seccin de Crear objetos , reescrita para
implementar Relatable.
public class RectanglePlus

implements Relatable {
public int width = 0;
public int height = 0;
public Point origin;
// cuatro constructores
public RectanglePlus() {
}
public RectanglePlus(Point p) {
origin = p;
}
public RectanglePlus(int w, int h) {
width = w;
height = h;
}
public RectanglePlus(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// a method for moving the rectangle
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// un mtodo para calcular
// el area del rectangulo
}
// un mtodo necesario para implementar
// la interfaz Relatable
public int isLargerThan(Relatable other) {
RectanglePlus otherRect
= (RectanglePlus)other;
if (this.getArea() < otherRect.getArea())
return -1;
else if (this.getArea() > otherRect.getArea())
return 1;
else
return 0;
}
}
Porque RectanglePlus implementa Relatable, se puede comparar el tamao de los dos
objetos RectanglePlus .
Nota: El mtodo isLargerThan, tal como se define en la interfaz de Relatable, toma un objeto
de tipo Relatable. La lnea de cdigo, que se muestra en negrita en el ejemplo anterior, castea o
arroja other a una instancia RectanglePlus. Este tipo de casting indica al compilador qu
objeto realmente es. Invocando getArea directamente en la instancia other
(other.getArea()) fallara la compilacin porque el compilador no entiende que other es
actualmente una instancia de RectanglePlus.
Usando una interfaz como un tipo

Cuando define una nueva interfaz, est definiendo un nuevo tipo de dato de referencia. Puede
utilizar nombres de interfaces en cualquier lugar puede utilizar cualquier otro nombre de tipo de dato.
Si define una variable de referencia cuyo tipo es una interfaz, cualquier objeto que se asigna
debe ser una instancia de una clase que implementa la interfaz.
Como ejemplo, aqu esta un mtodo para encontrar el objeto ms grande en un par de objetos, para
cualquier objeto que es instanciado desde una clase que implementa Relatable:
public Object findLargest(Object object1, Object object2) {

Relatable obj1 = (Relatable)object1;
if ((obj1).isLargerThan(obj2) > 0)
return object1;
else
return object2;
}
Por casting del object1 a un tipo Relatable, puede invocar al mtodo isLargerThan.
Si haces un punto de la implementacin de Relatable en una amplia variedad de clases, los
objetos instanciados desde cualquiera de esas clases pueden ser comparados con el mtodo
findLargest() siempre que ambos objetos sean de la misma clase. Asimismo, pueden todos
ser comparados con los siguientes mtodos:
public Object findSmallest(Object object1, Object object2) {

if ((obj1).isLargerThan(obj2) < 0)
return object1;
else
return object2;
}
public boolean isEqual(Object object1, Object object2) {
if ( (obj1).isLargerThan(obj2) == 0)
return true;
else
return false;
}
Estos mtodos funcionan para cualquier objeto "relatable", no importa cul sea su herencia de
clases. Cuando implementan Relatable, pueden ser de su propio tipo de clase (o superclase) y
un tipo de Relatable. Esto les da la algunas de las ventajas de herencia mltiple, donde
pueden tener comportamiento desde una interfaz y una superclase.
Evolucin de las Interfaces

Considere una interfaz que has desarrollado llamada DoIt:
public interface DoIt {

void doSomething(int i, double x);
}
Supongamos que, en un momento posterior, desea agregar un tercer mtodo para DoIt, para que
la interfaz se convierta en:

boolean didItWork(int i, double x, String s);
}
Si se realiza este cambio, todas las clases que implementan la interfaz vieja DoIt rompern porque
ya no implementan la interfaz antigua. Los programadores confiando en esta interfaz protestarn en
voz alta.
Trate de anticipar todas las aplicaciones para su interface y definirla completamente desde el
principio. Si desea agregar mtodos adicionales en una interfaz, usted tiene varias opciones. Se
puede crear una interfaz DoItPlus que se extiende de DoIt:
public interface DoItPlus extends DoIt {

boolean didItWork(int i, double x, String s);
}
Ahora los usuarios de su cdigo pueden optar por seguir utilizando la interfaz vieja o para
actualizar a la nueva interfaz.
Alternativamente, usted puede definir sus nuevos mtodos como mtodos por defecto. El ejemplo
siguiente define un mtodo por defecto denominado didItWork:

default boolean didItWork(int i, double x, String s) {
// Method body
}
}
Tenga en cuenta que usted debe proporcionar una implementacin de mtodos por defecto.
Tambin puede definir nuevos mtodos estticos para interfaces existentes. Los usuarios que tienen
las clases que implementan las interfaces mejoradas con nuevo valor por defecto o mtodos
estticos no tienen que modificarlos o recompilarlos para acomodar los mtodos adicionales.
Mtodos por defecto
La seccin Interfaces describe un ejemplo que involucra a fabricantes de coches controlados por
computadora que publican las interfaces estndar de la industria que describen los mtodos que
pueden invocarse para operar sus coches. Qu pasa si los fabricantes de coches controlados por
computadora aaden nuevas funciones, tales como vuelo, a sus coches? Estos fabricantes tendran
que especificar nuevos mtodos para permitir que otras empresas (como los fabricantes de
instrumentos de posicionamiento electrnico) adapten su software para autos voladores. Dnde
declararan estos fabricantes de automviles estos nuevos mtodos relacionados con los vuelos? Si
los aaden a sus interfaces originales, los programadores que han implementado las interfaces
tendran que reescribir sus implementaciones. Si los aaden como mtodos estticos, entonces los
programadores los consideraran como mtodos de utilidad, no como esenciales, como mtodos
bsicos.
Los Mtodos por defecto permiten aadir nuevas funciones a las interfaces de sus
bibliotecas y asegurar la compatibilidad binaria con cdigo escrito para las versiones ms
antiguas de las interfaces.
Considere la siguiente interfaz, TimeClient, como se describe en respuestas a las preguntas y
ejercicios: Interfaces:
import java.time.*;
public interface TimeClient {
void setTime(int hour, int minute, int second);
void setDate(int day, int month, int year);
void setDateAndTime(int day, int month, int year,
int hour, int minute, int second);
LocalDateTime getLocalDateTime();
}
La clase siguiente, SimpleTimeClient, implementa TimeClient:
package defaultmethods;
import java.time.*;
import java.lang.*;
import java.util.*;
public class SimpleTimeClient implements TimeClient {
private LocalDateTime dateAndTime;
public SimpleTimeClient() {
dateAndTime = LocalDateTime.now();
}
public void setTime(int hour, int minute, int second) {
LocalDate currentDate = LocalDate.from(dateAndTime);
LocalTime timeToSet = LocalTime.of(hour, minute, second);
dateAndTime = LocalDateTime.of(currentDate, timeToSet);
}
public void setDate(int day, int month, int year) {
LocalDate dateToSet = LocalDate.of(day, month, year);
LocalTime currentTime = LocalTime.from(dateAndTime);
dateAndTime = LocalDateTime.of(dateToSet, currentTime);
}
public void setDateAndTime(int day, int month, int year,
int hour, int minute, int second) {
LocalDate dateToSet = LocalDate.of(day, month, year);

LocalTime timeToSet = LocalTime.of(hour, minute, second);
dateAndTime = LocalDateTime.of(dateToSet, timeToSet);
}
public LocalDateTime getLocalDateTime() {
return dateAndTime;
}
public String toString() {
return dateAndTime.toString();
}
TimeClient myTimeClient = new SimpleTimeClient();
System.out.println(myTimeClient.toString());
}
}
Suponga que desea aadir nuevas funciones a la interfaz TimeClient, como la capacidad de
especificar una zona horaria a travs de un objeto ZonedDateTime (que es como un objeto
LocalDateTime excepto que almacena informacin de zona horaria):

ZonedDateTime getZonedDateTime(String zoneString);
}
A raz de esta modificacin a la interfaz TimeClient , tambin tendras que modificar la clase
SimpleTimeClient e implementar el mtodo getZonedDateTime. Sin embargo, en lugar de
dejar getZonedDateTime como abstract (como en el ejemplo anterior), en su lugar se puede
definir una implementacin por defecto. (Recuerde que un mtodo abstracto es un mtodo
declarado sin una implementacin).
import java.time.*;
static ZoneId getZoneId (String zoneString) {
try {
return ZoneId.of(zoneString);
} catch (DateTimeException e) {
System.err.println("Invalid time zone: " + zoneString +
"; using default time zone instead.");
return ZoneId.systemDefault();
}
}
default ZonedDateTime getZonedDateTime(String zoneString) {

return ZonedDateTime.of(getLocalDateTime(),
getZoneId(zoneString));
}
}
Especifica que una definicin de mtodo en una interfaz es un mtodo por defecto con la
palabra clave default al principio de la firma del mtodo. Todas las declaraciones de mtodo
en una interfaz, incluyendo mtodos por defecto, implcitamente son public, puede omitir el
modificador public .
Con esta interfaz, usted no tiene que modificar la clase SimpleTimeClient, y esta clase (y
cualquier clase que implemente la interfaz TimeClient), tendr el mtodo getZonedDateTime
ya definido. El ejemplo siguiente, TestSimpleTimeClient, invoca al mtodo
getZonedDateTime desde una instancia de SimpleTimeClient:
import java.time.*;
import java.lang.*;
import java.util.*;
public class TestSimpleTimeClient {
TimeClient myTimeClient = new SimpleTimeClient();
System.out.println("Current time: " +
myTimeClient.toString());
System.out.println("Time in California: " +
myTimeClient.getZonedDateTime("Blah blah").toString());
}
}
Extender Interfaces que contienen mtodos por defecto

Cuando se extiende una interfaz que contiene un mtodo por defecto, puede hacer lo
siguiente:
No mencione en absoluto el mtodo por defecto, deje que su interfaz extendida herede
el mtodo por defecto.
Vuelva a declarar el mtodo por defecto, que lo convierte en abstract.
Redefina el mtodo por defecto, que lo reemplaza.
Supongamos que se extiende la interfaz TimeClient como sigue:
public interface AnotherTimeClient extends TimeClient { }

Cualquier clase que implemente la interfaz AnotherTimeClient tendr la aplicacin especificada
por el mtodo por defecto TimeClient.getZonedDateTime.
public interface AbstractZoneTimeClient extends TimeClient {

public ZonedDateTime getZonedDateTime(String zoneString);
}
Cualquier clase que implemente la interfaz AbstractZoneTimeClient tendr que implementar

el mtodo getZonedDateTime; Este mtodo es un mtodo abstract como todos los dems
que no son mtodos por defecto (y no estticos) en una interfaz.
public interface HandleInvalidTimeZoneClient extends TimeClient {

default public ZonedDateTime getZonedDateTime(String zoneString) {
try {
return
ZonedDateTime.of(getLocalDateTime(),ZoneId.of(zoneString));
System.err.println("Invalid zone ID: " + zoneString +
"; using the default time zone instead.");
return
ZonedDateTime.of(getLocalDateTime(),ZoneId.systemDefault());
}
}
}
Cualquier clase que implemente la interfaz HandleInvalidTimeZoneClient utilizar la
implementacin de getZonedDateTime especificado por esta interfaz en lugar del especificado
por la interfaz TimeClient.
Mtodos estticos
Adems de los mtodos por defecto, se pueden definir mtodos estticos en las interfaces. (Un
mtodo esttico es un mtodo que se asocia con la clase en la que se define en lugar de con
cualquier objeto. Cada instancia de la clase comparte sus mtodos estticos). Esto hace ms
fcil para que usted pueda organizar mtodos auxiliares en sus bibliotecas; Puedes quedarte con
mtodos estticos especficos en una interfaz en la misma interfaz en lugar de una clase
aparte. El ejemplo siguiente define un mtodo esttico que recupera un objeto ZoneId
correspondiente a un identificador de zona horaria; utiliza la zona horaria del sistema por defecto si
no hay ningn objeto ZoneId correspondiente al identificador determinado. (Como resultado, puede
simplificar el mtodo getZonedDateTime):

// ...
static public ZoneId getZoneId (String zoneString) {
try {
return ZoneId.of(zoneString);
System.err.println("Invalid time zone: " + zoneString +
"; using default time zone instead.");
return ZoneId.systemDefault();
}
}
default public ZonedDateTime getZonedDateTime(String zoneString) {
return ZonedDateTime.of(getLocalDateTime(),
getZoneId(zoneString));
}
}
Como los mtodos estticos en clases, se especifica que una definicin de mtodo en una
interfaz es un mtodo esttico con la palabra clave static al principio de la firma del
mtodo. Todas las declaraciones de mtodo en una interfaz, incluyendo mtodos estticos,
implcitamente son public, puede omitir el modificador public.
Integracin de mtodos por defecto en bibliotecas existentes

Los Mtodos por defecto permiten aadir nuevas funciones a las interfaces existentes y
asegurar la compatibilidad binaria con cdigo escrito para las versiones ms antiguas de las
interfaces. En particular, mtodos predeterminados permiten agregar mtodos que aceptan
expresiones lambda como parmetros para interfaces existentes. Esta seccin muestra cmo ha
mejorado la interfaz Comparator con por defecto y mtodos estticos.
Considere las clases de Card y la Deck que se describe en preguntas y ejercicios: clases. En este
ejemplo reescribe las clases Card y Deck como interfaces. La interfaz de la Card contiene dos
tipos de enum (Suit y Rank) y dos mtodos abstractos (getSuit y getRank):
public interface Card extends Comparable<Card> {
public enum Suit
DIAMONDS (1,
CLUBS
(2,
HEARTS
(3,
SPADES
(4,
{
"Diamonds"),
"Clubs"
),
"Hearts" ),
"Spades" );
private final int value;

private final String text;
Suit(int value, String text) {
this.value = value;
this.text = text;
}
public int value() {return value;}
public String text() {return text;}
}
public enum Rank {
DEUCE (2 , "Two" ),
THREE (3 , "Three"),
FOUR
(4 , "Four" ),
FIVE
(5 , "Five" ),
SIX
(6 , "Six" ),
SEVEN (7 , "Seven"),
EIGHT (8 , "Eight"),
NINE
(9 , "Nine" ),
TEN
(10, "Ten" ),
JACK
(11, "Jack" ),
QUEEN (12, "Queen"),
KING
(13, "King" ),
ACE
(14, "Ace" );
private final int value;
private final String text;
Rank(int value, String text) {
this.value = value;
this.text = text;
}
public int value() {return value;}
public String text() {return text;}
}
public Card.Suit getSuit();
public Card.Rank getRank();
}
La interfaz de Deck contiene varios mtodos que manipulan las cartas de una baraja:
import java.util.*;
import java.util.stream.*;
import java.lang.*;
public interface Deck {
List<Card> getCards();
Deck deckFactory();
int size();
void addCard(Card card);
void addCards(List<Card> cards);
void addDeck(Deck deck);
void shuffle();
void sort();
void sort(Comparator<Card> c);
String deckToString();
Map<Integer, Deck> deal(int players, int numberOfCards)
throws IllegalArgumentException;
}
La clase PlayingCard implementa la interfaz de Card, y la clase StandardDeck implementa la
interfaz Deck.
La clase StandardDeck implementa el mtodo abstracto Deck.sort como sigue:
public class StandardDeck implements Deck {

private List<Card> entireDeck;
// ...
public void sort() {
Collections.sort(entireDeck);
}
// ...
}
El mtodo Collections.sort ordena una instancia de List cuyo tipo de elemento implementa
la interfaz Comparable. El miembro entireDeck es una instancia de List cuyos elementos son
del tipo de Card, que se extiende a Comparable. La clase PlayingCard implementa el mtodo
Comparable.compareTo de la siguiente manera:
public int hashCode() {

return ((suit.value()-1)*13)+rank.value();
}
public int compareTo(Card o) {
return this.hashCode() - o.hashCode();
}
El mtodo compareTo hace que el mtodo StandardDeck.sort() ordene primero la baraja de

cartas por pallo y luego por la rango.
Qu pasa si desea ordenar la baraja primero que el rango, luego por palo? Necesitara
implementar la interfaz Comparator para especificar nuevos criterios de clasificacin y utilice el
mtodo sort(List<T> list, Comparator<? super T> c) (la versin del mtodo de
sort que incluye un parmetro de Comparator ). Puede definir el siguiente mtodo en la clase
StandardDeck:
public void sort(Comparator<Card> c) {

Collections.sort(entireDeck, c);
}
Con este mtodo, se puede especificar cmo el mtodo Collections.sort ordena a instancias
de la clase de Card . Una manera de hacer esto es implementar la interfaz Comparator para
especificar cmo desea las tarjetas ordenadas. El ejemplo SortByRankThenSuit hace esto:
import java.util.*;
import java.util.stream.*;
import java.lang.*;
public class SortByRankThenSuit implements Comparator<Card> {
public int compare(Card firstCard, Card secondCard) {
int compVal =
firstCard.getRank().value() secondCard.getRank().value();
if (compVal != 0)
return compVal;
else
return firstCard.getSuit().value() secondCard.getSuit().value();
}
}
La siguiente invocacin ordena la baraja de cartas primero por su rango, luego por traje:
StandardDeck myDeck = new StandardDeck();

myDeck.shuffle();
myDeck.sort(new SortByRankThenSuit());
Sin embargo, este enfoque es muy detallado; sera mejor si puede especificar qu que desea
ordenar, no Cmo desea ordenarlo. Supongamos que usted es el desarrollador quien escribi la
interfaz Comparator. Qu defecto o mtodos estticos podra aadir a la interfaz de
Comparator para permitir a que otros desarrolladores ms fcilmente especifican criterios de
ordenacin?
Para empezar, supongamos que desea ordenar la baraja de cartas por rango, independientemente
del palo. Usted puede invocar el mtodo StandardDeck.sort de la siguiente manera:

myDeck.shuffle();
myDeck.sort(
(firstCard, secondCard) ->
firstCard.getRank().value() - secondCard.getRank().value()
);
Porque la interfaz Comparator es una interfaz funcional, puede utilizar una expresin lambda
como argumento para el mtodo de sort. En este ejemplo, la expresin lambda compara dos
valores enteros.
Sera ms simple para sus desarrolladores si podan crear una instancia de Comparator
invocando el mtodo Card.getRank slo. En particular, sera til si sus desarrolladores podran
crear una instancia de Comparator que compara a cualquier objeto que puede devolver un valor
numrico de un mtodo getValue como hashCode. Ha mejorado la interfaz Comparator con
esta capacidad con el mtodo esttico comparing :
myDeck.sort(Comparator.comparing((card) -> card.getRank()));

En este ejemplo, puede utilizar una Referencia de mtodo en su lugar:
myDeck.sort(Comparator.comparing(Card::getRank));
Esta invocacin mejor demuestra que para ordenar en lugar de Cmo hacerlo.
Se ha mejorado la interfaz Comparator con otras versiones del mtodo esttico comparing tales
como comparingDouble y comparingLong que permiten crear instancias Comparator que
comparar otros tipos de datos.
Supongamos que sus desarrolladores le gustara crear una instancia de Comparator que podra
comparar objetos con ms de uno de los criterios. Por ejemplo, cmo sera que ordenar la baraja
de cartas primero por fila y luego por traje? Como antes, se puede utilizar una expresin lambda
para especificar los criterios de ordenacin:

myDeck.shuffle();
myDeck.sort(
(firstCard, secondCard) -> {
int compare =
firstCard.getRank().value() secondCard.getRank().value();
if (compare != 0)
return compare;
else
return firstCard.getSuit().value() secondCard.getSuit().value();
}
);
Sera ms simple para sus desarrolladores si pudieran construir una instancia de Comparator de
una serie de instancias de Comparator. Se ha mejorado la interfaz Comparator con esta
capacidad con el mtodo por defecto del thenComparing:
myDeck.sort(
Comparator
.comparing(Card::getRank)
.thenComparing(Comparator.comparing(Card::getSuit)));
Se ha mejorado la interfaz Comparator con otras versiones del del mtodo por defecto
thenComparing (como thenComparingDouble y thenComparingLong) que permiten
construir instancias Comparator que comparar otros tipos de datos.
Supongamos que sus desarrolladores le gustara crear una instancia de Comparator que permite
ordenar una coleccin de objetos en orden inverso. Por ejemplo, cmo sera que ordenar la baraja
de cartas primero por orden descendente de rango, desde el as hasta dos (en lugar de entre dos y
As)? Como antes, puede especificar otra expresin lambda. Sin embargo, sera ms sencillo para
los desarrolladores podran revertir un Comparator de existente mediante la invocacin de un
mtodo. Se ha mejorado la interfaz Comparator con esta capacidad con el mtodo de
predeterminado reversed :
myDeck.sort(
Comparator.comparing(Card::getRank)
.reversed()
.thenComparing(Comparator.comparing(Card::getSuit)));
Este ejemplo muestra cmo se ha mejorado la interfaz Comparator con mtodos
predeterminados, mtodos estticos, expresiones lambda, y mtodo referencias para crear mtodos
ms expresivos de la biblioteca cuyos programadores de funcionalidad pueden deducir rpidamente
mirando cmo ellos son invocados. Utilice estas construcciones para mejorar las interfaces en las
bibliotecas.
Resumen de Interfaces
Una declaracin de interfaz puede contener firmas de mtodos, mtodos por defecto, mtodos
estticos y definiciones de constantes. Los nicos mtodos que tienen implementaciones son por
defecto y mtodos estticos.
Una clase que implementa una interfaz debe implementar todos los mtodos declarados en la
interfaz.
El Nombre de una interfaz puede ser usado en cualquier lugar que se pueda usar un tipo.
Preguntas y ejercicios: Interfaces

Preguntas
1.
Qu pasa con la siguiente interfaz?
public interface SomethingIsWrong {

void aMethod(int aValue){
System.out.println("Hi Mom");
}
}
2.
3.
Arreglar la interfaz en la pregunta 2.

Es vlida la siguiente interfaz?
public interface Marker {

}
Ejercicios
1.
Supongamos que usted ha escrito un servidor de hora que notifica peridicamente a sus
clientes la fecha y hora actual. Escriba una interfaz que podra utilizar el servidor para
cumplir un protocolo concreto con sus clientes.
Herencia
En las lecciones anteriores, usted ha visto herencia mencionado varias veces. En el lenguaje Java,
las clases pueden ser derivadas de otras clases, as heredar Campos y mtodos de las
clases.
Definiciones: Una clase que se deriva de otra clase se llama una subclase (tambin una clase
derivada, clase extendida o clase de nio). La clase de la cual se deriva la subclase se llama una
superclase (tambin una clase base o una clase padre).
Con la excepcin de Object, el cual no tiene ninguna superclase, cada clase tiene slo una
superclase directa (herencia simple). En ausencia de cualquier otro superclase explcita, cada clase
implcitamente es una subclase de Object.
Las clases se pueden derivar de las clases que se derivan de las clases que se derivan las clases y
as sucesivamente y deriva en ltima instancia de la clase superior, Object. Esa clase se dice que
desciende de todas las clases en la cadena de herencia que se remontan a Objeto.
La idea de la herencia es simple pero poderosa: cuando desea crear una nueva clase y ya hay una
clase que incluye parte del cdigo que usted quiere, puede derivar su nueva clase de la clase
existente. Al hacer esto, usted puede reutilizar los campos y mtodos de la clase existente sin tener
que escribir (y depurar) los mismos.
Una subclase hereda todos los miembros (campos, mtodos y clases anidadas) de su superclase.
Los constructores no son miembros, as que ellos no se heredan de las subclases, pero puede
invocar el constructor de la superclase desde la subclase.
La jerarqua de clases de la plataforma Java

La clase de Object, definida en el paquete java.lang, define e implementa el
comportamiento comn a todas las clases incluyendo las que escribes. En la plataforma Java,
muchas clases se derivan directamente de Object, otras clases se derivan de algunas de esas
clases y as sucesivamente, formando una jerarqua de clases.
Todas las clases en la plataforma Java son descendientes de Object

En la parte superior de la jerarqua, el Object es la ms general de todas las clases. Las clases
cerca de la parte inferior de la jerarqua proporcionan un comportamiento ms especializado.
Un ejemplo de herencia
Aqu est el cdigo de ejemplo para una posible implementacin de una clase de Bicycle que se
present en la leccin de clases y objetos:

// the
public
public
public
Bicycle class has three fields

int cadence;
int gear;
int speed;
// the Bicycle class has one constructor

gear = startGear;
speed = startSpeed;
}
// the Bicycle class has four methods
cadence = newValue;
}
gear = newValue;
}
speed -= decrement;
}
speed += increment;
}
}
Una declaracin de clase para una clase MountainBike que es una subclase de la Bicycle
podra verse as:

// la subclase MountainBike aade un campo
public int seatHeight;
// la subclase MountainBike tiene un constructor
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
}
// la subclase MountainBike aade un mtodo
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
MountainBike hereda todos los campos y mtodos de Bicycle y agrega el campo

seatHeight y un mtodo para establecerlo. Excepto por el constructor, es como si hubieras
escrito una nueva clase de MountainBike completamente desde cero, con campos de cuatro y
cinco mtodos. Sin embargo, no tenas que hacer todo el trabajo. Esto sera especialmente til si los
mtodos de la clase Bicycle fueran complejos y hubieran tomado tiempo considerable para
depurarse.
Lo que se puede hacer en una subclase

Una subclase hereda todos los miembros public y protected de su padre, no importa qu
paquete es la subclase. Si la subclase est en el mismo paquete como su padre, tambin hereda a
los miembros del paquete-privado de los padres. Usted puede utilizar a los miembros heredados
como estn, reemplazarlos, ocultarlos o complementarlos con nuevos miembros:
Los campos heredados pueden utilizarse directamente, al igual que cualquier otro
campo.
Puede declarar un campo en la subclase con el mismo nombre como el de la
superclase, as ocultandolo (no recomendado).
Se pueden declarar nuevos campos en la subclase que no estn en la superclase.
Los mtodos heredados pueden ser utilizados directamente como son.
Puede escribir un nuevo mtodo de instancia de la subclase que tiene la misma firma como
el de la superclase, as reemplazar todo.
Puede escribir un nuevo mtodo esttico en la subclase que tiene la misma firma
como el de la superclase, as sobreescribiendolo.
Se pueden declarar nuevos mtodos en la subclase que no estn en la superclase.
Puedes escribir un constructor de la subclase que invoca al constructor de la
superclase, implcita o mediante el uso de la palabra clave super.
Las secciones siguientes en esta leccin se expandirn sobre estos temas.
Miembros privados en una superclase

Una subclase no hereda los miembros privados de su clase padre. Sin embargo, si la
superclase tiene mtodos pblicos o protegidos para acceder a sus campos privados, stos tambin
pueden ser utilizados por la subclase.
Una clase anidada tiene acceso a todos los miembros privados de su clase envolvente
ambos mtodos y campos. Por lo tanto, una clase anidada pblica o protegida heredada por una
subclase tiene acceso indirecto a todos los miembros privados de la superclase.
Casting de Objetos
Hemos visto que un objeto es del tipo de datos de la clase de la cual se ha instanciado. Por
ejemplo, si escribimos:
public MountainBike myBike = new MountainBike();

Entonces myBike es de tipo MountainBike.
MountainBike es descendiente de Bicycle y de Object. Por lo tanto, una MountainBike es

un Bicycle y es tambin un Object, y puede ser utilizado dondequiera que se llame a objetos
Bicycle u Object.
La inversa no es necesariamente cierta: una Bicycle puede ser una MountainBike, pero no lo
es necesariamente. Del mismo modo, un Object puede ser una Bicycle o una MountainBike,
pero no necesariamente.
El Casting muestra el uso de un objeto de un tipo en lugar de otro tipo, entre los objetos
permitidos por la herencia y las implementaciones. Por ejemplo, si escribimos:
Object obj = new MountainBike();

obj es tanto un Object como un MountainBike (hasta el momento en que obj es asignado a
otro objeto que no es un MountainBike). Esto se llama casting implcito.
Si, por el contrario, escribimos
MountainBike myBike = obj;

tendramos un error de compilacin porque obj no es conocido por el compilador para ser un
MountainBike. Sin embargo, podemos decirle al compilador que prometemos asignarle un
MountainBike para obj por casting explcito:
MountainBike myBike = (MountainBike)obj;

Este cast inserta una comprobacin en tiempo de ejecucin de que obj es asignado a
MountainBike para que el compilador pueda asumir con seguridad que obj es un
MountainBike. Si obj no es un MountainBike en tiempo de ejecucin, se lanza una
excepcin.
Nota: Puedes hacer una prueba lgica en cuanto al tipo de un objeto determinado utilizando el
operador instanceof. Esto puede ahorrar un error en tiempo de ejecucin debido a un cast
inadecuado. Por ejemplo:
if (obj instanceof MountainBike) {

MountainBike myBike = (MountainBike)obj;
}
Aqu el operador instanceof verifica que obj se refiere a un MountainBike para que podamos
hacer el cast con el conocimiento de que no habr lanzamiento de excepcin en tiempo de
ejecucin.
Herencia mltiple de estado, la implementacin y el tipo

Una diferencia significativa entre las clases e interfaces es que las clases pueden tener
campos mientras que las interfaces no pueden. Adems, usted puede crear instancias de una
clase para crear un objeto, lo que no puedes hacer en las interfaces. Como se explica en la seccin
qu es un objeto?, un objeto almacena su estado en los campos, que se definen en las clases.
Una de las razones de por qu el lenguaje de programacin Java no permite extender ms de
una clase es evitar los problemas de la herencia mltiple de estado, que es la capacidad para
heredar campos de varias clases. Por ejemplo, supongamos que usted es capaz de definir una
nueva clase que se extiende de varias clases. Cuando se crea un objeto instanciando la clase, ese
objeto heredar campos de todas las superclases de la clase. Qu pasa si los mtodos o
constructores de superclases diferentes son instanciados del mismo campo? Qu mtodo o
constructor tendr prioridad? Debido a que las interfaces no contienen campos, usted no
tiene que preocuparse acerca de los problemas que se derivan de la herencia mltiple de
estado.
La implementacin de herencia mltiple es la capacidad de heredar las definiciones de
mtodos desde mltiples clases. Los problemas que surgen con este tipo de herencia mltiple,
son tales como conflictos de nombres y ambigedad. Cuando los compiladores de lenguajes que
admiten este tipo de herencia mltiple de programacin encuentran superclases que contienen
mtodos con el mismo nombre, a veces no pueden determinar el miembro o mtodo para
acceder o invocar. Adems, un programador puede introducir involuntariamente un conflicto de
nombres mediante la adicin de un nuevo mtodo de una superclase. Los mtodos por defecto
introducen una forma de implementacin de herencia mltiple. Una clase puede implementar ms
de una interfaz, que puede contener mtodos por defecto que tengan el mismo nombre. El
compilador de Java proporciona algunas reglas para determinar qu mtodo predeterminado utiliza
una clase en particular.
El lenguaje de programacin Java soporta herencia mltiple de tipo, que es la capacidad de una
clase para implementar ms de una interfaz. Un objeto puede tener varios tipos: el tipo de su
propia clase y los tipos de todas las interfaces que implementa la clase. Esto significa que si
una variable se declara como el tipo de una interfaz, entonces su valor puede hacer referencia a
cualquier objeto que es instanciado desde cualquier clase que implemente la interfaz. Esto se
discute en la seccin utilizando una interfaz como un tipo.
Como con la implementacin de la herencia mltiple, una clase puede heredar diferentes
implementaciones de un mtodo definido (como por defecto o esttico) en las interfaces que
extiende. En este caso, el compilador o el usuario deben decidir cul usar.
Sobreescribir y ocultar mtodos

Mtodos de instancia
Un mtodo de instancia de una subclase con la misma firma (nombre, ms el nmero y el tipo de
sus parmetros) y el tipo de retorno como un mtodo de instancia en la superclase sobreescribe el
mtodo de la superclase.
La capacidad de una subclase de sobreescribir un mtodo permite que una clase herede de una
superclase cuyo comportamiento es "lo suficientemente cerca" y luego modifique el comportamiento
segn sea necesario. El mtodo sobreescrito tiene el mismo nombre, nmero y tipo de parmetros y
tipo de valor devuelto como el mtodo que lo sobreescribe. Un mtodo sobreescrito tambin puede
devolver un subtipo del tipo devuelto por el mtodo que lo sobreescribe. Este subtipo se llama un
tipo de retorno covariante.
Cuando se sobreescribe un mtodo, tal vez quieras usar la anotacin @Override que indica al
compilador que pretende sobreescribir un mtodo en la superclase. Si por alguna razn, el
compilador detecta que el mtodo no existe en una de las superclases, entonces se generar un
error. Para obtener ms informacin sobre @Override, vea Annotations.
Mtodos estticos
Si una subclase define un mtodo esttico con la misma firma que un mtodo esttico en la
superclase, entonces el mtodo de la subclase oculta la de la superclase.
La distincin entre ocultar un mtodo esttico y reemplazar o socreescribir un mtodo de instancia
tiene implicaciones importantes:
La versin del mtodo de instancia overridden que se invoca es el de la subclase.

La versin del mtodo esttico hidden que se invoca depende de si se invoca de la
superclase o la subclase.
Examinemos un ejemplo que contiene dos clases. El primero es el Animal, que contiene un
mtodo de instancia y un mtodo esttico:
public class Animal {

public static void testClassMethod() {
System.out.println("The static method in Animal");
}
public void testInstanceMethod() {
System.out.println("The instance method in Animal");
}
}
La segunda clase, una subclase de Animal, se llama Cat:
public class Cat extends Animal {

public static void testClassMethod() {
System.out.println("The static method in Cat");
}
public void testInstanceMethod() {
System.out.println("The instance method in Cat");
}
Cat myCat = new Cat();
Animal myAnimal = myCat;
Animal.testClassMethod();
myAnimal.testInstanceMethod();
}
}
La clase Cat reemplaza el mtodo de instancia en Animal y esconde el mtodo esttico en
Animal. El mtodo main en esta clase crea una instancia de Cat e invoca
testClassMethod() en la clase y testInstanceMethod() en la instancia.
La salida de este programa es como sigue:
The static method in Animal

The instance method in Cat
Como se prometi, la versin del mtodo esttico oculto que se invoca es el de la superclase,
y la versin del mtodo de instancia overridden que se invoca es el de la subclase.
Mtodos de interfaz
Los mtodos por defecto y los mtodos abstractos en interfaces son heredados como mtodos de
instancia. Sin embargo, cuando los supertipos de una clase o interfaz proporcionan varios mtodos
por defecto con la misma firma, el compilador de Java sigue las reglas de herencia para resolver el
conflicto de nombres. Estas reglas son conducidas por los siguientes dos principios:
Los mtodos de instancia son preferidos sobre los mtodos de interfaz por defecto.
Considere las siguientes clases e interfaces:
public class Horse {
public String identifyMyself() {
return "I am a horse.";
}
}
public interface Flyer {
default public String identifyMyself() {
return "I am able to fly.";
}
}
public interface Mythical {
return "I am a mythical creature.";
}
}
public class Pegasus extends Horse implements Flyer, Mythical {
Pegasus myApp = new Pegasus();
System.out.println(myApp.identifyMyself());
}
}
El mtodo Pegasus.identifyMyself devuelve la cadena I am a horse.
Los mtodos que ya estn sobreescritos por otros candidatos son ignorados. Esta
circunstancia puede surgir cuando los supertipos comparten un ancestro comn.
Considere las siguientes interfaces y clases:
public interface Animal {
return "I am an animal.";
}
}
public interface EggLayer extends Animal {
return "I am able to lay eggs.";
}
}
public interface FireBreather extends Animal { }
public class Dragon implements EggLayer, FireBreather {
public static void main (String... args) {
Dragon myApp = new Dragon();
}
}
El mtodo Dragon.identifyMyself devuelve la cadena I am able to lay
eggs.
Si dos o ms conflictos de mtodos independientemente definidos por defecto, o un mtodo por
defecto entran en conflicto con un mtodo abstracto, entonces el compilador de Java produce un
error del compilador. Explcitamente debe sobreescribir los mtodos del supertipo.
Considere el ejemplo de coches controlados por computadora que ahora pueden volar. Tiene dos
interfaces (OperateCar y FlyCar) que proporciona implementaciones por defecto para el mismo
mtodo, (startEngine):
public interface OperateCar {
// ...
default public int startEngine(EncryptedKey key) {
// Implementation
}
}
public interface FlyCar {
// ...
default public int startEngine(EncryptedKey key) {
// Implementation
}
}
Una clase que implementa tanto OperateCar como FlyCar debe reemplazar el mtodo
startEngine. Se podra invocar cualquiera de las implementaciones por defecto con la palabra
clave super.
public class FlyingCar implements OperateCar, FlyCar {
// ...
public int startEngine(EncryptedKey key) {
FlyCar.super.startEngine(key);
OperateCar.super.startEngine(key);
}
}
El nombre anterior super (en este ejemplo, FlyCar u OperateCar) debe hacer referencia a una
superinterface directa que define o hereda un valor por defecto para el mtodo invocado. Esta forma
de invocacin de mtodo no se limita a diferenciar entre mltiples interfaces implementadas que
contienen mtodos por defecto con la misma firma. Puede utilizar la palabra clave super para
invocar un mtodo por defecto en ambas, clases e interfaces.
Los mtodos de instancia heredados de las clases pueden sobreescribir mtodos de interfaz
abstracta. Considere las siguientes interfaces y clases:
public interface Mammal {

String identifyMyself();
}
public class Horse {
public String identifyMyself() {
return "I am a horse.";
}
}
public class Mustang extends Horse implements Mammal {
Mustang myApp = new Mustang();
}
}
El mtodo Mustang.identifyMyself devuelve la cadena I am a horse. La clase
Mustang hereda el mtodo identifyMyself de la clase de Horse, que reemplaza el mtodo
abstracto del mismo nombre en la interfaz de Mammal.
Nota: nunca se heredan mtodos estticos en interfaces.
Modificadores
El especificador de acceso para un mtodo sobreescrito puede permitir ms, pero no menos,
acceso que el mtodo sobreescrito. Por ejemplo, un mtodo de instancia protegido en la
superclase puede hacerse pblico, pero no privado, en la subclase.
Obtendr un error de compilacin si se intenta cambiar un mtodo de instancia en la superclase a un
mtodo esttico en la subclase y viceversa.
Resumen
La siguiente tabla resume lo que sucede cuando se define un mtodo con la misma firma como un
mtodo en una superclase.
Definir un mtodo con la misma firma como mtodo de una superclase
Mtodo de instancia de la
superclase
Mtodo de instancia de la
subclase
Mtodo esttico de la
subclase
Mtodo esttico de la
superclase
Sobreescribir
Genera un error en tiempo de

compilacin
Genera un error en tiempo de

compilacin
Ocultar
Nota: En una subclase, se pueden sobrecargar los mtodos heredados de la superclase. Tales
mtodos sobrecargados ni ocultan ni sobreescriben los mtodos de instancia de la superclase
son nuevos mtodos, nicos de la subclase.
Polimorfismo
La definicin del diccionario de polimorfismo se refiere a un principio de biologa en el cual un
organismo o especie puede tener muchas formas diferentes o etapas. Este principio puede aplicarse
tambin a la programacin orientada a objetos y lenguajes como el lenguaje Java. Las subclases
de una clase pueden definir sus propios comportamientos nicos y an compartir la misma
funcionalidad de la clase padre.
Polimorfismo puede demostrarse con una pequea modificacin a la clase de Bicycle. Por
ejemplo, podra aadirse un mtodo printDescription a la clase que muestra todos los datos
almacenados actualmente en una instancia.
public void printDescription(){

System.out.println("\nBike is " + "in gear " + this.gear
+ " with a cadence of " + this.cadence +
" and travelling at a speed of " + this.speed + ". ");
}
Para demostrar las caractersticas polimrficas en el lenguaje Java, se extiende la clase Bicycle
con una MountainBike y una clase RoadBike. Para MountainBike, se agrega un campo para
la suspension, que es un valor String que indica si la moto tiene un amortiguador delantero,
Front. O, la moto tiene un amortiguador delantero y trasero, Dual.
Aqu est la clase actualizada:

private String suspension;
public MountainBike(
int startCadence,
int startSpeed,
int startGear,
String suspensionType){
super(startCadence,
startSpeed,
startGear);
this.setSuspension(suspensionType);
}
public String getSuspension(){
return this.suspension;
}
public void setSuspension(String suspensionType) {
this.suspension = suspensionType;
}
public void printDescription() {
super.printDescription();
System.out.println("The " + "MountainBike has a" +
getSuspension() + " suspension.");
}
}
Notese el mtodo sobreescrito printDescription. Adems de la informacin facilitada antes, se
incluye en la salida datos adicionales sobre la suspensin.
A continuacin, cree la clase RoadBike. Porque las bicicletas de carretera o de carreras tienen
neumticos delgados, se agrega un atributo para rastrear el ancho del neumtico. Aqu est la clase
RoadBike:
public class RoadBike extends Bicycle{

// In millimeters (mm)
private int tireWidth;
public RoadBike(int startCadence,
int startSpeed,
int startGear,
int newTireWidth){
super(startCadence,
startSpeed,
startGear);
this.setTireWidth(newTireWidth);
}
public int getTireWidth(){
return this.tireWidth;
}
public void setTireWidth(int newTireWidth){
this.tireWidth = newTireWidth;
}
public void printDescription(){
super.printDescription();
System.out.println("The RoadBike" + " has " + getTireWidth() +
" MM tires.");
}
}
Note una vez ms, el mtodo printDescription ha sido sobreescrito. Esta vez, se muestra
informacin sobre el ancho del neumtico.
Para resumir, hay tres clases: Bicycle, MountainBike y RoadBike. Las dos subclases
sobreescriben el mtodo printDescription e imprimen informacin nica.
Aqu esta un programa de prueba que crea tres variables de Bicycle. Cada variable se asigna a
una de las tres clases de bicicleta. Luego se imprime cada variable.
public class TestBikes {

Bicycle bike01, bike02, bike03;
bike01 = new Bicycle(20, 10, 1);
bike02 = new MountainBike(20, 10, 5, "Dual");

bike03 = new RoadBike(40, 20, 8, 23);
bike01.printDescription();
}
}
La salida del programa de prueba es el siguiente:
Bike is in gear 1 with a cadence of 20 and travelling at a speed of

10.
10.
The MountainBike has a Dual suspension.
20.
The RoadBike has 23 MM tires.
La Java virtual machine (JVM) llama al mtodo adecuado para el objeto al que se hace
referencia en cada variable. No llama al mtodo que esta definido por el tipo de la variable.
Este comportamiento se conoce como invocacin de mtodo virtual y muestra un aspecto de
las caractersticas importantes del polimorfismo en el lenguaje Java.
Ocultar campos
Dentro de una clase, un campo que tiene el mismo nombre que un campo de la superclase
oculta el campo de la superclase, incluso si sus tipos son diferentes. Dentro de la subclase, el
campo de la superclase no puede ser referenciado por su nombre simple. En lugar de ello, el campo
debe accederse a travs de super, que se cubre en la seccin siguiente. En trminos generales,
no es recomendable ocultar campos ya que hace difcil leer el cdigo.
Usando la palabra clave super

Acceso a miembros de la superclase
Si tu mtodo sobreescribe uno de los mtodos de su superclase, puede invocar el mtodo
sobreescrito mediante el uso de la palabra clave super. Tambin puede utilizar super para
referirse a un campo oculto (aunque ocultar campos se desaconseja). Considere esta clase,
Superclass:
public class Superclass {

public void printMethod() {
System.out.println("Printed in Superclass.");
}
}
Aqu est una subclase, llamada Subclass, que reemplaza a printMethod():
public class Subclass extends Superclass {

// sobreescribe printMethod en Superclass
public void printMethod() {
super.printMethod();
System.out.println("Printed in Subclass");
}
Subclass s = new Subclass();
s.printMethod();
}
}
Dentro de Subclass, el nombre simple printMethod() se refiere al declarado en la Subclass,
que sobreescribe en la Superclass. As que, para hacer referencia a printMethod() heredado
de la Superclass, Subclass debe utilizar un nombre cualificado, usando super como se
muestra. Al compilar y ejecutar Subclass imprime lo siguiente:
Printed in Superclass.
Printed in Subclass
Los constructores de la subclase

El ejemplo siguiente muestra cmo utilizar la palabra clave super para invocar un constructor
de una superclase. Recordemos del ejemplo de Bicycle que MountainBike es una subclase
de Bicycle. Este es el constructor de MountainBike (subclase) que llama al constructor de la
superclase y a continuacin agrega su propio cdigo de inicializacin:
public MountainBike(int startHeight,

int startCadence,
int startSpeed,
int startGear) {
}
La invocacin de un constructor de la superclase debe ser la primera lnea en el constructor
de la subclase.
La sintaxis para llamar a un constructor de la superclase
super();
o:
super(parameter list);
Con super(), se llama al constructor sin-argumentos de la superclase. Con super(parameter
list), se llama al constructor de la superclase con una lista de parmetros coincidentes.
Nota: Si un constructor no invoca explcitamente a un constructor de superclase, el

compilador de Java inserta automticamente una llamada al constructor sin-argumentos de la
superclase. Si la clase super no tiene un constructor sin-argumentos, obtendr un error en tiempo
de compilacin. Object tiene un constructor, as que si Object es la nica superclase, no hay
problema.
Si un constructor de la subclase invoca un constructor de su superclase, ya sea explcita o

implcitamente, se podra pensar que habr toda una cadena de constructores llamados, todo el
camino de regreso al constructor de Object. De hecho, este es el caso. Se le llama
encadenamiento del constructor, y tienes que ser consciente de ello cuando hay una larga lnea
de descenso de clase.
Objeto como una superclase

La clase de Object, en el paquete java.lang, se situa en la parte superior del rbol de la
jerarqua de clase. Cada clase es un descendiente, directo o indirecto, de la clase Object.
Cada clase que utilizas o escribes hereda los mtodos de instancia de Object. No necesitas
utilizar cualquiera de estos mtodos, pero si decides hacerlo, puede que necesites sobreescribirlos
con cdigo especfico en tu clase. Los mtodos heredados de Object que se describen en esta
seccin son:
protected Object clone() throws CloneNotSupportedException

Crea y devuelve una copia de este objeto.
public boolean equals(Object obj)
Indica si algn otro objeto es "igual a" ste.
protected void finalize() throws Throwable
Llamado por el recolector de basura en un objeto cuando el recolector de
basura determina que no existen ms referencias al objeto
public final Class getClass()
Devuelve la clase runtime de un objeto.
public int hashCode()
Devuelve un valor de cdigo hash para el objeto.
public String toString()
Devuelve una representacin de cadena del objeto.
Los mtodos de Object: notify, notifyAll y wait todos juegan un papel en la

sincronizacin de las actividades de los subprocesos que se ejecutan de forma independiente en un
programa, que se discute en una leccin posterior y no se cubre aqu. Hay cinco de estos mtodos:
public
public
public
public
public
final
final
final
final
final
void
void
void
void
void
notify()
notifyAll()
wait()
wait(long timeout)
wait(long timeout, int nanos)
Nota: Hay algunos aspectos sutiles a un nmero de estos mtodos, especialmente el mtodo
clone.
El mtodo clone()
Si una clase, o una de sus superclases, implementa la interfaz Cloneable, usted puede
utilizar el mtodo clone() para crear una copia de un objeto existente. Para crear un clon,
escribe:
aCloneableObject.clone();
La implementacin de Object en este mtodo comprueba si el objeto sobre el que se invoc
clone() implementa la interfaz Cloneable . Si el objeto no lo hace, el mtodo produce una
excepcin CloneNotSupportedException. El manejo de excepciones ser cubierto en una
leccin posterior. Por el momento, tienes que saber que clone() deben ser declarado como
protected Object clone() throws CloneNotSupportedException

o:
public Object clone() throws CloneNotSupportedException
Si vas a escribir un mtodo clone() para sobreescribir el de Object.

Si el objeto sobre el que se invoc clone() implementa la interfaz Cloneable , la
implementacin de Object del mtodo clone() crea un objeto de la misma clase que el objeto
original e inicializa las variables miembro del nuevo objeto para tener los mismos valores que las
variables miembro correspondiente del objeto original.
La forma ms sencilla de hacer tu clase clonable es agregar implements Cloneable a la
declaracin de la clase, a continuacin, los objetos pueden invocar el mtodo clone().
Para algunas clases, el comportamiento por defecto del mtodo clone() de Object funciona
muy bien. Sin embargo, si un objeto contiene una referencia a un objeto externo, es decir
ObjExternal, necesitar sobreescribir clone() para obtener el comportamiento correcto. De lo
contrario, un cambio en ObjExternal de un objeto ser visible en su clon tambin. Esto significa
que el objeto original y su clon no son independientes para desvincularlos, debe sobreescribir
clone() as que clona el objeto y ObjExternal. Entonces el objeto original hace referencia a
ObjExternal y el clon hace referencia a un clon de ObjExternal, para que el objeto y su clon
sean verdaderamente independientes.
El mtodo equals()
El mtodo equals() compara dos objetos para igualdad y devuelve true si son iguales. El
mtodo equals() proporcionado en la clase de Object utiliza el operador de identidad (==)
para determinar si dos objetos son iguales. Para tipos de datos primitivos, esto da el resultado
correcto. Para los objetos, sin embargo, no lo hace. El mtodo equals() proporcionado por
Object prueba si las referencias de objeto son iguales es decir, si los objetos comparados
son el mismo objeto exacto.
Para comprobar si dos objetos son iguales en el sentido de equivalencia (que contengan la misma
informacin), es necesario reemplazar el mtodo equals(). Aqu hay un ejemplo de una clase de
Book que reemplaza equals():
public class Book {

...
public boolean equals(Object obj) {
if (obj instanceof Book)
return ISBN.equals((Book)obj.getISBN());
else
return false;
}
}
Considere este cdigo prueba dos instancias de la clase Book para igualdad:
// Swing Tutorial, 2nd edition

Book firstBook = new Book("0201914670");
Book secondBook = new Book("0201914670");
if (firstBook.equals(secondBook)) {
System.out.println("objects are equal");
} else {
System.out.println("objects are not equal");
}
Este programa muestra objects are equal aunque firstBook y secondBook referencia a
dos objetos distintos. Se consideran iguales porque los objetos comparados contienen el mismo
nmero de ISBN.
Siempre debe sobreescribir el mtodo equals() si el operador de identidad no es el apropiado

para su clase.
Nota: Si sobreescribe equals(), deber sobreescribir hashCode() tambin.
El mtodo finalize()
La clase Object proporciona un mtodo de devolucin de llamada, finalize(), este puede
ser invocado por un objeto cuando se convierte en basura. La implementacin de Object de
finalize() no hace nada puede sobreescribir finalize() para hacer limpieza, como
liberando recursos.
El mtodo finalize()puede ser llamado automticamente por el sistema, pero cuando se llama,
o incluso si se llama, es incierto. Por lo tanto, no debe confiar en este mtodo para hacer la
limpieza por usted. Por ejemplo, si no cierra los descriptores de ficheros en el cdigo despus de
realizar la I/O y esperas finalize() para cerrarlas por usted, es posible que se quede sin
descriptores de archivos.
El mtodo getClass()
Usted no puede sobreescribir getClass.
El mtodo getClass() devuelve un objeto Class , que tiene mtodos que puede utilizar para
obtener informacin acerca de la clase, como su nombre (getSimpleName()), su superclase
(getSuperclass()) y las interfaces que implementa (getInterfaces()). Por ejemplo, el
siguiente mtodo obtiene y muestra el nombre de clase de un objeto:
void printClassName(Object obj) {

System.out.println("The object's" + " class is " +
obj.getClass().getSimpleName());
}
La clase Class en el paquete java.lang, tiene un gran nmero de mtodos (ms de 50). Por
ejemplo, se puede probar para ver si la clase es una anotacin (isAnnotation()), una
interfaz (isInterface()) o una enumeracin (isEnum()). Usted puede ver lo que los
campos del objeto (getFields()) o lo que sus mtodos son (getMethods()) y as
sucesivamente.
El mtodo hashCode()
El valor devuelto por hashCode() es cdigo hash del objeto, que es la direccin de memoria del
objeto en hexadecimal.
Por definicin, si dos objetos son iguales, sus cdigos hash tambin deben ser iguales. Si
reemplaza el mtodo equals(), cambia la forma en que se comparan dos objetos y la
implementacin de Object del hashCode() ya no es vlida. Por lo tanto, si reemplaza el
mtodo equals() , tambin debe reemplazar el mtodo hashCode().
El mtodo toString()
Siempre debe considerar sobreescribir el mtodo toString() en sus clases.
El mtodo toString() del Object devuelve una representacin de String del objeto, que es
muy til para la depuracin. La representacin de String de un objeto depende del objeto, por eso
tienes que sobreescribir toString() en tus clases.
Puede utilizar toString() junto con System.out.println() para mostrar una representacin
de un objeto, como una instancia de Book:
System.out.println(firstBook.toString());
Que seria, para un mtodo toString() sobreescrito apropiadamente, imprime algo til, como
esto:
ISBN: 0201914670; The Swing Tutorial; A Guide to Constructing GUIs,

2nd Edition
Escribir clases y mtodos finales

Se pueden declarar algunos o todos los mtodos de una clase final. Use la palabra final en una
declaracin de mtodo para indicar que el mtodo no puede ser sobreescrito por las
subclases. La clase Object hace esto un nmero de sus mtodos son final.
Tal vez desea hacer un mtodo final si tiene una implementacin que no debe ser cambiada y es
fundamental para el estado consistente del objeto. Por ejemplo, podras querer hacer final el mtodo
getFirstPlayer en esta clase ChessAlgorithm :
class ChessAlgorithm {
enum ChessPlayer { WHITE, BLACK }
...
final ChessPlayer getFirstPlayer() {
return ChessPlayer.WHITE;
}
...
}
Los mtodos llamados desde los constructores generalmente deben declararse como finales. Si un
constructor llama a un mtodo no-final, una subclase puede redefinir el mtodo con resultados
sorpresivos o indeseables.
Tenga en cuenta que tambin puede declarar una clase completa final. Una clase que se declara
final no puede tener subclases. Esto es particularmente til, por ejemplo, cuando se crea una clase
inmutable como la clase String.
Clases y mtodos abstractos

Una clase abstracta es una clase que se declara abstract puede o no incluir mtodos
abstractos. Las clases abstractas no pueden ser instanciadas, pero pueden tener subclases.
Un mtodo abstracto es un mtodo que se ha declarado sin una implementacin (sin llaves y
seguido por un punto y coma), as:
abstract void moveTo(double deltaX, double deltaY);

Si una clase incluye mtodos abstractos, luego la propia clase debe ser declarada abstract,
como en:
public abstract class GraphicObject {

// campos declarados
// mtodos no-abstractos declarados
abstract void draw();
}
Cuando una clase abstracta tiene subclases, la subclase generalmente proporciona
implementaciones de todos los mtodos abstractos de su clase padre. Sin embargo, si no es as,
entonces la subclase debe tambin ser declarada abstract.
Nota: Los mtodos de una interfaz (vase la seccin Interfaces ) que no se declararon como
por defecto o estticos son implcitamente abstractos, as que no se utiliza el modificador
abstract con los mtodos de la interfaz. (Puede ser utilizado, pero es innecesario).
Las clases abstractas en comparacin con las Interfaces

Las clases abstractas son similares a las interfaces. No se pueden crear instancias de ellas, y
pueden contener una mezcla de mtodos declarados con o sin implementacin. Sin embargo, con
las clases abstractas, puede declarar campos que no son estticos y finales y definir mtodos
concretos pblicos, privados y protegidos. Con las interfaces, todos los campos son
automticamente pblicos, estticos y finales, y todos los mtodos que se declaran o definen (como
los mtodos por defecto) son pblicos. Adems, se puede extender una sola clase, sea o no
abstracta, considerando que puede implementar cualquier nmero de interfaces.
Que debera utilizar, clases abstractas o interfaces?
Considere el uso de las clases abstractas, si alguna de estas afirmaciones se aplican a su

situacin:
o
o
o
Quieres compartir cdigo entre varias clases estrechamente relacionadas?

Esperas que las clases que extienden de la clase abstracta tengan muchos
campos o mtodos comunes, o requieren modificadores de acceso que no
sean pblicos (como protegido y privado).
Quieres declarar campos no estticos o no finales? Esto le permite definir
mtodos que pueden acceder y modificar el estado del objeto al que pertenecen.
Considere el uso de interfaces si alguna de estas afirmaciones se aplican a su situacin:
o
o
o
Espera que las clases no-relacionadas pudieran implementar su interfaz. Por

ejemplo, las interfaces Comparable y Cloneable son implementadas por
muchas clases no-relacionadas.
Quieres especificar el comportamiento de un tipo particular de datos, pero no
esta preocupado por quin implementa su comportamiento.
Quieres tomar ventaja de la herencia mltiple de tipo?
Un ejemplo de una clase abstracta en el JDK es AbstractMap, que forma parte de las
Colecciones. Sus subclases (que incluyen HashMap, TreeMap y ConcurrentHashMap)
comparten muchos mtodos get que define AbstractMap.
Un ejemplo de una clase en el JDK que implementa varias interfaces es HashMap, que implementa
las interfaces Serializable, Cloneable y Map<K, V>. Al leer esta lista de interfaces, se
puede deducir que una instancia de HashMap (independientemente del desarrollador o empresa
que implementa la clase) pueden ser clonados, es serializable (lo que significa que puede ser
convertido en un byte corriente; vea la seccin Objetos serializables), y tiene la funcionalidad de un
mapa. Adems, se ha mejorado la interfaz de Map<K, V> con muchos mtodos por defecto como
merge y forEach que no tienen clases mayores que han implementado esta interfaz para definir.
Tenga en cuenta que muchas bibliotecas de software utilizan tanto las clases abstractas como
las interfaces; la clase HashMap implementa varias interfaces y tambin extiende la clase
abstracta AbstractMap.
Un ejemplo de clase abstracta

En una aplicacin de dibujo orientado a objetos, puede dibujar crculos, rectngulos, lneas, curvas
Bezier y muchos otros objetos grficos. Todos estos objetos tienen ciertos Estados (por ejemplo:
posicin, orientacin, color de lnea, color de relleno) y comportamientos (por ejemplo: moveTo,
rotar, redimensionar, dibujar) en comn. Algunos de estos Estados y comportamientos son los
mismos para todos los objetos grficos (por ejemplo: posicin, color de relleno y moveTo). Otros
requieren diferentes implementaciones (por ejemplo, cambiar el tamao o dibujar). Todos los
GraphicObject deben ser capaces de dibujar o cambiar el tamao de ellos mismos; Slo se
diferencian en cmo lo hacen. Esta es una situacin perfecta para una superclase abstracta. Usted
puede tomar ventaja de las similitudes y declarar todos los objetos grficos que hereda el mismo
objeto abstracto (por ejemplo, GraphicObject) como se muestra en en la siguiente figura.
Las clases Crculo, lnea, curva y rectngulo heredan de GraphicObject

En primer lugar, se declara una clase abstracta, GraphicObject, para proporcionar las variables
miembro y mtodos que son totalmente compartidos por todas las subclases, tales como la posicin
actual y el mtodo moveTo. GraphicObject tambin declara mtodos abstractos para mtodos,
como draw o resize, que deben aplicarse todas las subclases, pero debe implementarse de
diferentes maneras. La clase de GraphicObject puede ser algo as:
abstract class GraphicObject {

int x, y;
...
void moveTo(int newX, int newY) {
...
}
abstract void draw();
abstract void resize();
}
Cada subclase nonabstract de GraphicObject, como el Circle y el Rectangle, debe
proporcionar implementaciones para los mtodos de draw y resize:
class Circle extends GraphicObject {

void draw() {
...
}
void resize() {
...
}
}
class Rectangle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
Cuando una clase abstracta implementa una interfaz

En la seccin de Interfaces, se observ que una clase que implementa una interfaz debe
implementar todos los mtodos de la interfaz. Es posible, sin embargo, para definir una clase que no
implementa todos los mtodos de la interfaz, siempre que la clase se declara ser abstract. Por
ejemplo,
abstract class X implements Y {

// implements all but one method of Y
}
class XX extends X {
// implements the remaining method in Y
}
En este caso, clase X debe ser abstract no implementa completamente Y, porque de hecho, la
clase XX , implementar Y.
Miembros de la clase
Una clase abstracta puede tener campos static y mtodos static. Puede utilizar a estos
miembros estticos con una referencia de la clase (por ejemplo,
AbstractClass.staticMethod()) como lo hara con cualquier otra clase.
Resumen de la herencia
Con excepcin de la clase de Object , una clase tiene exactamente una superclase directa. Una
clase hereda campos y mtodos de todos sus superclases, directa o indirecta. Una subclase puede
reemplazar mtodos que hereda, o pueden ocultar campos o mtodos que hereda. (Nota que ocultar
campos es generalmente mala prctica de programacin.)
La tabla en seccin de anulacin y ocultar mtodos muestra el efecto de declarar un mtodo con la
misma firma que un mtodo de la superclase.
La clase de Object es la parte superior de la jerarqua de clases. Todas las clases son
descendientes de esta clase y heredan los mtodos. Mtodos tiles heredados de Object incluyen
toString(), equals(), clone()y getClass().
Puede evitar que una clase de ser subclases mediante la palabra clave final en declaracin de la
clase. Asimismo, puede impedir que un mtodo siendo reemplazadas por las subclases
declarndola como forma final.
Una clase abstracta puede solamente ser subclases; No puede ser instanciada. Una clase abstracta
puede contener mtodos abstractos mtodos que son declarados pero no implementados.
Subclases proporcionan las implementaciones de los mtodos abstractos.
Preguntas y ejercicios: herencia

Preguntas
1. considere las siguientes dos clases:
public class ClassA {
public
}
public
}
public
}
public
}
void methodOne(int i) {
void methodTwo(int i) {
static void methodThree(int i) {
static void methodFour(int i) {
}
public class ClassB extends ClassA {
public static void methodOne(int i) {
}
public void methodTwo(int i) {
}
public void methodThree(int i) {
}
public static void methodFour(int i) {
}
}
a. Qu mtodo sobreescribe un mtodo en la superclase?
b. Qu mtodo oculta un mtodo en la superclase?
c. Qu hacen los otros mtodos?
Leccin: Nmeros y cadenas

Nmeros
Esta seccin comienza con una discusin de la clase Number (en el paquete java.lang) y sus
subclases. En particular, esta seccin habla sobre las situaciones donde se usara instancias
de estas clases en lugar de los tipos de datos primitivos. Adems, esta seccin habla de otras
clases que deben trabajar con nmeros, tales como el formato o el uso de funciones matemticas
para complementar los operadores incorporados en la lengua. Finalmente, hay una discusin sobre
autoboxing y unboxing, una caracterstica del compilador que simplifica su cdigo.
Strings
Las strings, que son ampliamente utilizadas en programacin Java, son una secuencia de
caracteres. En el lenguaje de programacin Java, las strings son objetos. Esta seccin describe
cmo utilizar la clase String para crear y manipular cadenas. Tambin compara las clases
String y StringBuilder.
Nmeros
Esta seccin comienza con una discusin sobre el Number de clase en el paquete java.lang,
sus subclases y las situaciones donde se usara instancias de estas clases en lugar de los tipos
primitivos de nmero.
Esta seccin presenta tambin las clases de PrintStream y DecimalFormat, que proporciona
mtodos para escribir con formato de salida numrica.
Por ltimo, se discute la clase de Math en java.lang. Contiene las funciones matemticas para
complementar los operadores incorporados en la lengua. Esta clase tiene mtodos para las
funciones trigonomtricas, funciones exponenciales y as sucesivamente.
Las clases de nmeros

Cuando se trabaja con nmeros, la mayora del tiempo utilizas los tipos primitivos en el cdigo. Por
ejemplo:
int i = 500;
float gpa = 3.65f;
byte mask = 0xff;
Sin embargo, hay razones para usar objetos en lugar de primitivos, y la plataforma Java proporciona
clases contenedoras para cada uno de los tipos de datos primitivos. Estas clases "envuelven" la
primitiva en un objeto. A menudo, la envoltura se realiza por el compilador, si utilizas un primitivo
donde se espera un objeto, el compilador cajas la primitiva en su envoltorio clase para usted.
Similarmente, si utilizas un objeto number cuando un hombre primitivo y se espera, el compilador
unboxes el objeto para ti. Para obtener ms informacin, vea Autoboxing y Unboxing
Todas las clases contenedoras numricos son subclases de la clase abstracta Number:
Nota: Hay cuatro otras subclases de Number que no se discuten aqu. BigDecimal y
BigInteger se utilizan para los clculos de alta precisin. AtomicInteger y AtomicLong se
utilizan para aplicaciones de subprocesos mltiples.
Hay tres razones que puede utilizar un objeto Number en lugar de una primitiva:
1.
2.
3.
Como argumento de un mtodo que espera un objeto (a menudo usado al manipular

colecciones de nmeros).
Para utilizar constantes definidas por la clase, como MIN_VALUE y MAX_VALUE, que
proporcionan los lmites superiores e inferiores del tipo de datos.
Para utilizar mtodos de la clase para convertir valores de a y de otros tipos primitivos, para
convertir a y desde las cuerdas y para convertir entre sistemas de numeracin (decimal,
octal, hexadecimal, binario).
La tabla siguiente enumeran los mtodos de instancia que implementan todas las subclases de la
clase de Number.
Mtodos implementada por todas las subclases de nmero
Mtodo
byte byteValue()
short shortValue()
int intValue()
long longValue()
float floatValue()
double doubleValue()
Descripcin
Convierte el valor de este objeto Number al tipo de datos

primitivo volvi.
int compareTo(Byte
anotherByte)
int compareTo(Double
anotherDouble)
int compareTo(Float
anotherFloat)
int compareTo(Integer
anotherInteger)
int compareTo(Long
anotherLong)
int compareTo(Short
anotherShort)
Compara el objeto de este Number a la discusin.
boolean equals(Object
obj)
Determina si este objeto number es igual al argumento.

Los mtodos de devuelven true si el argumento no es
null y es un objeto del mismo tipo y con el mismo valor
numrico.
Hay algunos requisitos adicionales para el Double y
Float los objetos que se describen en la documentacin
de la API de Java.
Cada clase Number contiene otros mtodos que son tiles para la conversin de nmeros y de las
cadenas y para convertir entre sistemas de numeracin. La tabla siguiente enumera estos mtodos
en la clase Integer . Mtodos para las otras subclases de Number son similares:
Mtodos de conversin, clase Integer
Mtodo
Descripcin
static Integer
decode(String s)
Descodifica una cadena en un entero. Puede aceptar

representaciones de cadena de nmeros decimales, octales o
hexadecimales como entrada.
static int
parseInt(String s)
Devuelve un entero (decimal solamente).
static int
parseInt(String s,
int radix)
Devuelve un entero, dada una representacin de cadena del

decimal, binario, octal o hexadecimal (radix equivale a 10, 2, 8
o 16 respectivamente) nmeros como entrada.
String toString()
Devuelve un objeto String que representa el valor de este

Integer.
static String
toString(int i)
Devuelve un objeto String que representa el entero

especificado.
static Integer
valueOf(int i)
Devuelve un objeto Integer sosteniendo el valor de lo primitivo

especificado.
static Integer
valueOf(String s)
Devuelve un objeto Integer sosteniendo el valor de la

representacin de cadena especificado.
static Integer
valueOf(String s,
int radix)
Devuelve un objeto Integer sosteniendo el valor entero de la

representacin de la cadena especificada, analizada con el valor
de raz. Por ejemplo, si s = "333" y radix = 8, el mtodo devuelve
el equivalente de base diez entero del nmero octal 333.
Formato de impresin numrica

Antes que viste el uso de los mtodos print y println para impresin cuerdas a la salida
estndar (System.out). Ya que todos nmeros pueden convertirse en cadenas (como se ver
ms adelante en esta leccin), puede utilizar estos mtodos para imprimir una mezcla arbitraria de
cadenas y nmeros. El lenguaje de programacin Java tiene otros mtodos, sin embargo, que le
permiten ejercer mucho ms control sobre su salida de la impresin cuando se incluyen nmeros.
Los mtodos printf y formato

El paquete java.io incluye una clase de PrintStream que tiene dos mtodos de formato que
se pueden utilizar para reemplazar a print y println. Estos mtodos, format y printf,
equivalen a uno al otro. El familiar System.out que usted ha estado usando pasa a ser un objeto
de PrintStream , as que usted puede invocar mtodos de PrintStream en System.out. Por
lo tanto, puede utilizar format o printf en cualquier lugar en el cdigo donde has previamente
usado print o println. Por ejemplo,
System.out.format(.....);
La sintaxis de estos dos mtodos de java.io.PrintStream es la misma:
public PrintStream format(String format, Object... args)

donde el format es una cadena que especifica el formato para ser utilizado y args es una lista de
las variables a imprimir utilizando ese formato. Un ejemplo sencillo sera
System.out.format("The value of " + "the float variable is " +

"%f, while the value of the " + "integer variable is %d, " +
"and the string is %s", floatVar, intVar, stringVar);
El primer parmetro, format, es una cadena de formato especifica cmo los objetos en el segundo
parmetro, args, son ser formateado. La cadena de formato contiene texto as como
especificadores de formato, que son caracteres especiales que los argumentos del Object...
argsdel formato. (La notacin Object... args se llama varargs, que significa que puede variar
el nmero de argumentos).
Especificadores de formato comienzan con un signo de porcentaje (%) y terminan con un
convertidor. El convertidor es un personaje que indica el tipo de argumento para ser formateado.
Entre el signo de porcentaje (%) y el convertidor puedes tener especificadores y banderas
opcionales. Existen muchos conversores, banderas y especificadores, documentadas en
java.util.Formatter
Aqu est un ejemplo bsico:
int i = 461012;
System.out.format("The value of i is: %d%n", i);
El %d especifica que la nica variable es un entero decimal. El %n es un caracter independiente de
la plataforma. La salida es:
The value of i is: 461012

Los mtodos printf y format estn sobrecargados. Cada uno tiene una versin con la siguiente
sintaxis:
public PrintStream format(Locale l, String format, Object... args)
Para imprimir nmeros en el sistema francs (donde se utiliza una coma en lugar de la posicin
decimal en la representacin inglesa de nmeros de coma flotante), por ejemplo, utilice:
System.out.format(Locale.FRANCE,
"The value of the float " + "variable is %f, while the " +
"value of the integer variable " + "is %d, and the string is
%s%n",
floatVar, intVar, stringVar);
Un ejemplo
La tabla siguiente enumeran algunos de los convertidores y banderas que se utilizan en el programa
de la muestra, TestFormat.java, que sigue en la tabla.
Convertidores y banderas utilizadas en TestFormat.java
Convertidor
Bandera
Explicacin
Un entero decimal.
Un flotador.
Un nuevo personaje de lnea

correspondiente a la plataforma de
ejecucin de la aplicacin. Siempre debe
usar %n, en lugar de \n.
tB
Una conversin de fecha y hora, nombre

completo locale especfico del mes.
TD, te
Una conversin de fecha y hora: da 2

dgitos del mes. TD tiene llevando ceros
como sea necesario, no te.
Ty tY
Una conversin de fecha y hora ty =

ao de 2 dgitos, tY = ao de 4 dgitos.
TL
Una conversin de fecha y hora: hora en

el reloj de 12 horas.
tM
Una conversin de fecha y hora: minutos

en 2 dgitos, con los principales ceros
como sea necesario.
TP
Una conversin de fecha y hora locale

especfico am/pm (en minsculas).
TM
Una conversin de fecha y hora

meses en 2 dgitos, con los principales
ceros como sea necesario.
tD
Una conversin de fecha y hora fecha

como % tm % td % ty
08
Ocho caracteres de ancho, con los

principales ceros como sea necesario.
Incluye la seal, ya sea positiva o

negativa.
Incluye caracteres de agrupacin local

especfico.
Justifica a la izquierda...
.3
Tres lugares despus del punto decimal.
10.3
Diez caracteres de ancho, bien

justificada, con tres lugares despus del
punto decimal.
El siguiente programa muestra algunos de los que puedes hacer con formatformato. La salida se
muestra dentro de comillas dobles en el comentario incrustado:
import java.util.Calendar;
import java.util.Locale;
public class TestFormat {
long n = 461012;
System.out.format("%d%n", n);
// --> "461012"
System.out.format("%08d%n", n);
// --> "00461012"
System.out.format("%+8d%n", n);
// --> " +461012"
System.out.format("%,8d%n", n);
// --> " 461,012"
System.out.format("%+,8d%n%n", n); // --> "+461,012"
double pi = Math.PI;
System.out.format("%f%n", pi);
// -->
System.out.format("%.3f%n", pi);
// -->
System.out.format("%10.3f%n", pi);
// -->
System.out.format("%-10.3f%n", pi); // -->
System.out.format(Locale.FRANCE,
"%-10.4f%n%n", pi); // -->
"3.141593"
"3.142"
"
3.142"
"3.142"
"3,1416"
Calendar c = Calendar.getInstance();
System.out.format("%tB %te, %tY%n", c, c, c); // -->
"May 29,
System.out.format("%tl:%tM %tp%n", c, c, c);
"2:34 am"
2006"
System.out.format("%tD%n", c);
// -->
// -->
"05/29/06"
}
}
Nota: La discusin en esta seccin cubre slo los conceptos bsicos de los mtodos de format y
printf . Ms detalles pueden encontrarse en la seccin de Basic I/O del camino esencial, en la
pgina de "Formato".
Utilizando String.format y para crear cadenas est cubierto de cadenas.
La clase DecimalFormat
Usted puede utilizar la clase java.text.DecimalFormat para controlar la visualizacin de
iniciales y ceros, prefijos y sufijos, separadores de agrupacin (miles) y el separador de decimales.
DecimalFormat ofrece una gran flexibilidad en el formato de nmeros, pero puede hacer ms
compleja su cdigo.
El ejemplo siguiente crea un objeto DecimalFormat , myFormatter, generando una cadena de
patrn para el constructor DecimalFormat . Luego se invoca el mtodo format() , que
DecimalFormat hereda de NumberFormat, por myFormatter acepta un valor double

como argumento y devuelve el nmero con formato en una cadena:
Aqu es un programa de ejemplo que ilustra el uso de DecimalFormat:
import java.text.*;
public class DecimalFormatDemo {
static public void customFormat(String pattern, double value ) {
DecimalFormat myFormatter = new DecimalFormat(pattern);
String output = myFormatter.format(value);
System.out.println(value + " " + pattern + " " + output);
}
customFormat("###,###.###", 123456.789);
customFormat("###.##", 123456.789);
customFormat("000000.000", 123.78);
customFormat("$###,###.###", 12345.67);
}
}
La salida es:
123456.789 ###,###.### 123,456.789

123456.789 ###.## 123456.79
123.78 000000.000 000123.780
12345.67 $###,###.### $12,345.67
La siguiente tabla explica cada lnea de salida.
Salida DecimalFormat.java
Valor
Patrn
Salida
Explicacin
123456.789
###,###.###
123,456.789
El signo de nmero (#) denota un dgito, la coma es

un marcador de posicin para el separador de la
agrupacin y el perodo es un marcador de posicin
para el separador decimal.
123456.789
###.##
123456.79
El value tiene tres dgitos a la derecha del punto

decimal, pero el pattern tiene slo dos. El mtodo
de format maneja esto por redondeo.
123.78
000000.000
000123.780
El pattern especifica iniciales y ceros, porque el

carcter 0 se utiliza en lugar del signo de nmero
(#).
$12.345,67
El primer personaje en el pattern es el signo de

dlar ($). Tenga en cuenta que precede
inmediatamente el dgito ms a la izquierda en el
formato de output.
12345.67
$###,###.###
Ms all de la aritmtica bsica
El lenguaje de programacin Java soporta aritmtica bsica con sus operadores aritmticos: +, -, *, /
y %. La clase de Math en el paquete java.lang proporciona mtodos y constantes para hacer el
clculo matemtico ms avanzado.
Los mtodos en la clase de Math son todo estticos, as se llaman directamente de la clase, as:
Math.cos(angle);
Nota: Mediante la funcin de lengua static import , no tienes que escribir Math frente a todas
las funciones matemticas:
import static java.lang.Math.*;

Esto le permite invocar los mtodos de la clase de Math por sus nombres. Por ejemplo:
cos(angle);
Constantes y mtodos bsicos

La clase de Math incluye dos constantes:
Math.E, que es la base de los logaritmos naturales, y

Math.PI, cual es la proporcin de la circunferencia de un crculo y su dimetro.
La clase de Math tambin incluye ms de 40 mtodos estticos. La tabla siguiente enumera una
serie de los mtodos bsicos.
Mtodos bsicos de matemticas
Mtodo
Descripcin
double abs(double d)
float abs(float f)
int abs(int i)
long abs(long lng)
Devuelve el valor absoluto del argumento.
double ceil(double d)
Devuelve el entero ms pequeo que es mayor

o igual que el argumento. Volvi como un
doble.
double floor(double d)
Devuelve el entero ms grande que sea menor

o igual al argumento. Volvi como un doble.
double rint(double d)
Devuelve el nmero entero ms cercano en el

valor del argumento. Volvi como un doble.
long round(double d)
int round(float f)
Devuelve el ms cercano larga o int, segn lo

indicado por el tipo de retorno del mtodo, a la
discusin.
double min(double arg1, double

arg2)
float min(float arg1, float arg2)
int min(int arg1, int arg2)
long min(long arg1, long arg2)
Devuelve el menor de los dos argumentos.
Mtodos bsicos de matemticas

Mtodo
double max(double arg1, double

arg2)
float max(float arg1, float arg2)
int max(int arg1, int arg2)
long max(long arg1, long arg2)
Descripcin
Devuelve el mayor de los dos argumentos.
El siguiente programa, BasicMathDemo , ilustra cmo utilizar algunos de estos mtodos:
public class BasicMathDemo {

double a = -191.635;
double b = 43.74;
int c = 16, d = 45;
System.out.printf("The absolute value " + "of %.3f is %.3f%n",
a, Math.abs(a));
System.out.printf("The ceiling of " + "%.2f is %.0f%n",
b, Math.ceil(b));
System.out.printf("The floor of " + "%.2f is %.0f%n",
b, Math.floor(b));
System.out.printf("The rint of %.2f " + "is %.0f%n",
b, Math.rint(b));
System.out.printf("The max of %d and " + "%d is %d%n",
c, d, Math.max(c, d));
System.out.printf("The min of of %d " + "and %d is %d%n",
c, d, Math.min(c, d));
}
}
Aqu est la salida de este programa:
The
The
The
The
The
The
absolute value of -191.635 is 191.635

ceiling of 43.74 is 44
floor of 43.74 is 43
rint of 43.74 is 44
max of 16 and 45 is 45
min of 16 and 45 is 16
Mtodos de funciones logartmicos y exponenciales

La siguiente tabla enumera los mtodos de la clase Math funciones logartmicos y exponenciales.
Mtodos de funciones logartmicos y exponenciales
Mtodo
Descripcin
double exp(double d)
Devuelve la base de los logaritmos naturales,

e, a la potencia de la discusin.
double log(double d)
Devuelve el logaritmo natural del argumento.
double pow(double base, double

exponent)
Devuelve el valor del primer argumento

elevado a la potencia del segundo argumento.
double sqrt(double d)
Devuelve la raz cuadrada del argumento.
Las siguientes pantallas de programa, ExponentialDemo, el valor de e, entonces llamadas cada

uno de los mtodos enumerado en la tabla anterior arbitrariamente elegido nmeros:
public class ExponentialDemo {

double x = 11.635;
double y = 2.76;
System.out.printf("The value of " + "e is %.4f%n",
Math.E);
System.out.printf("exp(%.3f) " + "is %.3f%n",
x, Math.exp(x));
System.out.printf("log(%.3f) is " + "%.3f%n",
x, Math.log(x));
System.out.printf("pow(%.3f, %.3f) " + "is %.3f%n",
x, y, Math.pow(x, y));
System.out.printf("sqrt(%.3f) is " + "%.3f%n",
x, Math.sqrt(x));
}
}
Aqu est la salida vers al ejecutar ExponentialDemo:
The value of e is 2.7183

exp(11.635) is 112983.831
log(11.635) is 2.454
pow(11.635, 2.760) is 874.008
sqrt(11.635) is 3.411
Mtodos de funciones trigonomtricos

La clase de Math tambin proporciona una coleccin de funciones trigonomtricas, que se resumen
en la tabla siguiente. El valor pasado en cada uno de estos mtodos es un ngulo expresado en
radianes. Puede utilizar el mtodo toRadians para convertir de grados a radianes.
Mtodos de funciones trigonomtricos
Mtodo
double sin(double d)
Descripcin
Devuelve el seno del doble valor especificado.
double cos(double d)
Devuelve el coseno del valor doble

especificado.
double tan(double d)
Devuelve la tangente del valor doble

especificado.
double asin(double d)
Devuelve el arcoseno de doble valor

especificado.
double acos(double d)
Devuelve el arcoseno de doble valor

especificado.
double atan(double d)
Devuelve el arco tangente del doble valor

especificado.
double atan2(double y, double x)
Coordenadas rectangulares (x, y) se

convierte en coordenadas polares (r,
theta) y devuelve theta.
double toDegrees(double d)
double toRadians(double d)
El argumento se convierte en grados o

radianes.
Aqu es un programa, TrigonometricDemo, que utiliza cada uno de estos mtodos para calcular
varios valores de funciones trigonomtricos para un ngulo de 45 grados:
public class TrigonometricDemo {

double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("The value of pi " + "is %.4f%n",
Math.PI);
System.out.format("The sine of %.1f " + "degrees is %.4f%n",
degrees, Math.sin(radians));
System.out.format("The cosine of %.1f " + "degrees is %.4f%n",
degrees, Math.cos(radians));
System.out.format("The tangent of %.1f " + "degrees is
%.4f%n",
degrees, Math.tan(radians));
System.out.format("The arcsine of %.4f " + "is %.4f degrees
%n",
Math.sin(radians),
Math.toDegrees(Math.asin(Math.sin(radians))));
System.out.format("The arccosine of %.4f " + "is %.4f degrees
%n",
Math.cos(radians),
Math.toDegrees(Math.acos(Math.cos(radians))));
System.out.format("The arctangent of %.4f " + "is %.4f degrees
%n",
Math.tan(radians),
Math.toDegrees(Math.atan(Math.tan(radians))));
}
}
La salida de este programa es como sigue:
The
The
The
The
The
The
The
value of pi is 3.1416
sine of 45.0 degrees is 0.7071
cosine of 45.0 degrees is 0.7071
tangent of 45.0 degrees is 1.0000
arcsine of 0.7071 is 45.0000 degrees
arccosine of 0.7071 is 45.0000 degrees
arctangent of 1.0000 is 45.0000 degrees
Nmeros aleatorios
El mtodo random() devuelve un nmero pseudo aleatoriamente seleccionado entre 0.0 y 1.0. La
gama incluye 0.0 pero no 1.0. En otras palabras: 0.0 <= Math.random() < 1.0. Para obtener
un nmero en un rango diferente, puede realizar aritmtica en el valor devuelto por el mtodo
aleatorio. Por ejemplo, para generar un nmero entero entre 0 y 9, escribira:
int number = (int)(Math.random() * 10);

Multiplicando el valor por 10, la gama de valores posibles se convierte 0.0 <= number < 10.0.
Utilizando Math.random funciona bien cuando usted necesita generar un nmero aleatorio. Si
necesita generar una serie de nmeros al azar, debe crear una instancia de java.util.Random
e invocar mtodos en ese objeto para generar nmeros.
Resumen de nmeros
Utiliza uno de las clases contenedoras Byte, Double, Float, Integer, Longo Short para
envolver un nmero de tipo primitivo en un objeto. El compilador de Java automticamente envuelve
a primitivas (cajas) para que cuando sea necesario y unboxes, otra vez cuando sea necesario.
El Number clases incluye constantes y mtodos de la clase til. Las constantes MIN_VALUE y
MAX_VALUE contienen los valores ms pequeos y ms grandes que pueden contener un objeto de
ese tipo. El byteValue, shortValuey mtodos similares convierten a un tipo numrico a otro. El
mtodo valueOf convierte una cadena en un nmero, y el mtodo toString convierte a un
nmero en una cadena.
Para dar formato a una cadena que contenga nmeros de salida, puede utilizar los mtodos
printf() o format() en la clase de PrintStream . Como alternativa, puede utilizar la clase
NumberFormat para personalizar formatos numricos usando patrones.
La clase Math contiene una variedad de mtodos de la clase para realizar funciones matemticas,
incluyendo mtodos exponenciales, logartmicos y trigonomtricos. Math tambin incluye funciones
aritmticas bsicas, tales como valor absoluto y redondeo y un mtodo random(), para la
generacin de nmeros aleatorios.
Caracteres
La mayora de las veces, si usted est utilizando un valor de carcter individual, utilizar el tipo
primitivo char. Por ejemplo:
char ch = 'a';
// Unicode for uppercase Greek omega character
char uniChar = '\u03A9';
// an array of chars
char[] charArray = { 'a', 'b', 'c', 'd', 'e' };
Hay veces, sin embargo, cuando tienes que usar un char como un objeto por ejemplo, como un
argumento de mtodo donde se espera un objeto. El lenguaje de programacin Java proporciona
una clase contenedora que "envuelve" el char en un objeto de Character para este propsito. Un
objeto de tipo Character contiene un solo campo, cuyo tipo es char. Esta clase de caracteres
tambin ofrece una serie de tiles clases (es decir, estticos) mtodos para manipular caracteres.
Puede crear un objeto de Character con el constructor de Character:
Character ch = new Character('a');

El compilador de Java tambin crear un objeto de Character para usted bajo ciertas
circunstancias. Por ejemplo, si pasas un primitivo char en un mtodo que espera un objeto, el
compilador convierte automticamente el char a un Character para ti. Esta caracterstica se
llama autoboxing o unboxing, si la conversin va al revs. Para obtener ms informacin sobre
autoboxing y unboxing, vea Autoboxing y Unboxing.
Nota: La clase de Character es inmutable, de modo que una vez que se crea, no se puede
cambiar un objeto de Character.
La tabla siguiente enumera algunos de los mtodos ms tiles en la clase de Character, pero no
es exhaustiva. Para una lista completa de todos los mtodos de esta clase (hay ms de 50),
consulte la especificacin java.lang.Character API.
Mtodos tiles en la clase de Character
Mtodo
Descripcin
boolean
isLetter(char ch)
boolean
isDigit(char ch)
Determina si el valor especificado char es una letra o un dgito,

respectivamente.
boolean
isWhitespace(char
ch)
Determina si el valor especificado char es el espacio en blanco.
boolean
isUpperCase(char
ch)
boolean
isLowerCase(char
ch)
Determina si el valor especificado char es mayscula o minscula,

respectivamente.
char
toUpperCase(char
ch)
char
toLowerCase(char
ch)
Devuelve la forma mayscula o minscula de los char especificado

valor.
Devuelve un objeto String que representa el carcter

especificado valor es decir, una cadena de un carcter.
toString(char ch)
Secuencias de escape
Un carcter precedido por una barra invertida (\) es una secuencia de escape y tiene un significado
especial para el compilador. La siguiente tabla muestra las secuencias de escape de Java:
Secuencias de escape
Secuencia
de escape
Descripcin
\t
Inserte una ficha en el texto en

este momento.
\b
Inserte un retroceso en el texto

en este momento.
\n
Insertar un salto de lnea en el

texto en este momento.
\r
Insertar un retorno de carro en

el texto en este momento.
\f
Inserte del formfeed en el texto

en este momento.
\'
Insertar un carcter de comilla

simple en el texto en este
momento.
\"
Insertar un carcter de comillas

dobles en el texto en este
momento.
\\
Insertar un carcter de barra

diagonal inversa en el texto en
este momento.
Cuando se encuentra una secuencia de escape en una instruccin print, el compilador lo interpreta
en consecuencia. Por ejemplo, si usted quiere poner citas entre comillas debe utilizar la secuencia
de escape, \ ", sobre las comillas interiores. Para imprimir la sentencia
She said "Hello!" to me.

usted escribira
System.out.println("She said \"Hello!\" to me.");
Strings
Las strings, que son ampliamente utilizadas en programacin Java, son una secuencia de
caracteres. En el lenguaje de programacin Java, las strings son objetos.
La plataforma Java proporciona la clase String para crear y manipular cadenas.
Creacin de strings
La manera ms directa para crear una cadena es escribir:
String greeting = "Hello world!";

En este caso, "Hola mundo!" es una cadena literal una serie de caracteres en el cdigo que est
entre comillas dobles. Cuando se encuentra con una cadena literal en el cdigo, el compilador crea
un objeto String con su valor en este caso, Hello world!
Como con cualquier otro objeto, puede crear objetos String utilizando la palabra clave new y un
constructor. La clase String tiene trece constructores que permita proporcionar el valor inicial de la
cadena utilizando diversas fuentes, tales como una matriz de caracteres:
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };

String helloString = new String(helloArray);
System.out.println(helloString);
La ltima lnea de este fragmento de cdigo muestra hello.
Nota: La clase String es inmutable, de modo que una vez que se crea un objeto String no
puede cambiarse. La clase String tiene un nmero de mtodos, algunos de los cuales sern
discutidos ms abajo, que parecen modificar cadenas. Puesto que las cadenas son inmutables,
estos mtodos realmente qu es crear y devolver una cadena nueva que contiene el resultado de la
operacin.
Longitud de cadena
Mtodos utilizados para obtener informacin acerca de un objeto son conocidos como mtodos de
descriptor de acceso. Un mtodo de descriptor de acceso que se puede usar con las cadenas es el
mtodo length() , que devuelve el nmero de caracteres contenidos en el objeto string. Despus
de las dos lneas de cdigo siguientes han sido ejecutadas, len equivale a 17:
String palindrome = "Dot saw I was Tod";

int len = palindrome.length();
Un palndromo es una palabra o frase que es simtrica, se escribe el mismo hacia adelante y hacia
atrs, haciendo caso omiso de caso y la puntuacin. Aqu es un programa corto e ineficiente para
revertir una cadena palndromo. Invoca la String mtodo charAt(i), que devuelve la ith carcter
de la cadena, contados a partir de 0.
public class StringDemo {

char[] tempCharArray = new char[len];
char[] charArray = new char[len];
// put original string in an
// array of chars
for (int i = 0; i < len; i++) {
tempCharArray[i] =
palindrome.charAt(i);
}
// reverse array of chars
for (int j = 0; j < len; j++) {
charArray[j] =
tempCharArray[len - 1 - j];
}
String reversePalindrome =
new String(charArray);
System.out.println(reversePalindrome);
}
}
Ejecutar el programa produce esta salida:
doT saw I was toD

Para lograr la revocacin de la cadena, el programa tena que convertir la cadena en una matriz de
caracteres (primera for bucle), reversa la matriz una segunda matriz (segundo for bucle) y luego
convertir a una cadena. La clase String incluye un mtodo getChars(), para convertir una
cadena o una parte de una cadena, en una matriz de caracteres as nos podramos reemplazar el
primer bucle for en el programa por encima con
palindrome.getChars(0, len, tempCharArray, 0);
Concatenacin de cadenas
La clase String incluye un mtodo para concatenar dos cadenas:
string1.concat(string2);
Esto devuelve una nueva cadena que cadena1 con cadena2 aadida al final.
Tambin puede utilizar el mtodo concat() con los literales de cadena, como en:
"My name is ".concat("Rumplestiltskin");

Las cadenas son ms comnmente concatenadas con el + operador, como en
"Hello," + " world" + "!"

que se traduce en
"Hello, world!"
El + operador es ampliamente utilizado en las declaraciones print . Por ejemplo:
String string1 = "saw I was ";

System.out.println("Dot " + string1 + "Tod");
que imprime
Dot saw I was Tod

Tan una concatenacin puede ser una mezcla de cualquier objeto. Para cada objeto que no es una
String, se llama a su mtodo toString() para convertirlo en una String.
Nota: El lenguaje de programacin Java no permite literales para abarcar las lneas en archivos de
cdigo fuente, as que usted debe usar el + operador de concatenacin al final de cada lnea en una
cadena de mltiples lneas. Por ejemplo:
String quote =
"Now is the time for all good " +
"men to come to the aid of their country.";
Rompiendo cadenas entre lneas usando el + operador de concatenacin es, una vez ms, muy
comn en las declaraciones print .
Creacin de cadenas de formato

Has visto el uso de los mtodos printf() y format() para salida con nmeros con formato de
impresin. La clase String tiene un mtodo de clase equivalente, format(), que devuelve un
objeto String en lugar de un objeto de PrintStream .
Mtodo String's esttica format() le permite crear una cadena con formato que se puede
reutilizar, en contraposicin a una sola instruccin print. Por ejemplo, en vez de
System.out.printf("The value of the float " +

"variable is %f, while " +
"the value of the " +
"integer variable is %d, " +
"and the string is %s",
Usted puede escribir
String fs;
fs = String.format("The value of the float " +
"variable is %f, while " +
"the value of the " +
"integer variable is %d, " +
" and the string is %s",
System.out.println(fs);
Conversin entre nmeros y cadenas

Conversin de cadenas a nmeros
Con frecuencia, un programa termina con datos numricos en un objeto string un valor
introducido por el usuario, por ejemplo.
Las subclases de Number que envuelven primitivos tipos numricos ( Byte, Integer, Double,
Float, Longy Short) cada proporcionan un mtodo de clase llamado valueOf que convierte
una cadena en un objeto de ese tipo. Aqu hay un ejemplo, ValueOfDemo , que obtiene dos
cadenas de la lnea de comandos, convierte a los nmeros y realiza las operaciones aritmticas en
los valores:
public class ValueOfDemo {

// this program requires two
// arguments on the command line

if (args.length == 2) {
// convert strings to numbers
float a = (Float.valueOf(args[0])).floatValue();
float b = (Float.valueOf(args[1])).floatValue();
// do some arithmetic
System.out.println("a + b = " +
(a + b));
System.out.println("a - b = " +
(a - b));
System.out.println("a * b = " +
(a * b));
System.out.println("a / b = " +
(a / b));
System.out.println("a % b = " +
(a % b));
} else {
System.out.println("This program " +
"requires two command-line arguments.");
}
}
}
La siguiente es la salida del programa cuando utilizas 4.5 y 87.2 por los argumentos de lnea de
comandos:
a
a
a
a
a
+
*
/
%
b
b
b
b
b
=
=
=
=
=
91.7
-82.7
392.4
0.0516055
4.5
Nota: Cada una de las subclases de Number que envuelven los tipos primitivos numricos tambin
proporciona un mtodo parseXXXX() (por ejemplo, parseFloat()) que puede utilizarse para
convertir cadenas en nmeros primitivos. Puesto que se devuelve un tipo primitivo en lugar de un
objeto, el mtodo parseFloat() es ms directo que el mtodo valueOf() . Por ejemplo, en el
programa ValueOfDemo , necesitamos:
float a = Float.parseFloat(args[0]);
float b = Float.parseFloat(args[1]);
Convertir nmeros en cadenas

A veces es necesario convertir a un nmero en una cadena porque necesita funcionar con el valor
en su forma de cadena. Hay varias maneras sencillas para convertir a un nmero en una cadena:
int i;
// Concatenate "i" with an empty string; conversion is handled for
you.
String s1 = "" + i;
o
// The valueOf class method.

String s2 = String.valueOf(i);
Cada una de las subclases Number incluye un mtodo de clase, toString(), que convertir a su
tipo primitivo en una cadena. Por ejemplo:
int i;
double d;
String s3 = Integer.toString(i);
String s4 = Double.toString(d);
El ejemplo ToStringDemo utiliza el mtodo toString para convertir a un nmero en una
cadena. Entonces, el programa utiliza algunos mtodos de cadena para calcular el nmero de
dgitos antes y despus del punto decimal:
public class ToStringDemo {

double d = 858.48;
String s = Double.toString(d);
int dot = s.indexOf('.');
System.out.println(dot + " digits " +
"before decimal point.");
System.out.println( (s.length() - dot - 1) +
" digits after decimal point.");
}
}
3 digits before decimal point.

2 digits after decimal point.
Manipulacin de caracteres de una cadena

La clase String tiene un nmero de mtodos para examinar el contenido de las cadenas,
encontrar caracteres o subcadenas dentro de una cadena, cambiando el caso y otras tareas.
Caracteres y subcadenas ndice

Puede obtener el carcter en un ndice en particular dentro de una cadena invocando el mtodo de
descriptor de acceso charAt() . El ndice del primer carcter es 0, mientras que el ndice del
ltimo carcter es length()-1. Por ejemplo, el cdigo siguiente obtiene el carcter en el ndice 9
en una cadena:
String anotherPalindrome = "Niagara. O roar again!";

char aChar = anotherPalindrome.charAt(9);
Los ndices comienzan en 0, as es el carcter del ndice 9 ' o ', como se ilustra en la figura
siguiente:
Si desea obtener ms de un carcter consecutivo de una cadena, puede utilizar el mtodo

substring . El mtodo substring tiene dos versiones, como se muestra en la siguiente tabla:
La substring mtodos en la clase String

Mtodo
Descripcin
String substring(int
beginIndex, int endIndex)
Devuelve una nueva cadena es una subcadena de esta

cadena. El primer argumento entero especifica el ndice
del primer carcter. El segundo argumento entero es el
ndice del ltimo carcter - 1.
String substring(int
beginIndex)
Devuelve una nueva cadena es una subcadena de esta

cadena. El argumento entero especifica el ndice del
primer carcter. Aqu, la subcadena devuelta se extiende
hasta el final de la secuencia original.
El cdigo siguiente obtiene desde el Palndromo Niagara la subcadena que se extiende desde ndice
11, pero no incluyendo, ndice 15, que es el palabra "rugido":
String anotherPalindrome = "Niagara. O roar again!";

String roar = anotherPalindrome.substring(11, 15);
Otros mtodos para manipular cadenas

Aqu hay varios otros mtodos de String para manipular cadenas:
Otros mtodos de la clase String para manipular cadenas
Mtodo
Descripcin
String[] split(String regex)

String[] split(String regex, int
limit)
Busca un partido segn lo especificado por el

argumento de cadena (que contiene una
expresin regular) y se divide esta cadena en
una matriz de cadenas en consecuencia. El
argumento entero opcional especifica el
tamao mximo de la matriz devuelta. Las
expresiones regulares estn cubiertas en la
leccin titulada "Expresiones regulares".
CharSequence subSequence(int
beginIndex, int endIndex)
Devuelve una nueva secuencia de carcter

construida a partir de ndice beginIndex
hasta endIndex - 1.
String trim()
Devuelve una copia de esta cadena con quitar

espacios en blanco iniciales y finales.
String toLowerCase()
String toUpperCase()
Devuelve una copia de esta cadena que se

puede convertir a maysculas o minsculas. Si
no hay conversiones son necesarias, estos
mtodos devuelven la cadena original.
La bsqueda de caracteres y subseries de caracteres en una cadena

Aqu estn algunos otros mtodos de String para encontrar caracteres o subcadenas dentro de
una cadena. La clase String proporciona mtodos de descriptor de acceso que devuelven la
posicin dentro de la cadena de un carcter especfico o subcadena: indexOf() y

lastIndexOf(). Los mtodos indexOf() buscar hacia delante desde el principio de la cadena,
y los mtodos lastIndexOf() buscar hacia atrs desde el extremo de la cuerda. Si no se
encuentra un carcter o subcadena, indexOf() y lastIndexOf() devuelven -1.
La clase String tambin proporciona un mtodo de bsqueda, contains, devuelve true si la
cadena contiene una secuencia de carcter particular. Utilice este mtodo cuando slo tienes que
saber que la cadena contiene una secuencia de caracteres, pero la ubicacin exacta no es
importante.
La tabla siguiente describen los distintos mtodos de bsqueda de cadena.
Los mtodos de bsqueda en la clase String
Mtodo
Descripcin
int indexOf(int ch)

int lastIndexOf(int ch)
Devuelve el ndice de la primera aparicin

(ltima) del carcter especificado.
int indexOf(int ch, int

fromIndex)
int lastIndexOf(int ch, int
fromIndex)

(ltima) del carcter especificado, bsqueda
hacia adelante (hacia atrs) en el ndice
especificado.
int indexOf(String str)

int lastIndexOf(String str)

(ltimo) de la subcadena especificada.
int indexOf(String str, int

fromIndex)
int lastIndexOf(String str, int
fromIndex)

(ltimo) de la subsecuencia especificada,
bsqueda hacia adelante (hacia atrs) en el
ndice especificado.
boolean contains(CharSequence s)
Devuelve true si la cadena contiene la

secuencia de caracteres especificado.
Nota: CharSequence es una interfaz implementada por la clase String . Por lo tanto, puede
utilizar una cadena como argumento para el mtodo contains() .
Sustitucin de caracteres y subseries de caracteres en una cadena

La clase String tiene muy pocos mtodos para insertar una cadena de caracteres o subcadenas.
En general, no son necesarios: puede crear una nueva cadena de concatenacin de subcadenas
tienes que quitar de una cadena con la subcadena que desee insertar.
La clase String tiene cuatro mtodos para reemplazar encontr caracteres o subcadenas, sin
embargo. Ellos son:
Mtodos de la clase String para manipular cadenas
Mtodo
Descripcin
String replace(char oldChar, char

newChar)
Devuelve una nueva cadena resultante de

reemplazar todas las apariciones de oldChar
en esta cadena con newChar.
String replace(CharSequence
target, CharSequence replacement)
Sustituye cada subcadena de esta cadena que

coincide con la secuencia de destino literal con
la secuencia especificada reemplazo literal.
String replaceAll(String regex,

String replacement)
Sustituye cada subcadena de esta cadena que

coincide con la expresin regular dada con el
reemplazo del dado.
String replaceFirst(String regex,

String replacement)
Reemplaza la primera subcadena de esta

cadena que coincide con la expresin regular
dada con el reemplazo del dado.
Un ejemplo
La clase siguiente, Filename, ilustra el uso de lastIndexOf() y substring() a aislar las
diferentes partes de un nombre de archivo.
Nota: Los mtodos en la clase siguiente de Filename no hacer ninguna comprobacin de errores
y asumir que su argumento contiene una ruta de directorio completo y un nombre de archivo con la
extensin. Si estos mtodos fueron cdigo de produccin, verificara que sus argumentos fueron
construidos correctamente.
public class Filename {

private String fullPath;
private char pathSeparator,
extensionSeparator;
public Filename(String str, char sep, char ext) {
fullPath = str;
pathSeparator = sep;
extensionSeparator = ext;
}
public String extension() {
int dot = fullPath.lastIndexOf(extensionSeparator);
return fullPath.substring(dot + 1);
}
// gets filename without extension
public String filename() {
int dot = fullPath.lastIndexOf(extensionSeparator);
int sep = fullPath.lastIndexOf(pathSeparator);
return fullPath.substring(sep + 1, dot);
}
public String path() {
int sep = fullPath.lastIndexOf(pathSeparator);
return fullPath.substring(0, sep);
}
}
Aqu es un programa, FilenameDemo, que construye un objeto de Filename y llama a todos sus
mtodos:
public class FilenameDemo {

final String FPATH = "/home/user/index.html";
Filename myHomePage = new Filename(FPATH, '/', '.');
System.out.println("Extension = " + myHomePage.extension());
System.out.println("Filename = " + myHomePage.filename());
System.out.println("Path = " + myHomePage.path());

}
}
Y aqu est la salida del programa:
Extension = html
Filename = index
Path = /home/user
Como se muestra en la figura siguiente, nuestro mtodo de extension utiliza lastIndexOf para
localizar la ltima aparicin del punto (.) en el nombre del archivo. Luego substring utiliza el valor
devuelto de lastIndexOf para extraer la extensin de nombre de archivo es decir, la
subcadena de la poca hasta el final de la cadena. Este cdigo asume que el nombre de archivo
tiene un perodo Si el nombre del archivo no tiene un perodo, lastIndexOf devuelve -1, y el
mtodo substring lanza un StringIndexOutOfBoundsException.
Adems, observe que el mtodo de extension utiliza dot + 1 como argumento de substring.
Si el personaje perodo (..) es el ltimo carcter de la cadena, dot + 1 es igual a la longitud de la
cadena, que es uno ms grande que el mayor ndice en la cadena (porque los ndices comienzan en
0). Este es un argumento legal para substring porque ese mtodo acepta un ndice igual, pero no
superior a la longitud de la cadena y lo interpreta en el sentido de "el final de la cadena".
Comparacin de cadenas y porciones de cadenas

La clase String tiene un nmero de mtodos para comparar cadenas y porciones de las cuerdas.
La tabla siguiente enumera estos mtodos.
Mtodos para comparar cadenas
Mtodo
Descripcin
boolean endsWith(String suffix)

boolean startsWith(String prefix)
Devuelve true si esta cadena termina con o

comienza con la subcadena especificada como
argumento al mtodo.
boolean startsWith(String prefix,

int offset)
Considera que el principio de la cadena en el

ndice de offsety devuelve true si se inicia
con la subcadena especificada como
argumento.
int compareTo(String
anotherString)
Compara dos cadenas lexicogrfico. Devuelve

un entero que indica si esta cadena es mayor
que (el resultado es > 0), igual a (el resultado
es = 0), o menos (el resultado es < 0) el
argumento.
int compareToIgnoreCase(String
str)
Compara dos cadenas lexicogrfico, ignorando

las diferencias en el caso. Devuelve un entero
que indica si esta cadena es mayor que (el

resultado es > 0), igual a (el resultado es = 0),
o menos (el resultado es < 0) el argumento.
boolean equals(Object anObject)
Devuelve true si y slo si el argumento es un

objeto String que representa la misma
secuencia de caracteres que este objeto.
boolean equalsIgnoreCase(String
anotherString)
Devuelve true si y slo si el argumento es

una String objeto representa la misma
secuencia de caracteres que este objeto,
ignorando las diferencias en el caso.
boolean regionMatches(int
toffset, String other, int
ooffset, int len)
Comprueba si la regin determinada de esta

cadena coincide con la regin determinada del
argumento.
Regin de longitud len y comienza en el
ndice toffset de esta cadena y ooffset
para la otra cadena.
Comprueba si la regin determinada de esta
cadena coincide con la regin determinada del
argumento.
boolean regionMatches(boolean
ignoreCase, int toffset, String
other, int ooffset, int len)
Regin de longitud len y comienza en el

ndice toffset de esta cadena y ooffset
para la otra cadena.
El argumento booleano que indica si el caso
debe ser ignorado; Si es true, caso se omite al
comparar caracteres.
boolean matches(String regex)
Comprueba si esta cadena coincide con la

expresin regular especificada. Las
expresiones regulares se discuten en la leccin
titulada "Expresiones regulares".
El siguiente programa, RegionMatchesDemo, utiliza el mtodo regionMatches para buscar

una cadena dentro de otra cadena:
public class RegionMatchesDemo {

String searchMe = "Green Eggs and Ham";
String findMe = "Eggs";
int searchMeLength = searchMe.length();
int findMeLength = findMe.length();
for (int i = 0;
i <= (searchMeLength - findMeLength);
i++) {
if (searchMe.regionMatches(i, findMe, 0, findMeLength)) {
foundIt = true;
System.out.println(searchMe.substring(i, i +
findMeLength));
break;
}
}
if (!foundIt)
System.out.println("No match found.");

}
}
La salida de este programa es Eggs.
Los pasos del programa a travs de la cadena de referidos por searchMe un carcter a la vez.
Para cada personaje, el programa llama al mtodo regionMatches para determinar si el principio de
la subcadena con el carcter actual coincide con la cadena que est buscando el programa.
La clase StringBuilder
Objetos StringBuilder son como objetos String, excepto que se puede modificar.
Internamente, estos objetos son tratados como arrays de longitud variable que contienen una
secuencia de caracteres. En cualquier momento, la longitud y el contenido de la secuencia
pueden ser cambiados a travs de invocaciones de mtodo.
Las strings siempre deben ser usadas a menos que los constructores de cadenas ofrecen una
ventaja en trminos de cdigo ms simple (ver el programa muestra al final de esta seccin) o mejor
rendimiento. Por ejemplo, si necesitas concatenar un gran nmero de cadenas, anexar un
objeto StringBuilder es ms eficiente
Longitud y capacidad
La clase StringBuilder, como la clase String , tiene un mtodo length() que devuelve la
longitud de la secuencia de caracteres en el constructor.
A diferencia de las cuerdas, cada constructor string tambin tiene una capacidad, el nmero de
espacios de carcter que han sido asignados. La capacidad, que es devuelto por el mtodo
capacity(), es siempre mayor o igual a la longitud (generalmente mayor) y se expandir
automticamente segn sea necesaria para acomodar las adiciones al constructor string.
StringBuilder Constructores
Constructor
Descripcin
StringBuilder()
Crea un constructor de cadena vaca con una

capacidad de 16 (16 elementos vacos).
StringBuilder(CharSequence cs)
Construye un constructor string que contiene

los mismos caracteres que el especificado
CharSequence, ms un extra de 16
elementos vacos siguiendo la
CharSequence.
StringBuilder(int initCapacity)
Crea un constructor de cadena vaca con la

capacidad inicial especificada.
StringBuilder(String s)
Crea un constructor string cuyo valor es

inicializado por la cadena especificada, adems
de un extra 16 elementos vacos se arrastra la
cadena.
Por ejemplo, el siguiente cdigo
// creates empty builder, capacity 16

StringBuilder sb = new StringBuilder();
// adds 9 character string at beginning
sb.append("Greetings");
producir un constructor de cadena con una longitud de 9 y una capacidad de 16 aos:
La clase StringBuilder tiene algunos mtodos relacionados con la longitud y capacidad que no
tiene la clase String :
Longitud y capacidades mtodos
Mtodo
Descripcin
void setLength(int newLength)
Establece la longitud de la secuencia de

caracteres. Si newLength es menor que
length(), se truncan los ltimos caracteres
en la secuencia de caracteres. Si newLength
es mayor que length(), caracteres nulos se
agregan al final de la secuencia de caracteres.
void ensureCapacity(int
minCapacity)
Asegura que la capacidad es igual o superior al

mnimo especificado.
Un nmero de operaciones (por ejemplo, append(), insert()o setLength()) puede

aumentar la longitud de la secuencia de caracteres en el configurador de cadena para que la
resultante length() sera mayor que el actual capacity(). Cuando esto sucede, la capacidad
aumenta automticamente.
Operaciones de StringBuilder
Las principales operaciones en un StringBuilder que no estn disponibles en String son los
mtodos append() y insert() , que estn sobrecargados para aceptar datos de cualquier tipo.
Cada uno convierte su argumento en una cadena y luego anexa o inserta los caracteres de la
cadena a la secuencia de caracteres en el configurador de cadena. El mtodo append agrega
siempre estos personajes al final de la secuencia de caracteres existentes, mientras que el mtodo
insert aade los caracteres en un punto especificado.
Aqu estn varios de los mtodos de la clase StringBuilder .
Varios mtodos de StringBuilder
Mtodo
StringBuilder append(boolean b)
StringBuilder append(char c)
StringBuilder append(char[] str)
StringBuilder append(char[] str,
int offset, int len)
StringBuilder append(double d)
StringBuilder append(float f)
StringBuilder append(int i)
StringBuilder append(long lng)
Descripcin
Anexa el argumento para el constructor de esta

cadena. Los datos se convierten en una
cadena antes de que lleva a cabo la operacin
de anexado.
StringBuilder append(Object obj)

StringBuilder append(String s)
StringBuilder delete(int start,
int end)
StringBuilder deleteCharAt(int
index)
El primer mtodo elimina el subsequence de

principio a fin-1 (ambos inclusive) en secuencia
el StringBuilderde char. El segundo
mtodo borra el carcter situado en el index.
StringBuilder insert(int offset,

boolean b)
char c)
char[] str)
StringBuilder insert(int index,
char[] str, int offset, int len)
double d)
float f)
int i)
long lng)
Object obj)
String s)
Inserta el segundo argumento del constructor

string. El primer argumento entero indica el
ndice antes de que los datos se va a insertar.
Los datos se convierten en una cadena antes
de la operacin de insercin lleva a cabo.
StringBuilder replace(int start,

int end, String s)
void setCharAt(int index, char c)
Sustituye el carcter especificado en el

constructor de esta cadena.
StringBuilder reverse()
Invierte la secuencia de caracteres en el

constructor de esta cadena.
String toString()
Devuelve una cadena que contiene la

secuencia de caracteres en el constructor.
Nota: Puede utilizar cualquier mtodo de String en un objeto StringBuilder primero

convirtiendo el constructor string a una cadena con el mtodo toString() de la clase
StringBuilder . Entonces convertir la cadena en un constructor string utilizando el constructor
StringBuilder(String str) .
Un ejemplo
El programa StringDemo que se enumera en la seccin titulada "Strings" es un ejemplo de un
programa que sera ms eficaz si se utilizaron un StringBuilder en lugar de una String.
StringDemo revirti un palndromo. Aqu, una vez ms, es su lista:
public class StringDemo {

char[] tempCharArray = new char[len];
char[] charArray = new char[len];
// put original string in an

// array of chars
for (int i = 0; i < len; i++) {
tempCharArray[i] =
palindrome.charAt(i);
}
// reverse array of chars
for (int j = 0; j < len; j++) {
charArray[j] =
tempCharArray[len - 1 - j];
}
String reversePalindrome =
new String(charArray);
System.out.println(reversePalindrome);
}
}
Ejecutar el programa produce esta salida:
doT saw I was toD

Para lograr la revocacin de la cadena, el programa convierte la cadena en una matriz de caracteres
(primera for bucle), en un segundo se invierte la matriz array (segundo bucle for ) y luego de
regreso se convierte en una cadena.
Si convierte la cadena palindrome a un constructor de cadena, puede utilizar el mtodo
reverse() en la clase StringBuilder . Hace el cdigo ms simple y ms fcil de leer:
public class StringBuilderDemo {

StringBuilder sb = new StringBuilder(palindrome);
sb.reverse();
// reverse it
System.out.println(sb);
}
}
Ejecutar este programa produce el mismo resultado:
doT saw I was toD

Tenga en cuenta que println() imprime un constructor de cadena, como en:
System.out.println(sb);
porque sb.toString() se llama implcitamente, como es con cualquier otro objeto en una
invocacin println() .
Nota: Tambin hay una clase StringBuffer que es exactamente el mismo que el
StringBuilder clase, excepto que es segura para subprocesos en virtud de tener sus mtodos
sincronizados. Hilos de rosca se discutir en la leccin en simultaneidad.
Resumen de caracteres y cadenas

La mayora de las veces, si usted est utilizando un valor de carcter individual, utilizar el tipo
primitivo char. Hay veces, sin embargo, cuando tienes que usar un char como un objeto por
ejemplo, como un argumento de mtodo donde se espera un objeto. El lenguaje de programacin
Java proporciona una clase contenedora que "envuelve" el char en un objeto de Character para
este propsito. Un objeto de tipo Character contiene un campo cuyo tipo es char. Esta clase de
Character tambin ofrece una serie de til clase (es decir, esttica) mtodos para manipular
caracteres.
Las cadenas son una secuencia de caracteres y son ampliamente utilizados en programacin Java.
En el lenguaje de programacin Java, las cadenas son objetos. La clase String tiene ms de 60
mtodos y 13 constructores.
Comnmente, se crea una cadena con una declaracin como
String s = "Hello world!";

en lugar de utilizar uno de los constructores de la String .
La clase String tiene muchos mtodos para buscar y recuperar subcadenas; Entonces estos
pueden montarlo fcilmente en nuevas cadenas utilizando el + operador de concatenacin.
La clase String tambin incluye un nmero de mtodos de utilidad, entre ellos valueOf(),
split(), toLowerCase()y toUpperCase(). El ltimo mtodo es indispensable para convertir
cadenas de entrada del usuario a nmeros. Las subclases Number tambin tienen mtodos para
convertir cadenas a nmeros y viceversa.
Adems de la clase String , hay tambin una clase StringBuilder . Trabajando con
StringBuilder objetos pueden ser a veces ms eficientes que trabaja con cadenas. La clase
StringBuilder ofrece algunos mtodos que pueden ser tiles para las cadenas, entre ellos
reverse(). En general, sin embargo, la clase String tiene una amplia variedad de mtodos.
Puede convertir una cadena a un constructor de cadena utilizando un constructor de
StringBuilder . Un constructor de cadena se puede convertir en una cadena con el mtodo
toString() .
Autoboxing y Unboxing
Autoboxing es la conversin automtica que hace que el compilador de Java entre los tipos
primitivos y sus correspondientes clases contenedoras de objeto. Por ejemplo, convertir un int a un
nmero entero, un doble con un dobley as sucesivamente. Si la conversin va al revs, esto
se llama unboxing.
Aqu es el ejemplo ms simple de autoboxing:
Character ch = 'a';
El resto de los ejemplos de esta seccin utilizar medicamentos genricos. Si todava no ests
familiarizado con la sintaxis de los genricos, vea la leccin de los medicamentos genricos
(actualizado) .
Considere el siguiente cdigo:
List<Integer> li = new ArrayList<>();

for (int i = 1; i < 50; i += 2)
li.add(i);
Aunque agrega los valores int tipos primitivos, sino como objetos enteros , a li, el cdigo se
compila. Li es una lista de objetos enteros , no una lista de valores int , se preguntarn por qu
el compilador de Java no emite un error en tiempo de compilacin. El compilador no generar un
error porque se crea un objeto Integer de i y agrega el objeto a li. Por lo tanto, el compilador
convierte el cdigo anterior al siguiente en tiempo de ejecucin:
List<Integer> li = new ArrayList<>();

for (int i = 1; i < 50; i += 2)
li.add(Integer.valueOf(i));
Convertir un valor primitivo (un int, por ejemplo) en un objeto de la correspondiente clase
contenedora (entero) se llama autoboxing. El compilador de Java aplica autoboxing cuando un
valor primitivo es:
Pasa como parmetro a un mtodo que espera un objeto de la correspondiente clase

contenedora.
Asignada a una variable de la correspondiente clase contenedora.
Considere el siguiente mtodo:
public static int sumEven(List<Integer> li) {

int sum = 0;
for (Integer i: li)
if (i % 2 == 0)
sum += i;
return sum;
}
Porque el resto (%) y los operadores unarios plus (+=) no se aplican a objetos enteros , se
preguntarn por qu el compilador Java compila el mtodo sin emitir ningn error. El compilador no
generar un error porque invoca el mtodo intValue para convertir un nmero entero a un
int en tiempo de ejecucin:
public static int sumEven(List<Integer> li) {

int sum = 0;
for (Integer i : li)
if (i.intValue() % 2 == 0)
sum += i.intValue();
return sum;
}
Convertir un objeto de un tipo de contenedor (Integer) a su correspondiente primitivo (int) se
llama valor unboxing. El compilador de Java aplica unboxing cuando es objeto de una clase
contenedora:
Pasa como parmetro a un mtodo que espera un valor del tipo primitivo correspondiente.
Asignado a una variable del tipo primitivo correspondiente.
El Unboxing ejemplo muestra cmo funciona esto:
import java.util.ArrayList;
import java.util.List;
public class Unboxing {
Integer i = new Integer(-8);

// 1. Unboxing through method invocation
int absVal = absoluteValue(i);
System.out.println("absolute value of " + i + " = " + absVal);
List<Double> ld = new ArrayList<>();
ld.add(3.1416);
// is autoboxed through method
invocation.
// 2. Unboxing through assignment
double pi = ld.get(0);
System.out.println("pi = " + pi);
}
public static int absoluteValue(int i) {
return (i < 0) ? -i : i;
}
}
El programa imprime lo siguiente:
absolute value of -8 = 8
pi = 3.1416
Autoboxing y unboxing permite los desarrolladores escribir limpiador el cdigo, hacindolo ms fcil
de leer. La tabla siguiente enumera los tipos primitivos y sus correspondientes clases contenedoras,
que son utilizados por el compilador de Java para autoboxing y unboxing:
Tipo primitivo Clase contenedora
Boolean
Boolean
Byte
Byte
Char
Personaje
flotador
Flotador
int
Nmero entero
largo
Largo
corto
Corto
doble
Doble

Tutorial Java ST

Cargado por

Copyright:

Formatos disponibles

Tutorial Java ST

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tutorial Java ST

Cargado por

Copyright:

Formatos disponibles

Tutorial Java

Preguntas y ejercicios: operadores ....................................................................................... 31

Resumen de crear y utilizar clases y objetos ....................................................................... 79

El formato de una anotacin ......................................................................................... 101

Sobreescribir y ocultar mtodos....................................................................................... 126

Ms all de la aritmtica bsica ........................................................................................... 147

Leccin: Lenguaje bsico

Expresiones, declaraciones y bloques

Instrucciones de flujo de control

Cules son las reglas y convenciones para nombrar un campo?

El lenguaje de programacin Java define los siguientes tipos de variables:

Variables de Clase (campos estticos)

Variables de Instancia (campos no-estticos)

Los nombres de variables distinguen maysculas de minsculas. El nombre de una

Tipos de datos primitivos

Esto implica declarar el tipo de la variable y el nombre, como ya lo has visto:

Tiene un valor mnimo de -128 y un valor mximo de 127 (inclusivo).

Tiene un valor mnimo de -32,768 y un valor mximo de 32,767 (inclusivo).

Tiene un valor mnimo de -231 y un valor mximo de 231-1.

La firma de long tiene un valor mnimo de -263 y un valor mximo de 263-1.

Use un float (en vez de double) si necesita guardar memoria en grandes

Para valores decimales, este tipo de datos es generalmente la opcin

char: el tipo de datos char es un solo carcter Unicode de 16 bits.

Tiene un valor mnimo de '\u0000' (o 0) y un valor mximo de '\uffff' (o

Adems de los ocho tipos de datos primitivos mencionados anteriormente, el lenguaje de

String s = "this is a string";.

Valores por defecto

No siempre es necesario asignar un valor cuando se declara un campo.

Valor por defecto (de campos)

String (o cualquier objeto) null

Las variables locales son ligeramente diferentes;

Los tipos primitivos son tipos de datos especiales incorporados en el lenguaje;

boolean result = true;

// The number 26, in decimal

Literales de coma flotante

Un literal de coma flotante es de tipo float si termina con la letra F o f; de lo contrario su

Carcteres y literales String

Si tu editor y sistema de archivos lo permiten, se pueden utilizar tales caracteres directamente en el

Finalmente, tambin hay un tipo especial de literal llamada

Una clase literal, se forma al tomar un nombre de tipo y anexar (.class);

Usando caracteres de subrayado en literales de valores numricos

long creditCardNumber = 1234_5678_9012_3456L;

Al principio o al final de un nmero

// Invalido: no se puede poner subrayado

Una arreglo de 10 elementos.

Declarar una Variable para hacer referencia a un Arreglo

// declara un arreglo de enteros

la declaracin en realidad no crea un arreglo; simplemente indica al compilador que esta

Del mismo modo, puede declarar arreglos de otros tipos:

// esta forma se desaconseja

Crear, inicializar y acceder a una arreglo

Otra forma de crear un array es con el operador new.

// crea un arreglo de enteros

ArrayDemo.java:4: Variable anArray may not have been initialized.

anArray[0] = 100; // inicializa el primer elemento

System.out.println("Element 1 at index 0: " + anArray[0]);

Tambin puede declarar un arreglo de arreglos (tambin conocido como un arreglo

// para determinar el tamao del arreglo