Vademecum Java, Apuntes de Ingeniería de Telecomunicaciones

¡Descarga Vademecum Java y más Apuntes en PDF de Ingeniería de Telecomunicaciones solo en Docsity!

Dept. De Ingeniería de Sistemas Telemáticos

E.T.S.I. de Telecomunicación

Universidad Politécnica

Madrid

Java

Vademecum

José A. Mañas

29 de enero de 2007

I. Introducción (Del latín vade , anda, ven, y mecum , conmigo).

1. m. Libro de poco volumen y de fácil manejo para consulta inmediata de nociones o informaciones fundamentales.
2. m. Cartapacio en que los niños llevaban sus libros y papeles a la escuela. Java es un lenguaje de programación orientado a objetos, como otros muchos, con los que comparte los conceptos fundamentales. Pero, además de los conceptos, cada lenguaje de programación conlleva multitud de pequeños detalles que a menudo se olvidan. Estas notas repasan los detalles conceptuales y sintácticos de Java. Se han ordenado alfabéticamente para que sean fáciles de localizar. Cada entrada se explica someramente y se incluyen pequeños ejemplos ilustrativos de cómo se usa. Algunas entradas se refieren a clases de la biblioteca java; en estos casos se comentan los elementos más frecuentemente utilizados. Para mayor detalle, hay que recurrir a la especificación completa.

Derechos de autor

**© 2005, José A. Mañas ** El autor cede a los lectores el derecho de reproducir total o parcialmente cualquier parte de este documento siempre y cuando se cite la fuente y la reproducción sea fiel al original o se indique que ha sido modificado con las palabras “inspirado en”. El autor cede a los lectores el derecho de utilizar el código incluido en los ejemplos, incluso comercialmente, siempre y cuando se cite la fuente. No obstante, el autor declina responsabilidad alguna respecto de la idoneidad del código para fin alguno o la posible existencia de errores que pudieran repercutir en sus usuarios. Cualquier uso del código que aparece en este documento será bajo la entera responsabilidad del usuario del mismo.

• I. Introducción......................................................................................................................................
• II. Vademécum.....................................................................................................................................
  • 1. abstract (palabra reservada).........................................................................................................
  • 1. Accesor [getter] (concepto).........................................................................................................
  • 1. Álgebra de Boole (concepto).......................................................................................................
  • 1. Algoritmo [algorithm] (concepto)...............................................................................................
  • 1. API (acrónimo)............................................................................................................................
  • 1. Argumentos [arguments] (concepto)...........................................................................................
  • 1. Arrays (concepto)......................................................................................................................
    • 7.1. declaración.........................................................................................................................
    • 7.2. creación..............................................................................................................................
    • 7.3. creación con inicialización.................................................................................................
    • 7.4. acceso.................................................................................................................................
    • 7.5. recorrido.............................................................................................................................
    • 7.6. paso de valores...................................................................................................................
    • 7.7. valores de tipo array...........................................................................................................
  • 1. arraycopy (método) java.lang.System.arraycopy(...).................................................................
  • 1. Arrays (clase) java.util.Arrays...................................................................................................
  • 1. Asignación [assignment] (concepto).......................................................................................
  • 1. Atributo (concepto)..................................................................................................................
  • 1. Bloque de sentencias (concepto)..............................................................................................
  • 1. boolean (palabra reservada).....................................................................................................
  • 1. Booleanos (concepto)..............................................................................................................
  • 1. Boolean (clase) java.lang.Boolean...........................................................................................
  • 1. break (palabra reservada).........................................................................................................
  • 1. Bucles [loops] (concepto)........................................................................................................
    • 17.1. while.................................................................................................................................
    • 17.2. do while........................................................................................................................
    • 17.3. for.....................................................................................................................................
    • 17.4. bucles n + ½.....................................................................................................................
    • 17.5. Errores frecuentes.............................................................................................................
  • 1. Bugs (concepto).......................................................................................................................
  • 1. byte (palabra reservada)...........................................................................................................
  • 1. Bytecode..................................................................................................................................
  • 1. Cabecera (de un método) (concepto).......................................................................................
  • 1. Campo [field] (concepto).........................................................................................................
  • 1. Caracteres (concepto)..............................................................................................................
  • 1. case (palabra reservada)...........................................................................................................
  • 1. casting (concepto)....................................................................................................................
    • 25.1. upcasting..........................................................................................................................
    • 25.2. downcasting......................................................................................................................
  • 1. catch (palabra reservada).........................................................................................................
  • 1. char (palabra reservada)...........................................................................................................
  • 1. Character (clase) java.lang.Character......................................................................................
  • 1. Clases (concepto).....................................................................................................................
    • 29.1. Operaciones con clases....................................................................................................
    • 29.2. clases abstractas...............................................................................................................
  • 1. class (palabra reservada)..........................................................................................................
