Java Basico 1

JAVA FUNDAMENTALS PROGRAMMING
[Type the document subtitle]

[Type the abstract of the document here. The abstract is typically a short summary of the contents of the document. Type the abstract of the document here. The abstract is typically a short summary of the contents of the document.] Ing. Marcel Chasiguasi 1/9/2012
TABLE OF CONTENTS
INTRODUCCION ................................................................................................................... 6 HISTORIA DE JAVA .......................................................................................................... 6 Los antecedentes de Java ................................................................................................ 6 La llegada de Java ........................................................................................................... 6 Caractersticas de Java .................................................................................................... 7 Utilizando java desde la consola de comandos ...................................................................... 8 Instalando la JDK y configurando el entorno..................................................................... 9 Compilando y ejecutando ................................................................................................. 10 Identificadores .................................................................................................................. 10 Identificadores legales ................................................................................................... 11 Convenciones de cdigo de Java Sun ............................................................................. 11 Estndares para nombres de JavaBeans........................................................................ 11 Declaraciones de clases y modificadores de acceso .......................................................... 12 Modificadores de acceso a clases .................................................................................. 13 Modificadores de no acceso .......................................................................................... 13 Declaracin de interfaces .................................................................................................. 14 Declaracin de mtodos y atributos ................................................................................. 15 Modificadores de acceso ............................................................................................... 15 Modificadores de acceso en variables locales ............................................................... 16 Modificadores de no acceso .......................................................................................... 16 Modificador de no acceso en mtodos final............................................................... 16 Modificador de no acceso en atributos final .............................................................. 16 Modificador de no acceso en mtodos abstract ......................................................... 16 Modificador de no acceso en mtodos synchronized ................................................ 16 Modificador de no acceso en mtodos Native ........................................................... 16 Modificador de no acceso en mtodos strictfp ...........................................................17 Chapter: INTRODUCCION
JAVA FUNDAMENTALS PROGRAMMING Mtodos con listas de argumentos variables .................................................................17 Declaracin de constructores ........................................................................................ 18 Declaracin de variables ................................................................................................... 18 Declaracin de variables primitivas y rango de variables ............................................. 18 Declaracin de variables de referencia ......................................................................... 19 Declaracin de arrays .................................................................................................... 20 Declaracin de variables final ....................................................................................... 20 Variables transient ........................................................................................................ 20 Variables volatile ........................................................................................................... 20 Variables y mtodos estticos ....................................................................................... 20 Declaracin de enumeradores....................................................................................... 20 Paradigmas de programacin ........................................................................................... 21 Paradigma estructural ................................................................................................... 21 Paradigma orientado a objetos ..................................................................................... 21 Definicin de una clase ................................................................................................. 22 Diferencia entre clase y objeto ...................................................................................... 23 Ms conceptos de la POO ................................................................................................. 24 Encapsulamiento........................................................................................................... 24 Herencia ........................................................................................................................ 24 Polimorfismo ................................................................................................................. 25 Sobre escritura .............................................................................................................. 26 Sobrecarga ..................................................................................................................... 27 Polimorfismo en sobre escritura y sobrecarga .............................................................. 28 Casteo de variables de referencia .................................................................................. 29 Implementar (implements) una interfaz ......................................................................... 31 Tipos de valor de retorno vlidos ..................................................................................... 31 Declaracin de tipos de valor de retorno (Return types declaration)........................... 31 Tipos de valor de retorno en mtodos sobrecargados .................................................. 31 Tipos de valor de retorno en mtodos sobre escritos ................................................... 32 Devolviendo un valor .................................................................................................... 32 Constructores e instanciacin........................................................................................... 32 Conceptos bsicos de los constructores (Constructor basics) ...................................... 32 Llamadas en cadena a constructores (Constructor chaining) ...................................... 32
JAVA FUNDAMENTALS PROGRAMMING Reglas de los constructores (Rules for constructors).................................................... 33 Determinar cundo se crear el constructor por defecto.............................................. 33 Como es el constructor por defecto? ............................................................................. 34 Qu pasa si el constructor de la superclase requiere argumentos? .............................. 34 Sobrecarga de constructores ......................................................................................... 34 Mtodos y variables estticos ........................................................................................ 34 Accediendo a mtodos y variables estticas.................................................................. 35 Valores literales para todos los tipos primitivos............................................................... 35 Integer ........................................................................................................................... 35 Literales decimal ........................................................................................................... 35 Literales octal ................................................................................................................ 35 Literal hexadecimal ....................................................................................................... 35 Punto flotante................................................................................................................ 35 Booleanos ...................................................................................................................... 36 Caracteres ...................................................................................................................... 36 Strings ........................................................................................................................... 36 Operadores de asignacin ................................................................................................. 36 Asignacin de valores primitivos .................................................................................. 36 Casteo de primitivas ...................................................................................................... 37 Tabla de casteos implcitos para primitivas .................................................................. 37 Asignacin de nmeros con punto flotante .................................................................. 38 Asignacin de un literal que es ms grande que la variable ......................................... 38 Asignar una variable primitiva a otra variable primitiva.............................................. 38 mbito de las variables (scope) .................................................................................... 38 Errores ms comunes con problemas de scope ............................................................ 39 Utilizar una variable o array que no ha sido inicializado ni asignado .......................... 39 Variables de instancia de tipos primitivos y objetos ..................................................... 39 Variables de instancia de tipo array .............................................................................. 40 Variables primitivas locales y objetos ........................................................................... 40 Envo de variables a mtodos ........................................................................................ 41 Declaracin, construccin e inicializacin de arrays .................................................... 41 Construccin de un array .............................................................................................. 41 Construir un array multidimensional ........................................................................... 42 Chapter: INTRODUCCION
JAVA FUNDAMENTALS PROGRAMMING Inicializacin de un array .............................................................................................. 42 Inicializando elementos en un bucle ............................................................................. 43 Declaracin, construccin, e inicializacin en una lnea .............................................. 43 Construyendo e inicializando un array annimo .......................................................... 43 Asignaciones legales de elementos de un array ............................................................ 44 Asignaciones legales de referencias de tipo array ............................................................ 44 Referencias para tipo de datos primitivos .................................................................... 44 Referencias para tipos de datos de referencia .............................................................. 44 Referencias para tipos de datos de referencia en arrays multidimensionales .............. 44 Bloques de inicializacin................................................................................................... 45 Las clases Wrapper........................................................................................................ 46 Creacin de objetos Wrapper ........................................................................................ 46 Los constructores del Wrapper ..................................................................................... 47 El mtodo valueOf() ...................................................................................................... 47 Utilidades de conversin de los Wrappers .................................................................... 47 Autoboxing .................................................................................................................... 49 Boxing, ==, y equals() ................................................................................................... 49 Sobrecarga (overloading) .............................................................................................. 49 Sobrecarga con boxing y var-args ................................................................................. 50 Sobrecarga con var-args ................................................................................................ 50 Operadores ........................................................................................................................... 50 Operadores de asignacin ................................................................................................. 50 Operadores de asignacin compuestos............................................................................. 51 Operadores relacionales ................................................................................................... 52 Operadores de igualdad .................................................................................................... 53 Igualdad en primitivas ...................................................................................................... 54 Igualdad en variables de tipo referencia........................................................................... 54 Igualdad en enumeradores ........................................................................................... 55 Comparacin con instanceof ......................................................................................... 55 Operadores aritmticos ................................................................................................. 56 Operadores de incremento y decremento ..................................................................... 56 Operador condicional.................................................................................................... 58 Operadores lgicos............................................................................................................ 58
JAVA FUNDAMENTALS PROGRAMMING Operadores lgicos sobre bits (no entra en el examen) ................................................ 58 Operadores lgicos de circuito corto............................................................................. 59 Operadores lgicos de circuito completo ...................................................................... 60 Operadores lgicos ^ y ................................................................................................ 61 If y Switch ......................................................................................................................... 62 If-else ............................................................................................................................. 62 Switch ............................................................................................................................ 65 Bucles e iteraciones ....................................................................................................... 67 While ............................................................................................................................. 67 Sentencias de ruptura con etiquetas ............................................................................. 72 Manejo de excepciones.................................................................................................. 73 Propagacin de excepciones.......................................................................................... 74 Definiendo que es una excepcion .................................................................................. 76 Jerarqua de excepciones .................................................................................................. 76 Atrapando excepciones ................................................................................................. 76 Declaracion de excepciones e interface pblica ............................................................ 77 Relanzando excepciones ............................................................................................... 78 De donde provienen las excepciones ............................................................................ 79 Afirmaciones .................................................................................................................80 El mtodo toString() ..................................................................................................... 83 Sobrescribiendo el mtodo equals().............................................................................. 84 Contratos a cumplir....................................................................................................... 86 Colecciones ....................................................................................................................... 86 Caractersticas de cada clase ......................................................................................... 86 List <<interface>> ........................................................................................................ 87 Set <<interface>> ......................................................................................................... 88 Map <<interface>> ....................................................................................................... 89 Queue <<interface>> .................................................................................................... 90 ArrayList........................................................................................................................ 91 Autoboxing con colecciones .......................................................................................... 92 Ordenando colecciones ................................................................................................. 92 La interfaz comparable.................................................................................................. 93 La interfaz comparator.................................................................................................. 94 Chapter: INTRODUCCION
JAVA FUNDAMENTALS PROGRAMMING Comparable vs Comparator .......................................................................................... 96 Ordenando con la clase Arrays...................................................................................... 96 Bsqueda en Arrays y Collections ................................................................................. 96 Conversion de Arrays a Lists a Arrays .......................................................................... 97 Utilizando los Lists ........................................................................................................ 98 Utilizando los Sets ....................................................................................................... 100 Utilizando los Maps......................................................................................................101 Bsqueda dentro de los TreeSets y TreeMaps ............................................................ 103 Colecciones respaldadas.............................................................................................. 103 Mtodos para crear colecciones respaldadas .............................................................. 104 Cola de prioridades (PriorityQueue) .............................................................................. 105 Mtodos de PriorityQueue .......................................................................................... 105 Resmen de mtodos para Arrays y Colecciones ........................................................ 105 Resumen de mtodos para List, Set y Map ................................................................. 106 Genricos ........................................................................................................................ 107 Un vistazo a colecciones con y sin genricos .............................................................. 107 Mezclando colecciones genricas y no genricas ........................................................ 109 Polimorfismo y genricos .............................................................................................110 Comodines en la declaracin de mtodos .................................................................... 111
Java Fundamentals Programming

INTRODUCCION
HISTORIA DE JAVA
LOS ANTECEDENTES DE JAVA Antes de que llegue Java a facilitarnos el desarrollo de aplicaciones existan ya varios lenguajes de programacin tales como Fortran, Cobol, Basic, Pascal, C, etc. Pero estos lenguajes usaban tcnicas de programacin estructurada, lo cual causaba problemas de cdigo incontrolable cuando la aplicacin creca. Entre ellos tambin estaba el lenguaje C, como el lenguaje ms popular en aquella poca. Este es un lenguaje muy verstil, con posibilidad de programar en ensamblador y la comodidad que da los lenguajes de alto nivel. El inconveniente de este lenguaje es que permita acceso directo a la memoria del computador usando punteros. Recuerdo que los punteros causaban dolores de cabeza a los programadores. Hay otro inconveniente es que un programa en C/C++ es ejecutable, provocando que el programa no sea independiente de la plataforma en la que se ejecuta. Para mitigar el problema de cdigo incontrolable se cre el Lenguaje C++ con soporte de programacin Orientada a Objetos. Pero segua teniendo problemas debido a que C++soportaba el paradigma de programacin estructurada, el cual provocaba que los programadores no usen el nuevo paradigma de Orientacin a Objetos. Java fue diseado para satisfacer las necesidades de la poca, planteada por nuevos requerimientos que surgan a los lenguajes existentes. LA LLEGADA DE JAVA En 1991, la empresa Sun Microsystem inicia el Proyecto Green(Proyecto Verde), sus objetivos estaban enfocados a crear un lenguaje para dispositivos electrnicos inteligentes y televisin interactiva. En el lapso de 18 meses se presentaron varios requerimientos: Lenguaje fcil de usar y aprender Programacin Orientada a Objetos Multiplataforma: Los dispositivos inteligentes cambian con frecuencia, asi que deseaban que el programa que funciones en un dispositivo funcione para las nuevos modelos de dispositivos El resultado fue un nuevo lenguaje llamado Oak (Roble en inlges, nombre originado por el roble que vea en la ventana de sus despacho), este lenguaje tenia similitudes con C/C++ y no estaba ligado a tipo de CPU especifico.
Chapter: INTRODUCCION
JAVA FUNDAMENTALS PROGRAMMING Ms tarde en 1995 el nombre fue cambiado de Oak a Java(Nombre dado por un tipo de caf originario de Asia) por custiones de propiedad intelectual, debido a que ya exista un lenguaje llamado Oak. Java se da a conocer al pblico. Adquiere notoriedad rpidamente. Java pasa a ser un lenguaje totalmente independiente de la plataforma y a la vez potente y orientado a objetos. Esa filosofa y su facilidad para crear aplicaciones para redes TCP/IP ha hecho que sea uno de los lenguajes ms utilizados en la actualidad. Sus ventajas sobre C++ son: Su sintaxis es similar a C y C++ No hay punteros (lo que le hace ms seguro) Totalmente orientado a objetos Muy preparado para aplicaciones TCP/IP Implementa excepciones de forma nativa Es interpretado (lo que acelera su ejecucin remota, aunque provoca que las aplicaciones Java se ejecuten ms lentamente que las C++ en un ordenador local). Permite multihilos Admite firmas digitales Tipos de datos y control de sintaxis ms rigurosa Es independiente de la plataforma La ltima ventaja (quiz la ms importante) se consigue ya que el cdigo Java no se compila, sino que se precompila, de tal forma que se crea un cdigo intermedio que no es ejecutable. Para ejecutarle hace falta pasarle por un intrprete que va ejecutando cada lnea. Ese intrprete suele ser la mquina virtual de Java CARACTERSTICAS DE JAVA Bytecodes Los programas Java no son ejecutables, no se compilan como los programas en C o C++. En su lugar son interpretados por una aplicacin conocida como la mquina virtual de Java (JVM). Gracias a ello no tienen porque incluir todo el cdigo y libreras propias de cada sistema. Previamente el cdigo fuente en Java se tiene que precompilar generando un cdigo (que no es directamente ejecutable) previo conocido como bytecode o J-code. Ese cdigo (generado normalmente en archivos con extensin class) es el que es ejecutado por la mquina virtual de Java que interpreta las instrucciones de los bytecodes, ejecutando el cdigo de la aplicacin. El bytecode se puede ejecutar en cualquier plataforma, lo nico que se requiere es que esa plataforma posea un intrprete adecuado (la mquina virtual de esa plataforma). La mquina virtual de Java, adems es un programa muy pequeo y que se distribuye gratuitamente para prcticamente todos los sistemas operativos. A este mtodo de ejecucin de programas en tiempo real se le llama Just in Time (JIT).
En Java la unidad fundamental del cdigo es la clase. Son las clases las que se distribuyen
JAVA FUNDAMENTALS PROGRAMMING en el formato bytecode de Java. Estas clases se cargan dinmicamente durante la ejecucin del programa Java. Seguridad Al interpretar el cdigo, la JVM puede delimitar las operaciones peligrosas, con lo cual la seguridad es fcilmente controlable. Adems, Java elimina las instrucciones dependientes de la mquina y los punteros que generaban terribles errores en C y la posibilidad de generar programas para atacar sistemas. Tampoco se permite el acceso directo a memoria y adems. La primera lnea de seguridad de Java es un verificador del bytecode que permite comprobar que el comportamiento del cdigo es correcto y que sigue las reglas de Java. Normalmente los compiladores de Java no pueden generar cdigo que se salte las reglas de seguridad de Java. Pero un programador malvolo podra generar artificialmente cdigo bytecode que se salte las reglas. El verificador intenta eliminar esta posibilidad. Hay un segundo paso que verifica la seguridad del cdigo que es el verificador de clase que es el programa que proporciona las clases necesarias al cdigo. Lo que hace es asegurarse que las clases que se cargan son realmente las del sistema original de Java y no clases creadas reemplazadas artificialmente. Finalmente hay un administrador de seguridad que es un programa configurable que permite al usuario indicar niveles de seguridad a su sistema para todos los programas de Java. Hay tambin una forma de seguridad relacionada con la confianza. Esto se basa es saber que el cdigo Java procede de un sitio de confianza y no de una fuente no identificada. En Java se permite aadir firmas digitales al cdigo para verificar al autor del mismo. Tipos de aplicaciones Java Applet: Son programas Java pensados para ser colocados dentro de una pgina web. Pueden ser interpretados por cualquier navegador con capacidades Java. Estos programas se insertan en las pginas usando una etiqueta especial (como tambin se insertan vdeos, animaciones flash u otros objetos). Los applets son programas independientes, pero al estar incluidos dentro de una pgina web las reglas de stas le afectan. Normalmente un applet slo puede actuar sobre el navegador. Hoy da mediante applets se pueden integrar en las pginas web aplicaciones multimedia avanzadas (incluso con imgenes 3D o sonido y vdeo de alta calidad) Aplicaciones de consola: Son programas independientes al igual que los creados con los lenguajes tradicionales. Aplicaciones grficas: Aquellas que utilizan las clases con capacidades grficas (como awt por ejemplo). Servlets: Son aplicaciones que se ejecutan en un servidor de aplicaciones web y que como resultado de su ejecucin resulta una pgina web.
UTILIZANDO JAVA DESDE LA CONSOLA DE COMANDOS

Vamos a hacer una diferencia entre dos componentes de Java: JRE JDK
Chapter: Utilizando java desde la consola de comandos
JRE (Java Runtime Environment): Set de libreras que permiten correr una JVM en la pc para poder ejecutar un programa escrito en Java (bytecodes). JDK (Java Development Kit): Como mencionamos arriba, los bytecodes son un lenguaje intermedio entre el cdigo fuente y el cdigo mquina, el cual es interpretado para la JVM. Para generar este cdigo, necesitamos de otras funcionalidades que no contiene la JRE. Adems, en la JDK encontraremos la API de Java. Un set de libreras predefinidas para que utilicemos en nuestros programas. Los pasos a continuacin representan una gua simple para poder utilizar la consola de comandos, simplemente para que puedan hacer ejercicios sobre los temas estudiados. De todas maneras, la consola de comandos se tratar ms a fondo en entregas posteriores.
INSTALANDO LA JDK Y CONFIGURANDO EL ENTORNO

1. Si ya tienes una version de la JDK igual o superior a la 1.6.0 puedes pasar al paso 3. Vamos a obtener la JDK desde el sitio oficial de sun http://java.sun.com. El link directo: http://java.sun.com/javase/downloads/widget/jdk6.jsp Lo que nosotros buscamos es la JDK de Java SE. 2. Una vez que hayas desccargado la JDK es tiempo de instalarla. 3. Dijimos que ibamos a utilizar la consola de comandos, el problema es que la JDK no se almacena en la variable PATH de windows, esto quiere decir que aun no podemos ejecutar los comandos de Java, salvo que nos encontremos en el directorio de los mismo \[Directorio instalacin JDK]\Bin\ En Windows, lo que vamos a hacer primero es rastrear este Path. Generalmente se encuentra en: C:\Archivos de programa\Java\jdk1.6.0_XX\bin\. Si no puedes dar con este Path, puedes buscar el archivo javac.exe. Una vez que tengas el directorio, guardalo en un txt. 4. Botn derecho sobre Mi Pc -> Propiedades. En la solapa de Opciones Avanzadas, buscamos la opcin que dice Variables de entorno. En el segundo recuadro, buscamos por una variable que se llame PATH. Doble click sobre la misma, y abrir la edicin. Ahora, agreguen el siguiente texto sin eliminar lo que hubiera antes: ;[Path copiado al txt]; donde Path copiado al txt es el path de los bin de la JDK (ponemos entre comillas el cdigo por si el path contiene algn espacio). Luego acepta los cambios. 5. Ve a Menu Inicio -> Ejecutar -> y tipea cmd. Se debera de abrir una consola de comandos. Ahora vamos a probar que la asignacin del Path fue correcta. Para ello tecleamos el comando javac. Debera de aparecerte algo como lo siguiente:
C:\>javac Usage: javac <options> <source files> where possible options include:
Si recibiste un mensaje que comienza como este, significa que la instalacin fue exitosa, de lo contrario, vuelve a rever los pasos anteriores.
COMPILANDO Y EJECUTANDO
Cuando escriban cdigo en Java, cada archivo fuente contendra la extensin java (dificil de recordar, no?!). En cambio, los archivos compilados contienen la extensin class. Tambin pueden estar dentro de un jar, que no es ms que un zip que los agrupa en un solo archivo (tiene otras particularidades). Nosotros vamos a centrarnos en la creacin de los .java y los .class. Los jar los dejaremos fuera por ahora. Esta seccin tiene en cuenta que el lector tiene conocimientos bsicos para manejarse en la consola de comandos. Vamos a crear nuestra primer app. Java: 1. Crea un archivo llamado HolaJavaWorld.java (en el directorio que quieras), y copia el cdigo a continuacin dentro del archivo.
1. 2. 3. 4. 5. public class HolaJavaWorld { static public void main(String[] args) { System.out.println("Hola Java World!"); } }
Con estos conocimientos bsicos de la consola, y un poco de conocimiento del lenguaje Java, ya te encuentras en condiciones de generar cdigo para probar tus conocimientos sobre lo que vayas leyendo.
System.out.println(Buena Suerte);
IDENTIFICADORES
Los identificadores permiten que podamos identificar una variable por un nombre y/o conjunto de caracteres alfanumricos (generalmente, describen el contenido). Para los identificadores, existen una serie de convenciones.
10
2. Ejecuta la consola de comandos, y posiciona el Prompt sobre el directorio donde creaste el archivo (Tip: si haces botn derecho sobre el directorio, vers una opcin que dice smbolo de sistema, esto te habre una consola de comandos posicionada en dicho directorio). 3. Ejecuta javac g HolaJavaWorld.java . En esta parte es donde le pedimos al compilador de Java que genere el Bytecode de dicho archivo fuente. Si llegase a existir algn error de compilacin, es en este punto que se nos informa de tal. 4. Ejecuta java HolaJavaWorld. Aqui creamos una instancia de la JVM sobre la cual correr nuestra aplicacin, en la cual veremos un grandioso Hola Java World!.
JAVA FUNDAMENTALS PROGRAMMING IDENTIFICADORES LEGALES Los identificadores legales se refieren a aquellos que cumplen con las normas mnimas de manera que el compilador no genere un error en tiempo de compilacin. Las caractersticas que deben de cumplir los identificadores son:
Debe estar compuesto de caracteres Unicode, nmeros, $ o _ Debe comenzar con un carcter Unicode, $ o _ Luego del primer carcter, puede contener cualquier conjunto de los nombrados en el primer punto No tienen un lmite de largo No es posible utilizar palabras reservadas de Java Son case-sensitive (distingue maysculas de minsculas)
Expresin regular de la composicin de un identificador legal: [\w$_]([\w\d$_]*) CONVENCIONES DE CDIGO DE JAVA SUN Sun cre un conjunto de estndares de codificacin para Java, y public estos estndares en un documento titulado Convenciones de cdigo de Java el cual puede ser encontrado en java.sun.com. Las caractersticas que debe de cumplir los identificadores son: Clases e interfaces o La primer letra debe ser mayscula o Utiliza nomenclatura camelCase o Para las clases, los nombres deben de ser sustantivos o Para las interfaces, los nombres deben de ser adjetivos Mtodos o La primer letra debe ser minscula o Utiliza nomenclatura camelCase o Los nombres deben conformarse por el par verbo + sustantivo Variables o La primer letra debe ser minscula o Utiliza nomenclatura camelCase o Es recomendable utilizar nombres con un significado explcito, y en lo posible, cortos Constantes o Todas las letras de cada palabra deben estar en maysculas o Se separa cada palabra con un _
ESTNDARES PARA NOMBRES DE JAVABEANS Al utilizar estndares para nombres, se garantiza que las herramientas puedan reconocer los componentes realizados por cualquier desarrollador. Las caractersticas que debe de cumplir los identificadores son: Atributos
JAVA FUNDAMENTALS PROGRAMMING Ambos (getters y setters) se conforman del prefijo especificado + el nombre del atributo con su primer letra en mayscula o Getters Si la propiedad no es de tipo boolean el prefijo debe ser get Si la propiedad es de tipo boolean el prefijo debe ser is Deben de ser public, no recibir ningn argumento, y devolver un valor del mismo tipo que el setter para la propiedad. o Setters El prefijo debe ser set Deben de ser public, recibir un parmetro del mismo tipo que la propiedad, y devolver void Listeners o Los mtodos que agreguen un listener deben de comenzar con el prefijo add o Los mtodos que quiten un listener deben de comenzar con el prefijo remove o El tipo del listener a agregar/quitar debe de ser pasado como argumento o Deben de terminar con el sufijo Listener Archivos de cdigo fuente o Solo puede haber una clase public por cada archivo o Los comentarios pueden aparecer en cualquier lnea o Si existe una clase public, el nombre de la misma debe corresponderse con el nombre del archivo o Si la clase pertenece a un package, esta sentencia debe ser incluida como primera lnea o Si hay import, estos deben de ser incluidos entre la declaracin del package y de la clase (class) o Los import y package aplican a todas las clases dentro del archivo o Un archivo puede tener ms de una clase, siempre que esta no sea public o Los archivos que no tengan una clase public pueden contener cualquier nombre o
DECLARACIONES DE CLASES Y MODIFICADORES DE ACCESO

