Tutorial para el Examen de certificacion: SCJP 1.2 Traducción del tutorial de Marcus Green.

RuGI Isaac Ruiz Guerra [email protected]

javaHispano Tu lenguaje, tu comunidad. Versión Julio del 2003.

Tutorial para el examen de certificación: SCJP 1.2

El presente documento es una traducción/adaptación del tutorial de Marcus Green correspondiente a la versión de diciembre del 2002. Dicho tutorial cubre los objetivos correspondientes al examen SCJP 1.2. La mayor parte de este documento cubre tambien los objetivos para la versión 1.4 únicamente se deben pasar por alto las secciones 8 y 11, y agregar el tema de Aserciones. Esta traducción se realizó con la colaboración de: Nombre: Isaac Ruiz Guerra Joslyn Flores Romero Francisco Fernández Miser Alberto Molpeceres

Sección: 1, 2, 3, 4, 6, 8, 9, 10 7 5 11

Puedes hacer cualquier comentario sobre la traducción a [email protected] La dirección del tutorial de Marcus Green: http://www.jchq.net/certkey/index.htm Un artículo de Emili Miedes de Elías sobre Aserciones: http://www.javahispano.org/articles.article.action?id=57 Este documento forma parte del proyecto “Examen de Certificación”: http://www.javahispano.org/text.viewer.action?file=proyectos

Copyright (c) 2003,Isaac Ruiz Guerra. Este documento puede ser distribuido solo bajo los términos y condiciones de la licencia de Documentación de javaHispano v1.0 o posterior (la última versión se encuentra en http://www.javahispano.org/licencias/).

2

javaHispano. Tu comunidad, tu lenguaje.

Sección 1. Declaración y control de Acceso ......................7

Objetivo 1........................................................................................................................ 7 Arreglos................................................................................................................... 7 Declaración sin asignación. ........................................................................................ 7 Creación y Declaración Simultanea............................................................................ 8 Arreglos Java VS Arreglos C/C++ . .................................................................... 8 Los arreglos conocen su tamaño. ........................................................................... 9 Arreglos Java VS Arreglos VB............................................................................ 9 Combinar declaración con inicialización.................................................................. 10 Objetivo 2...................................................................................................................... 15 Comparando las clases de C++/VB con las de Java. ................................................ 15 El rol de las clases en Java........................................................................................ 15 La clase más sencilla................................................................................................. 16 Creando una clase sencilla- HelloWorld................................................................... 16 La magia del nombre main ....................................................................................... 16 Creando una instancia de una Clase.......................................................................... 17 Creando Métodos. ..................................................................................................... 18 Variables Automáticas .............................................................................................. 19 Modificadores y Encapsulamiento............................................................................ 20 Usando modificadores en combinación .................................................................... 26 Objetivo 3...................................................................................................................... 35 Nota de este objetivo................................................................................................. 35 ¿Qué es un constructor? ............................................................................................ 35 ¿Cuándo proporciona Java el constructor predefinido?............................................ 35 El prototipo del constructor predefinido ................................................................... 37 Objetivo 4...................................................................................................................... 43 Nota de este objetivo................................................................................................. 43 Métodos en la misma clase ....................................................................................... 43 Métodos en una subclase. ......................................................................................... 44 Sección 2. Control de Flujo y Manejo de Excepciones. ...........47

Objetivo 1...................................................................................................................... 47 La sentencia if/else.................................................................................................... 47 La Sentencia switch................................................................................................... 48 Argumentos validos para las sentencias if y switch. ................................................. 49 El operador ternario ?................................................................................................ 49 Objetivo 2...................................................................................................................... 55 La sentencia for......................................................................................................... 55 Los ciclos while y do, nada inesperado................................................................. 56 La sentencia goto, ¿ciencia o religión? ..................................................................... 57 Break y Continue ...................................................................................................... 57 Saltar a una Etiqueta. ................................................................................................ 58 Objetivo 3...................................................................................................................... 64 Comparando con Visual Basic y C/C++................................................................... 64 La Cláusula finally .................................................................................................... 65 Sobrescribiendo métodos que lanzan excepciones ................................................... 66

3

Tutorial para el examen de certificación: SCJP 1.2 Sección 3. Recolector de basura –Garbage Collector- ............72

Objetivo 1...................................................................................................................... 72 ¿Por qué querrías utilizar el recolector de basura? ................................................... 72 Java y el recolector de basura. .................................................................................. 72 Sección 4. Fundamentos del lenguaje. ...........................76

Objetivo 1...................................................................................................................... 76 Nota sobre este objetivo............................................................................................ 76 La sentencia package ................................................................................................ 76 La sentencia import ............................................................................................... 77 Clases y la declaración de clases internas................................................................. 77 Clases internas declaradas dentro de métodos .......................................................... 79 Visibilidad de campos para clases definidas dentro de un método........................... 80 Creando una interface ............................................................................................... 81 Objetivo 2...................................................................................................................... 85 Objetivo 3...................................................................................................................... 87 Objetivo 4...................................................................................................................... 90 Variables ................................................................................................................... 90 Arreglos..................................................................................................................... 91 Objetivo 5...................................................................................................................... 95 Tamaño de los tipos primitivos enteros .................................................................... 95 Declarando literales enteros...................................................................................... 95 Tamaño de los tipos primitivos de coma flotante ..................................................... 96 Indicando tipos de datos con un literal sufijo ........................................................... 97 Los tipos boolean y char........................................................................................... 97 Declarando literales String ................................................................................... 99 Sección 5. Operadores y Asignaciones ..........................102

Objetivo 1.................................................................................................................... 102 El operador instanceof ....................................................................................... 102 El operador + .......................................................................................................... 103 Asignando variables primitivas de tipos diferentes ................................................ 104 Asignando referencias de objetos de diferentes tipos. ............................................ 105 Operadores de desplazamiento de bits.................................................................... 106 Operadores de desplazamiento con signo > ................................................. 107 Desplazamiento sin signo a la derecha >>>............................................................ 108 Applet BitShift ........................................................................................................ 108 Objetivo 2.................................................................................................................... 113 Diferencia entre el método equals y el operador = = .............................................. 113 Usando el método equals con Strings ..................................................................... 113 Usando el método equals con la Clase Boolean ..................................................... 114 Usando el método equals con objetos..................................................................... 115 Objetivo 3.................................................................................................................... 119 El efecto corto circuito con los operadores lógicos. ............................................... 119 Operadores a nivel de bits....................................................................................... 120 Pensando en binario ................................................................................................ 120 Objetivo 4.................................................................................................................... 124 Nota sobre este objetivo.......................................................................................... 124 Referencias de Objetos como parámetros de métodos. .......................................... 124 4

javaHispano. Tu comunidad, tu lenguaje. Primitivas como parámetros de métodos ................................................................ 125 Sección 6. Sobrecarga, sobreescritura, tipos en tiempo de ejecución y orientación a objetos .............................128

Objetivo 1) .................................................................................................................. 128 Relaciones “es un” y “tiene un”.............................................................................. 128 Encapsulamiento ..................................................................................................... 128 Tipos en Tiempo de ejecución ................................................................................ 130 Objetivo 2) .................................................................................................................. 135 Comentario sobre el objetivo .................................................................................. 135 Sobrecarga de métodos ........................................................................................... 135 Sobrescritura de métodos....................................................................................... 136 Invocando constructores de clases base.................................................................. 137 Invocando constructores con this() ..................................................................... 138 El constructor y la jerarquía de clases..................................................................... 139 Objetivo 3) .................................................................................................................. 146 Nota sobre este objetivo.......................................................................................... 146 Instanciando una clase ............................................................................................ 146 Clases internas ........................................................................................................ 146 Clases Anidadas de nivel Superior (Top Level) ..................................................... 147 Clases Miembro ...................................................................................................... 147 Clases creadas dentro de métodos........................................................................... 148 Clases anónimas...................................................................................................... 148 Sección 7. Threads ............................................152