• 1. Código [code] (concepto)........................................................................................................
• 1. Colas [queues] (estructura de datos)........................................................................................
• 1. Collator (clase) java.text.Collator............................................................................................
• 1. Comentarios [comments] (concepto).......................................................................................
• 1. Compilación [compilation] (concepto)....................................................................................
• 1. Command Line Interface (CLI)...............................................................................................
• 1. Composición [composition] (concepto)...................................................................................
  • 37.1. ¿Cuándo usar composición?.............................................................................................
• 1. Conjuntos [set] (estructuras de datos)......................................................................................
• 1. Consola....................................................................................................................................
• 1. Constantes [constant] (concepto).............................................................................................
• 1. Constructores [constructors] (concepto)..................................................................................
• 1. continue (palabra reservada)....................................................................................................
• 1. Cortocircuito [short-circuit] (concepto)...................................................................................
• 1. Cuerpo (de un método) [method body] (concepto).................................................................
• 1. Debug (concepto).....................................................................................................................
• 1. Delegación [delegation] (concepto).........................................................................................
• 1. do while (palabra reservada)................................................................................................
• 1. Documentación [documentation] (concepto)...........................................................................
• 1. double (palabra reservada).......................................................................................................
• 1. Double (class)..........................................................................................................................
• 1. Downcasting (concepto)..........................................................................................................
• 1. Edición [edition] (concepto)....................................................................................................
• 1. Ejecución [execution] (concepto)............................................................................................
  • 53.1. ficheros .class...................................................................................................................
  • 53.2. Con paquetes (o directorios)............................................................................................
  • 53.3. ficheros .jar.......................................................................................................................
  • 53.4. ficheros .jar con manifest.................................................................................................
• 1. Ejecución condicional [conditional execution] (concepto).....................................................
• 1. else (palabra reservada)...........................................................................................................
• 1. Encapsulación [encapsulation] (concepto)..............................................................................
• 1. enum (palabra reservada).........................................................................................................
• 1. Enumerados (concepto)...........................................................................................................
  • 58.1. Métodos estándar.............................................................................................................
  • 58.2. Campos y métodos...........................................................................................................
  • 58.3. Iteración............................................................................................................................
• 1. Enumeration (interface) java.util.Enumeration................................................................
• 1. EnumSet (clase) java.util.EnumSet.........................................................................................
• 1. Envoltorios [wrappers] (concepto)..........................................................................................
• 1. equals (método) public boolean equals(Object)......................................................................
• 1. Error (clase) java.lang.Error....................................................................................................
• 1. Errores (concepto)....................................................................................................................
  • 64.1. de compilación.................................................................................................................
  • 64.2. de ejecución......................................................................................................................
  • 64.3. semánticos........................................................................................................................
  • 64.4. sintácticos.........................................................................................................................
• 1. Etiquetas [labels] (concepto)...................................................................................................
• 1. Excepciones [exceptions] (concepto)......................................................................................
• 1. Excepciones y métodos............................................................................................................
• 1. Exception (clase) java.lang.Exception.....................................................................................
  • 68.1. ¿Cuándo tener excepciones propias?...............................................................................
  • 68.2. ¿Cuándo lanzar Error o subclases de ella?.......................................................................
  • 68.3. ¿Cuándo lanzar Exception o subclases de ella?...............................................................
  • 68.4. ¿Cuándo lanzar RuntimeException o subclases de ella?.................................................
• 1. Expresiones [expressions] (concepto).....................................................................................
  • 69.1. aritméticas........................................................................................................................
  • 69.2. lógicas..............................................................................................................................
  • 69.3. expresiones condicionales................................................................................................
  • 69.4. precedencia de operadores...............................................................................................