El acceso significa visibilidad. Dependiendo de los modificadores aplicados a la clase, atributos, o propiedades, ser que estos podrn ser accedidos o no por otros. Modificadores de acceso o public o prvate o protected o Default (package). Si no se especifica un modificador, este es el que toma por defecto Modificadores de no acceso o strictpf o final
12
JAVA FUNDAMENTALS PROGRAMMING o abstract
MODIFICADORES DE ACCESO A CLASES package (default) Nivel de visibilidad: clase visible para todas las clases que se encuentren dentro del mismo package. Este no debe especificarse (modificador por defecto).
public Nivel de visibilidad: clase visible para todas las clases de todos los package. Para especificar este modificador se antepone a la palabra clave class, la palabra public. De todas maneras, si la clase es utilizada por otra clase que no se encuentra en el mismo package, es necesario realizar el import de la misma. MODIFICADORES DE NO ACCESO Estos modificadores pueden combinarse con aquellos que si modifican el acceso. strictpf No es necesario saber para la certificacin como es que funciona strictpf. Lo nico que es necesario, es saber que: Es una palabra reservada Puede modificar solo clases y mtodos Hacer una clase strictpf significa que todos los mtodos que la conforman cumplen con la norma IEEE 754 para punto flotante
final El modificador final indica que una clase no puede ser heredada o redefinida por una subclase. abstract Caractersticas de una clase abstract: No puede ser instanciada (new), solo puede ser heredada. Si un mtodo de la clase es abstract, esto fuerza a que la clase completa sea abstract. No todos los mtodos de una clase abstract tienen que ser abstractos. Los mtodos abstract no llevan cuerpo (no llevan los caracteres {}). La primer subclase concreta que herede de una clase abstract debe implementar todos los mtodos de la superclase.
abstract y final Es posible combinar estos dos modificadores de no acceso, pero si interpretamos el funcionamiento de cada uno nos dicen que:
JAVA FUNDAMENTALS PROGRAMMING abstract: obliga a que la subclase defina el cuerpo de los mtodos. final: previene que la clase sea heredada o redefinida.
Un modificador se opone al otro, de manera que, aunque no recibamos un error de compilacin, la clase declarada de esta manera es inutilizable.
DECLARACIN DE INTERFACES
Cuando creamos una interfaz, lo que estamos diciendo es lo que la clase deber de poder hacer, pero no como lo har. Una interfaz tambin es conocida como contrato. Caractersticas de una interfaz: Todos los mtodos de una interfaz son implcitamente public abstract, no es necesario especificarlo en la declaracin del mismo. Todos los atributos de una interfaz son implcitamente constantes (public static final), no es necesario especificarlo en la declaracin del mismo. Todas las variables de una interfaz deben de ser constantes (public static final). Los mtodos de una interfaz no pueden ser: static, final, strictfp ni native. Una interfaz puede heredar (extends) de una o ms interfaces. Una interfaz no puede heredar de otro elemento que no sea una interfaz. Una interfaz no puede implementar (implements) otra interfaz. Una interfaz debe ser declarada con la palabra clave interface. Los tipos de las interfaces pueden ser utilizados polimrficamente. Una interfaz puede ser public o package (valor por defecto). Los mtodos toman como mbito el que contiene la interfaz. Chapter: Utilizando java desde la consola de comandos
IMPORTANTE: cuando se menciona el implcitamente, se refiere a que si no se especifican estos son los modificadores que toma, pero se pueden especificar todos, ninguno, o algunos, siendo declaraciones semejantes, por ejemplo:
1. public interface Dibujable { 2. int CONST = 1; 3. public int CONST = 1; 4. public static int CONST = 1; 5. public final int CONST = 1; 6. static int CONST = 1; 7. final int CONST = 1; 8. static final int CONST = 1; 9. public static final int CONST = 1; 10. 11. void doCalculo(); 12. 13. public void doCalculo(); 14. 15. abstract void doCalculo();
14
16. 17. 18. }
public abstract void doCalculo();
DECLARACIN DE MTODOS Y ATRIBUTOS

Un mtodo puede contener modificadores de acceso y de no acceso. Adems, posee ms combinaciones que la definicin de clases. Dado que ambos, mtodos y atributos se declaran de manera semejante, se especifican en un mismo apartado. MODIFICADORES DE ACCESO Los modificadores disponibles son: public protected package prvate
Con estos modificadores tenemos dos conceptos que entender: Cuando un mtodo de una clase puede acceder a un miembro de otra clase. Cuando una subclase puede heredar un miembro de su superclase.
El primer caso se da cuando un mtodo de una clase intenta acceder a un mtodo o atributo de otra clase, valindose del operador . para invocar un mtodo, u obtener una variable. El segundo caso se da cuando una clase hereda de otro, permitiendo que la subclase acceda a los mtodos y atributos de la superclase, a travs de la herencia (extends). public Cuando un atributo o mtodo es declarado como public, significa que cualquier clase en cualquier package puede acceder a dicho miembro. private Cuando un atributo o mtodo es declarado como private, solo puede ser referenciado por la misma clase (ni siquiera por una subclase). Incluso si una subclase declarara un atributo o mtodo con el mismo nombre, solo estara generando un nuevo miembro, no sobrescribindolo, como puede llegar a ser malinterpretado. package (default) Cuando un atributo o mtodo es declarado como package, solo puede ser referenciado por cualquier clase que se encuentre dentro del mismo package, por medio de herencia y referencia.
JAVA FUNDAMENTALS PROGRAMMING protected Cuando un atributo o mtodo es declarado como protected, este se comporta de la siguiente manera: Una variable declarada como protected, se comporta como un modificador de tipo package en el paquete donde se encuentra la clase que declar el miembro. Una variable declarada como protected, solo puede ser accedida a travs de la herencia (no referencia), cuando se encuentra fuera del package.
Esto quiere decir que, un miembro declarado como protected es visible para todas las clases dentro del package donde fue declarado (ya sean subclases de la misma o no) a travs de referencia y herencia, y solo disponible a travs de la herencia para las subclases que se encuentran fuera del package. Para el resto de las clases, se comporta como un modificador prvate (no subclases fuera del package de declaracin). MODIFICADORES DE ACCESO EN VARIABLES LOCALES No es posible aplicar ningn modificador de acceso a una variable local. Solo es posible aplicar un modificador de no acceso: final. MODIFICADORES DE NO ACCESO Dentro de los modificadores de no acceso, se agregan varios de los 2 ya conocidos a la lista para modificadores de miembros. MODIFICADOR DE NO ACCESO EN MTODOS FINAL El modificador final fuerza a que un mtodo no pueda ser redefinido por una subclase. MODIFICADOR DE NO ACCESO EN ATRIBUTOS FINAL En el caso de un modificador final para un atributo, pueden darse 2 casos:
Si el atributo es un valor primitivo, impide de que modifique su valor (un valor primitivo es por ejemplo un int). Si el atributo es una referencia, impide que se modifique la referencia, pero no el estado de la misma.
MODIFICADOR DE NO ACCESO EN MTODOS ABSTRACT El modificador abstract en un mtodo indica que el mismo se ha declarado en el contrato, pero no se ha especificado su comportamiento (cuerpo del mtodo). MODIFICADOR DE NO ACCESO EN MTODOS SYNCHRONIZED El modificador sinchronized indica que el mtodo solo puede ser accedido por un Thread a la vez. Este modificador puede utilizarse en conjunto con cualquiera de los 4 modificadores de acceso. MODIFICADOR DE NO ACCESO EN MTODOS NATIVE El modificador native indica que el cdigo es dependiente de la plataforma, generalmente en cdigo C. Solo es necesario saber para la certificacin que un modificador
16
JAVA FUNDAMENTALS PROGRAMMING de no acceso native solo puede ser aplicado a un mtodo. El mtodo debe especificarse como si fuera abstracto (sin los caracteres {}, y directamente con ;) MODIFICADOR DE NO ACCESO EN MTODOS STRICTFP Al igual que para una clase, el modificador de no acceso strictfp indica que los caracteres de punto flotante utilizan la norma IEEE 754. MTODOS CON LISTAS DE ARGUMENTOS VARIABLES A partir de Java 5.0, es posible crear mtodos que reciban una cantidad de argumentos variables.
Pueden ser de tipo primitivo o un objeto. La definicin de var-args se hace: tipoDato nombreVariable. Solo se puede especificar un solo parmetro de tipo var-args en la firma del mtodo. El parmetro var-args debe de ser el ltimo especificado en la firma del mtodo. La sintaxis de estos es: TipoDeDato nombreVariable.
Al llamar a un mtodo sobrecargado o sobre escrito, primero se verifica si la llamada concuerda con algn mtodo que no tenga argumentos variables, si no se encuentra ninguno de estos, se verifica con los mtodos de argumentos variables.
1. public class PruebaParametrosVariables { 2. static public void haceAlgo(int val) { 3. System.out.println("Soy haceAlgo con un parmetro int"); 4. } 5. 6. static public void haceAlgo(int val1, int val2) { 7. System.out.println("Soy haceAlgo con dos parmetros int"); 8. } 9. 10. static public void haceAlgo(int... val) { 11. System.out.println("Soy haceAlgo con parmetros variables"); 12. } 13. 14. static public void main(String[] args) { 15. PruebaParametrosVariables.haceAlgo(1); 16. PruebaParametrosVariables.haceAlgo(2, 3); 17. PruebaParametrosVariables.haceAlgo(4, 5, 6); 18. PruebaParametrosVariables.haceAlgo(4, 5, 6, 7); 19. } 20. }
Soy Soy Soy Soy
haceAlgo haceAlgo haceAlgo haceAlgo
con con con con
un parmetro int dos parmetros int parmetros variables parmetros variables
JAVA FUNDAMENTALS PROGRAMMING DECLARACIN DE CONSTRUCTORES En Java, cada vez que un objeto es instanciado, esto se logra a travs de un constructor, el cual fue invocado con un new. Toda clase tiene al menos un constructor. Si este no se especifica, existe un constructor implcito. Si se especifica explcitamente al menos un constructor, el constructor implcito deja de existir. Un constructor se define como un mtodo, con la salvedad de que jams puede devolver ningn parmetro. Puede utilizar cualquiera los modificadores de acceso (public, private, protected, package). El nombre del mtodo debe de ser siempre igual al de la clase. Puede existir ms de un constructor. Esto se logra utilizando la sobrecarga de mtodos. Al igual que no pueden existir dos mtodos iguales, no pueden existir dos constructores iguales. No pueden ser: static, final ni abstract. Pueden contener en su definicin como parmetro cualquier tipo primitivo, objeto, o incluso var-args.
DECLARACIN DE VARIABLES
Se dividen en dos grupos:
DECLARACIN DE VARIABLES PRIMITIVAS Y RANGO DE VARIABLES Estas pueden ser declaradas como:
Tabla 1 *Tipo byte short Bits 8 16 *Bytes 1 2 Minimum range -128 -32768 Maximum range (2^7)-1 (2^15)-1
Variables de clase (static) Variables de instancia (objeto) Parmetros Variables locales
18
Primitivas: estas pueden ser cualquiera de los tipos contenidos en la tabla 1 Referencias: se utilizan para referenciar un objeto. Estas son declaradas para ser de un tipo especfico, y ese tipo no podr cambiar jams