Objetivo 1) .................................................................................................................. 152 ¿Qué es un Thread ?................................................................................................ 152 Las dos formas de crear un Hilo (Thread) .............................................................. 152 Instanciando e Iniciando un hilo. ............................................................................ 153 Objetivo 2) .................................................................................................................. 157 Comentario de este objetivo.................................................................................... 157 Razones por las que un thread puede ser bloqueado............................................... 157 Objetivo 3) .................................................................................................................. 161 ¿Por qué necesitarías el protocolo wait/notify? ...................................................... 161 synchronized ........................................................................................................... 161 wait/notify ............................................................................................................... 162 Sección 8. El paquete java.awt y su disposición ...............167

Objetivo 1.................................................................................................................... 167 Nota sobre este objetivo.......................................................................................... 167 Comparando la disposición de componentes de Java y Visual Basic..................... 167 La filosofía de los administradores de disposición ................................................. 167 Administradores de disposición que debes conocer para el examen. ..................... 169 Responsabilidades de los Administradores de Disposición VS los Contenedores . 169 Curiosidades del administrador BorderLayout ....................................................... 170 El administrador de disposición GridLayout .......................................................... 171 GridBagLayout ....................................................................................................... 172 Usando gridx y gridy para sugerir la posición de un componente.......................... 175 ipadx y ipady para controlar el relleno interior de los componentes ...................... 176 Componentes dentro de un panel utilizando GridBagLayout................................. 178 5

Tutorial para el examen de certificación: SCJP 1.2 Fijando componentes dentro de la cuadrícula......................................................... 180 Elementos GridBag no cubiertos por este ejercicio............................................... 182 Objetivo 2.................................................................................................................... 189 El modelo oyente -Listener- de eventos.................................................................. 189 El modelo de eventos del JDK 1.1.......................................................................... 189 Sección 9. El paquete java.lang.Math ..........................196