• 1. extends (palabra reservada).....................................................................................................
• 1. Extensión (concepto)...............................................................................................................
• 1. Fábricas [factories] (concepto)................................................................................................
• 1. Fichero fuente [source code file].............................................................................................
• 1. Ficheros .java...........................................................................................................................
• 1. final (palabra reservada)..........................................................................................................
• 1. finally (palabra reservada).......................................................................................................
• 1. float (palabra reservada)..........................................................................................................
• 1. for (palabra reservada).............................................................................................................
  • 78.1. Bucles con contador.........................................................................................................
  • 78.2. Bucles con iterador...........................................................................................................
  • 78.3. Recorrido de arrays..........................................................................................................
  • 78.4. Bucles con varios contadores...........................................................................................
  • 78.5. Bucles degenerados..........................................................................................................
• 1. Format (método) void format(String, Object ...).....................................................................
• 1. Formatter (clase) java.util.Formatter.......................................................................................
  • 80.1. Ejemplos...........................................................................................................................
  • 80.2. Especificación de formato................................................................................................
• 1. Friendly....................................................................................................................................
• 1. Genéricos [generics] (concepto)..............................................................................................
  • 82.1. Clases genéricas en el package java.util..........................................................................
  • 82.2. Creación de clases genéricas............................................................................................
  • 82.3. Limitaciones de las clases genéricas en java....................................................................
  • 82.4. Métodos genéricos...........................................................................................................
  • 82.5. Tipos formales acotados...................................................................................................
• 1. Getter (concepto).....................................................................................................................
• 1. hashCode (método) public int hashCode()..............................................................................
• 1. Herencia [inheritance] (concepto)...........................................................................................
  • 85.1. Ocultación versus redefinición.........................................................................................
  • 85.2. Constructores....................................................................................................................
  • 85.3. final..................................................................................................................................
  • 85.4. ¿Cuándo usar herencia?....................................................................................................
• 1. Identificadores [identifiers] (concepto)...................................................................................
• 1. if (palabra reservada)...............................................................................................................
  • 87.1. If encadenados..................................................................................................................
  • 87.2. Situaciones ambiguas.......................................................................................................
  • 87.3. Errores típicos..................................................................................................................
• 1. Igualdad (==)...........................................................................................................................
• 1. Implementación (concepto).....................................................................................................
  • 89.1. Implementación múltiple.................................................................................................
  • 89.2. Implementación parcial....................................................................................................
• 1. implements (palabra reservada)...............................................................................................
• 1. import (palabra reservada).......................................................................................................
• 1. Inheritance (concepto).............................................................................................................
• 1. Inicialización (concepto)..........................................................................................................
• 1. instanceof (palabra reservada).................................................................................................
• 1. int (palabra reservada).............................................................................................................
• 1. Integer (clase) java.lang.Integer...............................................................................................
• 1. Interfaz de programación (concepto).......................................................................................
• 1. Iterable (interface) java.lang.Iterable .......................................................................
• 1. Iterator (interface) java.util.Iterator .........................................................................
  • 99.1. ejemplo de uso..................................................................................................................
• 1. interface (palabra reservada)..................................................................................................
  • 100.1. ¿Cuándo usar interfaces?................................................................................................
• 1. Interfases (concepto)..............................................................................................................
• 1. Interpretación (concepto).......................................................................................................
• 1. jar...........................................................................................................................................
• 1. java (herramienta estándar)....................................................................................................
• 1. javac (herramienta estándar)..................................................................................................
  • 105.1. Con paquetes (o directorios)..........................................................................................
  • 105.2. Incorporando datos de otro proyecto..............................................................................
• 1. javadoc (herramienta estándar)..............................................................................................
• 1. JDK (acrónimo).....................................................................................................................
• 1. JRE (acrónimo)......................................................................................................................
• 1. JVM (acrónimo).....................................................................................................................
• 1. Keywords (palabras reservadas)............................................................................................
• 1. Map (interface) java.util.Map ......................................................................
  • 111.1. métodos de la interface...................................................................................................
  • 111.2. implementaciones estándar............................................................................................
  • 111.3. ejemplo de uso................................................................................................................
  • 111.4. Mapas de Object.............................................................................................................