char int long float double boolean 16 24 32 16 32 2 4 8 4 8 0 -8388608 -2,1E+09 -32768 -2,1E+09 2^16 (2^23)-1 (2^31)-1 (2^15)-1 (2^31)-1
Dependiente de la JVM
*Con conocer el valor de estas dos columnas, es ms que suficiente para deducir el resto.
DECLARACIN DE VARIABLES DE REFERENCIA Estas pueden ser declaradas como: Variables de clase (static) Variables de instancia (objeto) Parmetros Variables locales
Variables de instancia Representan los atributos de una clase. Se definen dentro de la clase, pero fuera de los mtodos, y solo se inicializan cuando el objeto es inicializado. Caractersticas: Pueden utilizar cualquiera de los cuatro modificadores de acceso Pueden ser final, transient, volatile No pueden ser abstract, sinchronized, strictfp, native, static
Variables locales Son variables declaradas dentro de un mtodo. Una variable local puede definirse con el mismo nombre que una variable de instancia. A esto se lo conoce con el nombre de shadowing. Dado un caso de estos (shadowing), si se quisiera referenciar la variable de instancia, se debe utilizar el operador this. Este almacena una referencia al objeto actual. Caractersticas: No son inicializadas por defecto Pueden ser final No pueden ser transient, volatile, abstract, sinchronized, strictfp, native, static (porque se volveran variables de clase)
JAVA FUNDAMENTALS PROGRAMMING DECLARACIN DE ARRAYS Un array es un objeto que almacena multiples variables del mismo tipo, o subclases del mismo. Estos pueden contener tanto variables primitivas como objetos, pero el array, siempre ser almacenado en el heap. Sintaxis: TipoVariable[] NombreVariable De esta manera, al encontrarnos con una declaracin como la anterior, es simple identificar el tipo de dato, en este caso, una referencia a un array de objetos de tipo TipoVariable. Tambin es posible declarar arrays multidimensionales, que no son otra cosa que arrays de arrays. Por cada dimensin, se especifica un par de []. DECLARACIN DE VARIABLES FINAL El declarar una variable con el modificador final hace imposible modificar su valor una vez que esta ha sido inicializada con un valor explcito. En el caso de ser una variable primitiva, su valor no podr modificarse nunca. En el caso de ser una variable de referencia, no se podr modificar la referencia al objeto que contiene, pero si su estado. VARIABLES TRANSIENT
Solo es aplicable a variables de instancia. Cuando una variable es marcada como transient, cuando el objeto es serializado, esta variable es excluida.
VARIABLES VOLATILE Cuando una variable es marcada como volatile, le indica a la JVM que cada vez que un thread quiera acceder a su copia local de la variable, deber verificarla con la copia maestra en memoria. VARIABLES Y MTODOS ESTTICOS El modificador static es utilizado para crear variables y mtodos que existirn independientemente de las instancias creadas. Los atributos y mtodos static existen aun antes de la primer inicializacin de un objeto de dicha clase, y solo habr una copia de estos, por ms que no se realice ninguna o n instancias. Elementos que pueden contener este modificador: Mtodos Variables de clase Una clase anidada dentro de otra clase (pero no dentro de un mtodo). Bloques de inicializacin
DECLARACIN DE ENUMERADORES Java permite restringir una variable para que solo tenga un conjunto determinado de elementos (valores predefinidos). Declaracin: enum NombreEnumerador { VALOR1, VALOR2, , VALORn } Referencia: NombreEnumerador.VALOR1 Cada valor de un enumerador es una clase del tipo del NombreEnumerador. Cada enumerador conoce su ndice, de manera que la posicin en que sea declarado el valor si importa.
20
JAVA FUNDAMENTALS PROGRAMMING Declaracin de contructores, mtodos y variables Debido a que los enum son en realidad un tipo especial de clase, estos pueden contener: constructores, mtodos, variables de instancia, y cuerpo constante de clase especfico (constant specific class body). Debes recordar las siguientes caractersticas sobre enum: Nunca puedes invocar un constructor enum directamente. El contructor de enum es invocado automticamente, con los argumentos que defines luego de las constantes. Puedes definir ms de un argumento para el constructor, y puedes sobrecargar los constructores, as como cualquier clase.
El constant specific class body, es una declaracin de lo que a simple vista parece una clase interna. Es utilizado cuando una constante requiere sobrescribir el comportamiento de algn mtodo.
PARADIGMAS DE PROGRAMACIN
Para aquellos que son iniciados en el tema de la programacin, es bueno tener en cuenta un poco la evolucin en temas de cmo se programa. Desde siempre la programacin fue una serie de algoritmos que resuelven un problema, lo que cambi, fue la manera de agrupar y asociar estos algoritmos. PARADIGMA ESTRUCTURAL Este paradigma busca como objetivo dividir un problema complejo (sistema), en varios problemas menos complejos (funciones). Este es un paradigma que ha ido quedando en desuso con el correr de los tiempos, aunque aquellos que estn dando sus primeros pasos en alguna institucin, puede que lo vean en lenguajes como Pascal o C++. PARADIGMA ORIENTADO A OBJETOS En este paradigma, cada elemento del sistema se divide en objetos. Estos son representaciones de entidades que encontramos en la vida real. Por ejemplo, si estuviramos diseando un sistema para un aeropuerto, sera ms que factible encontrarse con las clases Aeroplano, Pasajero, Capitan. Pero, y la diferencia? En este paradigma, cada entidad es responsable de realizar las acciones que le conciernen, y solo las que le conciernen. Supongamos que estamos diseando un juego, y tenemos un avin, segn los paradigmas hubiramos hecho lo siguiente: Estrucura procedural en lenguaje C
1. 2.
typedef struct Avion {
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.
int cantidadPasajerosSoportada; float peso; //... otras propiedades de un avion } Avion_1; public void volar(avion av) { //... codigo } public void aterrizar(avion av) { //...codigo } public main() { volar(Avion_1) aterrizar(Avion_1) 16. }
Estructura orientada a objetos en Java La diferencia ms grande la podemos apreciar al momento de llamar a las acciones de volar y aterrizar. En el modelo estructural se llama a una funcin a la cal se le pasa un avin como argumento, pero en el modelo orientado a objetos, se le dice al propio avin que vuele o aterrice.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. class Avion { int cantidadPasajerosSoportada; float peso; // ... otras propiedades de un avin public void volar() { // ... Codigo } public void aterrizar() { // ... Codigo } } public class Juego { public static void main(String[] args) { Avion avion_01 = new Avion(); avion_01.volar(); avion_01.aterrizar(); } }
DEFINICIN DE UNA CLASE

1. 2. public class Persona { // Atributos
22
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. }
String nombre; String apellido; int edad; float peso; // Constructores public Persona(String nombre, String apellido) { // Cdigo ... } // Mtodos public void correr() { // Cdigo... } public void caminar() { // Cdigo... } public void hablar() { // Cdigo... }
Bsicamente, una clase contiene estos elementos: Atributos Definen el estado de un objeto Mtodos Definen el comportamiento (pueden ser de clase o de objeto) Constructores Permiten crear objetos
Existen otros elementos que pertenecen a la clase, y no al objeto. Estos contienen el identificador static. Pero no te preocupes, ya los veremos. DIFERENCIA ENTRE CLASE Y OBJETO Una clase representa una especie de molde para cada objeto. Cuando nosotros creamos un objeto, lo hacemos utilizando alguna clase en particular, esto quiere decir que el objeto creado, puede realizar el comportamiento de la clase, y contiene todos sus atributos. Vamos a verlo con un ejemplo ms grfico. Utilicemos la clase Persona que definimos anteriormente. Basandonos en ella, podemos apreciar que cada Persona (clase), tendr ciertas caractersticas (atributos). Por ejemplo, supongamos una persona llamada Gabriel y otra Laura.
JAVA FUNDAMENTALS PROGRAMMING Clase Persona Nombre Apellido Edad Peso Objetos Gabriel Gabriel Mendoza 15 56.3
Laura Laura Rios 38 65.2
Al definir un objeto de tipo Persona estamos diciendole a la JVM que cree una estructura con tales propiedades y tal comportamiento. En el ejemplo anterior, Laura y Gabriel tambin tienen la capacidad de correr(), caminar(), y hablar().
MS CONCEPTOS DE LA POO
Al adentrarnos en este nuevo paradigma, no solamente cambia la manera de codificar, sino que se introducen varios conceptos que forman las bases de este, tales como encapsulamiento, polimorfismo y herencia. ENCAPSULAMIENTO Algunos de los beneficios aportados por el paradigma de orientacin a objetos (OO) son: flexibilidad y mantenimiento. Pero para lograr esto, es necesario escribir las clases de una manera en particular. La clave para lograr esto es encapsular la lgica y el estado de la clase para que no pueda ser accedido de forma directa, y dejar de manera publica un set de mtodos para poder interactuar con la clase. Las claves son: Siempre mantener las variables de instancia protegidas (con un modificador de acceso, generalmente public) Crea mtodos pblicos (public) para acceder a las variables de instancia Para los anteriores, utiliza la convencin de nombres de JavaBeans
HERENCIA Cuando utilizamos la herencia, a veces es necesario saber si un objeto pertenece a una clase en concreto. Para realizar esto utilizamos el operador instanceof, este devuelve un boolean, siendo true en caso de que pertenezca a dicha clase, falso en caso contrario. objeto
24
JAVA FUNDAMENTALS PROGRAMMING instanceof clase Es posible crear relaciones de herencia en Java extendiendo una clase. Las dos caractersticas ms comunes para utilizar la herencia son: Para promover la reutilizacin del cdigo Para el uso del polimorfismo
El polimorfismo nos permite tratar una subclase como si fuera una clase del tipo de su superclase. La contrapartida de esto es que solo se podrn llamar a los atributos que se encuentren disponibles para el tipo de clase declarada. Is-A Para el examen es necesario saber: Is-A indica que la clase X es del tipo Y. Esto se logra a travs de extends o implements. Al termino Is-A tambin se lo puede llamar: derived, subclass, inherits, o subtype. A la superclase tambin se la conoce como supeclase
Has-A Indica que una clase A tiene una variable de instancia que contiene una referencia a B. POLIMORFISMO Un objeto es polimrfico cuando cumple con al menos una condicios Is-A. Esto es cierto para todas las clases que no sean de tipo Object, ya que todas heredan de esta. La nica manera de acceder a un objeto es a travs de una variable de referencia. Algunas pautas para recordar de estas: Una variable de referencia puede ser de un solo tipo, y una vez que fue declarada, ese tipo jams puede modificarse. Una referencia es una variable, de manera que puede ser reasignada a otros objetos (a menos que se declare como final). Un tipo de variable de referencia determina los mtodos que pueden ser invocados sobre el objeto que la variable referencia. Una variable de referencia puede tomar como referencia cualquier objeto del mismo tipo, o un subtipo del mismo. Una variable de referencia puede tener como tipo el de una interface. Si es declarada de esta manera, podr contener cualquier clase que implemente la interfaz. El concepto es que solo los mtodos de instancia son invocados dinmicamente. Esto es logrado por la JVM, la cual siempre tiene conocimiento de que tipo de objeto es el que se est tratando, as como su rbol de herencia.
JAVA FUNDAMENTALS PROGRAMMING SOBRE ESCRITURA Cada vez que una clase hereda un mtodo de su superclase, existe la posibilidad de sobrescribir el mtodo (a menos que este haya sido declarado con el modificador de no acceso final). El beneficio de la sobre escritura es la habilidad de definir comportamiento particular para una clase especfica. Caractersticas necesarias para hacer uso de la sobre escritura: La lista de argumentos debe ser exactamente igual que el mtodo a sobrecargar. El valor de retorno debe ser del mismo tipo, o un subtipo. El modificador de acceso no puede ser ms restrictivo que el del mtodo a sobre escribir. El modificador de acceso puede ser menos restrictivo que el mtodo a sobre escribir. Los mtodos de instancia solo pueden ser sobre escritos si es que son heredados por la subclase. El mtodo sobre escrito puede lanzar cualquier excepcin sin verificacin en tiempo de ejecucin, sin importar de las excepciones que hayan sido declaradas en el mtodo de la superclase. El mtodo no deber lanzar excepciones verificadas que son nuevas o amplan a las ya definidas por el mtodo a sobre escribir. El mtodo sobre escrito puede lanzar una cantidad menor de excepciones que las definidas en el mtodo a sobre escribir. No puedes sobre escribir un mtodo que haya sido declarado como final (creo que es la 20 vez que repetimos esto, pero, nunca es suficiente). No es posible sobre escribir un mtodo que haya sido declarado como static. Si un mtodo no puede ser heredado, no puede ser sobre escrito. Chapter: Utilizando java desde la consola de comandos
Invocando la versin de la superclase de un mtodo sobre escrito Tambin es posible valerse del cdigo definido en la superclase. La manera de invocarlo es con la palabra super (esta hace referencia a la superclase).
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. class Generic { public void doSomething() throws Exception { // . . . some code here } } class Specific extends Generic { public void doSomething() { // . . . some code here } } public class Program { static public void main(String[] args) {
26
15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. }
Generic obj1 = new Specific(); Specific obj2 = new Specific(); obj2.doSomething(); obj1.doSomething(); // Se genera un error de compilacin, dado que no // se declaro como recibir la excepcin Exception // El cdigo podra solucionarse con un try-catch try { obj1.doSomething(); } catch (Exception ex) { // . . . some code here } }
SOBRECARGA La sobrecarga de mtodos permite utilizar el mismo nombre de un mtodo, el cual toma una cantidad y/o tipo de parmetros diferentes. Las reglas para la sobrecarga son: Deben de modificarse la lista de parmetros. Pueden modificar el tipo de valor de retorno. Pueden cambiar el modificador de acceso. Pueden declarar excepciones nuevas o ms abarcativas. Pueden ser sobrecargados en la misma clase, o en una subclase.
Bsicamente, un mtodo sobrecargado no es ms que un mtodo completamente diferente, pero que utiliza un nombre que ya existe. Invocacin de mtodos sobrecargados Para invocar un mtodo sobrecargado, es necesario especificar los parmetros del tipo esperado segn el mtodo que queramos invocar.
1. public class Something { 2. public void doSomething(int val) { 3. // . . . some code here 4. } 5. 6. public void doSomething(float val) { 7. // . . . some code here 8. } 9. 10. static public void main(String[] args) { 11. Something s1 = new Something(); 12. int valor1 = 1; 13. float valor2 = 2.3; 14. s1.doSomething(valor1); // Se invoca al mtodo doSomething(int val) 15. s1.doSomething(valor2); // Se invoca al mtodo doSomething(float val) 16. s1.doSomething(new Object); //Error de compilacin. No existe ningn 17. // mtodo que reciba como parmetro un tipo Object 18. }
19. }
En el caso de la invocacin con objetos, se vuelve un poco ms complicado.

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. class Generic { } class Specific extends Generic { } public class Program { public void doSomething(Generic obj) { // . . . some code here } public void doSomething(Specific obj) { // . . . some code here } static public void main(String[] args) { Generic obj1 = new Generic(); Specific obj2 = new Specific(); Generic obj3 = new Specific(); Program p = new Program(); p.doSomething(obj1); // Se invoca al mtodo doSomething(Generic obj) p.doSomething(obj2); // Se invoca al mtodo doSomething(Specific obj) p.doSomething(obj3); // Se invoca al mtodo doSomething(Generic obj) }
En el ltimo caso, por ms que obj3 sea de tipo Specific, la referencia contiene un tipo Generic, y es esta la que determina a que mtodo se invoca.
POLIMORFISMO EN SOBRE ESCRITURA Y SOBRECARGA El polimorfismo no determina que mtodo invocar cuando se trata de sobrecarga, pero si cuando se trata de sobre escritura. Tabla de diferenciacin entre sobrecarga y sobre escritura:
Sobrecarga de mtodo Parmetros Valor de retorno Excepciones Deben cambiar. Puede cambiar el tipo. Pueden cambiar. Sobre escritura de mtodo No deben cambiar. No puede cambiar, salvo por alguna covariante (subclass). Pueden reducirse o eliminarse. No se pueden lanzar nuevas excepciones u otras ms abarcativas.
28

Modificadores de acceso Invocacin Pueden cambiar El tipo de la determina que invocar. referencia mtodo No pueden ser ms restrictivos (pueden ser menos restrictivos). El tipo del objeto determina que mtodo invocar. Sucede en tiempo de ejecucin.
CASTEO DE VARIABLES DE REFERENCIA En ciertas ocasiones, es necesario utilizar un mtodo de la clase especfica (subclase), pero la referencia es de la superclase. En estos casos se utiliza un casteo denominado downcast. El problema con este tipo de casteos, es que no generar errores en tiempo de compilacin, pero pueden generarlos en tiempo de ejecucin.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. class Generic { public void doSomething() { // . . . some code here } } class Specific { public void doSomethingMoreSpecific() { // . . . some code here } } public class Program { static public void main(String[] args) { Generic g1 = new Specific(); Generic g2 = new Generic(); g1.doSomething(); g1.doSomethingMoreSpecific(); // Genera un error de compilacin // "cannot find symbol", esto indica que // la clase Generic no contiene un // mtodo doSomethingMoreSpecific Specific s1 = (Specific) g1; s1.doSomethingMoreSpecific(); // En este caso, la instancia es de tipo // Specific, de manera que conoce el // mtodo doSomethingMoreSpecific g2.doSomething(); g2.doSomethingMoreSpecific(); // Genera un error de compilacin // "cannot find symbol", esto indica que // la clase Generic no contiene un // mtodo doSomethingMoreSpecific s1 = (Specific) g2; // Se genera un error en tiempo de ejecucin // "java.lang.ClassCastException" // Para prevenir esto en tiempo de ejecucin, antes de realizar el // downcast verificamos que el objeto sea del tipo a castear if (g2 instanceof Specific) { // Como el objeto no es de tipo Specific, // ni un subtipo del mismo, la sentencia // if resulta false, y no se entra en la // condicin, previniendo el error en
39. 40. 41. 42. 43. 44. 45. 46. }
// tiempo de ejecucin s1 = (Specific) g2; s1.doSomethingMoreSpecific(); // Tambin se puede realizar un casteo directo como el siguiente ((Specific) g2).doSomethingMoreSpecific(); } }
Lo nico que el compilador verifica es que el tipo de la variable con el tipo a castear se encuentren en el mismo rbol de herencia. Lo que si puede generar un error de casteo es al intentar realizar un upcasting.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. class Generic { } class Specific extends Generic { } class Another { } public class Program { static public void main(String[] args) { Specific sp = new Specific(); Another an = new Another(); Generic s1 = (Generic) sp; Generic an = (Generic) an; // Error de compilacin al intentar realizar // un upcasting "inconvertible types" // El upcasting tambin se puede escribir de la siguiente manera Generic s1 = sp; // Esta sintaxis automticamente est realizando un // upcasting } }
Tambin, puede darse un caso como el planteado a continuacin:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. interface Doable { void doSomething(); } class Generic implements Doable { public void doSomething() { // . . . some code here } } class Specific extends Generic { }
30
La clase Specific puede ser tanto de tipo: Specific, Generic, o Doable, dado que su superclase la implementa, y ya se hizo cargo de darle un cuerpo a los mtodos definidos en la interfaz.
IMPLEMENTAR (IMPLEMENTS) UNA INTERFAZ

Cuando se implementa una interfaz, lo que se hace es aceptar el contrato provisto por esta, e implementarlo en la clase. Para el compilador, lo nico que requiere es que se le d una implementacin legal al mtodo, pudiendo ser esta un cuerpo vaco por ejemplo ({}). Para que la implementacin de una interfaz sea legal, la primer clase no abstracta del rbol de herencia debe cumplir con las siguientes reglas: Especificar una implementacin concreta para todos los mtodos definidos en el contrato de la interfaz. Seguir todas las reglas para la sobre escritura de mtodos. Declarar sin excepciones controles sobre los mtodos de ejecucin distintos de los declarados por el mtodo de interfaz, o subclases de los declarados por el mtodo de interfaz. Mantener la misma firma del mtodo, y devolver un valor del mismo tipo (o subtipo).
TIPOS DE VALOR DE RETORNO VLIDOS

Esta seccin implica dos cosas: Lo que se puede declarar como un valor de retorno. Qu tipo de dato se puede devolver realmente como valor de retorno.
DECLARACIN DE TIPOS DE VALOR DE RETORNO (RETURN TYPES DECLARATION) Esta seccin indica que tipo de valor de retorno puedes escribir en la declaracin del mtodo, dependiendo si se trata de un mtodo: Sobrecargado Sobre escrito Nuevo
TIPOS DE VALOR DE RETORNO EN MTODOS SOBRECARGADOS El tipo de valor de retorno puede ser cualquiera (el mtodo debe calificar para la declaracin de sobrecarga).
JAVA FUNDAMENTALS PROGRAMMING TIPOS DE VALOR DE RETORNO EN MTODOS SOBRE ESCRITOS Se puede especificar el mismo tipo, o un subtipo (sublass), como tipo de valor de retorno (el mtodo debe calificar para la declaracin de sobre escritura). NOTA: esto es posible a partir de Java 5, en versiones anteriores, solo es posible utilizar el mismo tipo. DEVOLVIENDO UN VALOR Solo existen seis reglas: Puedes devolver un null cuando el tipo es un objeto. Un array representa un tipo de dato valido como retorno. En un mtodo con un valor de retorno de tipo primitivo, es posible devolver un tipo de dato de otro tipo, que sea casteado implcitamente al tipo de retorno. Idem anterior con un tipo que puede ser casteado explcitamente (se debe realizar el cast antes de devolver el valor). Si el tipo es void, el mtodo no puede contener ningn return. Si el tipo es un objeto, se puede devolver cualquier objeto que sea del mismo tipo o que pertenezca al rbol de herencia (no superclases ni superiores). Cualquier tipo que pase la condicin instanceof del tipo de valor de retorno es vlido.
CONSTRUCTORES E INSTANCIACIN
Los objetos son construidos. No es posible construir un nuevo objeto, sin antes invocar el constructor. Los constructores representan bloques de inicializacin, los cuales pueden llegar a ser invocados con el operador new (no es el caso de los bloques de inicializacin estticos). CONCEPTOS BSICOS DE LOS CONSTRUCTORES (CONSTRUCTOR BASICS) Toda clase, incluidas aquellas que sean abstractas, debern de tener un constructor. Pero esto no implica que el programador tenga que especificarlo. LLAMADAS EN CADENA A CONSTRUCTORES (CONSTRUCTOR CHAINING) Suponiendo el siguiente rbol de herencia:
Clase Especifico
Clase Genrico
Clase Objeto
Al invocar la creacin de un objeto de tipo Especifico, el proceso de inicializacin es el siguiente: 1. Se invoca el constructor se Especifico. Este invoca el constructor de Generico (esta invocacin puede ser implcita o explcita).
32
JAVA FUNDAMENTALS PROGRAMMING 2. Se invoca el constructor de Generico. Este invoca el constructor de Objeto (esta invocacin es siempre implcita). 3. Las variables de instancia del objeto Objeto reciben sus valores explcitos. 4. Se ejecuta el constructor de Objeto. 5. Las variables de instancia del objeto Generico reciben sus valores explcitos. 6. Se ejecuta el constructor de Generico. 7. Las variables de instancia del objeto Especifico reciben sus valores por defecto. 8. Se ejecuta el constructor de Especifico. REGLAS DE LOS CONSTRUCTORES (RULES FOR CONSTRUCTORS) Los constructores pueden utilizar cualquier modificador de acceso. El nombre del constructor debe ser igual al de la clase. Los constructores no deben de tener un valor de retorno. Es legal tener un mtodo que tenga el mismo nombre que la clase. Siempre que este tenga un valor de retorno, es un mtodo. Si no se especifica explcitamente un constructor en la clase, implcitamente se genera un constructor que no recibe parmetros. Si se especifica al menos un constructor, el constructor implcito no ser generado, de manera que si es necesario un constructor con argumentos, y el por defecto, es necesario especificarlo explcitamente. Todos los constructores tienen en la primer lnea, una llamada a un constructor sobrecargado (this()), o una llamada a un constructor de la superclase (super()). La llamada a un constructor de la superclase puede ser con o sin argumentos. Un constructor sin argumentos no es necesariamente un constructor por defecto (este es el que especifica el compilador, en caso de no declarar explcitamente ningn constructor). No es posible acceder a una variable de instancia, o mtodo de instancia, hasta que se ejecute el constructor de la superclase. Solo variables y/o mtodos estticos pueden ser llamados al invocar un constructor mediante this() o super(). Las clases abstractas tambin tienen constructores, y estos son ejecutados cuando se instancie una subclase. Las interfaces no tienen constructores. Las interfaces no forman parte del rbol de herencia. La nica manera de invocar un constructor es desde otro constructor.
DETERMINAR CUNDO SE CREAR EL CONSTRUCTOR POR DEFECTO El constructor por defecto ser creado por el compilador, siempre que no se haya declarado ningn constructor en la clase.
JAVA FUNDAMENTALS PROGRAMMING COMO ES EL CONSTRUCTOR POR DEFECTO? Tiene el mismo modificador de acceso que la clase. No recibe ningn argumento (no tiene parmetros en su definicin). Llama al constructor de la superclase sin argumentos.
QU PASA SI EL CONSTRUCTOR DE LA SUPERCLASE REQUIERE ARGUMENTOS? Es necesario crear explcitamente los constructores en la clase, y dentro de la implementacin de estos, llamar al constructor de la superclase pasando los argumentos necesarios.
SOBRECARGA DE CONSTRUCTORES Simplemente se comporta al igual que los mtodos. Para sobrecargar un constructor basta con declarar varios de estos con diferentes parmetros.
Regla absoluta de los constructores. La primer lnea de estos deber ser una llamada a super() o this() (pueden contener parmetros en la llamada, siempre que la llamada no la realice el compilador).
MTODOS Y VARIABLES ESTTICOS Todos los mtodos y atributos declarados con el modificador de no acceso static pertenecen a la clase y no al objeto (instancia de la clase). Para saber cundo debemos deberamos de crear un atributo o mtodo esttico, simplemente necesitamos saber si este requiere o no acceder a algn atributo de la clase (en el caso de los mtodos), o si debe ser un valor compartido para todos los objetos (en el caso de los atributos). Caractersticas de los atributos y mtodos estticos: No es necesario inicializar ningn objeto para poder acceder a estos. Los atributos estticos son compartidos por todos los objetos (en realidad son de la clase, y dado que el objeto pertenece a dicha clase, tambin tiene acceso a los atributos y mtodos de esta). Las variables estticas tienen la misma inicializacin por defecto que las variables de clase.
34
Alguno de los constructores de la clase deber de llamar a super(), y verificar que todos los dems constructores terminen yendo al que realiza dicha llamada.
JAVA FUNDAMENTALS PROGRAMMING Un mtodo esttico no puede acceder a ningn miembro no esttico (main es esttico!). No existe la sobre escritura (overriding) de mtodos estticos, pero si la sobrecarga (overloading).
ACCEDIENDO A MTODOS Y VARIABLES ESTTICAS Dado que podemos acceder a miembros estticos sin siquiera haber instanciado una clase, para referenciarlos, utilizamos el nombre de la clase con el . para acceder.
En caso de utilizar un identificador que no sea el nombre de la clase (una variable de referencia), se accede a los miembros estticos del tipo declarado de la referencia (no el tipo real contenido).
VALORES LITERALES PARA TODOS LOS TIPOS PRIMITIVOS

Un valor literal es simplemente una manera de representar el tipo de dato primitivo. INTEGER Hay tres maneras de representar un nmero entero en Java Decimal (base 10) Hexadecimal (base 16) Octal (base 8)
LITERALES DECIMAL Simplemente es escribir el nmero sin ningn prefijo. LITERALES OCTAL Se antepone al nmero que deseamos escribir el 0. Para formar el 9 (en decimal) se escribe 011 (en octal) LITERAL HEXADECIMAL Los nmero hexadecimales son construidos utilizando valores numricos y alfabticos, siendo el orden el siguiente: 0 1 2 3 4 5 6 7 8 9 A B C D E F NOTA: en los valores exadecimales, las letras pueden ir tanto en maysculas como en minsculas. Se antepone el 0x para identificar un valor hexadecimal. PUNTO FLOTANTE Se utiliza el . como separador de decimales. Por defecto un literal de punto flotante es interpretado como de tipo double. Para que sea interpretado como un float se debe agregar la F al final del literal (12.35F).
JAVA FUNDAMENTALS PROGRAMMING Idem. con la D para que se interprete como un double, aunque no es necesario, dado que es el tipo que se le da por defecto.
BOOLEANOS Solo pueden ser true o false. CARACTERES Se escriben entre (comillas simples). Un carcter es un int sin signo. Es legal asignarle un valor numrico a un caracter. Si el rango es mayor a un integer, o es negativo, no da error, pero es necesario castearlo para impedir la perdida de datos (loss of precision). Para especificar caracteres con un significado especial (salto de lnea, tabulaciones, etc.) se utiliza la \ seguido de un identificador (u para Unicode, n para salto de lnea, t para tabulador).
STRINGS Es una representacin de un objeto String. Se escriben entre (comillas dobles). Representan un objeto, pero se pueden escribir como literales.
Recordemos que una variable puede contener una de dos cosas: El valor del dato. La posicin de memoria donde se encuentra el objeto (puntero). o Puede contener un valor null, que indica que no apunta a ninguna posicin.
ASIGNACIN DE VALORES PRIMITIVOS Se utiliza el operador =. Simplemente evala la expresin y/o literal que se encuentre del lado derecho, y asigna el resultado a la variable especificada en el lado izquierdo:
1. 2. 3.
int a = 1; int b = 2 * a; int c = a / b;
36
OPERADORES DE ASIGNACIN
Si se utiliza simplemente un literal del lado derecho del =, este puede ser casteado al valor de la variable, siempre que sea posible.
CASTEO DE PRIMITIVAS El casteo puede ser implcito o explcito. Un casteo implcito significa que no es necesario escribir ningn cdigo, la conversin se efecta automticamente. Un casteo explcito, por el contrario, requiere de una codificacin.
Las reglas son simples: Si la variable a asignar es de menor o igual tamao a la variable donde ser asignada, se produce un casteo implcito. Si la variable a asignar es de mayor tamao a la variable donde ser asignada, se debe realizar un casteo explcito, o de lo contrario, se generar un error de compilacin.
TABLA DE CASTEOS IMPLCITOS PARA PRIMITIVAS La siguiente tabla indica la posicin de variables primitivas, y cules de ellas puede contener. La interpretacin es: una variable siempre puede contener todas las variables desde su posicin (columna 1), hasta las inferiores, pero nunca superiores. Para ello es necesario un casteo explcito.
Posicin 1 2 3 4 5 6 7
Tipo de dato Byte Short Char Int Long Float Double
Puede contener Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual + anteriores.
JAVA FUNDAMENTALS PROGRAMMING El tipo de dato boolean solo puede contener su mismo tipo. Para darles un ejemplo, una variable de tipo int puede contener un int, char, short o byte.
ASIGNACIN DE NMEROS CON PUNTO FLOTANTE Todo nmero de punto flotante es implcitamente de tipo double.
ASIGNACIN DE UN LITERAL QUE ES MS GRANDE QUE LA VARIABLE En el caso de que la primitiva sea ms grande que el valor mximo permitido, existen dos alternativas: Si el resultado es casteado, se trunca la variable, y esta es almacenada con xito. Si el resultado no es casteado, se genera un error de compilacin Error. Possible loss of precision.
Cuando se trunca una variable, simplemente se eliminan las posiciones extra a la izquierda, siendo por ejemplo: int 128 equivale a 00000000 00000000 00000000 10000000, cuando casteamos a byte, nos queda 10000000 (el resto de la izquierda es eliminado). Los operadores +=, -=, *=, /= realizan un casteo implcito. ASIGNAR UNA VARIABLE PRIMITIVA A OTRA VARIABLE PRIMITIVA Cuando asignamos una variable primitiva a otra variable primitiva, simplemente se copia el valor de esta, quedando ambas como equivalentes, pero totalmente independientes. Esto quiere decir que si modificamos una, la otra no se ver afectada. MBITO DE LAS VARIABLES (SCOPE) Bsicamente, el mbito indica por cunto tiempo la variable existir. Existen cuatro tipos diferentes de mbitos: Variables estticas: Son creadas cuando la clase es cargada, y existirn mientras que la clase siga cargada en la JVM. Variables de instancia: Son creadas cada vez que una nueva instancia es inicializada, y existirn mientras que la instancia exista. Variables locales: Estas existirn durante el tiempo que el mtodo permanece en el stack. Variables de bloque: Estas existirn mientras que se est ejecutando el bloque de cdigo.
1. 2.
public class AlgunaClase { private static int valorEstatico;
38
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. }
public static int getValorEstatico() { return valorEstatico; } private int valorInstancia; public AlgunaClase() { valorInstancia = 0; } public void setValorInstancia(int valor) { valorInstancia = valor; } public int getValorInstancia() { return valorInstancia; } public void otroMetodo(int valor) { valor++; for (int x = 0; x < 100; x++) { // Cdigo... } }
ERRORES MS COMUNES CON PROBLEMAS DE SCOPE Intentar acceder a un variable de instancia desde un contexto esttico. Intentar acceder a una variable local desde un mtodo anidado (un mtodo que llama a otro, y el segundo utiliza una variable local del primero). Intentar utilizar una variable de bloque, luego de haber concluido la ejecucin del bloque.
UTILIZAR UNA VARIABLE O ARRAY QUE NO HA SIDO INICIALIZADO NI ASIGNADO Java permite inicializar una variable declarada o dejarla sin inicializar. Cuando intentemos utilizar dicha variable (en el caso de no haberla inicializado), podemos encontrarnos con diferentes comportamientos dependiendo del tipo de variable o array con que estemos trabajando, as como, el mbito de la variable. VARIABLES DE INSTANCIA DE TIPOS PRIMITIVOS Y OBJETOS Las variables de instancia son inicializadas a un valor por defecto. La siguiente tabla muestra los valores de inicializacin segn el tipo:
Tipo de variable Valor por defecto

Referencia a objeto byte, short, int, long float, double boolean char null (no referencia a ningn objeto) 0 0.0 false \u0000
VARIABLES DE INSTANCIA DE TIPO ARRAY Cuando se declara una variable de este tipo, pueden darse dos casos de no inicializacin: Si no se inicializa el array, el mismo contendr una referencia a null (al fin y al cabo, un array es un objeto). Si se inicializa el array, pero a sus elementos no se le asignan valores (int[] a = new int[10]), los elementos del array sern inicializados al valor por defecto del tipo del array (en el caso del ejemplo 0).
VARIABLES PRIMITIVAS LOCALES Y OBJETOS Las variables locales son aquellas que hayan sido declaradas dentro de un mtodo, y esto incluye a los parmetros del mismo. En este caso, el trmino automtico indica variable local, no que se inicializa automticamente. Variables primitivas locales Estas variables debern de ser inicializadas siempre antes de utilizarlas, de lo contrario, obtendremos un error en tiempo de compilacin Variable X may not have been initialized. Otro problema que puede llegar a surgir es el de inicializar la variable dentro de un bucle condicional. El compilador detecta esto, e indica con un error de compilacin el posible problema Variable X might not have been initialized. Variables de referencia locales Si se declara una variable de referencia local, pero no se inicializa, por ms que luego solo se haga una verificacin de si vale null, esto arroja un error. Esto se debe a que null, tambin es un valor. Variables de array locales Se comportan igual que las referencia a objetos locales, con la salvedad de que si una variable array a sido inicializada, y se le asigna un conjunto de elementos de tipo X, pero no los valores, estos siempre sern inicializados al valor por defecto del tipo, sin importar el mbito de la variable.
40
JAVA FUNDAMENTALS PROGRAMMING ENVO DE VARIABLES A MTODOS Los mtodos pueden ser declarados con parmetros de tipo primitivos y/o referencias a objetos. Es importante conocer el efecto de modificar cualquiera de los dos tipos de parmetro, y los efectos de realizar esto. Envo de variables de referencia Cuando se pasa como argumento una referencia a un mtodo, lo que se est enviando es la direccin de memoria a la que apunta la referencia, y no el objeto en s. Esto quiere decir que ambas variables estarn referenciando al mismo objeto en el heap, de manera que si el objeto es modificado dentro del mtodo, se ver afectado fuera de este tambin. Java utiliza la semntica de paso por valor? Si. A pesar de que pareciera que no, dado lo anterior, en realidad se est pasando el valor contenido por la variable. Ahora, que este valor sea un tipo primitivo o una referencia no importa, al pasar un argumento, el parmetro se carga con una copia bit a bit. Otra consideracin es que el parmetro no puede modificar el valor del argumento, lo que es diferente de modificar el estado del objeto al que apuntan ambos. DECLARACIN, CONSTRUCCIN E INICIALIZACIN DE ARRAYS En Java, un array es un objeto que almacena mltiples variables del mismo tipo. Estos pueden contener tanto tipos primitivos como referencias a objetos, pero el array en si mismo siempre ser un objeto en el heap. Para utilizar los arrays, es necesario saber tres cosas: Como crear una variable que referencie a un array (declaracin). Como crear un objeto de tipo array (construccin). Como completar el array con elementos (inicializacin).
Declaracin de un array Los array son declarados especificando el tipo de dato que contendr el array seguido de []. Tambin se pueden especificar varias dimensiones de arrays, siendo cada par de [] equivalentes a una dimensin.
1. 2. 3. 4. 5. int[] array_1; // Un array con primitivos int[][] array_2; // Un array con primitivos de 2 dimensiones (tambin // conocido como matriz) int[][][] array_3; // Un array con primitivos de 3 dimensiones (tambin // conocido como hipermatriz)
CONSTRUCCIN DE UN ARRAY Construir un array significa crear el objeto en el heap. Para reservar el espacio en el heap, Java debe saber el tamao del array, de manera que este debe ser especificado al momento de la creacin.
JAVA FUNDAMENTALS PROGRAMMING Construir un array de una dimensin Para construir (crear o inicializar son sinnimos vlidos para esta accin) un array, se puede utiliza cualquiera de las siguientes sintaxis:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. int[] array_1 = new int[5]; // Declara una variable de tipo referencia // que contiene un array de ints, e // inicializa el array para poder contener // 5 variables de tipo int (son // inicializadas al valor por defecto). Object[] array_2 = new Object[5]; // Idem. Tener en cuenta que los // elementos del array contienen // una referencia a null (valor por // defecto). En ningn momento se // crea un objeto de tipo Object // (salvo el Array en si mismo). Object[] array_3; // Un array con referencias
Es necesario si utilizamos la sintaxis anterior especificar la cantidad de elementos que el array contendr (1 es el mnimo). Existe otra manera de construir un array, la cual es una forma abreviada para realizar esto ltimo, y a la vez inicializarlo (esta se explica ms adelante). CONSTRUIR UN ARRAY MULTIDIMENSIONAL Un array multidimensional no es ms que un array de arrays.
1. 2. 3. int[][] array_1 = new int[5][]; // Es vlido en Java, dado que solo se // requiere saber el espacio necesario // para la variable array_1
INICIALIZACIN DE UN ARRAY Inicializar un array significa cargar los elementos del mismo.
1. 2. 3. 4. 5. 6. 7. 8. int[] array_1 = new int[3]; array_1[0] = 23; // Al elemento 1 se le da el valor 23 array_1[1] = 12; // Al elemento 2 se le da el valor 12 array_1[2] = 45; // Al elemento 3 se le da el valor 45 array_1[3] = 1; // Ops. Si realizamos esto nos encontraremos con un // error en tiempo de ejecucin // "ArrayOutOfBoundsException". El lmite del array es // [0;2]
Recordemos que los lmites de un array estn comprendidos siempre entre 0 y total de elementos 1.
42
JAVA FUNDAMENTALS PROGRAMMING INICIALIZANDO ELEMENTOS EN UN BUCLE Los arrays tienen una nica variable de instancia pblica, la cual es el length. Esta variable indica cuantos elementos puede contener el array, pero no cuntos de ellos se encuentran inicializados.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. class Persona { } public class Program { static public void main(String[] args) { Persona[] arrayPersona = new Persona[5]; for (int x = 0; x < arrayPersona.length; x++) { // x llegar a valer 4. // Cuando su valor sea // 5, la condicin ser // 5 < 5 por lo que // no entra en el bucle // y no se excede el // lmite del array arrayPersona[x] = new Persona(); // Inicializa cada elemento del // array con un nuevo objeto // persona } } }
DECLARACIN, CONSTRUCCIN, E INICIALIZACIN EN UNA LNEA Existen dos maneras de realizar estos pasos con un array:
1. 2. 3. 4. 5. 6. 7. 8. 9. // Forma 1 - Todo en una lnea int x = 12; int[] array_0 = { 8, x, 22 }; // Forma 2 - Multiples lneas int x2 = 12; int[] array_1 = new int[3]; array_1[0] = 8; array_1[1] = x2; array_1[2] = 22;
Ambas sintaxis son totalmente equivalentes. CONSTRUYENDO E INICIALIZANDO UN ARRAY ANNIMO Permite construir un array e inicializarlo, sin asignarlo a ninguna variable. Pero, para que se podra utilizar? Es muy til para enviar como argumento un array que se genere en el momento. La sintaxis es:
1. 2. new int[] { 1, 14, 2, 4 }; int[] array_1 = new int[] { 1, 3 }; // A la variable array_1 se le pasa
3. 4.
// la referencia del array // annimo.
ASIGNACIONES LEGALES DE ELEMENTOS DE UN ARRAY Un array solo puede ser declarado de un tipo en particular, pero eso no quiere decir que todos los elementos que este contenga tengan que ser explcitamente del mismo tipo. Arrays de tipos primitivos y referencia Aplican las mismas propiedades para los elementos de un array que para una variable del mismo tipo.
ASIGNACIONES LEGALES DE REFERENCIAS DE TIPO ARRAY

Cuando hablamos de la referencia es al objeto array, y no a sus elementos. REFERENCIAS PARA TIPO DE DATOS PRIMITIVOS Dado que un array es un objeto, los tipos de array para primitivos son objetos totalmente diferentes, que no comparten un rbol de herencia, por lo que no es legal asignar ningn tipo de array, siempre que no sea el declarado (no aplican los tipos vlidos para conversiones implcitas). REFERENCIAS PARA TIPOS DE DATOS DE REFERENCIA En estos casos, se puede asignar lo siguiente: La referencia de array asignada puede ser de la misma clase o subclase (downcasting en el rbol de herencia). La referencia de array asignada no puede ser de una superclase (upcasting en el rbol de herencia). La referencia de array asignada puede ser una interfaz, pudiendo ser el tipo de la referencia cualquier clase que implemente la interfaz, o subclase que derive de una clase que implemento esta.
REFERENCIAS PARA TIPOS DE DATOS DE REFERENCIA EN ARRAYS MULTIDIMENSIONALES En estos casos, es necesario que el tipo de dato a asignar sea una referencia a un array de las mismas dimensiones que el tipo de dato.
1. 2. 3. 4. 5. int[] array = new int[4]; int[][] array2D = new int[5][]; array2D = array; // Error. Las dimensiones no concuerdan int[] arrayOther = new int[15]; array = arrayOther; // OK. Las dimensiones y el tipo concuerdan.
44
BLOQUES DE INICIALIZACIN
Estos bloques permiten ejecutar lgica, fuera de un constructor o un mtodo. Existen dos tipos de bloques de inicializacin: estticos y de instancia. Las reglas que aplican a estos son: Los bloques de inicializacin se ejecutan en el orden en que aparecen (arriba hacia abajo). Los bloques de inicializacin estticos Se ejecutan una sola vez, cuando la clase es cargada. Los bloques de inicializacin de instancia Se ejecutan cada vez que se crea una nueva instancia de la clase. Se ejecutan luego de la llamada a super(). Veamos un ejemplo de inicializacin:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35.
class Padre { static { System.out .println("Se ejecuta el bloque de instancia de la clase padre"); } { System.out .println("Se ejecuta el bloque de inicializacin de la clase padre"); } public Padre() { System.out .println("Se ejecuta el contructor de instancia de la clase padre"); } } class Hija extends Padre { static { System.out .println("Se ejecuta el bloque de instancia de la clase hija"); } { System.out .println("Se ejecuta el bloque de inicializacin de la clase hija"); } public Hija() { System.out .println("Se ejecuta el contructor de instancia de la clase hija"); } } public class Inicializacion { static public void main(String[] args) { new Hija();
36. 37. }
Resultado: Se ejecuta el bloque de instancia de la clase padre Se ejecuta el bloque de instancia de la clase hija Se ejecuta el bloque de inicializacin de la clase padre Se ejecuta el contructor de instancia de la clase padre Se ejecuta el bloque de inicializacin de la clase hija Se ejecuta el contructor de instancia de la clase hija
LAS CLASES WRAPPER Estas clases sirven para dos propsitos funadmenales en Java: Otorgar un mecanismo para envolver (wrap) valores primitivos en un objeto. Otorgar una serie de funciones tiles para los valores primitivos.
Tabla con los diferentes wrappers:
Tipo primitivo boolean byte short char int long float double
Wrapper Boolean Byte Short Character Integer Long Float Double
CREACIN DE OBJETOS WRAPPER Es necesario comprender para el examen las tres maneras ms comunes de crear un objeto Wrapper. Algunas cuestiones a tener en cuenta con los Wrappers: Los objetos Wrapper son inmutables (no pueden modificar su valor una vez creados). Si se inicializa un Wrapper con un String para obtener un tipo primitivo, puede generar una Excepcin de tipo NumberFormatException, si el String no corresponde con el tipo de dato esperado por el Wrapper.
46
Argumentos para el constructor boolean o String byte o String short o String char int o String long o String float, double, o String double o String
LOS CONSTRUCTORES DEL WRAPPER La mayora de los Wrappers proporcionan dos constructores, argumento del tipo primitivo, o String.
1. 2. 3. 4. Integer i1 = new Integer(23); Integer i1 = new Integer("23"); Float f1 = new Float(1.23F); Float f1 = new Float("1.23F");
EL MTODO VALUEOF() Este mtodo esttico otorga otra manera de crear un objeto Wrapper de un primitivo. En casi todos los Wrappers se encuentra sobrecargado. valueOf(String valor) valueOf(String valor, int base)
UTILIDADES DE CONVERSIN DE LOS WRAPPERS Los mtodos detallados a continuacin son los ms utilizados y los que se incluyen en el examen. xxxValue() Utilizado para convertir el valor de un Wrapper numrico en su tipo primitivo.
5. 6. Integer i1 = new Integer(23); int i = i1.intValue();
Todos los Wrapper de los valores numricos primitivos tienen los mtodos xxxValue() para todos los primitivos numricos. parseXxx() y valueOf() Ambos toman como primer argumento un String para crear el valor Ambos arrojan una excepcin NumberFormatException parseXxx() o Devuelve el valor primitivo de un Wrapper o Para cada Wrapper de tipo primitivo numrico, el mtodo se obtiene reemplazando Xxx por el nombre del tipo primitivo con la primer letra en mayscula. valueOf() o Devuelve un nuevo Wrapper del mismo tipo que el del mtodo invocado o Existen en todos los Wrappers con tipo primitivo numrico
JAVA FUNDAMENTALS PROGRAMMING toString() Este mtodo se encuentra en la clase Object. Se utiliza para poder representar de manera ms explcita un objeto. Todos los Wrappers tienen este mtodo sobre escrito y marcado como final. Devolviendo un String con el valor del primitivo que contienen. A su vez, todos los Wrappers numricos tienen un mtodo esttico sobrecargado, con un parmetro del tipo primitivo del Wrapper, devolviendo un objeto String. Tambin, Integer y Long tienen otro mtodo esttico sobrecargado que tiene dos parmetros, el primero del tipo primitivo del Wrapper, y el segundo de tipo int, que indica la base sobre la cual formatear el valor. toXxxString() (Binario, Hexadecimal, Octal) Para los Wrappers Integer y Long existen tres mtodos: toOctalString() toHexString() toBinaryString()
Todos estos tienen un solo parmetro, que es el tipo primitivo del Wrapper.
Mtodo byteValue shortValue intValue longValue floatValue doubleValue parseXxx parseXxx (con base) valueOf valueOf (con base) toString toString (primitivo) toString (primitivo, base)
s=static n= NFE
Boolean
Byte X X X X X X
Short X X X X X X X X X X X X
Character
Integer X X X X X X X X X X
Long X X X X X X X X X X X X X
Float X X X X X X X
Double X X X X X X X
s,n s,n s,n s,n
X X
X X
X s s X
X X
X X
X X X
X X
X X
Firmas de los mtodos:
48
JAVA FUNDAMENTALS PROGRAMMING primitive xxxValue() convierte un Wrapper en un primitivo primitive parseXxx(String) convierte un String en un primitivo Wrapper valueOf(String) convierte un String en un Wrapper
AUTOBOXING Este trmino viene relacionado con unboxing, boxing, y sus respectivos automticos. Estos son utilizados en el momento en que se utilizan Wrappers y primitivas. Para explicar mejor el concepto, mostramos un ejemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. // Este ejemplo realiza un unboxing y boxing automtico Integer wrapper = new Integer(78); int primitive = wrapper.intValue(); // Unboxing - obtenemos la variable // primitiva primitive++; // Realizamos las operaciones necesarias sobre la // primitiva wrapper = new Integer(primitive); // Boxing - volvemos a contener a la // primitiva en el Wrapper La // sintaxis anterior en Java 5 es // equivalente a: Integer wrapper1 = new Integer(78); wrapper1++; // Esto hace el unboxing, realiza la operacin, y el boxing
BOXING, ==, Y EQUALS() El operador != o Este no se encuentra sobrecargado. Compara posiciones de memoria. El operador == o Se encuentra sobrecargado. Compara valores o Cuando se compara un wrapper y una primitiva, al wrapper se le hace un outboxing. El mtodo equals() o Compara valores. La regla general para Wrappers y auto-unboxing y auto-boxing, es que, estos pueden ser utilizados como primitivas.
SOBRECARGA (OVERLOADING) En esta seccin agregaremos algunos conceptos a la sobrecarga: Widening Autoboxing Var-args
JAVA FUNDAMENTALS PROGRAMMING Cuando una clase tiene mtodos sobrecargados, uno de los trabajos del compilador es determinar que mtodo utilizar si encuentra una invocacin a un mtodo sobrecargado. En cada caso, cuando no se encuentra una concordancia, la JVM utiliza el mtodo con un parmetro ms abarcativo que el de la llamada con la menor cantidad de parmetros. SOBRECARGA CON BOXING Y VAR-ARGS El compilador prefiere utilizar variables ms abarcativas, que realizar un unboxing. Ejemplo:
1. public class UnboxingVsWidering { 2. static public void figth(Integer i) { 3. System.out.println("Unboxing wins!"); 4. } 5. 6. static public void figth(long l) { 7. System.out.println("Widering wins!"); 8. } 9. 10. static public void main(String[] args) { 11. int x = 45; 12. UnboxingVsWidering.figth(x); 13. } 14. }
La regla es: Widering le gana a boxing Boxing le gana a var-args
No es posible combinar widering and boxing. Si el compilador debiera realizar ambas acciones para encontrar una concordancia de mtodo, se produce un error. SOBRECARGA CON VAR-ARGS Al igual que widering y boxing, estos aplican de la misma manera para var-args.
OPERADORES
Chapter: Operadores Los operadores son aquellos elementos que producen un resultado realizando operaciones con uno o varios operandos (estos son los elementos que se encuentran a la izquierda y derecha del operador).
OPERADORES DE ASIGNACIN
El operador de asignacin es el =. Algunos conceptos a tener en cuenta:
50
JAVA FUNDAMENTALS PROGRAMMING Cuando se le asigna un valor a una primitiva, el tamao si importa. (Es importante saber cuando ocurrir un casteo implcito, explcito, y cuando se trunca el valor). Una variable de referencia no es un objeto, es una manera de obtener el objeto al que hace referencia. Cuando se asigna un valor a una referencia, el tipo importa. (Es importante saber las reglas para superclases, subclases, y arrays).
OPERADORES DE ASIGNACIN COMPUESTOS

Actualmente, existen alrededor de 11 operadores de asignacin compuestos, pero en el examen solo aparecern los 4 ms comunes (+=, -=, *=, /=) se encuentran en el examen. Pero, que es un operador de asignacin compuesto? Simplemente, es una manera abreviada de realizar una operacin con el valor de la variable en donde se asigna el resultado con otro
1. 2. 3. 4. 5. int a = 2; a = a * 3; // Diferente sintaxis, mismo significado. int a1 = 2; a1 *= 3;
conjunto. Veamos un ejemplo: 1. 2. 3. 4. 5. 6. 7. 8. 9. int a = 2; int b = 3; int c = 5; a = a * (b + c); // Diferente sintaxis, mismo significado. int a1 = 2; int b1 = 3; int c1 = 5; a1 *= b1 + c1;
A simple vista, parece sencillo, pero no hay que confundirse. El operador de asignacin compuesto se refleja en realizar una opeacin con el resultado de todo lo que se encuentra luego del igual. Veamos un ejemplo: Es posible confundirse con esto, creyendo que la operacin fuera ( a * b ) + c, pero reitero, el operador de asignacin compuesto realiza los siguientes pasos: 1. Realiza todas las operaciones contenidas a la derecha del operador de asignacin (=). 2. Realiza la operacin compuesta (Multiplicar, Dividir, Sumar, Restar, ...). 3. Asigna el valor de la operacin a la variable.
OPERADORES RELACIONALES
El examen cubre sies operadores relaciones (<, <=, >, >=, == y =). Los operadores relacionales siempre producen como resultado un valor de tipo boolean. Los operadures se traducen como: < menor que <= menor o igual que > mayor que >= mayor o igual que == igual que = distinto de
Veamos algunos ejemplos:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. int x = 7; if (x < 9) { // Codigo ... } else { // Codigo ... } // Entra en el if boolean a = 100 > 90; if (a) { // Codigo ... } else { // Codigo ... } // Entra en el else
Ahora, veamos un ejemplo un poco ms complicado:

15. 16. 17. 18. 19. 20. int x = 12; if ((x = 2 * 3) == 6) { // Codigo ... } else { // Codigo ... }
52
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING En este cdigo, se ejecuta el if. Los pasos que realiz el programa fueron: 1. Realizar la operacin 2 * 3. 2. Asignar el resultado de la operacin anterior a x. 3. Comparar el valor de x con el literal 6. Vuelvo a recalcar la importancia de entender la diferencia entre = e ==, y saber identificar cuando podra haber un posible error. Quiero mostrar otro ejemplo, en donde se aprecia aun ms la importancia de detectar las diferencias entre dichos operadores:
1. 2. 3. 4. 5. 6. boolean x = false; if (x = true) { // Codigo ... } else { // Codigo ... }
No es lo mismo que: 1. 2. 3. 4. 5. 6. boolean x = false; if (x == true) { // Codigo ... } else { // Codigo ... }
En este cdigo se ejecuta el else. Tambin es posible realizar una comparacin como:
7. 8. 9. 10. 11. 12. char a = 7; if (a < 'g') { // Codigo ... } else if (a < 16) { // Codigo ... }
Cuando se compara un valor de tipo char, se utiliza el valor unicode del caracter.
OPERADORES DE IGUALDAD
Los operadores de igualdad son: == Igual que = Distinto de
Estos operadores solo comparan el patrn de bits. Esto es importante dado que en una variable de tipo referencia, el valor es la posicin de memoria donde se encuentra el objeto.
IGUALDAD EN PRIMITIVAS
Algunos ejemplos:
1. 2. 3. 4. 5. 'a' == 'a' //TRUE 'a' == 'b' //FALSE 7 != 9 //TRUE 1.0 == 1L //TRUE (se realiza un casteo implcito) true == false //FALSE
IGUALDAD EN VARIABLES DE TIPO REFERENCIA

Cuando se compara una referencia con los operadores de igualdad, solo se compara el objeto al que referencian (el valor de la variable es la direccin de memoria en donde se encuentra el objeto realmente).
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. class Simple { int x; Simple(int x) { this.x = x; } } public class Temp { public static void main(String[] args) { Temp t = new Temp(); Simple obj_1 = new Simple(16); Simple obj_2 = new Simple(16); Simple obj_3 = obj_1; System.out.println("Objeto 1 es igual a objeto 2? " + (obj_1 == obj_2)); System.out.println("Objeto 1 es igual a objeto 3? " + (obj_1 == obj_3)); } }
Resultado:

54
Chapter: Operadores
Objeto 1 es igual a objeto 2? False Objeto 1 es igual a objeto 3? True
JAVA FUNDAMENTALS PROGRAMMING A pesar de que el nico atributo que tiene el objeto Simple es igual en obj_1 como en obj_2, su comparacin de igualdad da false. Vamos a hacerlo un poco ms grfico para dejar este importante concepto bien en claro.
Obj_1 Obj_2 Obj_3 Variables 0x0000F0 0x0000A9 0x0000F0
Memoria
16
16
En el grfico podemos apreciar facilmente el porque la comparacin entre obj_1 y obj_2 facilmente fallo, cuando entre obj_1 y obj_3 fue exitosa. Ms alla de que obj_1 y obj_2 contentan su nico atributo con el mismo valor. IGUALDAD EN ENUMERADORES ORES Se aplica la poltica de variables de referencia. Al final, un enumerador es un objeto. COMPARACIN CON INSTANCEOF ANCEOF El operador instanceof devuelve un valor de tipo boolean, que indica si el objeto Es Es-Un objeto del tipo especificado (o subtipo). Tambin aplica a interfaces, cuando el objeto Implementa una interfaz especificada (o alguna de sus superclases la implementa). na
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. interface Dibujable { } class Triangulo implements Dibujable { } class Cuadrado extends Triangulo { } class Circulo implements Dibujable { }
Tipo null Dibujable Circulo Triangulo Cuadrado
Se puede comparar con Cualquier clase o interface Dibujable Object Circulo Triangulo Cuadrado Circulo Dibujable Object Cuadrado Triangulo Dibujable Object Cuadrado Triangulo Dibujable Object
No se puede comparar con Triangulo Cuadrado Circulo Circulo
OPERADORES ARITMTICOS No hay mucho que decir acerca de estos, salvo que todos los utilizamos. El operador de resto Cualdo realizamos una operacin de divisin, existe un resto. Este valor puede ser obtenido a partir del operador %.
1. 2. 3. 4. 5. 6. public class ejemploResto { static public void main(String[] arg) { System.out.println("9 dividido 2 es " + (9 / 2) + ". Y el resto es " + (9 % 2)); } }
Un ejemplo del operador: 9 dividido 2 es 4. Y el resto es 1.
El operador de concatenacin El operador + tambin puede ser utilizado para concatenar cadenas de caracteres. La regla para saber cuando se comporta como suma y cuando como concatenacin es simple: Si alguno de los dos valores es un String, el + funciona como concatenador. Algunos ejemplos:
1. 2. 3. 4. System.out.println(67 + 45 + 9); // 121 System.out.println(67 + 45 + " - valores" + 67 + 45); // 112 // valores6745 System.out.println("hola" + " " + "mundo"); // hola mundo
OPERADORES DE INCREMENTO Y DECREMENTO Estos operadores sirven para incrementar o decrementar en 1 el valor de cualquier variable numrica. Preincremento ++variable Antes de realizar cualquier accin, el valor de la variable es incrementado en 1. Luego contina con la lgica. Posincremento variable++ Primero realiza la lgica, y al finalizar incrementa el valor de la variable en 1. Chapter: Operadores
Veamos un ejemplo:
56
1. 2. 3. 4. 5. 6. 7.
int x; x = 0; System.out.println(x++ + 6); // 6 System.out.println(x); // 7 x = 0; System.out.println(++x + 6); // 7 System.out.println(x); // 7
Hay que tener cuidado en codigos de condicin complejos, veamos algunos ejemplos:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. int x, y, z; x = 0; y = 2; z = 2; if ((x++ == y) || (z == ++y)) { System.out.println("( (x++ == y) || (z == ++y) ) ? true"); } else { System.out.println("( (x++ == y) || (z == ++y) ) ? false"); } // Resultado: false x = 0; if ((x++ == ++x)) { System.out.println("( (x++ == ++x) ) ? true"); } else { System.out.println("( (x++ == ++x) ) ? false"); } // Resultado: false x = 0; if ((++x == x++)) { System.out.println("( (++x == x++) ) ? true"); } else { System.out.println("( (++x == x++) ) ? false"); } // Resultado: true x = 0; y = 1; z = 2; if ((--z > y) && (x == z)) { System.out.println("( (--z > y) && (++x < z) ) ? true"); } else { System.out.println("( (--z > y) && (++x < z) ) ? false"); } // Resultado: false x = 2; y = 1; z = 2; if ((--z > y) && (x > z)) { System.out.println("( (--z > y) && (x > z) ) ? true"); } else { System.out.println("( (--z > y) && (x > z) ) ? false");
41. 42.
} // Resultado: false
OPERADOR CONDICIONAL Este operador requiere tres trminos, y es utilizado para la asignacin de valores a una variable. Su funcionamiento es similar al de un if, verifica una condicin, y si esta es true asigna un valor, caso contrario asigna la otra. Ejemplo de la sintaxis: variable = (expresion booleana) ? valor a asignar si la condicion fue true : valor a asignar si la condicion fue false;
1. 2. x = (true) ? 1 : 2; // x ahora contiene el valor 1 x = (false) ? 1 : 2; // x ahora contiene el valor 2
OPERADORES LGICOS
Los operadores lgicos necesarios para el examen son: &, |, ^, , && y ||. OPERADORES LGICOS SOBRE BITS (NO ENTRA EN EL EXAMEN) Los siguientes operadores &, | y ^ pueden utilizarse en diferentes situaciones, una de ellas es para comparacin a nivel de bits. Estos fueron incluidos en versiones de examenes previas, pero para nuestra versin, no son necesarios.
58
Chapter: Operadores
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.
byte b01 = 5 & 15; // Compuerta AND /* *00101=5 0 1 1 1 1 = 15 ---------00101=5 */ byte b02 = 3 | 8; // Compuerta OR /* *00011=3 01000 =8 ---------0 1 0 1 1 = 11 */ byte b03 = 29 ^ 11; // Compuerta XOR /* * 1 1 1 0 1 = 29 0 1 0 1 1 = 11 ----------
20. 21.
1 0 1 1 0 = 21 */
OPERADORES LGICOS DE CIRCUITO CORTO Estos son: && AND de circuito corto || OR de circuito corto
Pero, por qu de circuito corto? Se denominan de esta manera porque cuando se evalua una expresin, si la primer evaluacin hace que la condicin no se cumpla no se evalua la siguiente. Veamos algunos ejemplos:
1. class Valores { 2. public int getValor1() { 3. System.out.println("Devuelvo el valor 1"); 4. return 1; 5. } 6. 7. public int getValor2() { 8. System.out.println("Devuelvo el valor 2"); 9. return 2; 10. } 11. } 12. 13. public class ejemploOperadoresLogicosCircuitoCorto { 14. static public void main(String[] args) { 15. Valores valores = new Valores(); 16. if ((valores.getValor1() == 2) && (valores.getValor1() == 1)) { 17. System.out 18. .println("( (valores.getValor1() == 2) && (valores.getValor1() == 1) ) ? true"); 19. } else { 20. System.out 21. .println("( (valores.getValor1() == 2) && (valores.getValor1() == 1) ) ? false"); 22. } 23. if ((valores.getValor2() > 0) || (valores.getValor2() != 5)) { 24. System.out 25. .println("( (valores.getValor2() > 0) || (valores.getValor2() != 5) ) ? true"); 26. } else { 27. System.out 28. .println("( (valores.getValor2() > 0) || (valores.getValor2() != 5) ) ? false");
29. 30. 31. }
} }
Resultado:
Devuelvo el valor 1 ( (valores.getValor1() == 2) && (valores.getValor1() == 1) ) ? false Devuelvo el valor 2 ( (valores.getValor2() > 0) || (valores.getValor2() != 5) ) ? true
Como se puede apreciar, en los dos casos, al evaluar la primer condicin no es necesario evaluar la segunda, de manera que esta ltima, directamente es obviada.
OPERADORES LGICOS DE CIRCUITO COMPLETO Estos son: | &
Al contrario de los de circuito corto, estos siempre evaluan todas las condiciones, por ms que ya se conozca de antemano el resultado de la operacin lgica (estos operadores son ineficientes). Veamos el ejemplo con los operadores de circuito completo: A diferencia de los operadores lgicos de circuito corto, vemos como se verifica la segunda condicin.
1. class Valores { 2. public int getValor1() { 3. System.out.println("Devuelvo el valor 1"); 4. return 1; 5. } 6. 7. public int getValor2() { 8. System.out.println("Devuelvo el valor 2"); 9. return 2; 10. } 11. } 12. 13. public class ejemploOperadoresLogicosCircuitoCompleto { 14. static public void main(String[] args) { 15. Valores valores = new Valores(); 16. if ((valores.getValor1() == 2) & (valores.getValor1() == 1)) {
60
Chapter: Operadores
17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31.
System.out .println("( (valores.getValor1() == 2) & (valores.getValor1() == 1) ) ? true"); } else { System.out .println("( (valores.getValor1() == 2) & (valores.getValor1() == 1) ) ? false"); } if ((valores.getValor2() > 0) | (valores.getValor2() != 5)) { System.out .println("( (valores.getValor2() > 0) | (valores.getValor2() != 5) ) ? true"); } else { System.out .println("( (valores.getValor2() > 0) | (valores.getValor2() != 5) ) ? false"); } } }
Resultado:
Devuelvo el valor 1 Devuelvo el valor 1 ( (valores.getValor1() == 2) & (valores.getValor1() == 1) ) ? false Devuelvo el valor 2 Devuelvo el valor 2 ( (valores.getValor2() > 0) | (valores.getValor2() != 5) ) ? true
OPERADORES LGICOS ^ Y Estos operadores cumplen la uncin de las siguientes compuertas: Not ^ Xor
Not El operador Not solo toma un trmino, y el resultado refleja el valor de entrada invertido.
JAVA FUNDAMENTALS PROGRAMMING Xor El operador Xor evalua dos trminos. Si estos son diferentes, el resultado es true, de lo contrario es false.
IF Y SWITCH
Las sentencias if y switch generalmente se refieren a sentencias de decisin. Utilizamos las sentencias de decisin cuando deseamos que nuestro programa ejecute un comportamiento u otro, dependiendo del estado de una o ms variables. IF-ELSE
1. 2. 3. 4. 5. 6. 7.
if (expresionBooleana) { // Cdigo1 ... } else if (expresionBooleana) { // Cdigo2 ... } else { // Cdigo3 ... }
Lo que hace el cdigo es lo siguiente: 1. Evala la primer expresin booleana 2. Si el resultado es true 2.1. Se ejecuta Cdigo1 3. Si el resultado es false 3.1. Se verifica la segunda expresin booleana 3.2. Si el resultado es true 3.2.1. Se ejecuta Cdigo2 3.3. Si el resultado es false 3.4. Se ejecuta el else (condicin por defecto si no se cumplen los ifs) 3.4.1. Se ejecuta Cdigo3 Ahora, vamos a aclarar cmo puede llegar a ser la sintaxis: Solo debe existir un if Puede haber uno o ms else if, siempre que exista un if previo Puede haber solo un else, siempre que esxista un if previo No es necesario encerrar el contenido de las sentencias entre llaves (esto solo permite escribir cdigo de una lnea). No es una prctica recomendada Solo se pueden evaluar expresiones booleanas (esto no es C, un boolean true no es un int mayor que 0).
62
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING Los else if y else deben de estar encadenados al if (empiezan a medida que el otro finaliza). Si esta cadena se rompe generar un error de compilacin. Los else if y else son encadenados al if ms prximo. Se ejecuta solo la primer condicin que califique (en caso de que no califique ninguna, se ejecuta si existe el else).
Expresin 1
1. 2. 3. 4. 5. 6. 7.
static public void main(String[] args) { boolean expresion = false; if (expresion) System.out.println("Soy el valor 1"); System.out.println("Soy el valor 2"); System.out.println("Soy el valor 3"); }
Soy el valor 2 Soy el valor 3
Expresin 2
1. 2. 3. 4. 5. 6. 7. 8.
static public void main(String[] args) { boolean expresion = false; if (expresion) System.out.println("Soy el valor 1"); else System.out.println("Soy el valor 2"); System.out.println("Soy el valor 3"); }
Soy el valor 2 Soy el valor 3

Expresin 3
1. 2. 3. 4. 5.
static public void ejecutarIf(int valor) { if (valor == 1) { System.out.println("Soy el valor 1"); } else if (valor > 0) { System.out.println("Soy el valor 2");
6. 7. 8. 9. 10. 11. 12. 13. 14. 15.
} else { System.out.println("Soy el valor 3"); } } static public void main(String[] args) { ejecutarIf(1); ejecutarIf(0); ejecutarIf(87); }
Soy el valor 1 Soy el valor 3 Soy el valor 2
Expresin 4
1. 2. 3. 4. 5. 6. 7. 8.
static public void main(String[] args) { boolean expresion = false; if (expresion) System.out.println("Soy el valor 1"); System.out.println("Soy el valor 2"); else System.out.println("Soy el valor 3"); }
Error de compilacin! Como se puede apreciar en la expresin 1 solo tenemos el if. En la expresin 2, le sumamos un else. En ambas expresiones, no utilizamos las {} para encerrar el cdigo, pero aun as es vlido, dado que ninguno de ellos ocupa ms de una lnea.
En la expresin 3 agregamos un else if a la condicin, y las {}. Como vers, al llamar a la expresin con el 1, podra calificar para la primera sentencia, o para la segunda, pero como la primera es quien la captura primero, se ejecuta esta. En la expresin 4 nos encontramos con un error de ejecucin. Este se produce por el precepto de que los else else if, deben de estar encadenados unos a otros comenzando por el if. Como vern, al no tener {}, dentro del if solo entra el print para Soy el valor 1. Luego se ejecuta el print Soy el valor 2, y el else a continuacin. Dado que la sentencia anterior no fue un if, o else if, se genera un error de compilacin. Veamos un ejemplo un poco ms complicado:
64
Chapter: Operadores
1. public class ifTest { 2. static public void main(String[] args) { 3. if (expresion) 4. if (expresion2) 5. System.out.println("Me ejecuto 1"); 6. else 7. System.out.println("Me ejecuto 2"); 8. else 9. System.out.println("Me ejecuto 3"); 10. } 11. }
En realidad, no es ms difcil que lo anterior, solamente tiene un if anidado, una indentacin que no sirve para nada, pero el examen es generado dinmicamente, por lo cual, los creadores admiten que podemos llegar a encontrarnos con cdigo como este. Ahora pensemos, que valor veramos si, expresion es true y expresion2 es false?
Me ejecuto 2
Y si expresion es false y expresion2 es true?

Me ejecuto 3
Y si expresion es false y expresion2 es false?

Me ejecuto 3
Para que vean ms claramente, el cdigo indentado y con llaves sera el siguiente:
1. public class ifTest { 2. static public void main(String[] args) { 3. if (expresion) { 4. if (expresion2) { 5. System.out.println("Me ejecuto 1"); 6. } else { 7. System.out.println("Me ejecuto 2"); 8. } 9. } else { 10. System.out.println("Me ejecuto 3"); 11. } 12. } 13. }
Si quieren hacer la prueba se darn cuenta de que el cdigo resultante es el mismo. SWITCH Una manera de simular el uso de mltiples else if es la sentencia switch. Bsicamente, cuando tengan que verificar una variable por algunos valores en concreto, lo mejor es utilizar switch. Cuando el conjunto de valores a verificar es muy grande (ejemplo, cualquier valor menor que 100), se utiliza if. Estructura de la sentencia switch:
1. public class switchtest { 2. static public void main(String[] args) { 3. int x = 45; 4. switch (x) { 5. case 1: 6. System.out.println("valor: 1"); 7. break; 8. case 2: 9. System.out.println("valor: 2"); 10. break; 11. case 3: 12. case 4: 13. System.out.println("valor: 3 o 4"); 14. break; 15. case 5: 16. System.out.println("valor: 5"); 17. break; 18. default: 19. System.out.println("Ningn valor fue tenido en cuenta"); 20. } 21. } 22. }
Iremos explicando el cdigo anterior por pasos. Primero, tengamos en cuenta las condiciones que debe cumplir una sentencia switch para ser vlida: Cada valor especificado en el case debe de ser un literal o una constante final cargada en tiempo de compilacin (cuando se declara se inicializa. final int a = 1;) Solo se puede comparar contra un valor, no contra un rango (>, <, >=, <= no estn permitidos). La sentencia break es opcional, pero si no se especifica, se seguirn ejecutando las lneas inferiores hasta toparse con otro break o terminar la sentencia switch. Los valores tanto para el case, como para la entrada del switch, solo pueden ser aquellos que se puedan tipificar como int (no importa que el casteo sea implcito). Tampoco califica un String. Puede llegar calificar un enum. No pueden haber dos case que comparen el mismo valor. Si se utilizan tipos de dato que no sean int, tener mucho cuidado, ya que si alguno de los valores de un case produce un overflow, se genera un error de compilacin. Se pueden combinar varios case sucesivamente (ver ejemplo case 3: case 4:) puede calificar con cualquiera de los valores, y solo es necesario que califique para 1. La sentencia default se ejecuta si no calific ningn case. Esta no necesita estar al final.
66
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING Por ms que se ejecute default, si no se especifica un break, y hay ms sentencias debajo de esta, se ejecutarn como con un case normal.
BUCLES E ITERACIONES En java existen tres sentencias para bucles: while, do y for (este ltimo tiene dos alternativas). WHILE La sentencia while es adecuada cuando no tenemos idea de cuantas veces se ejecutar un bloque de cdigo, pero si queremos que en algn momento, este finalice. La sintaxis del while:
1. 2. 3. while (condicion) { // Bloque de cdigo ... }
Siempre que la condicin sea verdadera se ejecutar el bloque de cdigo. Puede que el bloque de cdigo no se ejecute nunca, si la condicin inicialmente es false. La condicin tiene que ser una expresin booleana. Cualquier variable utilizada dentro del while debe de ser declarada previamente (es ilegal declarar una variable dentro de la condicin).
Do La sentencia do es semejante al while, son la diferencia de que primero ejecuta el bloque de cdigo, y luego evala la condicin (al revs del while). La sintaxis del do:
1. 2. 3. do { // Bloque de cdigo ... } while (condicin);
A diferencia del while: La condicin se ejecutara al menos una vez. El while se finaliza con ;.
For El for es un poco ms complejo, pero simplemente porque contiene ms elementos en su invocacin que la condicin. Estos se pueden resumir de la siguiente manera:
1. 2. 3.
for ( inicializacion ; condicion ; incremento variables contador ) { //Bloque de cdigo ... }
Vamos a describir que hace, y que se puede hacer en cada seccin: Inicializacin :En esta parte se pueden asignar valores a variables ya declaradas, as como declarar una variable (esta solo ser visible para la sentencia for) e inicializarla. Condicin: Al igual que en las sentencias de bucle anteriores, la condicin indica si se vuelve a ejecutar el bloque de cdigo o no. Incremento variables contador: Aqu se incrementan las variables que son utilizadas para verificar la condicin (en realidad, se pueden incrementar o decrementar con cualquier operacin matemtica). A su vez, esta seccin permite realizar cualquier accin, hasta puedes realizar un print dentro de la misma.
Veamos una sentencia real:

1. 2. 3. 4. 5. int y = 0; int x = 0; for (x = 0, y = 3; x == 0 && y < 10; y++, x--) { // Bloque de cdigo ... }
Algunas cuestiones sobre la sentencia for: A diferencia de los bucles anteriores, el for es utilizado cuando conocemos la cantidad de veces que queremos que se ejecute un bloque de cdigo. En la inicializacin podemos especificar varias variables, separadas cada una por una coma, pero solo una accin o Podemos cambiar el valor de variables ya declaradas previamente al for o Podemos declarar e inicializar variables solo para el for, que no se encuentren definidas previamente en el mismo scope. Solo podemos evaluar una condicin (esto no quiere decir que no podamos combinar sentencias con los operadores &&, &, || y |). Podemos realizar cualquier operacin matemtica sobre las variables en el incremento de variables contador. La seccin de incremento variables contador se ejecuta cada vez que se completa el bloque de cdigo. Para separar elementos en la misma seccin se utiliza la ,.
68
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING For-each Es una nueva funcionalidad que se encuentra disponible a partir de java 6, la cual permite realizar una iteracin de un array o coleccin. En vez del tradicional for el cual contiene tres secciones, el for-each contiene dos secciones. Veamos un ejemplo con los dos tipos de sintaxis:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. // Sintaxis for int[] arr = { 1, 2, 3, 4, 5 }; for (int x = 0; x < arr.length; x++) { System.out.println(a[x]); } // Sintaxis for-each int[] arr = { 1, 2, 3, 4, 5 }; for (int x : arr) { System.out.println(x); }
La nueva sintaxis est formada por:

1. 2. 3. for ( declaracin : expresin ) { //Bloque de cdigo ... }
Vamos a describir que hace, y que se puede hacer en cada seccin: Declaracin o Permite declarar una variable, la cual se ir completando con cada elemento del array/coleccin. o La variable declarada debe ser del mismo tipo que cada elemento dentro del array, o un tipo compatible (casteo implcito, o dentro del mismo rbol de herencia siempre que sea downcasting, no se permite upcasting). o La variable no debe de existir en el mismo nivel de visin (scope). Expresin o Especifica el array o coleccin sobre el cual se realiza la iteracin. o Se puede especificar la llamada a un mtodo, siempre que este devuelva un array o coleccin. o El tipo del array puede ser cualquiera: primitivas, objetos, incluso array de arrays.
Algunos ejemplos de for-eachs vlidos:

1. 2. class Vehiculo { public String toString() {
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37.
return "Soy un vehiculo"; } } class Auto extends Vehiculo { public String toString() { return "Soy un auto"; } } class Moto extends Vehiculo { public String toString() { return "Soy una moto"; } } public class forEachTest { static public void main(String[] args) { int[] intArray = { 1, 2, 3 }; int[][] intIntArray = { { 1, 2 }, { 3, 4 }, { 5, 6 } }; Vehiculo[] vehiculoArray = { new Auto(), new Moto() }; System.out.println("intArray:"); for (int x : intArray) { System.out.println(x); } System.out.println("\nintIntArray:"); for (int[] x : intIntArray) { System.out.println(x); } System.out.println("\nvehiculoArray:"); for (Vehiculo x : vehiculoArray) { System.out.println(x); } } }
Break y continue Estos operadores pueden ser utilizados para salir del bucle, o para saltar a la siguiente iteracin. Pero que significa esto, bueno, vamos a ver en profundidad cada una de las sentencias dentro de un bucle if. Ejemplo con continue:
1. 2. 3. 4. 5. for (int x = 0; x < 10; x++) { if (x == 3) continue; System.out.print(x); }
70
Chapter: Operadores
6.
System.out.println("\nSe termin el for");
12456789 Se termin el if
Podemos ver como continue hace que se pase a la siguiente iteracin. Ejemplo con break:
1. 2. 3. 4. 5. 6. for (int x = 0; x < 10; x++) { if (x == 3) break; System.out.print(x); } System.out.println("\nSe termin el for");
12 Se termin el if
En este caso, al ejecutarse el break se sale del bucle, lo que produce la salida anterior. En el siguiente cdigo podemos apreciar el nivel sobre el que afecta el break:
1. 2. 3. 4. 5. 6. 7. 8. for (int x = 0; x < 3; x++) { for (int y = 0; y < 2; y++) { if (x > 0) break; System.out.print(" y:" + y); } System.out.print(" x:" + x); }
Cuando se ejecuta el break, solo sale del bucle de mayor anidacin, que en el caso anterior, es el if ( int y Veamos una anidacin de ifs con breaks y continues ms compleja para entender cmo funciona:
1. 2. 3. 4. 5. 6. public class breakTest { static public void main(String[] args) { for (int x = 0; x < 5; x++) { if (x == 4) // El bucle correspondiente a X=4 no se ejecuta break; for (int y = 0; y < 3; y++) {
7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. } // llega a este punto } } }
System.out.print(" y:" + y); if (y == 1) { // y=1 hace que se pase a la siguiente iteracin continue; } else if (y == 2) { break; // y=2 hace que se corte el bucle for( int y } else { System.out.print(" z:" + y); // Si y=0 se muestra z } if (x == 2) continue; System.out.println(" x:" + x); // Solo cuando y=0 && x!=2 se
Es tortuoso el solo mirar este cdigo, pero si puedes obtener la salida por pantalla, significa que eres uno con los bucles. La salida por pantalla sera:
y:0 y:1 y:1 y:1 z:0 x:0 y:2 y:0 z:0 x:1 y:2 y:0 z:0 y:1 y:2 y:0 z:0 x:3 y:2
SENTENCIAS DE RUPTURA CON ETIQUETAS La etiqueta permite identificar a un bucle mediante un nombre, de manera que cuando ejecutamos un break o continue, se le puede especificar a qu bucle deseamos que afecte, sin importar donde se encuentre. Las etiquetas deben de cumplir con las reglas de identificadores legales y convenciones de Java.
Ejemplo: Chapter: Operadores

1. 2. 3. 4. 5. 6. 7. 8. exterior: for (int a = 0; a < 10; a++) { for (int b = 0; b < 3; b++) { if (a == 3) break exterior; System.out.println("B:" + b); continue exterior; } System.out.println("A:" + a);
72
9.
B:0 B:1 B:2
Como vern, nunca se ejecuta la salida por pantalla de A, ni ninguna de B para valores de b>0. Esto es porque las sentencias de ruptura no afectan al elemento ms prximo, sino al que contiene la etiqueta, que en este caso es el ms externo. MANEJO DE EXCEPCIONES Una excepcin significa una condicin excepcional, la cual altera el flujo normal de ejecucin del programa. El manejo de excepciones en Java permite una manera limpia de manejar las mismas aislndolas del cdigo que las puede lanzar, sin tener que escribir cdigo que verifique los valores de retorno. Adems, permite utilizar la misma forma de tratar una excepcin para un rango de estas. Capturando una excepcin utilizando try y catch Cuando se genera una excepcin se dice que esta se lanza (throw). El cdigo encargado de manejar la excepcin es el manejador de excepciones (exception handler), y este atrapa (catch) la excepcin lanzada. Para poder especificar que cdigo ejecutar si es que una excepcin es lanzada, utilizamos la sintaxis try catch.
1. 2. 3. 4. 5. 6. 7. try { //Bloque de cdigo a verificar ... } catch(excepcion) { //Excepcin con que se verifica ... } finally { //Bloque de cdigo que se ejecutar siempre. }
Dentro del try se coloca todo el bloque de cdigo que pueda llegar a lanzar una excepcin y quisiramos verificar y/o, que dependa de algn otro bloque que puede llegar a lanzar la excepcin. Dentro del catch se especifica el cdigo a ejecutar en caso de identificarse la excepcin declarada.
JAVA FUNDAMENTALS PROGRAMMING Dentro del finally se pone el bloque de cdigo que se ejecutar siempre, sin importar si se lanz o no alguna excepcin, sea cual sea. Algunas cuestiones Try o Una vez que se lance una excepcin, no se contina ejecutando el bloque de cdigo del try. Solo se detecta la primera excepcin lanzada. Si se especifica un try, se debe especificar un catch y/o un finally.
o o Catch o Se pueden especificar la cantidad de catch que se desee, con las siguientes condiciones Estos se deben de ubicar inmediatamente despus del try y antes del finally si es que se especifica. Si hay ms de un catch, estos se deben de especificar uno a continuacin del otro. No es posible especificar dos catch que manejen la misma excepcin No es posible especificar un catch que maneja una excepcin que un catch anterior tambin lo hace (el catch anterior es la superclase, y el catch siguiente una subclase. Genera error de compilacin). Un catch puede manejar un tipo de excepcin que admita un grupo de estas o Una vez que se detecta una excepcin, se entra en el primer catch que califique con el tipo de excepcin lanzada o No hay forma de que una vez cargado el catch se contine con la ejecucin del try. o Es posible no especificar un catch y que la compilacin sea vlida (siempre que se especifique un throws en la firma). Finally o Este bloque es opcional. o Se ejecutar siempre, por ms que se lance una excepcin o no, sea cual sea (en realidad es un 90% cierto). Es posible que no se ejecute si se lanza un return en alguna de las sentencias try o catch. o Se ejecuta luego del try y catch. o Debe especificarse inmediatamente luego de un bloque catch (si es que se lo especific), en su defecto, del try. Chapter: Operadores
PROPAGACIN DE EXCEPCIONES En realidad no es necesario capturar una excepcin inmediatamente. A lo que me refiero es que cada cdigo que pueda lanzar una excepcin no necesariamente debe de estar rodeado por un try.
74
JAVA FUNDAMENTALS PROGRAMMING Cuando un mtodo no captura la excepcin de esta manera, se dice que la est esquivando (ducking).
Pero hay una regla fundamental, si se produce una excepcin, alguien la tiene que capturar, o lo har la JVM y creme, no te agradar que lo haga (si lo hace, detendr la ejecucin del programa, y mostrar por pantalla la excepcin lanzada, junto con el stack de la misma). Veamos un ejemplo simple:
1. public class exceptionDividoPorCero { 2. static public int tercerMetodo() { 3. return 4 / 0; // Ouch!, dividido por 0... 4. } 5. 6. static public int segundoMetodo() { 7. return exceptionDividoPorCero.tercerMetodo(); 8. } 9. 10. static public int primerMetodo() { 11. return exceptionDividoPorCero.segundoMetodo(); 12. } 13. 14. static public void main(String[] args) { 15. System.out.println("Valor:" + exceptionDividoPorCero.primerMetodo()); 16. } 17. }
Como podemos apreciar, una divisin por 0 lanza una excepcin en tiempo de ejecucin. En la salida por pantalla (producida porque
Exception in thread "main" java.lang.ArithmeticException: / by zero at exceptionDividoPorCero.tercerMetodo(exceptionDividoPorCero.java:3) at exceptionDividoPorCero.segundoMetodo(exceptionDividoPorCero.java:7) at exceptionDividoPorCero.primerMetodo(exceptionDividoPorCero.java:11) at exceptionDividoPorCero.main(exceptionDividoPorCero.java:14)
la excepcin llego hasta la JVM, o dicho de otra forma, la excepcin fue esquivada por el mtodo main), vemos dos cosas: El tipo de excepcin lanzada: java.lang.ArithmeticException con el texto / by zero (dividido por cero) que en realidad es una excepcin de tipo RuntimeException. El stack (pila) de llamadas, desde donde se lanzo la excepcin, hasta el main. Tambin informa las lneas de las llamadas (esto ltimo es muy til para rastrear los errores).
DEFINIENDO QUE ES UNA EXCEPCION En Java, o es una primitiva o es un Objeto, y dado que ya cubrimos todas las primitivas, nos queda as es, una Excepcin es un Objeto. Con la salvedad de que todas las excepciones tienen en su rbol de herencia a la clase java.lang.Exception.
JERARQUA DE EXCEPCIONES
Exception De esta se desprenden dos categoras de excepciones: Excepciones que son posibles de interceptar, y excepciones en tiempo de ejecucin, que son muy difciles de detectar, y que pueden derivarse de errores del programa.
ATRAPANDO EXCEPCIONES Cuando decimos que se puede atrapar una excepcin por su tipo, o por un tipo de una de sus superclases, nos referimos al comportamiento habitual de un objeto con respecto a los parmetros de un mtodo. Solo hay que tener en cuenta una cuestin, cuando en una sentencia try-catch se lanza una excepcin, se verifican los catch desde arriba hacia abajo, y se ejecuta el que primero califique para la excepcin. Veamos un ejemplo: (No se preocupen en entender ahora el por qu de las clases que cree, solo sepan que podemos crear nuestras propias excepciones)
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. class PadreException extends Exception { public PadreException() { } public PadreException(String s) { super(s); } } class HijoException extends PadreException { public HijoException() { } public HijoException(String s) { super(s); } } class NietoException extends HijoException { public NietoException() { } public NietoException(String s) { super(s);
76
Chapter: Operadores
25. } 26. } 27. 28. public class pruebaExcepciones_1 { 29. static public void metodoLanzaException() throws NietoException { 30. throw new NietoException(); 31. } 32. 33. static public void main(String[] args) { 34. try { 35. pruebaExcepciones_1.metodoLanzaException(); 36. } catch (PadreException e) { 37. System.out.println(e); 38. } 39. try { 40. pruebaExcepciones_1.metodoLanzaException(); 41. } catch (HijoException e) { 42. System.out.println(e); 43. } 44. try { 45. pruebaExcepciones_1.metodoLanzaException(); 46. } catch (NietoException e) { 47. System.out.println(e); 48. } 49. try { 50. pruebaExcepciones_1.metodoLanzaException(); 51. } catch (NietoException e) { 52. System.out.println("Nieto"); 53. } catch (HijoException e) { 54. System.out.println("Hijo"); 55. } catch (PadreException e) { 56. System.out.println("Padre"); 57. } 58. } 59. }
NietoException NietoException NietoException Nieto
Como vern, la excepcin puede ser captura por el tipo de la clase o de alguna de sus superclases. Tambin se puede apreciar como en la coleccin de catchs califica en el primer intento.
DECLARACION DE EXCEPCIONES E INTERFACE PBLICA Como vern en el ejemplo anterior, el mtodo que lanza la excepcin tiene en su firma un throws, esto es as porque las excepciones que puede llegar a generar un mtodo o clase son parte de la firma.
JAVA FUNDAMENTALS PROGRAMMING RELANZANDO EXCEPCIONES Si utilizas un try-catch, al capturar la excepcin puedes relanzarla, o lanzar otro tipo. Veamos un ejemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. class MyException extends Exception { public MyException() { } public MyException(String s) { super(s); } } public class ejemploRelanzarException { static public void metodoTercero() throws Exception { try { throw new Exception(); // Lanza una excepcion } catch (Exception ex) { // La atrapa (catch) throw ex; // La vuelve a relanzar y se produce un duck (sale del // mtodo) } } static public void metodoSegundo() throws MyException { try { ejemploRelanzarException.metodoTercero(); // Llama a un mtodo que // puede devolver una // excepcion de tipo // Exception } catch (Exception ex) { // Verifica por la excepcion de ese tipo throw new MyException(ex.toString()); // Relanza una nueva excepcion // con el informe de la // primera como mensaje } } static public void main(String[] args) { try { ejemploRelanzarException.metodoSegundo(); // Verifica un mtodo que // puede devolver una // excepcion de tipo // MyException } catch (MyException ex) { // Atrapa la excepcion System.out.println(ex); // Muestra la informacin de la excepcion } } }
Demasiadas excepciones! Ahhh ERROR!!! Vamos, que no es tan difcil. Primero prestemos atencin a las firmas de cada mtodo:
78
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING metodoSegundo dice lanzar una excepcin de tipo myException metodoTercero dice lanzar una excepcin de tipo Excepcion
En el caso del metodoTercero, este lanza la excepcin, la captura, y relanza la misma (cuando hace el segundo throw, no tiene el new). segundoMetodo captura la excepcin, y en respuesta lanza una nueva excepcin de tipo MyException. Dado que el mtodo main solo interactua con metodoSegundo, cuando se realiza el try, solo buscamos por la excepcin lanzada por este (de todas maneras, si hubiramos especificado como tipo Exception hubiera sido vlido, dado que MyException hereda de esta).
DE DONDE PROVIENEN LAS EXCEPCIONES Es importante conocer que causa los errores y excepciones, y de donde provienen. Para propsitos del examen, dividimos los orgenes en dos categoras: Excepciones de la JVM: Aquellas que son lanzadas por la JVM. Excepciones de programacin: Aquellas que son lanzadas explcitamente mediante un throw.
Veamos una tabla que resume las excepciones que necesitamos conocer para el examen:
Excepcin ArrayIndexOutOfBoundsException
Descripcin Lanzada cuando se intenta acceder a un elemento del array con un ndice negativo o mayor a la cantidad de elementos contenidos (length 1). Lanzado cuando se intenta castear una clase que falla a la verificacin Is-A. Lanzada cuando un mtodo recibe un argumento formateado de forma diferente a la que lo espera. Lanzada cuando el estado del ambiente no coincide con la operacin solicitada. Lanzado cuando se intenta acceder a un objeto a travs de una referencia que contiene un valor nulo (null).
Lanzado por JVM
ClassCastException IllegalArgumentException
JVM Programticamente
IllegalStateException
Programticamente
NullPointerException
JVM

NumberFormatException Lanzada cuando un mtodo que convierte un String en un nmero recibe una cadena que no puede ser formateada como tal. Lanzada cuando una sentencia de verificacin booleana detecta un false. Lanzado cuando intentas inicializar una variable esttica o un bloque de inicializacin. Lanzada generalmente cuando un mtodo se llama recursivamente muchas veces (cada invocacin se agrega al stack). Lanzada cuando la JVM no puede encontrar una clase que necesita, debido a un error en la lnea de comandos, un problema con los classpaths, o un .class que falta. Programticamente
AssertionError
Programticamente
ExceptionInInitializerError
JVM
StackOverflowError
JVM
NoClassDefFoundError
JVM
AFIRMACIONES Las afirmaciones (assertions), son una herramienta para poder verificar aquellas partes del cdigo que creemos no fallarn nunca en nuestro cdigo, pero que si las tuviramos que verificar, tendramos que empezar a generar ms excepciones. Un vistazo a las afirmaciones Supongamos que tienes un cdigo como el siguiente:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. private float hazAlgo(int valor1, int valor2) { float resultado = 0.0f; if (valor2 != 0) { resultado = (float) (valor1 / valor2); } else { // Nunca debera de suceder este caso System.out .println("Error crtico. Tenemos una divisin por 0!!!! Ahhhhhh!!!!"); // El mensaje lo exager un poco para acentuar el problema de // mostrar este mensaje al usuario } return resultado; }
Si no quisieras realizar excepciones para verificar esta condicin, y no deseas hacer un if/else, ya que si no se da la condicin, en realidad el programa its toast. Las afirmaciones nos permiten realizar esta verificacin de manera que la verificacin que realicemos tiene dos posibilidades:
80
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING Si es true El cdigo contina ejecutndose con naturalidad Si es false Se detiene la ejecucin del programa y se lanza una AssertionException.
Otro punto interesante de las afirmaciones, es que estas solo se ejecutan cuando las mismas se encuentran habilitadas, caso contrario es como si no existieran. Esto es muy prctico cuando se trabaja en el ambiente de desarrollo, pero no querrs que el programa que publicaste en el ambiente de produccin se detenga totalmente por haberse lanzado una afirmacin. De todas formas, las afirmaciones siguen existiendo por ms que estn deshabilitadas, es solo que la JVM las ignora. Esto facilita que si tenemos algn error en produccin que era verificado por las afirmaciones, estas pueden ser habilitadas para detectar el problema ms rpido. Reglas de sintaxis de las afirmaciones Una afirmacin tiene dos tipos de sintaxis, la simple y la detallada. Afirmacin simple
1. 2. 3. 4. private float hazAlgo(int valor1, int valor2) { assert (valor2 != 0); return (float) (valor1 / valor2); }
Verifica una condicin. Si esta se cumple la ejecucin contina, caso contrario, lanza la excepcin AssertionExcepcion. Afirmacin detallada
1. 2. 3. 4. private float hazAlgo(int valor1, int valor2) { assert (valor2 != 0) : "valor1:" + valor1 + " - valor2:" + valor2; return (float) (valor1 / valor2); }
Se comporta de la misma manera que la afirmacin simple, con la diferencia de que aade una expresin. La funcin del segundo parmetro es simplemente la de aadirse al stack para brindar un detalle del error ocurrido. El prototipo de la sintaxis sera el siguiente: assert (condicion) : expresion; Condicin: debe resultar siempre en un valor de tipo boolean.
JAVA FUNDAMENTALS PROGRAMMING Expresin: puede resultar en un valor de cualquier tipo, pero debe de especificarse un valor. Habilitando las afirmaciones Es importante saber cmo ejecutar y cmo compilar cdigo con afirmaciones. Un problema que nos podemos llegar a encontrar es que en versiones anteriores de Java, assert se poda utilizar como identificador o como palabra reservada. A partir de Java 6, assert es una palabra reservada, cualquier intento de utilizarla como variable derivar en un error de compilacin. Por defecto las afirmaciones se encuentran desactivadas, pero podemos habilitarlas en tiempo de ejecucin. Al invocar nuestro programa desde la consola de comandos, le indicamos si se encuentran activadas o no. Ejemplo de llamada con afirmaciones habilitadas:
java -ea MiClase java -enableassertions MiClase
Ejemplo de llamada con afirmaciones deshabilitadas:

java -da MiClase java -disableassertions MiClase
Utilizando la sintaxis para afirmaciones deshabilitadas obtenemos el mismo comportamiento que la invocacin por defecto, pero, cambia cuando lo utilizamos de manera selectiva. Habilitando afirmaciones de manera selectiva Podemos aplicar la habilitacin o des habilitacin sobre una clase o package (y sus subpaquetes) especfico. Ejemplo de llamada con afirmaciones selectivas habilitadas:
java -ea:MiOtraClase MiClase java -ea:com.utils MiClase
Ejemplo de llamada con afirmaciones selectivas deshabilitadas:

java -da:MiOtraClase MiClase
Como mencionamos anteriormente, tampoco es de mucha ayuda este cdigo, dado que por defecto, las afirmaciones se encuentran deshabilitadas.
82
Chapter: Operadores
En este ejemplo, solo habilitamos las afirmaciones para la clase MiOtraClase, y en la segunda llamada, para el paquete com.utils y todos sus subpaquetes.
JAVA FUNDAMENTALS PROGRAMMING Cul es el secreto entonces? Se pueden combinar un comando general y uno selectivo, siempre que sean opuestos (uno habilita y el otro deshabilita). Ejemplos de combinaciones:
java -da -ea:MiOtraClase MiClase java -ea -da:com.utils... MiClase
En el primero, se encuentran deshabilitadas, salvo en la clase MiOtraClase. En el segundo, se encuentran habilitadas, salvo dentro del paquete com.utils y sus subpaquetes. Utilizar las afirmaciones apropiadamente No utilices nunca las afirmaciones para validar los parmetros de un mtodo public, si deseas validar la entrada de un parmetro, puedes utilizar la excepcin IllegalArgumentException.
Utiliza las afirmaciones para verificar los parmetros de un mtodo privado. Cuando asumes que los parmetros que le envas son correctos, verifica esto con una afirmacin. No utilices nunca las afirmaciones para validar los argumentos de entrada de la lnea de comandos. En todo caso, utiliza una excepcin. Utiliza las afirmaciones para verificar cdigo que nunca debera de ejecutarse. No utilices nunca las afirmaciones cuando estas puedan causar efectos secundarios. El programa no debe de modificarse porque una afirmacin se encuentra habilitada.
private int x; private void verificaAsertion(int valor) { assert (validacionAsertion()); // Se llama a un mtodo que modifica un atributo de la clase } private boolean validacionAsertion() { x++; return true; }
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
EL MTODO TOSTRING() El mtodo toString() es el encargado de transformar un objeto en una cadena de texto. Dado que el mtodo est contenido en java.lang.Object, significa que todos los objetos
JAVA FUNDAMENTALS PROGRAMMING poseen este mtodo. Adems, es posible sobrescribirlo, de manera de modificar su comportamiento. Normalmente cuando mostramos un objeto, es [nombre de la clase]@[hash code de la clase].
1. public class Persona { 2. private int edad; 3. private String nombre; 4. 5. static public void main(String[] args) { 6. System.out.println(new Persona("Venito", 32)); 7. } 8. 9. public Persona(String nombre, int edad) { 10. this.edad = edad; 11. this.nombre = nombre; 12. } 13. }
Persona@3e25a5
Ahora si sobrescribimos el mtodo toString de la siguiente manera, podemos obtener una representacin ms legible del objeto:
1. 2. 3. public String toString() { return "La persona llamada " + nombre + " tiene " + edad + " ao(s)."; }
La persona llamada Venito tiene 32 ao(s).
SOBRESCRIBIENDO EL MTODO EQUALS() El mtodo equals() indica si dos objetos son iguales (contienen los mismos atributos y son del mismo tipo). Ahora, cual es la diferencia entre == y equals(). == Compara las referencias entre dos variables, e indica si las mismas apuntan al mismo objeto. equals() Compara dos objetos e indica si los mismos son equivalentes con respecto al valor de sus atributos. Veamos un poco de cdigo como ejemplo:
1. 2. 3. 4. public class Prueba { static public void main(String[] args) { Valor obj_1 = new Valor(17); Valor obj_2 = new Valor(17);
84
Chapter: Operadores
5. Valor obj_3 = obj_2; 6. System.out.println("es obj_1 == obj_2 ? " + (obj_1 == obj_2)); 7. System.out.println("es obj_1 equals obj_2? " + (obj_1.equals(obj_2))); 8. System.out.println("es obj_2 == obj_3 ? " + (obj_2 == obj_3)); 9. System.out.println("es obj_2 equals obj_3? " + (obj_2.equals(obj_3))); 10. } 11. } 12. 13. class Valor { 14. private int valor; 15. 16. public Valor(int valor) { 17. this.valor = valor; 18. } 19. 20. public int getValor() { 21. return valor; 22. } 23. 24. public boolean equals(Object obj) { 25. boolean resultado = false; 26. if (obj instanceof Valor) { 27. if (valor == ((Valor) obj).getValor()) { 28. resultado = true; 29. } 30. } 31. return resultado; 32. } 33. }
es obj_1 == obj_2 ? false es obj_1 equals obj_2? true es obj_2 == obj_3 ? true es obj_2 equals obj_3? True
Cuando hacemos obj_1 == obj_2 devuelve false porque los objetos a los que apunta cada referencia son distintos. En cambio el equals() fue sobrescrito para verificar el campo valor y verificar por una igualdad. Sobrescribiendo el mtodo hashCode() El hashCode es un identificador, el cual, no es nico. Este se utiliza para aumentar la velocidad de bsqueda en grandes colecciones de datos, de manera que la bsqueda se resuma a todos aquellos que tengan el mismo hashing. Para el examen solo es necesario saber el funcionamiento de este mtodo y que sea una implementacin vlida, sin importar si es o no eficiente.
JAVA FUNDAMENTALS PROGRAMMING Un cdigo hash dentro de una tabla seala solamente un grupo, luego, dentro de ese grupo, hay que buscar el objeto.
Dado que el hash se utiliza para almacenar y para obtener, es una condicin bsica de que siempre devuelva el mismo cdigo para el mismo objeto. En trminos de cdigo hashing, lo ms performante sera tener un algoritmo que genere un cdigo hashing distribuido uniformemente para todos los objetos, aunque tambin es vlido tener un hasing que siempre devuelva el mismo nmero (cumple con la regla de el mismo hashing para el mismo objeto). CONTRATOS A CUMPLIR Hashcode El mismo objeto debe devolver siempre el mismo hash. Si segn equals() dos objetos son iguales, la llamada a hashcode para cada uno debe devolver el mismo valor (obj1.hashcode() == obj2.hashcode()). Si segn equals() dos objetos son diferentes, la llamada a hashcode para cada uno puede llegar a devolver el mismo valor, pero no es obligatorio.
Equals Si a equals se le pasa el mismo objeto que el que invoca el mtodo, el resultado debe ser siempre true (obj1.equals(obj1)). Si la llamada de equals entre dos objetos devuelve true, los operandos pueden ser invertidos(obj1.equals(obj2) == obj2.equals(obj1)). Si se compara cualquier objeto con null, este debe devolver false ( obj1.equals(null) siempre debe ser false).
COLECCIONES
CARACTERSTICAS DE CADA CLASE Una coleccin puede clasificarse de la siguiente manera:
86
Chapter: Operadores
Coleccion
Distribucion
Orden
Distribuida
No distribuida
Ordenada
Desordenada
Cada coleccin va a tener un atributo de Distribucin y otro de Orden. Distribucin: Indica la forma en que los elementos son almacenados en base a las reglas de ordenamiento. o Distribuido Los elementos son ordenados segn un conjunto de reglas. o No distribuido Los elementos no se ordenan de manera definida. stribuido Orden: Indica la forma en que los elementos son accedidos. o Ordenado Se itera en los elementos de una forma definida. o Desordenado Se itera en los elementos de una forma que pareciera casi aleatorea.
LIST <<INTERFACE>> Todas las listas manejan sus colecciones mediante ndices. Permiten agregar un elemento dentro de la coleccin en un ndice especfico, obtener un elemento de la coleccin segn el ndice, y buscar en que posicin se encuentra un objeto en particular.
ArrayList
Funciona como un array que puede modificar su tamao dinmicamente. Permite acceder aleatoriamente a sus elementos. Se comporta exactamente igual que el ArrayList, con la salvedad de que es Thread-Safe (multihilo seguro).
Vector
LinkedList Mantiene un ndice aparte, de manera que se puede utilizar como una cola, o como un simple ArrayList. Aade mtodos como agregar al comienzo o al final. SET <<INTERFACE>> Los sets solo manejan objetos nicos, impidiendo su duplicidad dentro de la coleccin. Para saber si un objeto ya se encuentra agregado en la coleccin, es necesario que se implemente el mtodo equals().
88
Chapter: Operadores
HashSet
Los cdigos se almacenan sin un orden definido, utilizando como identificador su cdigo de hash.
LinkedHashSet Se comporta como HashSet con la salvedad de que esta mantiene otro ndice, el cual almacena el orden de los elementos segn fueron siendo insertados en la coleccin. TreeSet Mantiene los elementos ordenados segn su orden natural. Los objetos almacenados en esta coleccin requieren implementar Comparable o Comparator.
MAP <<INTERFACE>> Los maps corresponden con la funcionalidad de los sets, con la diferencia de que los maps no tienen restricciones en cuanto a la duplicidad de sus elementos. Al igual que los sets, requiere que se implemente equals() y hashCode().
HashMap
Los cdigos se almacenan sin un orden definido, utilizando como identificador su cdigo de hash. Se comporta como HashMap, con la salvedad de que es Thread-Safe (multihilo seguro).
Hashtable
LinkedHashMap Se comporta como HashMap con la salvedad de que esta mantiene otro ndice, el cual almacena el orden de los elementos segn fueron siendo insertados en la coleccin. TreeMap Mantiene los elementos ordenados segn su orden natural. Los objetos almacenados en esta coleccin requieren implementar Comparable o Comparator.
QUEUE <<INTERFACE>> Representan un listado de cosas por hacer. El comportamiento puede variar, pero se comportan por defecto como una cola o FIFO, First-In First-Out (Primero en entrar primero en salir). Chapter: Operadores
90
LinkedList
Ver interface List.
PriorityQueue Es una lista por defecto FIFO con prioridad. Requiere la implementacin de Comparable.
Resumen de las clases de collection

Clase HashMap Hashtable TreeMap LinkedHashMap HashSet TreeSet LinkedHashSet ArrayList Verctor LinkedList PriorityQueue Map X X X X X X X X X X X X Set List Queue Distribucin (order) No No Por orden (sorted) Por orden de insercin o ltimo acceso. No Por orden (sorted) Por orden de insercin Por ndice Por ndice Por ndice Por orden (sorted) Orden (sorted) No No Por orden natural o reglas de comparacin. No No Por orden natural o reglas de comparacin. No No No No Por orden de prioridades.
ARRAYLIST java.util.ArrayList. Representa un array que puede modificar su tamao dinmicamente. Ventajas: Puede crecer dinmicamente Provee mecanismos de insercin y bsqueda ms potentes que los de un Array.
JAVA FUNDAMENTALS PROGRAMMING Ahora que conoces las interfaces de las colecciones, lo mejor es utilizarlas. Veamos como instanciar un ArrayList.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
import java.util.List; import java.util.ArrayList; public class Prueba { static public void main(String[] args) { // ... cdigo List myArray = new ArrayList(); // O tambin podemos hacer uso de genricos List<String> myArray = new ArrayList<String>(); } }
No te preocupes por los genricos, ya los veremos en detalle ms adelante. AUTOBOXING CON COLECCIONES Las colecciones solo pueden majera objetos, no primitivas. En versiones previas a Java 5, si queramos agregar una primitiva a un Array la tenamos que codificar manualmente dentro de su respectivo Wrapper. A partir de Java 5, de esto se encarga el autoboxing.
1. 2. 3. 4. // Antes de Java 5 miArrayList.add(new Integer(15)); // A partir de Java 5 miArrayList.add(15);
ORDENANDO COLECCIONES
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. import java.util.ArrayList; import java.util.Collections; import java.util.List; public class PruebasCollections_001 { static public void main(String[] args) { List<String> myArray = new ArrayList<String>(); myArray.add("JavaWorld"); myArray.add("Gustavo Alberola"); myArray.add("Leonardo Blanco"); myArray.add("Matias Alvarez"); // Mostramos el array sin orden System.out.println("Desordenado: " + myArray.toString()); // El // ordenamiento se realiza con la clase // Collections Collections.sort(myArray); // Mostramos el array ordenado System.out.println("Ordenado : " + myArray.toString()); }
92
Chapter: Operadores
18. }
Como puedes observar, el ordenamiento se realiz con el mtodo esttico sort de la clase java.util.Collections.
Desordenado: [JavaWorld, Gustavo Alberola, Leonardo Blanco, Matias Alvarez] Ordenado : [Gustavo Alberola, JavaWorld, Leonardo Blanco, Matias Alvarez]
Pero, si intentamos hacer este ejercicio con elementos dentro del ArrayList que no sean ni Strings ni Wrappers de primitivas, obtendremos un error. LA INTERFAZ COMPARABLE Si queremos hacer que nuestras propias clases se puedan ordenar, deberemos de implementar dicha interfaz y definir el mtodo compareTo. La firma de este mtodo es int compareTo(Object). El valor devuelto debe ser: Negativo Si this < Object 0 Si this == Object Positivo Si this > Object
El mtodo sort utilizar el mtodo compareTo para ordenar el array. Existen dos maneras de declarar el mtodo, mediante genricos y mediante la notacin antigua.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. //Utilizando genricos class ImplementaGenerico1 implements Comparable<ImplementaGenerico1> { // ... // cdigo public int comparteTo(ImplementaGenerico1 obj) { // ... cdigo return 1; } } // Utilizando notacin antigua class ImplementaGenerico implements Comparable { // ... cdigo public int compareTo(Object obj) { if (obj instanceof ImplementaGenerico) { ImplementaGenerico tmpObj = (ImplementaGenerico) obj; // ... cdigo } return 1; } }
JAVA FUNDAMENTALS PROGRAMMING Utilizando genricos, automticamente podemos especificar como parmetro el mismo tipo de la clase, en cambio, bajo la notacin antigua, debemos castear el objeto recibido a dicho tipo. LA INTERFAZ COMPARATOR Bien, vimos la interfaz Comparable, pero, que pasara si quisiramos ordenar una Clase que no podemos modificar, u ordenar en ms de una forma diferente? Comparator al rescate! Si vemos el mtodo sort, podemos encontrar una sobrecarga que recibe como segundo parmetro un Comparator. Veamos cmo crear uno.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. import java.util.List; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; public class PruebasCollections_002 { private String nombre; private String apellido; public PruebasCollections_002(String nombre, String apellido) { this.nombre = nombre; this.apellido = apellido; } public String getNombre() { return nombre; } public String getApellido() { return apellido; } public String toString() { return nombre + " " + apellido; } static public void main(String[] args) { List myArray = new ArrayList(); myArray.add(new PruebasCollections_002("Gustavo", "Alberola")); myArray.add(new PruebasCollections_002("Matias", "Alvarez")); myArray.add(new PruebasCollections_002("Leonardo", "Blanco")); myArray.add(new PruebasCollections_002("Java", "World")); // Mostramos // la coleccion tal cual est ahora System.out.println("Desordenada : " + myArray.toString()); // Ordenamos // por nombre Collections.sort(myArray, new ComparatorByNombre()); System.out.println("Ordenada por nombre : " + myArray.toString()); // Ordenamos por apellido Collections.sort(myArray, new ComparatorByApellido());
94
Chapter: Operadores
40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60.
System.out.println("Ordenada por apellido: " + myArray.toString()); } } class ComparatorByNombre implements Comparator<PruebasCollections_002> { public int compare(PruebasCollections_002 obj1, PruebasCollections_002 obj2) { return obj1.getNombre().compareTo(obj2.getNombre()); } } class ComparatorByApellido implements Comparator { public int compare(Object obj1, Object obj2) { if (obj1 instanceof PruebasCollections_002 && obj2 instanceof PruebasCollections_002) { return ((PruebasCollections_002) obj1).getApellido().compareTo( ((PruebasCollections_002) obj2).getApellido()); } else { return -1; } } }
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17.
class ComparatorByNombre implements Comparator<PruebasCollections_002> { public int compare(PruebasCollections_002 obj1, PruebasCollections_002 obj2) { return obj1.getNombre().compareTo(obj2.getNombre()); } } class ComparatorByApellido implements Comparator { public int compare(Object obj1, Object obj2) { if (obj1 instanceof PruebasCollections_002 && obj2 instanceof PruebasCollections_002) { return ((PruebasCollections_002) obj1).getApellido().compareTo( ((PruebasCollections_002) obj2).getApellido()); } else { return -1; } } }
Desordenada : [Gustavo Alberola, Matias Alvarez, Leonardo Blanco, Java World] Ordenada por nombre : [Gustavo Alberola, Java World, Leonardo Blanco, Matias Alvarez] Ordenada por apellido: [Gustavo Alberola, Matias Alvarez, Leonardo Blanco, Java World]
COMPARABLE VS COMPARATOR Ya vimos ambas interfaces, entonces, Cundo utilizar una o la otra? Cuando solo queramos definir un mtodo de ordenamiento en una clase cuyo cdigo fuente podemos acceder y modificar, utilizamos Comparable. Cunado queremos implementar varios mtodos de ordenamiento, u ordenar una clase cuyo cdigo no tenemos o no podemos modificar, utilizamos Comparator. ORDENANDO CON LA CLASE ARRAYS Las firmas de los mtodos son iguales que Collections: sort(Object) y sort(Object, Comparator). El problema radica en que un Array, a diferencia de un List, puede contener elementos de tipo primitivo. y, cual es el problema entonces? Simple, veamos la firma de Comparator: public int compare(Object obj1, Object obj2) Sigues sin verlo? Bueno, aqu va una pista: Object. Este solo recibe objetos, no primitivas. A menos que se almacenen en sus respectivos Wrappers, podemos utilizar las sobrecargas de sort(Xx) que existen para cada primitivo.
BSQUEDA EN ARRAYS Y COLLECTIONS Ambas clases permiter realizar bsquedas dentro de colecciones. Para ello, necesitamos conocer las siguientes reglas: Las bsquedas son realizadas utilizando el mtodo binarySearch(). Las bsquedas exitosas devuelven un int con el ndice donde se encuentra el objeto. Si la bsqueda no encuentra el valor, devuelve un valor negativo. La coleccin o array sobre la cual buscar, debe de haber sido previamente ordenada. Si no cumples con el paso anterior, el resultado puede ser impredecible. Si la coleccin o array se encuentra en un orden natural, la bsqueda se debe realizar en un orden natural. Si la coleccin o array fue ordenada con un Comparator, se debe utilizar el mismo Comparator para realizar la bsqueda, pasndolo como segundo argumento al mtodo binarySearch().
Veamos un ejemplo:
1. 2. 3. 4. 5. 6. 7. import java.util.Comparator; import java.util.Arrays; public class PruebasCollections_003 { static public void main(String[] args) { String[] myArray = { "uno", "dos", "tres", "cuatro" }; for (String s : myArray) {
96
Chapter: Operadores
8. System.out.print(s + " "); 9. } 10. System.out.println(); 11. System.out.println("Posicion de \"tres\": " 12. + Arrays.binarySearch(myArray, "dos")); 13. NuevoOrdenamiento ordenador = new NuevoOrdenamiento(); 14. Arrays.sort(myArray, ordenador); 15. for (String s : myArray) { 16. System.out.print(s + " "); 17. } 18. System.out.println(); 19. System.out.println("Posicion de \"tres\": " 20. + Arrays.binarySearch(myArray, "dos")); 21. System.out.println("Posicion de \"tres\": " 22. + Arrays.binarySearch(myArray, "dos", ordenador)); 23. } 24. } 25. 26. class NuevoOrdenamiento implements Comparator<String> { 27. public int compare(String obj1, String obj2) { 28. return obj2.compareTo(obj1); 29. } 30. }
uno dos tres cuatro Posicion de "tres": 1 uno tres dos cuatro Posicion de "tres": -1 Posicion de "tres": 2
Dado que en la segunda bsqueda (luego del nuevo ordenamiento), no utilizamos el mismo Comparator para la bsqueda, nos dio como resultado -1 (resultado inesperado), luego, cuando utilizamos el mismo Comparator, la bsqueda result exitosa.
CONVERSION DE ARRAYS A LISTS A ARRAYS Para pasar de Array a List, tenemos el mtodo Arrays.asList(). La firma del mtodo es: static public <T> List<T>(T elementsOrArray) Algo muy importante para recordar. Si se le pasa un array, generar un List cuyos elementos apuntan a la misma direccin de memoria que los elementos del Array, de manera que si modificamos los valores en uno, se vern reflejados en el otro.
JAVA FUNDAMENTALS PROGRAMMING Para pasar de List a Array, tenemos el mtodo toArray(). Este puede generar un array de objetos, o se le puede pasar un array de un tipo determinado.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.ArrayList; public class PruebasCollections_004 { static public void main(String[] args) { Integer[] myArrayDeInts = { 1, 3, 12, 5, 47 }; List myListDeInts = Arrays.asList(myArrayDeInts); System.out.println(myListDeInts.size()); System.out.println(myListDeInts); myListDeInts.set(4, 456); for (int a : myArrayDeInts) { System.out.print(a + " "); } System.out.println(); Object[] myArrayDeObjects = myListDeInts.toArray(); Integer[] myArrayDeIntegers = new Integer[5]; myListDeInts.toArray(myArrayDeIntegers); myArrayDeIntegers[2] = 555; for (int a : myArrayDeInts) { System.out.print(a + " "); } System.out.println(); for (int a : myArrayDeIntegers) { System.out.print(a + " "); } } }
5 [1, 3, 12, 5, 47] 1 3 12 5 456 1 3 12 5 456 1 3 555 5 456
UTILIZANDO LOS LISTS Lo ms comn para iterar a travs de los elementos de un List es un iterador (tambin se puede utilizar un simple for-each, pero con un iterador es menos acoplamiento). El iterador posee dos mtodos simples:
98
Chapter: Operadores
JAVA FUNDAMENTALS PROGRAMMING boolean hasNext() Indica si aun quedan ms elementos. No nos desplaza de la posicin acutal dentro del array. Object next() Obtiene el elemento actual, y desplaza a la siguiente posicin del array.
A partir de Java 5, los iteradores tambin soportan genricos. Veamos un ejemplo:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. import java.util.List; import java.util.Iterator; import java.util.ArrayList; public class PruebasCollections_005 { static public void main(String[] args) { List<String> myLista = new ArrayList(); myLista.add("JavaWorld"); myLista.add("Dragon Ball"); myLista.add("Pampita"); Iterator<String> it = myLista.iterator(); while (it.hasNext()) { String s = it.next(); System.out.print(s + " "); } System.out.println(); Iterator it2 = myLista.iterator(); while (it2.hasNext()) { String s = (String) it2.next(); System.out.print(s + " "); } } }
JavaWorld Dragon Ball Pampita JavaWorld Dragon Ball Pampita
Como podrn apreciar, cuando utilizamos el iterador con genricos, no hubo que castear el tipo de dato, ya que automticamente se obtiene el String. En el segundo caso, es necesario realizar el casteo explcitamente.
JAVA FUNDAMENTALS PROGRAMMING UTILIZANDO LOS SETS Recordemos que los sets almacenan objetos nicos (no existen dos elementos que respondan a x.equals(y) == true). En los Sets, los mtodos add devuelven un valor de tipo boolean, que indica si el valor fue o no agregado a la coleccin. Veamos un ejemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. import java.util.Set; import java.util.HashSet; import java.util.TreeSet; public class PruebasCollections_006 { static public void main(String[] args) { boolean[] resultados = new boolean[4]; Set mySet = new HashSet(); resultados[0] = mySet.add(new Integer(45)); resultados[1] = mySet.add("b"); resultados[2] = mySet.add(new Object()); resultados[3] = mySet.add(45); // Se produce un autoboxing System.out.println("Resultados para el HashSet"); for (boolean res : resultados) { System.out.println(res); } mySet = new TreeSet(); resultados[0] = mySet.add("a"); resultados[1] = mySet.add("b"); resultados[2] = mySet.add("a"); resultados[3] = mySet.add("c"); System.out.println("Resultados para el TreeSet"); for (boolean res : resultados) { System.out.println(res); } mySet.add(new Integer(45)); // Al llegar a esta lnea se produce una // excepcin. } }
Consola Resultados para el HashSet true true true false Resultados para el TreeSet true true false true Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at java.lang.Integer.compareTo(Unknown Source) at java.util.TreeMap.put(Unknown Source) at java.util.TreeSet.add(Unknown Source) at PruebasCollections_006.main(PruebasCollections_006.java:XX)
100
Chapter: Operadores
UTILIZANDO LOS MAPS Los maps se manejan almacenando pares clave/valor. Veamos un poco ms a fondo como funciona un Map para insercin y para obtencin de datos. Veamos un ejemplo en cdigo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. import java.util.Map; import java.util.HashMap; public class PruebasCollections_007 { static public void main(String[] args) { Map<Object, Object> myMap = new HashMap<Object, Object>(); Persona p1 = new Persona(45); Persona p2 = new Persona(30); Animal a1 = new Animal(30); myMap.put(p1, "Clave persona1"); myMap.put(p2, "Clave persona2"); myMap.put(a1, "Clave animal1"); System.out.println("1 - " + myMap.get(new Persona(45))); System.out.println("2 - " + myMap.get(new Persona(30))); System.out.println("3 - " + myMap.get(a1)); System.out.println("4 - " + myMap.get(new Animal(30))); System.out.println("Cant:" + myMap.size()); } } class Persona { private int edad; public int getEdad() { return edad; } public Persona(int edad) { this.edad = edad; } public boolean equals(Object persona) { if (persona instanceof Persona && edad == ((Persona) persona).getEdad()) { return true; } else { return false; } } public int hashCode() { return edad; } }
45. class Animal { 46. int edad; 47. 48. public int getEdad() { 49. return edad; 50. } 51. 52. public Animal(int edad) { 53. this.edad = edad; 54. } 55. } 1 - Clave persona1 2 - Clave persona2 3 - Clave animal1 4 - null Cant:3
Bien, pero no entend nada de nada Ok, si estas dentro de este grupo, veamos como funcionan las colecciones Map. Insersin: Se ingresa el par clave/valor De la clave se obtiene el int del hashCode. Se almacena el valor en un grupo identificado por el hashCode del paso anterior.
Obtencin: Se especifica la clave De esta se obtiene el hashCode y se busca el grupo Si el hashCode existe, se comparan mediante equals las claves. Si son equivalentes, se devuelve el valor
102
Chapter: Operadores
En el caso de Animal, contiene tanto el mtodo HashCode como equals redefinido, de manera que al crear una nueva clase, se puede encontrar la clave. Cuando utilizamos la misma instancia de Animal (a1), esta primero genera el mismo HashCode (utilizando el hash por defecto, generando algo como Animal@44532), y luego utiliza el equals. Dado que este ltimo no esta sobrescrito, lo que hace es verificar las posiciones de memoria. Dado que es la misma instancia (esta apuntando al mismo objeto), el resultado es true. Pero cuando creamos un nuevo objeto de tipo Animal, por ms que este tenga las mismas caractersticas, al no haber sobrescrito los mtodos equals y hashCode, jams podremos obtener dicho valor, y el mismo quedar perdido dentro del HashMap. Es muy comn ver ejemplos en los que como clave utilizan Strings, bien, recuerda que tanto los Strings como
JAVA FUNDAMENTALS PROGRAMMING los Wrappers de los tipos primitivos sobrescriben equals y hashCode, de manera que es posible utilizarlos como clave.
BSQUEDA DENTRO DE LOS TREESETS Y TREEMAPS Vimos como navegar a travez de Arrays y Colecciones, ahora veremos como hacerlo a travs de los trees. Para ello utilizamos los mtodos de las 2 nuevas interfaces: java.util.NavigableSet y java.util.NavigableMap. El siguiente cuadro representa un resumen de los mtodos encontrados en ambas clases:
Clase TreeSet TreeMap TreeSet TreeMap TreeSet TreeMap TreeSet TreeMap TreeSet TreeMap TreeSet TreeMap TreeSet TreeMap Mtodo ceiling(e) ceilingKey(key) higher(e) higherKey(key) floor(e) floorKey(key) lower(e) lowerKey(key) pollFirst() pollFirstEntry() pollLast() pollLastEntry() descendingSet() descendingMap() Descripcin Devuelve el valor ms cercano a e que sea valor >= e. Devuelve la clave ms cercana a key que sea keyDevuelta >= key. Devuelve el valor ms cercano a e que sea valor > e. Devuelve la clave ms cercana a key que sea keyDevuelta >= key. Devuelve el valor ms cercano a e que sea valor <= e. Devuelve la clave ms cercana a key que sea keyDevuelta <= key. Devuelve el valor ms cercano a e que sea valor < e. Devuelve la clave ms cercana a key que sea keyDevuelta < key. Devuelve y elimina la primer entrada. Devuelve y elimina el primer par clave/valor. Devuelve y elimina la ltima entrada. Devuelve y elimina el ltimo par clave/valor. Devuelve un NavigableSet en orden inverso. Abrebiatura Val >= e Val >= key Val > e Val > key Val <= e Val <= key Val < e Val < key
Devuelve un NavigableMap en orden inverso.
COLECCIONES RESPALDADAS En ingls denominadas backed collections, representan un subset de una coleccin completa el cual no es simplemente una copia del ltimo, sino que quedan enlazados, de manera que ciertos cambios en uno pueden afectar a otro, y viceversa. Veamos un ejemplo:
1. 2. 3. 4. 5. 6.
import java.util.TreeMap; import java.util.SortedMap; public class PruebasCollections_008 { static public void main(String[] args) { TreeMap<String, String> map = new TreeMap<String, String>();
7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. }
SortedMap<String, String> sorted = null; // Cargamos algunos valores en // el map map.put("a", "Anaconda"); map.put("r", "Rambo"); map.put("t", "Terminator"); map.put("i", "Indiana Jones"); sorted = map.subMap("c", "o"); System.out.println("Map :" + map); System.out.println("Sorted:" + sorted); map.put("j", "Jurassik Park"); map.put("o", "Open Seasson"); map.put("v", "V for Vendetta"); System.out.println(); System.out.println("Map :" + map); System.out.println("Sorted:" + sorted); sorted.put("f", "Final Fantasy VII Advent Children"); // sorted.put("z", // "Zorro"); Si ejecutaramos esta lnea tendramos una excepcion // IllegalArgumentException System.out.println(); System.out.println("Map :" + map); System.out.println("Sorted:" + sorted); }
Map :{a=Anaconda, i=Indiana Sorted:{i=Indiana Jones} Map :{a=Anaconda, i=Indiana r=Rambo, t=Terminator, v=V j=Jurassik Park}
Jones,
r=Rambo,
t=Terminator}
Jones, j=Jurassik Park, o=Open Seasson, for Vendetta} Sorted:{i=Indiana Jones,
Map :{a=Anaconda, f=Final Fantasy VII Advent Children, i=Indiana Jones, j=Jurassik Park, o=Open Seasson, r=Rambo, t=Terminator, v=V for Vendetta} Sorted:{f=Final Fantasy VII Advent Children, i=Indiana Jones, j=Jurassik Park}
MTODOS PARA CREAR COLECCIONES RESPALDADAS
Mtodo
Descripcin
104
Chapter: Operadores
Generamos un subMap del primero de tipo SortedMap, Pero los cambios que hacemos en uno o en otro afectan entre si. La lnea que se encuentra comentada que indica que generara un error, es debido a que un SortedMap se encuentra limitado al rango de keys con que lo hayamos generado, en nuestro caso de c a o. Al insertar una z, esta no entra en c <= z < o.

headSet(e, b*) headMap(e, b*) tailSet(e, b*) tailMap(e, b*) subSet(a, b*, e, b*) subMap(a, b*, e, b*) Devuelve un subset de todos los elementos que sean < e (int). Devuelve un subset de todas las claves que sean < e (int). Devuelve un subset de todos los elementos que sean >= e (int). Devuelve un subset de todas las claves que sean >= e (int). Devuelve un subset de todos los elementos que sean >= a (int) y < e (int). Devuelve un subset de todas las claves que sean >= a (int) y < e (int).
Nota: b* representa un valor de tipo boolean, el cual es en realidad una sobrecarga del mtodo. Si no se especifica el parmetro boolean, se devuelve un SortedXxx. En cambio, si se especifica, se devuelve un NavigableXxx.
COLA DE PRIORIDADES (PRIORITYQUEUE)

La PriorityQueue ordena los elementos segn reglas predefinidas. Por defecto esta regla es por ordenamiento natural. MTODOS DE PRIORITYQUEUE
Mtodos peek() poll() offer(o<T>) size()
Descripcin Obtiene el elemento actual. Obtiene el elemento actual y lo elimian de la coleccin. Aade un elemento a la coleccin, Al igual que en cualquier coleccin, devuelve la cantidad de elementos que esta contiene.
Para crear nuestro propio algoritmo de ordenamiento para una ProrityQueue, debemos de utilizar una clase que: Implemente (implements) Comparator<T> Defina el mtodo public int compare(Integer uno, Integer dos)
Nota: recuerda que solo los Arrays pueden contener elementos de tipo primitivos, de manera que compare utiliza Integer y no int. RESMEN DE MTODOS PARA ARRAYS Y COLECCIONES

java.util.Array
static List asList(<T>[]) static int binarySearch(Object[], key) static int binarySearch(primitivo[], key) static int binarySearch(<T>[], key, Comparador) static boolean equals(Object[], Objet[]) static boolean equals(primitivo[], primitivo[]) public static void sort(Object[]) public static void sort(primitivo[]) public static void sort(<T>[], Comparador) public static String toString(Object[]) public static String toString(primitive[])
Descripcin Conviete un Array de tipo <T> en una Lista y enlaza los elementos. Busca dentro de un Array ordenado por un valor, y devuelvel ndice en que se encuentra. Busca dentro de una Array ordenado con un comparador por un valor en particular. Compara dos Arrays para determinar si su contenido es semejante. Ordena los elementos de un Array por orden natural. Ordena los elementos de un Array utilizando un Comparador. Crea una cadena con el contenido del Array (invoca los toString de cada elemento). Busca dentro de un Array ordenado por un valor, y devuelve el ndice que se encutra. Invierte el orden de los elementos en la lista. Devuelve un Comparador que ordena la coleccin al revs Ordena una lista ya sea por orden natural l,
static int binarySearch(List, key) static int binarySearch(List, key, Comparator) static void reverse(List) static Comparator reverseOrder() static Comparator reverseOrder() static void sort(List) static void sort(List, Comparator)
RESUMEN DE MTODOS PARA LIST, SET Y MAP
Mtodos boolean add(elemento) boolean add(ndice, elemento) boolean contains(Objet) boolean containsKey(Objet key) boolean containsValue(Objet valor) Object get(ndice) Object get(key) int indexOf(Object) Iterator iterator() Set keySet() offer(<T>)
List
Set X
Map
Queue
Descripcin Aade un elemento. En el caso de los List, puede especificar la posicin donde agregarlo. Busca dentro de los elementos de la coleccin un objeto (o en los Maps una clave), y devuelve como resultado un boolean.
X X X
X
X
Obtiene un objeto de la coleccin a travs del ndice o la clave.
X X
Aande un elemento a la Queue.
106
Chapter: Operadores
Obtiene la ubicacin (ndice) de un objeto dentro de la coleccin. Obtiene un iterador para poder recorrer la coleccin. Genera un Set con todas las claves del Map.

<T> peek() <T> poll() put(key, valor) remove(indice) remove(Object) remove(key) int size() Object[] toArray() <T>[] toArray(<T>[]) X
X X X X X X X X X
X X
Devuelve el objeto actual de la Queue. En el segundo caso tambin es eliminado de la coleccin. Agrega un par clave/valor a un Map. Elimina un elemento de la coleccin.
Devuelve el nmero de elementos en la coleccin. Devuelve un array con los elementos de la coleccin.
X X
GENRICOS
Los genricos son una manera de especificar el tipo de dato de un elemento que por naturaleza es ms abstracto. Generalmente es utilizado en las colecciones. Dado que estas contienen elementos, su naturaleza gira en torno a los diferentes tipos de datos que puedan albergar. Antes de java 5, un List como un ArrayList, contena solo tipo Object, o sea, cualquier cosa que no fuera un primitivo. Aunque por un lado parece tentador, por otro lado nos incurre en tener que castear cada elemento para poder utilizar sus mtodos, y verificar que el mismo sea de dicho tipo (Is-A). La solucin a esto son los genricos. Estos permiten especificar el tipo de dato que contendr, y verificarlo en tiempo de compilacin, de manera que te aseguras de que los tipos de datos son vlidos para la coleccin, evitando casteos y verificaciones de por medio. A su vez, Java ideo una manera que permite la retro compatibilidad, permitiendo utilizar colecciones sin genricos. En estos, a la hora de compilar la aplicacin, nos muestra una advertencia. Tambin veremos que se pueden llegar a dar serior problemas si mezclamos colecciones genricas con colecciones no genricas. UN VISTAZO A COLECCIONES CON Y SIN GENRICOS Primero veamos un ejemplo sin genricos:
1. 2. 3. 4. 5. 6. 7. 8. 9.
import java.util.ArrayList; class Perro { public void ladrar() { System.out.println("wouf!"); } } public class PruebasGenerics_01 {
10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.
static public void main(String[] args) { ArrayList lista = new ArrayList(); lista.add("Hola"); lista.add(15); lista.add(new Perro()); for (Object o : lista) { if (o instanceof Perro) { ((Perro) o).ladrar(); } } }
21. }
Primero noten la falta de restriccin en cuanto a tipos de datos que pudimos agregar en el ArrayList (String, Integer, Perro). Luego, si lo que queremos es invocar los ladridos de todos los perros de la coleccin, tenemos primero que verificar que el elemento sea de tipo Perro (Is-A). recin sabiendo esto, podemos castearlo a Perro e invocar el mtodo ladrar. Por el contrario, si no hubiramos aadido la verificacin instanceof, al primer intento habramos recibido una excepcin en tiempo de ejecucin ClassCastException.
Ahora, veamos el mismo ejemplo con genricos:
108
Chapter: Operadores
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21.
import java.util.ArrayList; class Perro { public void ladrar() { System.out.println("wouf!"); } } public class PruebasGenerics_02 { static public void main(String[] args) { ArrayList<Perro> lista = new ArrayList<Perro>(); // lista.add("Hola"); // Genera un error de compilacin // lista.add(11); // Genera un error de compilacin lista.add(new Perro()); for (Perro p : lista) { p.ladrar(); } } }
JAVA FUNDAMENTALS PROGRAMMING Primera gran diferencia, no se puede aadir ningn elemento a la coleccin que no corresponda a la relacin Is-A Perro. Por esa razn comentamos las lneas en que agregamos el String e Integer, de lo contrario recibiremos un error de compilacin. Segundo, dado que especificamos el tipo, no es necesario castear los elementos de la coleccin, y de manera que estamos seguros de que todos son perros, no necesitamos realizar la verificacin de la condicin Is-A Perro. Como vern, genriocos provee una manera limpia de definir un tipo de dato con el cual se manejar la coleccin, de manera de minimizar errores. MEZCLANDO COLECCIONES GENRICAS Y NO GENRICAS Dado que para conservar la compatibilidad de cdigo anterior a Java 5 se deban de poder seguir utilizando colecciones no genricas, puede llegar a darse el caso de que ambas se mezclen. Veamos un ejemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.
import java.util.ArrayList; class ContenedoraArrayNoGenerico { static public void agregarElementoEnArray(ArrayList list) { list.add("Hola"); list.add(45); list.add(new ArrayList()); } } public class PruebasGenerics_03 { static public void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(40); list.add(new Integer(63)); System.out.println("Antes: " + list.toString()); ContenedoraArrayNoGenerico.agregarElementoEnArray(list); System.out.println("Despues: " + list.toString()); } }
Ahora, si el ArrayList original es genrico, y est como de tipo Integer, no debera de generar un error de compilacin?... Pues no. La salida por pantalla es:
Antes: [40, 63] Despues: [40, 63, Hola, 45, []]
Como es fcil apreciar, las limitaciones de tipo de dato en genricos solo aplican a aquellos que hayan sido declarados como tales, de manera que si estamos utilzando cdigo antiguo, posiblemente un algoritmo que hicimos hace mucho o una librera de terceros, debemos de tener cuidado con esto.
JAVA FUNDAMENTALS PROGRAMMING De todas maneras, que el compilador lo permita no quiere decir que est totalmente de acuerdo y nos muestra una advertencia de compilacin. El mensaje que muestra al compilar el cdigo es:
Note: PruebasCollections_004.java uses unchecked or unsafe operations. Note: Recompile with -Xlint:unchecked for details.
Traducido al criollo, significa algo como Hay ciertas operaciones que no son seguras, la ejecucin de este cdigo puede llegar a desatar un cataclismo y tu inmediato despido. No digas despus que no te avis!.
POLIMORFISMO Y GENRICOS Otra cuestin a tener en cuenta es que tipos de datos se pueden declarar y en que tipo de variables de referencia se pueden almacenar. Muy simple, siempre deben de ser del mismo tipo. No vale un hujo o padre. Si creamos un ArrayList de objetos, no es correcto hacer: ArrayList<Object> list = new ArrayList<String>(); Por ms que String califica para la condicin Is-A Object, este cdigo no es vlido. La nica manera es: ArrayList<Object> list = new ArrayList<Object>(); Tambin podemos asignarlo a un List, pero siempre que sea del mismo tipo: List<Object> list = new ArrayList<Object>(); Declaracin de genricos
Comodn <T> <E>
Descripcin Representa cualquier tipo de dato. Este se debe especificar cuando se cree un objeto concreto. Representa cualquier tipo de dato pero solo para colecciones. Este se debe especificar cuando se cree un objeto concreto. Representa un tipo de dato concreto. Solo podr recibir parmetros del mismo tipo. Representa un tipo de dato concreto. Solo podr recibir parmetros del mismo tipo o super tipos. Representa un tipo de dato concreto. Solo podr recibir parmetros del mismo tipo o subtipos. El extends en genricos aplica a las interfaces tambin,
<Xxx> <? super Xxx> <? extends Xxx>
Xxx representa un tipo de dato.
110
Chapter: Operadores
Comodines en la declaracin de clases

1. public class Almacen<T> { 2. List<T> lista; 3. 4. public Almacen() { lista = new ArrayList<T>; } 5. this.lista = lista; 6. } 7. 8. public T getLista() { 9. return lista; 10. } 11. 12. public void addToLista(T item) { 13. lista.add(item); 14. } 15. }
public Almacen(T lista) {
Se declara luego del nombre de la clase. De ah en ms, cada tipo de dato que requiera corresponder con este, utiliza la letra sin los <>. Siempre que se cree un objeto que a su vez sea un genrico, se deben de utilizar los caracteres <>. COMODINES EN LA DECLARACIN DE MTODOS
1. 2. 3. 4. 5. public <T> realizarAccion(T item) { //... } //En cabio, no existe la declaracin de un mtodo public void realizarAccion(<T> item) //Tampoco se puede hacer un public void realizarAccion(T item) //Salvo que la clase se declarara como NombreClase<T>

Java Basico 1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Basico 1

Uploaded by

Copyright:

Available Formats

JAVA FUNDAMENTALS PROGRAMMING

[Type the document subtitle]

JAVA FUNDAMENTALS PROGRAMMING

JAVA FUNDAMENTALS PROGRAMMING

Java Fundamentals Programming

UTILIZANDO JAVA DESDE LA CONSOLA DE COMANDOS

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

INSTALANDO LA JDK Y CONFIGURANDO EL ENTORNO

JAVA FUNDAMENTALS PROGRAMMING

Chapter: Utilizando java desde la consola de comandos

DECLARACIONES DE CLASES Y MODIFICADORES DE ACCESO

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING o abstract

JAVA FUNDAMENTALS PROGRAMMING

16. 17. 18. }

public abstract void doCalculo();

DECLARACIN DE MTODOS Y ATRIBUTOS

Chapter: Utilizando java desde la consola de comandos

Soy Soy Soy Soy

haceAlgo haceAlgo haceAlgo haceAlgo

con con con con

un parmetro int dos parmetros int parmetros variables parmetros variables

Variables de clase (static) Variables de instancia (objeto) Parmetros Variables locales

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

Chapter: Utilizando java desde la consola de comandos

typedef struct Avion {

JAVA FUNDAMENTALS PROGRAMMING

3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.

DEFINICIN DE UNA CLASE

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

Laura Laura Rios 38 65.2

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

JAVA FUNDAMENTALS PROGRAMMING

En el caso de la invocacin con objetos, se vuelve un poco ms complicado.

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

JAVA FUNDAMENTALS PROGRAMMING

39. 40. 41. 42. 43. 44. 45. 46. }

Tambin, puede darse un caso como el planteado a continuacin:

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

IMPLEMENTAR (IMPLEMENTS) UNA INTERFAZ

TIPOS DE VALOR DE RETORNO VLIDOS

Chapter: Utilizando java desde la consola de comandos

Chapter: Utilizando java desde la consola de comandos

VALORES LITERALES PARA TODOS LOS TIPOS PRIMITIVOS

int a = 1; int b = 2 * a; int c = a / b;

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

Tipo de dato Byte Short Char Int Long Float Double

public class AlgunaClase { private static int valorEstatico;

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

JAVA FUNDAMENTALS PROGRAMMING

Chapter: Utilizando java desde la consola de comandos

Chapter: Utilizando java desde la consola de comandos

JAVA FUNDAMENTALS PROGRAMMING

// la referencia del array // annimo.

ASIGNACIONES LEGALES DE REFERENCIAS DE TIPO ARRAY

Chapter: Utilizando java desde la consola de comandos