Objetivo 1.................................................................................................................... 196 Nota sobre este objetivo.......................................................................................... 196 abs ........................................................................................................................... 196 ceil........................................................................................................................... 196 floor......................................................................................................................... 197 max y min ............................................................................................................... 197 random .................................................................................................................... 198 round ....................................................................................................................... 198 sin cos tan................................................................................................................ 199 sqrt........................................................................................................................... 199 Resumen.................................................................................................................. 199 Objetivo 2.................................................................................................................... 203 Nota sobre este objetivo.......................................................................................... 203 Sección 10. El paquete java.util ..............................206

Objetivo 1.................................................................................................................... 206 Nota sobre este objetivo.......................................................................................... 206 Las colecciones antiguas......................................................................................... 206 Las nuevas colecciones ........................................................................................... 206 Set ........................................................................................................................... 207 List .......................................................................................................................... 207 Map ......................................................................................................................... 207 Usando Vectores ..................................................................................................... 208 Usando Hashtables.................................................................................................. 209 BitSet....................................................................................................................... 209 Sección 11. El paquete java.io ................................214

Objetivo 1.................................................................................................................... 214 Objetivo 2.................................................................................................................... 222 Objetivo 3.................................................................................................................... 228 Objetivo 4.................................................................................................................... 229 FileInputStream and OutputStream ........................................................................ 229 BufferedInputStream y BufferedOutputStream...................................................... 230 DataInputStream y DataOutputStream ................................................................... 230 La clase File......................................................................................................... 231 RandomAccesFile ................................................................................................... 231 Objetivo 5.................................................................................................................... 235 FileInputStream and FileOutputStream .................................................................. 235 RandomAccessFile ................................................................................................. 236

6

javaHispano. Tu comunidad, tu lenguaje.

Sección 1. Declaración y control de Acceso Objetivo 1. Escribir código que declare, construya e inicie arreglos de cualquier tipo base, usando cualquiera de las formas permitidas, para declaración y para inicialización. Arreglos.

Los arreglos en Java son similares en sintaxis a los arreglos en otros lenguajes como C/C++ y Visual Basic. Sin embargo, Java elimina la característica de C/C++ mediante la cual puedes pasar los corchetes ([]) accediendo a los elementos y obteniendo sus valores utilizado punteros. Esta capacidad en C/C++, aunque poderosa, propicia la escritura de software defectuoso. Debido a que Java no soporta esta manipulación directa de punteros, se remueve esta fuente de errores. Un arreglo es un tipo de objeto que contiene valores llamados elementos. Esto te da un conveniente contenedor de almacenamiento para un grupo de valores que pueden modificarse durante el programa, y permite que accedas y cambies los valores según lo necesites. A diferencia de las variables que son accedidas por un nombre, los elementos de un arreglo son accedidos por números comenzando por cero. De esta manera puedes “avanzar” a través del arreglo, accediendo a cada elemento en turno. Todos los elementos de un arreglo deben ser del mimo tipo. El tipo de elementos de un arreglo, se decide cuando se declara el arreglo. Si lo que necesitas es una manera para almacenar un grupo de elementos de tipos diferentes, puedes usar las clases de colecciones, estas son una nueva característica en Java 2 y son discutidas en la sección 10.

Declaración sin asignación. La declaración de un arreglo no asigna almacenamiento alguno, ésta solo anuncia la intención de crear un arreglo. Una diferencia significativa con la manera en que C/C++ declara un arreglo es que el tamaño no se especifica con el identificador. Por lo tanto lo siguiente causara un error durante la compilación int num[5];

El tamaño de un arreglo se da cuando este se crea realmente con el operador new: int num[]; num = new int[5];

7

Tutorial para el examen de certificación: SCJP 1.2

Creación y Declaración Simultanea. Lo anterior puede ser compactado en una sola línea así: int num[] = new int[5];

Además los corchetes pueden ser también colocados después del tipo de dato o después del nombre del arreglo. Por lo tanto son legales las siguientes declaraciones: int[] num; int num[];

Puedes leer esto de la siguiente manera: • •

Un arreglo de enteros llamado num Un arreglo llamado num de tipo entero.

Arreglos Java VS Arreglos C/C++ . Una gran diferencia entre java y C/C++ es que en java se conocen de que tamaño son los arreglos, y el lenguaje proporciona protección para no sobrepasar los limites del arreglo.

Este comentario es particularmente útil si vienes de un ambiente de programación como Visual Basic donde no es muy común iniciar el conteo de un arreglo desde 0. También ayuda a evitar uno de los mas insidiosos errores de C/C++. Por lo tanto, lo siguiente causará el siguiente error en tiempo de ejecución: ArrayIndexOutOfBoundException int[] num = new int [5]; for (int i = 0;i