• 1. List (interface) java.util.List ..................................................................................
  • 112.1. métodos de la interface...................................................................................................
  • 112.2. implementaciones estándar............................................................................................
  • 112.3. ejemplo de uso................................................................................................................
  • 112.4. listas de Object...............................................................................................................
• 1. Listas (estructura de datos)....................................................................................................
• 1. Listas encadenadas [linked lists] (estructura de datos)..........................................................
  • 114.1. Nodos.............................................................................................................................
  • 114.2. Algoritmos sobre listas...................................................................................................
  • 114.3. Listas doblemente encadenadas.....................................................................................
  • 114.4. Listas circulares..............................................................................................................
• 1. long (palabra reservada).........................................................................................................
• 1. main (método) public static void main(String[])...................................................................
• 1. Máquina virtual java (concepto)............................................................................................
• 1. Math (clase) java.lang.Math..................................................................................................
• 1. Método [method] (concepto).................................................................................................
  • 119.1. variables.........................................................................................................................
  • 119.2. signatura.........................................................................................................................
  • 119.3. constructores..................................................................................................................
  • 119.4. métodos de acceso (getters)...........................................................................................
  • 119.5. métodos de carga (setters)..............................................................................................
  • 119.6. paso de argumentos por valor........................................................................................
  • 119.7. paso de argumentos por referencia.................................................................................
  • 119.8. valor devuelto.................................................................................................................
  • 119.9. número indefinido de argumentos (varargs)..................................................................
  • 119.10. métodos recursivos.......................................................................................................
• 1. Miembro [member] (concepto)..............................................................................................
• 1. new (palabra reservada).........................................................................................................
• 1. null (palabra reservada).........................................................................................................
• 1. Números (concepto)...............................................................................................................
  • 123.1. enteros............................................................................................................................
  • 123.2. reales..............................................................................................................................
  • 123.3. valores fuera de rango....................................................................................................
  • 123.4. notación local.................................................................................................................
• 1. Object (clase) java.lang.Object..............................................................................................
• 1. Objetos [objects] (concepto)..................................................................................................
• 1. OO (acrónimo).......................................................................................................................
• 1. OOP (acrónimo).....................................................................................................................
• 1. Operadores (concepto)...........................................................................................................
• 1. Overloading...........................................................................................................................
• 1. package (palabra reservada)...................................................................................................
• 1. Palabras reservadas [keywords].............................................................................................
• 1. Paquete [package] (concepto)................................................................................................
  • 132.1. Nombres canónicos........................................................................................................
  • 132.2. Importación de paquetes..............................................................................................
  • 132.3. Nombre universales......................................................................................................
• 1. Parámetros (concepto).........................................................................................................
• 1. Pilas [stacks] (estructura de datos).......................................................................................
• 1. Polimorfismo [polimorphism] (concepto)...........................................................................
• 1. print (método) void print(...)................................................................................................
• 1. printf (método) void printf(String, Object ...)......................................................................
• 1. println (método) void println(...)..........................................................................................
• 1. private (palabra reservada)...................................................................................................
• 1. Programación orientada a objetos (concepto)......................................................................
• 1. Programación estructurada (concepto)................................................................................
• 1. Programa [program] (concepto)...........................................................................................
• 1. Promoción [widening] (concepto).......................................................................................
• 1. protected (palabra reservada)...............................................................................................
• 1. public (palabra reservada)....................................................................................................
• 1. Recursión (concepto)...........................................................................................................
• 1. Reducción [narrowing] (concepto)......................................................................................
• 1. Refactoring (concepto)........................................................................................................
  • 148.1. Encapsulación..............................................................................................................
  • 148.2. Introducción de variables explicativas.........................................................................
  • 148.3. Extracción / eliminación de variables..........................................................................
  • 148.4. Sustitución de condiciones anidadas por guardas........................................................
  • 148.5. Extracción de métodos.................................................................................................
  • 148.6. Sustituir iteración por recursión (o viceversa).............................................................
• 1. Referencias [references] (concepto)....................................................................................
• 1. return (palabra reservada)....................................................................................................
• 1. RuntimeException (clase) java.lang.RuntimeException.....................................................
• 1. Scanner (clase) java.util.Scanner.........................................................................................
• 1. SDK (acrónimo)...................................................................................................................
• 1. Set (clase) java.util.Set.........................................................................................................
  • 154.1. métodos de la interface.................................................................................................
  • 154.2. implementaciones estándar..........................................................................................
  • 154.3. ejemplo de uso..............................................................................................................
  • 154.4. conjuntos de Object......................................................................................................
  • 1. Setters (concepto)................................................................................................................
  • 1. short (palabra reservada)......................................................................................................
  • 1. Signatura (de un método) (concepto)...................................................................................
  • 1. Sobrecarga de nombres [name overloading] (concepto).....................................................
    • 158.1. Sobrecarga, promoción y upcasting.............................................................................
  • 1. Stacks (concepto).................................................................................................................
  • 1. static (palabra reservada).....................................................................................................
  • 1. String (clase) java.lang.String..............................................................................................
  • 1. StringBuffer (clase) java.lang.StringBuffer.........................................................................
  • 1. StringBuilder (clase) java.lang.StringBuilder......................................................................
  • 1. subclases (concepto)............................................................................................................
  • 1. super (palabra reservada).....................................................................................................
  • 1. Superclases (concepto)........................................................................................................
  • 1. switch (palabra reservada)...................................................................................................
  • 1. System.err............................................................................................................................
  • 1. System.in..............................................................................................................................
  • 1. System.out............................................................................................................................
  • 1. this (palabra reservada)........................................................................................................
  • 1. throw (palabra reservada)....................................................................................................
  • 1. throws (palabra reservada)...................................................................................................
  • 1. Tipos abstractos de datos (TAD) (concepto).......................................................................
  • 1. Tipos formales [type parameters]........................................................................................
  • 1. Tipos primitivos [primitive data types]...............................................................................
  • 1. toString (método) public String toString()...........................................................................
  • 1. try catch finally (palabras reservadas).................................................................................
  • 1. Unicode (concepto)..............................................................................................................
  • 1. Upcasting (concepto)...........................................................................................................
  • 1. Variables [variables] (concepto)..........................................................................................
    • 181.1. actualización (asignación)............................................................................................
    • 181.2. ámbito: accesibilidad....................................................................................................
    • 181.3. ciclo de vida: creación y destrucción...........................................................................
    • 181.4. de clase.........................................................................................................................
    • 181.5. constantes.....................................................................................................................
    • 181.6. declaración...................................................................................................................
    • 181.7. finales...........................................................................................................................
    • 181.8. inicialización................................................................................................................
    • 181.9. locales (en un bloque)..................................................................................................
    • 181.10. de objeto.....................................................................................................................
  • 1. Visibilidad............................................................................................................................
  • 1. void (palabra reservada).......................................................................................................
  • 1. while (palabra reservada).....................................................................................................
• III. Diccionario.................................................................................................................................
  • 1. Acrónimos................................................................................................................................
  • 1. Términos en inglés...................................................................................................................

su comportamiento adecuando la ejecución a lo que interesa en cada momento. double suma (int a, double b) { return a + b; } double c = suma(2, 3.14); argumentos formales [formal arguments] Se denomina así a las variables que aparecen en la cabecera del método. En el ejemplo de arriba: a y b. argumentos reales [actual arguments] Se denomina así a los valores concretos que se usan en la llamada al método. En el ejemplo de arriba: 2 y 3.14. Ver “métodos”.

7. Arrays (concepto)

Son colecciones de objetos numerados, todos del mismo tipo. Pueden ser

• unidimensionales (en álgebra se suelen llamar vectores),
• bidimensionales (en álgebra se suelen llamar matrices),
• tridimensionales (a veces se les llaman tensores)
• de un número superior de dimensiones Por ser más precisos, un "array" multidimensional se concibe como un "vector de vectores" lo que permite que cada vector sea de un tamaño diferente^1. Para poder utilizar un array hay que seguir unos ciertos pasos:

1. declararlo: nombre del array, número de dimensiones y tipo de datos que contiene
2. crearlo o ubicar memoria (memory allocation): número de datos que contiene
3. se puede acceder al array: lectura y escritura 7.1. declaración En la declaración se identifica el nombre, el número de dimensiones y el tipo de datos. int[] vector; // vector de enteros double[][] matriz; // matriz de reales Tipo[]...[] variable; // N dimensiones Sintaxis alternativa (para programadores de C) int vector[]; // vector de enteros double matriz[][]; // matriz de reales Tipo variable[]...[]; // N dimensiones Un array declarado vale NULL hasta que se cree. 7.2. creación Tras declarar un array hay que crearlo, lo que supone asignar memoria en todas y cada una de sus dimensiones: vector = new int[100]; // 0.. 1 Así, una matriz puede verse como una serie de filas, cada una con una serie de columnas. Como no todas las filas tienen que tener el mismo número de columnas, la matriz no necesariamente tiene que ser rectangular.

matriz = new double[2][3]; Se pueden crear arrays de tamaño 0. Declaración y creación pueden llevarse a cabo juntas: int[] vector = new int[100]; // 0.. double[][] matriz = new double[2][3]; Una vez creados de un cierto tamaño, no se puede cambiar este tamaño. Al crear el array, sus elementos reciben un valor por defecto que depende de su tipo:

• enteros: valor 0
• reales: valor 0.
• booleanos: valor false
• caracteres: valor (char)
• objetos: valor null En el siguiente ejemplo se crea una matriz con un número aleatorio de filas y columnas: /**

• Crea una matriz aleatroria.
• Número aleatorio de filas (1 .. 10).
• Número aleatorio de columnas en cada fila (1 .. 10).
• Datos aleatorios en cada posición (-9 .. +99). */ static int[][] crea() { Random random = new Random(); int filas = 1 + random.nextInt(9); int[][] resultado = new int[filas][]; for (int i = 0; i < filas; i++) { int columnas = 1 + random.nextInt(9); resultado[i] = new int[columnas]; for (int j = 0; j < columnas; j++) resultado[i][j] = -9 + random.nextInt(109); } return resultado; } La dimensión de un array viene dada por el “campo” length, que puede ser diferente en diferentes filas: vector.length matriz.length // número de filas matriz[0].length // columnas de la primera fila matriz[1].length // columnas de la segunda fila 7.3. creación con inicialización int[] primos = { 2, 3, 5, 7, 11, 13, 17 }; String[] dialogo = { "hola", "adiós" }; int[][] matriz = { { 1, 2, 3 }, { 4, 5, 6 } };

} 7.6. paso de valores Un array se trata a todos los efectos como un objeto, pasándose referencias entre variables:

• cuando se llama a un método y se le pasa un array, el método hace su copia de la referencia; pero comparte el array void metodo(int[] x) { x[0] = 2; } int[] a = new int[7]; ... a[0] // vale 0 metodo(a); ... a[0] // vale 2
• cuando una variable de tipo array se hace igual a otra, se copia la referencia; pero se comparte el array int[] a = new int[7]; ... a[0] // vale 0 int[] b = a; b[0] = 2; ... a[0] // vale 2 copia del contenido Si no basta con compartir la referencia, sino que se necesita otra copia de un array int[] a = ...; int[] b = (int[]) a.clone()^2 ; O se puede usar el método estándar “arraycopy”. int[] a = ...; int[] b = new int[a.length]; System.arraycopy(a, 0, b, 0, a.length); 7.7. valores de tipo array Se pueden generar directamente valores que son arrays, tanto para cargar una variable como para pasárselos a un método (como argumento de llamada): vector = new int[] { 2, 4, 6, 8, 16, 32, 64, 128 }; opciones(new String[] { “si”, “no” }); new Triangulo(new Punto[] {new Punto(0, 0), new Punto(2, 0), new Punto(1, 1) } );

8. arraycopy (método) java.lang.System.arraycopy(...)

Este método sirve para copiar unos cuantos datos de un array en otro. void arraycopy(Object origen, int p1, Object destino, int p2, int n) copia “n” datos del array “origen” al array “destino”. El primer dato que se copia del origen es el que esté en la posición “p1”, que va a la posición “p2” del destino. Los arrays deben existir y disponer de suficientes datos en origen y espacio en destino para trasladar los n valores solicitados. Además, los objetos en “origen” deben poder asignarse al array 2 Si los elementos del array son de un tipo primitivo, se copia su valor. Si son objetos, se copia la referencia, compartiéndose el objeto.

“destino” (es decir, ser de tipos compatibles en asignación. arraycopy es cuidadoso con los casos en que origen y destino sean el mismo array. Los siguientes fragmentos de código son equivalentes en cuanto a su función; pero “arraycopy” es notablemente más rápido: void arraycopy(Object origen, int p1, Object destino, int p2, int n) class A {} class B extends A {} void copiador(B[] origen, int p1, A[] destino, int p2, int n) { A[] temporal = new A[n]; for (int k = 0; k < n; k++) temporal[k] = origen[p1 + k]; for (int k = 0; k < n; k++) destino[p2 + k] = temporal[k]; }

9. Arrays (clase) java.util.Arrays

Esta clase proporciona múltiples métodos para manipular arrays sobre múltiples tipos de datos T : primitivos (enteros, reales, caracteres y booleanos) y objetos. static void fill(T[] array, T valor) Llena el array con el valor indicado: todos los elementos iguales. static boolean equals(T[] a1, T[] a2) Chequea si los arrays son idénticos, comprobando valores primitivos (==) y referencias (con equals). static boolean deepEquals(Object[] a1, Object[] a2) Chequea si los arrays son idénticos, comprobando valores primitivos (==) y referencias (con equals ). Además, si el array es multidimensional, profundiza en las sucesivas dimensiones. static String toString(T[] datos) Genera una cadena para impresión. static int binarySearch(T[] datos, T clave) Busca en qué posición del array datos se encuentra la clave dada. El array debe estar ordenado. static void sort(T[] datos) Ordena el array. static void sort(T[] datos, int desde, int hasta) Ordena el array entre las posiciones indicadas.

10. Asignación [assignment] (concepto)

Se llaman sentencias de asignación a las que cargan un nuevo valor en una variable: variable = expresión ; El tipo de la variable debe ser

• igual al de la expresión
• en tipos primitivos:
  • asignable por promoción (ver “promoción”)
  • asignable por reducción (ver “reducción”)

• x ^ y
• negación lógica (en inglés, NOT: el resultado es lo contrario del operando -! x Ejemplo. Un año es bisiesto si es múltiplo de 4, excepto si es múltiplo de 100. No obstante, lo múltiplos de 400 son también bisiestos. boolean bisiesto (int año) { boolean multiplo4 = año % 4 == 0; boolean multiplo100 = año % 100 == 0; boolean multiplo400 = año % 400 == 0; return (multiplo4 && (! multiplo100)) || multiplo400; }

14. Booleanos (concepto)

Ver "boolean".

15. Boolean (clase) java.lang.Boolean

Clase que sirve para tratar los booleanos como objetos, además de proporcionar una serie de métodos útilies: Boolean (boolean b) Constructor. Pasa de tipo primitivo a objeto. Boolean (String s) usa como boolean el resultado de: s.equalsIgnoreCase("true") static boolean parseBoolean(String s) return s.equalsIgnoreCase("true"); static String toString(boolean b) pasa el valor b a una String

16. break (palabra reservada)

Se emplea para forzar la terminación de un bucle^6. Es útil en bucles cuya condición de terminación no se puede chequear cómodamente ni al principio (bucles "while") ni al final (bucles "do ... while"). for ( ; ; ) { String linea = entrada.readLine(); if (linea == null) break; // se hace algo con la línea leída } Aunque es muy práctico, puede dar lugar a programas de difícil lectura. Se recomienda NO usarlo salvo que sea evidente su necesidad. 6 “break” también se emplea en construcciones “switch”.

sin break con break String linea = teclado.readLine(); while (linea != null) { procesa(linea); linea = teclado.readLine(); } for ( ; ; ) { String linea = teclado.readLine(); if (linea == null) break ; procesa(linea); }

17. Bucles [loops] (concepto)

Fragmentos de código que se ejecutan repetidamente. Java proporciona diferentes tipos de bucles:

• "while", que se ejecutan cero o más veces; la condición de terminación se chequea al principio
• "do ... while", que se ejecutan una o más veces; la condición de terminación se chequea al final
• "for", que se ejecutan N veces Cuando un bucle está lanzado, java proporciona dos formas de forzarlo desde dentro:
• "break": provoca la terminación del bucle: lo aborta
• "continue: provoca el comienzo de una nueva repetición: aborta esta pasada 17.1. while Los bucles “while” se ejecutan cero o más veces. Ver “while”. 17.2. do ... while Los bucles “do ... while” se ejecutan una o más veces. Ver “do”. 17.3. for Los bucles “for” se ejecutan un número determinado de veces. Ver “for”. 17.4. bucles n + ½ En algunas ocasiones no es cómodo escribir la condición de terminación ni al principio (“while”) ni al final (“do ... while”) sino que aparece de forma natural por en medio: for ( ; ; ) { String linea = consola.readLine(); if (linea == null) break; procesa(linea); } while (true) { String linea = consola.readLine();

• lo que hay en los ficheros .class
• lo que genera el compilador (javac)
• lo que pasamos al intérprete (java)
• lo que ejecuta la máquina virtual (JVM) Ver "código".

21. Cabecera (de un método) (concepto)

Son las primeras líneas de un método, donde se indicaremos:

• su visibilidad: public, ..., private
• el tipo de valor que devuelve (o void si no devuelve nada)
• el nombre del método
• los argumentos formales: tipo y nombre public String cifra(String texto, byte[] clave);

22. Campo [field] (concepto)

Son los valores internos de las clases y/o objetos.

• de objeto: cuando cada objeto de una clase tiene su propia copia
• de clase ( static ): cuando todos los objetos de una clase comparten una copia común class Circulo class Circulo { public static final double PI = 3.1416; private double radio ; double area () { return PI * r * r; }
• "PI" es un campo de clase porque pone " static "^7. Todos los objetos de clase Circulo comparten el mismo valor de "PI".
• "radio es un campo de objeto porque no pone " static "^8. Cada objeto de clase Circulo tendrá su propio radio. Cada campo puede calificarse como:

1. public , protected , de paquete o private , según la visibilidad que se desee
2. static si es de clase; si no se dice nada es de objeto
3. final si queremos que su valor sea inmodificable; si no se dice nada, podrá modificarse Se recomienda que

• todos los campos de objeto sean private
• todos los campos de objeto queden inicializados en su construcción
• los nombre de los campos de objeto empiecen por una letra minúscula
• los nombres de los campos de clase empiecen por una letra minúscula, salvo que sean constantes ( static final ) en cuyo caso se escribirán con letras mayúsculas 7 Además, es público ("public") e inmutable ("final"); es decir, una constante. 8 Además, es privado ("private").

23. Caracteres (concepto)

Ver "char": caracteres individuales. Ver "String": cadenas de caracteres.

24. case (palabra reservada)

Componente sintáctico de sentencias condicionales de tipo “switch”.

25. casting (concepto)

Se dice de la conversión entre tipos de datos. Con tipos primitivos, se denomina promoción (cuando se pasa de un tipo más pobre a un tipo más rico) y reducción (cuando se pasa de un tipo más rico a un tipo más pobre). Ver “promoción” y “reducción”. Con objetos, el objeto en sí no se modifica; pero sí se modifica el tipo de objeto que la variable cree que referencia. En los párrafos siguientes usaremos las definiciones class A { ... } class B extends A { ... } 25.1. upcasting Se dice del caso en el que una variable de tipo A recibe el valor de una variable de tipo B. B b = ...; A a = (A)b; // explícito; no es necesario A a = b; // implícito Esta operación siempre se puede hacer, sin necesidad de indicárselo explícitamente al compilador. Es una operación segura que jamás causa ningún error. 25.2. downcasting Se dice del caso en el que una variable de tipo B recibe el valor de una variable de tipo A. A a = ...;; B b = (B)a; // explícito; es necesario Esta operación sólo se puede hacer, si el objeto referenciado por “a” es realmente de tipo B; es decir, sólo es posible cuando el downcasting deshace un upcasting anterior. De lo contrario se provoca un error en tiempo de ejecución, lanzándose una excepción de tipo ClassCastException. factible ClassCastException A a = new B(); B b = (B)a; A a = new A(); B b = (B)a;