Tutorial para el Examen de certificacion: SCJP 1.

2
Traducción del tutorial de Marcus Green.

RuGI Isaac Ruiz Guerra rugi@javahispano.org

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 rugi@javahispano.org 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 << y >> ................................................. 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

........................................................................................................................................................................128 Objetivo 1) .................... 161 synchronized ................................................. Sobrecarga..................... 152 ¿Qué es un Thread ?....... tu lenguaje........................................................................................... 146 Nota sobre este objetivo....................................... 148 Sección 7.................................................152 Objetivo 1) .................................................. tipos en tiempo de ejecución y orientación a objetos ................... Threads ............... ............................................... 157 Razones por las que un thread puede ser bloqueado..................................... 146 Clases internas ................................. 146 Instanciando una clase ..................... 128 Tipos en Tiempo de ejecución .............. 157 Objetivo 3) ........................................................................................................................................................................................................................................................................................................................................... 148 Clases anónimas.................................................................................................................... 175 ipadx y ipady para controlar el relleno interior de los componentes ......................................................................................................... 167 La filosofía de los administradores de disposición ................................................................................................................................... 146 Clases Anidadas de nivel Superior (Top Level) ........... El paquete java............................ 147 Clases creadas dentro de métodos...................................... ................. 162 Sección 8............................................................................................................................ 152 Las dos formas de crear un Hilo (Thread) ...................... 128 Encapsulamiento ......... 136 Invocando constructores de clases base........................... 135 Comentario sobre el objetivo ........................................................................ 167 Comparando la disposición de componentes de Java y Visual Basic....................................................................... 138 El constructor y la jerarquía de clases..................................................................................................... Tu comunidad............................................................... 153 Objetivo 2) ............................................................. 167 Administradores de disposición que debes conocer para el examen....................... 152 Instanciando e Iniciando un hilo.......................................................................................................... 161 wait/notify ............................................................................................................awt y su disposición .......... 169 Curiosidades del administrador BorderLayout ............................................................ Primitivas como parámetros de métodos ...................................................................................................................................................................................................................................................... 171 GridBagLayout ................. 170 El administrador de disposición GridLayout ... 176 Componentes dentro de un panel utilizando GridBagLayout.......................javaHispano... 157 Comentario de este objetivo....................................................................167 Objetivo 1......................................................................................... 178 5 .. 137 Invocando constructores con this() ................................................................................................. 135 Sobrescritura de métodos...... 135 Sobrecarga de métodos ........................................ 139 Objetivo 3) .............................................................................................................. 125 Sección 6.......................... 169 Responsabilidades de los Administradores de Disposición VS los Contenedores .............................................................................................................................................. sobreescritura.......................... 128 Relaciones “es un” y “tiene un”............................................................. 161 ¿Por qué necesitarías el protocolo wait/notify? ............. 147 Clases Miembro .. 130 Objetivo 2) .................................................................................................................... 167 Nota sobre este objetivo......... 172 Usando gridx y gridy para sugerir la posición de un componente........

........................................ 206 Las nuevas colecciones ......................................................................................................................................................................................................................................................206 Objetivo 1................................................................................................. 206 Set ........................................................................................................... 180 Elementos GridBag no cubiertos por este ejercicio.......... 196 floor............................................................... 203 Sección 10.............................................. 229 FileInputStream and OutputStream .......de eventos.....Math .................... 235 RandomAccessFile ........................ 199 Resumen..................................................................................................... 196 ceil...............................................................................2 Fijando componentes dentro de la cuadrícula........................................ 203 Nota sobre este objetivo............................................................................................. 197 random ................................................... 222 Objetivo 3................................................................................. 199 sqrt........ 198 sin cos tan......................................................................................................................................................................................................................................................... El paquete java........................................................................................................................................................................................ El paquete java................................................................................................................................ 230 La clase File.............................................................................................................. 231 Objetivo 5.....................................................................................................................................................................1............................................................................................................................................196 Objetivo 1............ 189 Sección 9.................................. 196 abs ......................................................................................lang........................................................................................................................ 214 Objetivo 2....................... 199 Objetivo 2............................................................................................................................... 228 Objetivo 4................................................................................................ 189 El modelo oyente -Listener.......................................................................................................................... 209 Sección 11................................................................................................................................................................................................................................................................................................................................................ 236 6 ............ 208 Usando Hashtables.......................... 209 BitSet.............................................................................................. El paquete java..................................... 230 DataInputStream y DataOutputStream ........................... 229 BufferedInputStream y BufferedOutputStream................................................................................ 235 FileInputStream and FileOutputStream ................. 207 Usando Vectores ......... 207 List ........................................ 198 round ..........................................................................................................214 Objetivo 1......................................................................... 207 Map ................................. 182 Objetivo 2... 206 Nota sobre este objetivo....................................Tutorial para el examen de certificación: SCJP 1............................................................................................................. 231 RandomAccesFile ......................util ...................................................................... 189 El modelo de eventos del JDK 1............ 197 max y min ................................................................................................ 206 Las colecciones antiguas...........................................................................................................................................................................io ................. 196 Nota sobre este objetivo...

ésta solo anuncia la intención de crear un arreglo. Arreglos. puedes usar las clases de colecciones. para declaración y para inicialización. y permite que accedas y cambies los valores según lo necesites. 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. A diferencia de las variables que son accedidas por un nombre. se decide cuando se declara el arreglo. Tu comunidad. tu lenguaje. Debido a que Java no soporta esta manipulación directa de punteros. usando cualquiera de las formas permitidas. Todos los elementos de un arreglo deben ser del mimo tipo. se remueve esta fuente de errores. aunque poderosa. accediendo a cada elemento en turno. Escribir código que declare. El tipo de elementos de un arreglo. Por lo tanto lo siguiente causara un error durante la compilación int num[5]. Un arreglo es un tipo de objeto que contiene valores llamados elementos. De esta manera puedes “avanzar” a través del 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. Si lo que necesitas es una manera para almacenar un grupo de elementos de tipos diferentes. 7 . Declaración sin asignación. El tamaño de un arreglo se da cuando este se crea realmente con el operador new: int num[]. Sin embargo. La declaración de un arreglo no asigna almacenamiento alguno. Sección 1. Declaración y control de Acceso Objetivo 1. Los arreglos en Java son similares en sintaxis a los arreglos en otros lenguajes como C/C++ y Visual Basic. construya e inicie arreglos de cualquier tipo base.javaHispano. num = new int[5]. los elementos de un arreglo son accedidos por números comenzando por cero. Esto te da un conveniente contenedor de almacenamiento para un grupo de valores que pueden modificarse durante el programa. propicia la escritura de software defectuoso. Esta capacidad en C/C++. estas son una nueva característica en Java 2 y son discutidas en la sección 10.

Lo anterior puede ser compactado en una sola línea así: int num[] = new int[5]. la manera mas común es a través del campo length de los arreglos.length. Por lo tanto son legales las siguientes declaraciones: int[] num. } Para recorrer un 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. } 8 . Por lo tanto. y el lenguaje proporciona protección para no sobrepasar los limites del arreglo. También ayuda a evitar uno de los mas insidiosos errores de C/C++.2 Creación y Declaración Simultanea. Arreglos Java VS Arreglos C/C++ .i++){ num[i]=i*2. for (int i = 0.Tutorial para el examen de certificación: SCJP 1. Además los corchetes pueden ser también colocados después del tipo de dato o después del nombre del arreglo.i++){ num[i] = i*2. Una gran diferencia entre java y C/C++ es que en java se conocen de que tamaño son los arreglos. int num[].i<6. así: int [] num = new int[5]. Puedes leer esto de la siguiente manera: • • Un arreglo de enteros llamado num Un arreglo llamado num de tipo entero.i<num. for(int i = 0. lo siguiente causará el siguiente error en tiempo de ejecución: ArrayIndexOutOfBoundException int[] num = new int [5].

tu lenguaje. NT. es que cada arreglo no tiene que ser del mismo tamaño. j<myarray. sin embargo si soporta arreglos de arreglos.com/docs/books/jls/html/10. Los arreglos en VB pueden comenzar desde 1 si se usa la declaración Option base. también conocidos como arreglos anidados. En Java no hay equivalente para el comando redim preserve a través del cual puedes cambiar el tamaño de un arreglo sin borrar su contenido. La declaración de un arreglo puede tener múltiples conjuntos de corchetes (“[]”). 9 . Así podrías almacenar las coordenadas de un mapa con un arreglo de 2 dimensiones: int [][]. Arreglos Java VS Arreglos VB Los arreglos en Java siempre comienzan desde cero. } Nota que los arreglos tienen el campo length y no el método length(). Así. Tu comunidad. de la siguiente manera: s. la 1ª dimensión podría ser la coordenada X y la segunda la coordenada Y. como en C/C++ y los arreglos anidados. Cuando comiences a utilizar Strings usaras el método length. j++){ myarray[j]=j. De acuerdo con la Especificación del Lenguaje Java: (http://java. puedes llenar dinámicamente un arreglo con el código siguiente: int myarray[] = new int [10].length(). Java formalmente no soporta los arreglos multidimensionales. cada arreglo puede tener un tamaño distinto. Solo en caso de que te hayas saltado la comparación con C/C++ -hecha anteriormentelos arreglos en Java siempre conocen cual es su tamaño. for(int j=0.doc.sun.: En otras palabras. Una diferencia importante entre los arreglos multidimensionales. Los arreglos conocen su tamaño.length. y este se representa en el campo length. la matriz no tiene que ser una matriz rectángulo . Pero por supuesto puedes crear un nuevo arreglo con un nuevo tamaño y copiar los elementos actuales a ese arreglo y obtener el mismo resultado.javaHispano. En un arreglo length es un campo (o propiedad) no un método. Si vemos un arreglo como una matriz.html#27805) “El número de corchetes indica la profundidad de un arreglo anidado” En otros lenguajes esto se conoce como la dimensión de un arreglo.

”Two”.out. Solución sugerida para el ejercicio 1. b.1.1. //¡¡¡ error. Esto mostrará la cadena Zero. de la siguiente manera: String s[] = new String [] {“Zero”.”Two”.2. un arreglo puede ser creado e inicializado a la vez en una sola declaración. Observa que en ninguna parte necesitas especificar el número de elementos en el arreglo.”One”. por lo tanto puedes crear un arreglo de cadenas.”One”. Crea un método llamado amethod. 10 . Ejercicio 1) Crea una clase con un método que simultáneamente cree e inicialize un arreglo de cadenas.4}. preguntándote si el siguiente código es correcto: Int k = new int[5]{0.”Four”}.4}. int k[] = new int[] {0.”Three”.println(s[0]). Puedes analizar esto.3.”Four”}. System. Los elementos de un arreglo pueden ser direccionados como lo harías en C/C++: String s[] = new String [] {“Zero”. después muestra el primer nombre contenido en el arreglo.”Three”. En amethod inicializa los primeros cuatro elementos con nombres de frutas.Claines(). pero no lo inicializes con cualquier valor. Inicializa el arreglo con cuatro nombres. no compilara !!! Puedes crear y llenar arreglos simultáneamente con cualquier tipo de dato. Crea otro método llamado modify y cambia el contenido del primer elemento del arreglo Fruit para que contenga la cadena “bicycle”. Ejercicio 2) Crea una clase que cree un arreglo de cadenas de 5 elementos llamado Fruit en el nivel de clase. Dentro del método modify crea un ciclo for que imprima todos los elementos del arreglo. Esto es particularmente recomendable para arreglos pequeños.2.3.2 Combinar declaración con inicialización. public class Bevere{ public static void main(String argv[]){ Bevere b = new Bevere(). En vez de ciclarse a través de un arreglo para llevar a cabo la inicialización.Tutorial para el examen de certificación: SCJP 1. La siguiente línea creara un arreglo de enteros y lo llenara con los números 0 hasta el 4.

System.modify().println(names[0])."Raj"}. b.javaHispano. } public void amethod(){ Fruit[0]="Apple". i++){ System.out. Solución Sugerida para el ejercicio 2. Fruit[2]="Bannana".length. i< Fruit. Se preguntó por el primer nombre del arreglo para asegurar que no utilizarás names[1]. tu lenguaje. } } Nota: La sintaxis para la creación e inicialización simultanea no es evidente y vale la pena practicarla. Tu comunidad. public static void main(String argv[]){ Barbourne b = new Barbourne(). public class Barbourne{ String Fruit[]= new String[5].println(Fruit[i]). b. } public void Claines(){ String[] names= new String[]{"Peter"."Balhar". } } } Nota: Cuando el ciclo ejecute la salida de elemento final este será null. Fruit[3]="Mango".out. 11 . Fruit[1]="Orange".amethod(). for(int i=0."John". } public void modify(){ Fruit[0]="Bicycle".

length.Tutorial para el examen de certificación: SCJP 1. } } Pregunta 3) Quieres hacer un ciclo a través de un arreglo y detenerte cuando llegues al ultimo elemento. Pregunta 4) Tu jefe esta complacido por que escribiste el programa Hello World y te ha dado un aumento. y olvidando lo que alguna vez conociste sobre C/C++. 3)myarray. int[][] i=new int[3][3]. Siendo un buen programador en Java. 2)myarray. Pregunta 5) 12 . Escribiendo el siguiente Código. int[] i=new int[3][3].length(). Ahora te encomienda que crees un juego como el TicTacToe(o puntos y cruces como lo conocí en mi adolescencia). Decides que para eso necesitas un arreglo multidimensional. ¿Cuál de las siguientes líneas realizan el trabajo? 1) 2) 3) 4) int i=new int[3][3].¿Qué pasara cuando lo compiles y ejecutes? public class MyAr{ public static void main(String argv[]){ int[] i = new int[5]. Pregunta 1) ¿Cómo puedes redimensionar un arreglo con una declaración sencilla manteniendo el contenido original? Pregunta 2) Quieres averiguar el valor del último elemento de un arreglo.2 Preguntas. System. ¿Cuál de las siguientes sentencias puedes usar? 1)myarray. sabes que los arreglos contienen información acerca de su tamaño.size().out.println(i[5]). int i[3][3]=new int[][].size 4)myarray.

"One".”One”.”Two”."One".javaHispano. 4)String s[]=new String[]={"Zero".”Four”}. 13 . [2]="Two". end with 2)String s[5]=new String[] {"Zero". Necesitas crear un nuevo arreglo temporal con un tamaño diferente y llenarlo con el contenido del arreglo original. Java Proporciona contenedores redimencionables con clases como Vector o uno de los miembros de la clase collection ."Two"."Two"."Four"}. Debido a que los arreglos son indexados desde 0."Two"."Three". Quieres encontrar una manera más elegante para llenar un arreglo que a través de un ciclo con la sentencia for. ¿Cuál de las siguientes líneas usarías? 1) myArray{ [1]="One". Respuesta 2) Intentar avanzar mas allá del final del arreglo genera un error en tiempo de ejecución. Respuesta 5) 3) String s[] = new String[]{“Zero.length."Four"}."Three"."One". [3]="Three". Respuesta 3) 2) myarray. Respuestas Respuesta 1) No puedes redimensionar un arreglo. el elemento final será i[4] y no i[5]. Respuesta 4) 3) int[][] = new int[3][3]. Tu comunidad. 3)String s[]=new String[] {"Zero". tu lenguaje."Four"}.”Three”."Three".

sun.com/Athens/Acropolis/3797/Java028.html Richard Baldwin trata este tema en: http://www.Geocities.Tutorial para el examen de certificación: SCJP 1.html#obj1 Bruce Eckel Thinking In Java Capítulo 8 14 .com/docs/books/tutorial/java/data/arraysAndStrings.htm Jyothi Krishnan en: http://www.2 Otras Fuentes de este tema: Este tema es cubierto en el Tutorial de Sun en: http://java.geocities.com/SiliconValley/Network/3693/obj_sec1.

Algunas de sus diferencias fueron hechas para hacer de Java un lenguaje más fácil de aprender y usar. El rol de las clases en Java Las clases son el corazón de Java. final. Hasta la más sencilla aplicación HelloWorld involucra la creación de una clase. static. Supongo que esto significa que debes estar consciente de los modificadores: native transient synchronized volatile Comparando las clases de C++/VB con las de Java. polimorfismo.javaHispano. Declarar clases. este tiene muchas similitudes en la manera en que ambos lenguajes trabajan con las clases. a la cual los diseñadores del lenguaje le decidieron dar algunas de las ventajas de la herencia múltiple. Si no se usa extends. pero sin las desventajas. clases internas. algunas funciones básicas incluyendo la habilidad para mostrar su nombre y algunas de las capacidades requeridas en los Threads. Para sobreponer esta limitación. variables y variables automáticas(métodos locales). variables de instancia estáticas. las clases pueden tener únicamente un padre. El lenguaje C++ implementa la herencia múltiple y así una clase puede tener más de un padre (o clase base) Java únicamente permite la herencia simple. Para indicar que una clase desciende de otra clase se usa la palabra clave extends. tu lenguaje. la clase descenderá de la clase Object lo cual proporciona a la clase creada. Objetivo 2. y demás). Todas las clases en Java son descendientes de una gran clase antecesora llamada Object. abstract. métodos. y ocultamiento de datos usando modificadores de visibilidad. Java tiene una característica llamada: Interfaces. es decir. Conocer importancia de cada uno de estos modificadores ya sea solos o en combinación Comentario sobre este objetivo Encuentro un poco molesto que en el objetivo se use la frase “y demás”. Tu comunidad. todo el código en Java ocurre dentro de una clase. Debido a que Java fue diseñado para facilitar que programadores C++ lo aprendieran. Ambos lenguajes tienen herencia. 15 . No hay un concepto de código llano y de posición libre. haciendo un uso apropiado de todos los modificadores permitidos (como son: public.

public class HelloWorld{ public static void main(String argv[]){ System. Observa que Java es sensible a mayúsculas en todos los aspectos. Entonces: class classname {} es una definición sintacticamente correcta para una clase. La magia del nombre main 16 .Tutorial para el examen de certificación: SCJP 1.out. lo siguiente es una plantilla mas sensata para definir una clase: public class classmane{ // el cuerpo de la clase va acá } Creando una clase sencilla. Observa que la llave de cierre que finaliza la definición de la clase no involucra un punto y coma de cerradura. Java también comprende los comentarios multilíneas de la forma /* */. El archivo que contenga esta clase deberá llamarse HelloWorld. Los requerimientos mínimos para definir una clase son: la palabra clave class.2 La clase más sencilla. cuando creo ejemplos para ilustrar la herencia) Normalmente una clase también incluirá un especificador de acceso antes de la palabra clave class y por supuesto. el cuerpo de la clase entre las llaves. Si declaras mas de una clase en un archivo como publica. me he encontrado definiendo clases como esta. Solo una clase por archivo puede ser declarada publica. Así. } }//Fin de la Definición de la clase La palabra clave public es un modificador de visibilidad que indica que la clase deberá ser visible para cualquier otra clase.println("hello world"). ocurrirá un error en tiempo de ejecución. El comentario: //Fin de la Definición de la clase Usa el estilo de comentario de una sola línea que esta disponible en C/C++. pero no es una clase particularmente útil (sorprendentemente.HelloWorld Este es un sencillo programa HelloWorld que mostrar: la cadena “hello world” en la pantalla. el nombre de la clase y las llaves de apertura y cerradura.java La palabra clave class indica que una clase comienza a ser definida y HelloWorld es el nombre de la clase.

es útil para ilustrar la más sencilla de las aplicaciones que puedes crear.println que es un método estático y no requiere la creación de una clase que utilice la palabra new. Dando a un método la siguiente forma. la Maquina virtual de Java (JVM) no reconocerá el método como el lugar en donde se debe comenzar la ejecución del programa. El parámetro del método main: String argv[] Indica que el método toma un arreglo de tipo String. tu lenguaje. y que toma como parámetros (o argumentos) a un arreglo de cadenas. la palabra clave new. La aplicación de HelloWorld puede modificarse ligeramente para ilustrar la creación de una nueva instancia de una clase. Este método es publico. public class HelloWorld2{ public static void main(String argv[]){ HelloWorld2 hw = new HelloWorld2(). Esto es importante ya que Java es totalmente sensible a las mayúsculas.println("Hello world"). (similar al main del lenguaje C).un arreglo. en su momento se cubrirán con detalle los métodos estáticos (static) en otra parte de este tutorial. La palabra clave void indica el tipo de dato retornado por el método cuando se llama. Usar void indica que ningún valor será retornado. Tu comunidad. La cual indica la creación de una nueva instancia de la clase. Pero le falta mostrar uno de los elementos más cruciales al usar las clases. Los métodos estáticos pueden acceder solo a variables estáticas. como describí anteriormente. Si eso no significa nada para ti.out. Sin estas exactitudes. esté obtiene cierta significancia (o magia) cuando indica a Java que es aquí en donde el programa debe empezar a ejecutarse. Observa que el tipo de dato String comienza con una “S” mayúscula. Los corchetes indican –como ya vimos.amethod(). es decir es visible desde cualquier parte de la clase.out. En la aplicación HelloWorld esto no era necesario ya que el único método que se llamó era System. } public void amethod(){ System. no te preocupes.javaHispano. de las que sólo puede existir una instancia por la clase. Creando una instancia de una Clase La aplicación HelloWorld. } } 17 . La palabra clave static indica que este método puede ejecutarse sin crear una instancia de la clase. public static void main(String argv[]){ Esta línea indica que esta definiéndose un método llamado main. hw.

El mismo método se podría haber definido de estas maneras alternativas: private void amethod(String s) private void amethod(int i.2 Este código crea una nueva instancia de si mismo en la línea: HelloWorld2 hw = new HelloWorld2(). La diferencia entre los métodos de Java y métodos en lenguajes no orientados a objetos como C es que los métodos pertenecen a una clase. La primera vez indica el tipo de dato de la referencia a la clase. Éste simplemente es un nombre escogido para una variable. Retorna el tipo: void Indicando que ningún valor será retornado. El paréntesis vacío para el nombre de la clase HelloWorld() indica que la clase está creándose sin algún parámetro en su constructor. utilizando la convención para escritura de código Java)ya que una instancia de una clase empieza con una letra minúscula. Esta sintaxis para crear una nueva instancia de una clase es básica para el uso de clases. Esta necesidad no es la misma que el tipo actual de la clase puesto que ésta se indica después de usar la palabra clave new.Tutorial para el examen de certificación: SCJP 1. Creando Métodos. Si estuvieras creando una instancia de una clase que se inicializa con un valor o un arreglo como la clase Label o Button el paréntesis contendría uno o mas valores de inicialización. El nombre de esta instancia de la clase es hw. Esto significa que se llaman usando la anotación del punto que indica la instancia de la clase a la que el método pertenece (Los métodos estáticos son una excepción a esto pero no te preocupes sobre ellos por el momento) 18 . El uso de las palabras clave private y protected se cubrirá en otro apartado. Como ilustro en el último ejemplo HelloWorld2. Observa cómo el nombre de la clase aparece dos veces. considerando que la definición de una clase empieza con una letra mayúscula. String s) protected void amethod(int i) Estos ejemplos ilustran algunas otras firmas típicas de declaración de métodos. Y los paréntesis vacíos indican que no toma parámetros. un método en Java es similar a una función en C/C++ y a una función o sub función en Visual Basic. El método llamado amethod en este ejemplo se declara como: public que indica que puede accederse desde cualquier parte. Este es un nombramiento convencional (es decir.

Tu comunidad. Cada instancia de la clase tendría acceso a sus propias variables. public static void main(String argv[]){ Shad s = new Shad(). hw2. s. Son sólo visibles dentro del método y son útiles principalmente para la manipulación de datos temporales.amethod(). Así lo siguiente involucraría la llamada al código del método amethod de las diferentes instancias de la clase. Así el código siguiente mostrará 99 y no 10: public class Shad{ public int iShad=10. Si se hubieran creado otras instancias de la clase HelloWorld el método podría llamarse desde cada instancia de la clase. hw.amethod().amethod(). System. }//fin de main public void amethod(){ int iShad=99. hw. Así en HelloWorld2 el método amethod se llamo así: HelloWorld hw = new HelloWorld().out.javaHispano. tu lenguaje. Variables Automáticas Las variables automáticas son las variables de los métodos. HelloWorld hw2 = new HelloWorld(). Si quieres que un valor permanezca entre las llamadas de un método entonces la variable necesita ser creada al nivel de la clase. }//fin de amethod } 19 . Una variable automática será la "sombra" de una variable de nivel de clase. Las dos instancias de la clase: hw y hw2 podrían tener acceso a variables diferentes.amethod(). Estas entran en el alcance del programa cuando empieza a ejecutarse el código del método y dejan de existir una vez que el método deja de ejecutarse. HelloWorld hw = new HelloWorld().println(iShad).

Como se dijo anteriormente. }//End of main } 20 . class Base{ private int iEnc=10. Los modificadores de visibilidad son parte del mecanismo de encapsulamiento para Java. esto es útil para separar la interfase de la implementación. El encapsulamiento permite la separación de la interfase y la implementación de métodos.println("Enc value must be less than 1000"). exceptuando aquellos en la clase actual. por ejemplo: si el valor esta dentro de un rango en particular o revisar si es un numero positivo. }else System.2 Modificadores y Encapsulamiento. b. Esto significa que NO son visibles dentro de las subclases. //Or Perhaps thow an exception }//End if } public class Enc{ public static void main(String argv[]){ Base b = new Base(). public void setEnc(int iEncVal){ if(iEncVal < 1000){ iEnc=iEncVal.setEnc(1001). La convención para nombrar a estos métodos es setFoo para modificar y getFoo para obtener el contenido de una variable. Esto permite que la variable sea aislada de ser modificada por cualquier método. el valor de la variable también puede verificarse. Son conocidos como métodos accessor (acceder o obtener el valor de la variable) y mutator (modificar el contenido de una variable). Así si estuvieras almacenado una variable llamada age deberías hacerla privada y actualizarla con: setAge y recuperar su valor con: getAge Usando código para modificar variables. A menudo estos métodos son para recuperar y actualizar los valores de una variable local privada.Tutorial para el examen de certificación: SCJP 1.out. Private Las variables privadas son sólo visibles dentro de la misma clase donde se crean.

b. Tu comunidad.iNoEnc=2. Cualquier clase que esté en el mismo directorio se considera que está en el paquete predefinido.javaHispano.out. en una subclase. que se programó en un principio. tendrías que modificar la implementación de cada parte del código externo que lo modifica. Si revisas el código para HelloWorld. y así las clases protegidas serán visibles. Public El modificador public puede aplicarse a una variable (campo) o una clase. Protected El modificador protected es una pequeña rareza. La cualidad de ser visible dentro del mismo paquete puede darle más visibilidad de la que podrías sospechar. Esto significa que una variable protegida tiene más visibilidad que una variable definida sin modificador de acceso. sólo revisa en una clase declarada como publica: public static void main(String argv[]) Una clase pública tiene alcance global. pero no en otra parte. Si defines más de una clase en un archivo con la palabra clave public el compilador generará un error class Base { public int iNoEnc=77.println(b. Si decidieras cambiar el tipo de dato de iNoEnc. y una instancia puede crearse desde cualquier parte dentro o fuera de un programa. System. tu lenguaje. Una variable protegida es visible dentro de una clase. }//End of main } Observa que generalmente ésta no es la manera sugerida ya que no permite ninguna separación entre la interfase y implementación del código. } public class NoEnc{ public static void main(String argv[]){ Base b = new Base(). 21 . la clase se declaró como: public class HelloWorld Esto es porque para iniciar el método mágico la JVM.iNoEnc). Únicamente una clase en un archivo puede definirse con la palabra clave public.Java. Es probablemente el primer modificador que conociste aprendiendo Java. y en el mismo paquete.

a un método y una variable. m1. MyClass m3 = new MyClass().2 Se dice que una variable definida sin modificador de acceso tiene visibilidad predefinida. m2. }//End of MyClass public class Stat{ public static void main(String argv[]){ MyClass m1 = new MyClass(). Marcando una variable como estática se indica que sólo una copia de esa variable existirá por clase. }//End of main } El Ejemplo siguiente muestra que pasa cuando tienes múltiples instancias de una clase que contiene una variable estática. La visibilidad predefinida significa que una variable puede verse dentro de la clase. Así en el ejemplo siguiente existirán tres instancias de la variable integer iMyVal y cada instancia podra contener un valor diferente. class MyClass{ public int iMyVal=0. MyClass m2 = new MyClass(). m3. //Debido a que iMyVal es static.iMyVal=1.out. MyClass m2 = new MyClass(). El modificador static puede aplicarse a una clase. Esto está en contraste con las variables normales donde por ejemplo una copia de una variable integer pertenece a cada instancia de una clase. y desde otra parte dentro del mismo paquete.iMyVal=99.iMyVal=2. en este ejemplo la variable estática es iMyEval. MyClass m3 = new MyClass(). Ya que cada instancia de // la clase tiene su propia copia de MyVal System.iMyVal=99. Static Static no es directamente un modificador de visibilidad.Tutorial para el examen de certificación: SCJP 1. class MyClass{ public static int iMyVal=0. pero no desde una subclase que no esté en el mismo paquete. //Esto mostrará 1.iMyVal=1. m2. m1.iMyVal). } public class NonStat{ public static void main(String argv[]){ MyClass m1 = new MyClass().println(m1. m2.iMyVal=0. //hay sólo una copia de él no importa 22 . aunque en la práctica tiene este efecto.

El código siguiente causará un error cuando intentes sobreescribir el método amethod de la clase Base para ser no estático. No hay ninguna regla similar con referencia a la sobrecarga. }//End of main } Ten presente que no puedes acceder a variables no estáticas desde dentro de un método estático.iMyVal)." cannot override the static method "void amethod(). class Base{ public static void amethod(){ } } public class Grimley extends Base{ public void amethod(){}//Causa un error en tiempo de compilación } El compilador Jikes de IBM produce el siguiente error: Found 1 semantic error compiling "Grimley.java": 6." declared in type "Base" Native El modificador native sólo se usa para los métodos e indica que el cuerpo del código esta escrito en un lenguaje que no es Java como C y C++. public static void main(String argv[]){ i = i + 2.javaHispano.//Causará un error al compilar } } Un método estático no puede ser sobreescrito para ser no estático en una clase hija. public void amethod(){} <-------> *** Error: The instance method "void amethod(). Se escriben a menudo métodos 23 . Tu comunidad. Así lo siguiente causará un error en tiempo de compilación. public class St{ int i. tu lenguaje. //Este código mostrará el valor de 99 System. Un método estático no puede ser sobreescrito para ser no estático en una clase hija. //cuantas instancias de la clase se creen.out.println(m1.

Así lo siguiente llamaría una rutina externa. El modificador abstracto puede aplicarse a las clases y a los métodos. Cuando se aplica a un método indica que éste no tendrá cuerpo y el código sólo puede ejecutarse cuando se implemente en una clase hija. Aquí hay un ejemplo de una clase abstracta con un método abstracto. Cuando se aplica a una clase.println("hello in the abstract"). De nuevo nota que la propia clase se declara abstracta.2 nativos para propósitos específicos de la plataforma como acceder a algún elemento de hardware del cual la Maquina Virtual de Java no este consciente. } public abstract int amethod(). Otra razón es utilizarlo donde se requiere mayor desempeño. Sin embargo. Cualquier clase que descienda de una clase abstracta debe implementar los métodos abstractos de la clase base o debe declararlos abstractos ella misma. pero la implementación real queda a las personas que usan las clases después. 24 . public native fastcalc().out. indica que la clase tiene un por lo menos método abstracto. Sin embargo hay algunas restricciones sobre cuando y donde puedes tener métodos abstractos y reglas sobre las clases que los contienen. Ofrecen al diseño de una clase una manera de crear un prototipo para métodos que han de ser implementados. escrita quizás en C++.Tutorial para el examen de certificación: SCJP 1. Un método nativo termina con punto y coma en lugar de un bloque del código. Si una clase tiene algún método abstracto esta debe ser asimismo declarada abstracta . ¿Tienden estas reglas a generar la pregunta por qué querrías crear métodos abstractos? Los métodos abstractos son principalmente beneficiosos a los diseñadores de clases. Abstract Es fácil pasar por alto el modificador abstract y perderse algunas de sus implicaciones. Es la clase de modificador que a los examinadores les gusta para hacer preguntas complicadas. de otra manera habría ocurrido un error en tiempo de compilación. no te distraigas pensado que una clase abstracta no puede tener métodos no abstractos. La siguiente clase es abstracta y se compilará sin problemas: public abstract class abstr{ public static void main(String argv[]){ System.

Tu comunidad. Otra manera de entender esto es que una clase final no puede ser una clase padre. El código siguiente ilustra el uso del modificador final en una clase. Indica que una variable no debe escribirse fuera cuando una clase es serializada. } } public class Fin{ public static void main(String argv[]){ Base b = new Base(). Esto se cubre mejor en el Volumen 1 de Core Java. } } Shynchronized La palabra clave synchonized se usa para prevenir que más de un thread acceda a un bloque de código a la vez.javaHispano.println("amethod"). b.out. Este código mostrará la cadena "amethod": final class Base{ public void amethod(){ System. Cualquier método en una clase final es automáticamente final. Ve la sección 7 sobre threads para entender más cómo funciona esto. } Final El modificador final indica que un método no puede ser heredado. Esto puede ser útil si no quieres que otros programadores "hechen a perder tu código". tu lenguaje. Lo peor que conseguirás es reconocer que realmente es un palabra clave de Java. Volatile Probablemente no conseguirás realizar alguna pregunta sobre la palabra clave volatile. Otro beneficio es la eficacia puesto que el compilador tiene menos trabajo al trabajar con un método final.amethod(). Según Barry Boone: "le dice al compilador que una variable puede cambiar asincrónicamente debido a los threads" 25 . Transient La palabra clave transient es uno de los modificadores frecuentemente menos usados.

Puedes tener combinaciones de los modificadores de visibilidad y los modificadores mencionados.2 Acepta que es parte del lenguaje y entonces mejor preocúpate por otras cosas. • • • • native transient synchronized volatile Así puedes tener un método public static native. por supuesto. Donde pueden usarse los modificadores Modificador Método Variable clase public private protected abstract final transient native volatile si si si si si no si no si si si no si si no si si si(anidable) si(anidable) si si no no no Ejercicio 1) Crea un archivo llamado Whitley. En el mismo archivo crea una clase llamada Whitley que descienda de la clase Base. Crea un método nativo para la clase llamado mynative. Ejercicio 2) 26 . así una variable no puede ser privada y pública.Tutorial para el examen de certificación: SCJP 1. pública y protegida o protegido y privada. en mi lista "y demás". Proporciona a la clase Whithley un método llamado lamprey con el código necesario para mostrar en pantalla la cadena “lamprey”. En este archivo define una clase llamada Base con un método abstracto llamado lamprey que retorne un valor de tipo int. Usando modificadores en combinación Los modificadores de visibilidad no pueden usarse en combinación. Ahora compila y ejecuta el código.java.

Crea una clase publica llamada Malvern. } native public void mynative().println("lamprey"). Haz que esta instancia llame al método go. } public class Whitley extends Base{ public static void main(String argv[]){ } public int lamprey(){ System.javaHispano. Solución sugerida para el ejercicio 1. Proporciona a la clase Malvern un método publico llamado go que cree una instancia de Great y después de ser instanciada llame al método show.go(). Compila y ejecuta el código. Haz que este método muestre en pantalla la cadena “Show”.out. Tu comunidad. } public void go(){ Great g = new Great(). Crea una clase interna y privada llamada Great que tenga un método llamado show de la forma public void. return 99.out. m. En el método main de la clase Malvern crea una instancia de sí misma. } } } 27 . } private class Great{ public void show(){ System.show(). public class Malvern{ public static void main(String argv[]){ Malvern m = new Malvern(). g. abstract class Base{ abstract int lamprey().println("Show"). tu lenguaje. } Solución sugerida para el ejercicio 2.

public void another(){ System. Pregunta 1) ¿Qué pasará cuando intentes compilar y ejecutar este código? abstract class Base{ abstract public void myfunc(). } public void myfunc(){ System. } } 1) El código se compilará y se ejecutará.println("My func"). } public void amethod(){ myfunc(). Pregunta 2) ¿Qué pasara cuando intentes compilar y ejecutar este código? public class MyMain{ public static void main(String argv){ System.out. mostrando la cadena “My func” 2) El código indicara que la clase Base no tiene métodos abstractos. 3) El código se compilara pero indicará un error en tiempo de ejecución (run time error): la clase base no tiene métodos abstractos 4) El compilador indicara que el método myfunc en la clase Base no tiene cuerpo.println("Another method").out.2 Preguntas.out.println("Hello cruel world").Tutorial para el examen de certificación: SCJP 1. a. } } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(). } } 28 .amethod().

a.out. tu lenguaje. 2) El código se compilará y cuando se ejecute mostrara en pantalla la cadena “Hello cruel world”.println("Another method"). 3) El código se compilará pero indicará un error en tiempo de ejecución: la clase base no tiene métodos abstractos 4) El compilador indicará que el método myfunc en la clase Base no tiene cuerpo.out. public void another(){ System. Pregunta 3) ¿De los siguientes cuales son modificadores de Java? 1) 2) 3) 4) public private friendly transient Pregunta 4) ¿Qué pasará cuando intentes compilar y ejecutar este código? class Base{ abstract public void myfunc(). } public void amethod(){ myfunc(). } public void myfunc(){ System. 4) El código se compilara pero indicara que la función main no esta definida correctamente. } } 1) El código se compilará y se ejecutará. mostrando la cadena “My func” 2) El compilador indicará que la clase Base no esta declarada como abstracta.javaHispano. Tu comunidad. 29 .amethod(). 1) El compilador indicara que main es una palabra reservada y no puede ser usada para nombrar una clase.println("My func"). } } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(). 3) El código se compilara pero indicará un error en tiempo de ejecución: el constructor no esta definido.

println("amethod"). 2) Un error en tiempo de compilación indicará que no puedes heredar de una clase con métodos final 3) Un error en tiempo de ejecución indicando que Base no esta definida como final 4) Éxito en la compilación y al ejecutarse mostrará en pantalla “amethod”. 4) Para superar la limitación del alcance privado de un método Pregunta 6) ¿Qué pasará cuando intentes compilar y ejecutar este código? class Base{ public final void amethod(){ System.2 Pregunta 5) ¿Para que defines un método como nativo? 1) Para conseguir acceder a Hardware desconocido por Java 2) Para definir un nuevo tipo de dato como un entero sin signo. } } 1) Un error en tiempo de compilación indicando que una clase con algún método final debe ser declarado final por si misma.out.amethod(). Pregunta 7) ¿Qué pasará cuando intentes compilar y ejecutar este código? public class Mod{ public static void main(String argv[]){ } public static native void amethod(). } 1) Error en la compilación: método nativo no puede ser static. 3) Para escribir código optimizado para el mejor desempeño en un lenguaje como C/C++.Tutorial para el examen de certificación: SCJP 1. b. } } public class Fin extends Base{ public static void main(String argv[]){ Base b = new Base(). 30 .

Pregunta 8) ¿Qué pasará cuando intentes compilar y ejecutar este código? private class Base{} public class Vis{ transient int iVal. 4) P1 se compilará limpiamente pero P2 tendrá un error al compilarse. } 1) Ambos se compilarán y P2 mostrará en pantalla “Wath a fancy method” cuando se ejecute. 2) Un error en tiempo de compilación indicando que un entero no puede ser transient 3) Un error en tiempo de compilación indicando que transient no es un tipo de dato. 4) Un error en tiempo de compilación indicando que el método main esta deformado Pregunta 9) ¿Qué pasara cuando intentes compilar y ejecutar estos dos archivos en el mismo directorio? //Archivo P1. 31 . 3) Compilación correcta pero habrá un error en tiempo de ejecución a menos que hallas hecho código para hacer útil el método nativo. 4) Compilación y ejecución sin error. class P1{ void afancymethod(){ System.java public class P2 extends P1{ afancymethod(). } } //Archivo P2. tu lenguaje.println("What a fancy method").javaHispano. 2) No se compilará ninguno. 3) Ambos se compilarán pero P2 tendrá un error en tiempo de ejecución. Tu comunidad. public static void main(String elephant[]){ } } 1) Un error en tiempo compilación: la clase Base no puede ser privada. 2) Error en la compilación: método nativo debe retornar algún valor.out.java package MyPackage.

java:1: class Base must be declared abstract. Respuesta 1) 1) El código se compilara y se ejecutara. esta no es una palabra reservada de Java. class Base{ 32 . La función main recibe un String en lugar de un arreglo de String que es lo correcto. It does not define void myfunc () from class Base. Respuesta 2) 1) El código se compilara pero indicara que la función main no esta definida correctamente. pero cualquier clase que descienda de ella.2 Pregunta 10) ¿Cuáles de las declaraciones siguientes son legales? 1) 2) 3) 4) public protected amethod(int i) public void amethod(int i) public void amethod(void) void public amethod(int i) Respuestas. El mensaje de error utilizando JDK 1. mostrando la cadena “My func” Una clase abstracta puede tener métodos no abstractos. Toma en cuenta que será casi seguro que el examen contenga problemas que te pidan que identifiques palabras claves de Java en una lista. debe implementar todos los métodos abstractos.1. es: Abs. Respuesta 3) 1) public 2) private 4) transient Aunque algunos textos usan la palabra “friendly” cuando tratan el tema de visibilidad. Respuesta 4) 2) El compilador indicara que la clase Base no esta declarada como abstracta.Tutorial para el examen de certificación: SCJP 1.

Si intentas implementar una versión sustituida del método en la clase Fin conseguirás un error en tiempo de compilación. Respuesta 8) 1)Un error en tiempo compilación: la clase Base no puede ser privada. Tu comunidad. particularmente para permitir la independencia de plataforma. 33 . Aunque P2 esta en el mismo directorio que P1. P1 no esta visible para P2. Una clase de un nivel alto. Respuesta 6) 4)Éxito en la compilación y al ejecutarse mostrará en pantalla “amethod”.y por lo tanto no ocurre un error en la ejecución.javaHispano. Respuesta 10) 2)public void amethod(int i) Si pensaste que la opción 3 es legal utilizando como parámetro el argumento void. Este código llama a una versión de amethod de la clase Base. ^ 1 error Respuesta 5) 1) Para conseguir acceder a hardware desconocido por Java 3) Para escribir código optimizado para el mejor desempeño en un lenguaje como C/C++ Aunque la creación de código “PURE JAVA”es altamente conveniente. no puede ser declarada como privada Respuesta 9) 4)P1 se compilará limpiamente pero P2 tendrá un error al compilarse. y hay ocasiones en que se requiere el código nativo. debido a que P1 fue declarado como parte de un paquete. Respuesta 7) 4)Compilación y ejecución sin error. tu lenguaje. debes quitarte un poco de C/C++ de la cabeza. no debe de tomarse como una religión. Esta línea no es una llamada a un método nativo –solo se esta declarando. al igual que una clase base.

Geocities. Otras Fuentes para este tema.com/Athens/Acropolis/3797/Java040.sun.htm Jyothi Krishnan en: http://www.html Controlando el acceso a los miembros de una clase: http://java.html Richard Baldwin Cubre este tema en http://www.geocities.2 La opción 4 no es legal porque el tipo de datos debe aparecer después de cualquier especificador de acceso.sun.com/docs/books/tutorial/reflect/class/getModifiers.Tutorial para el examen de certificación: SCJP 1. Este tema es cubierto en el tutorial de Sun como Modificadores de clases: http://java.com/docs/books/tutorial/java/javaOO/accesscontrol.html#obj2 Bruce Eckel Thinking in Java Chapter 5 (aunque tiene la cabeza llena de C++ e insiste en incluir el modificador “friendly”) 34 .com/SiliconValley/Network/3693/obj_sec1.

35 . declarar el prototipo de ese constructor. Objetivo 3. que se concentra en un aspecto fácilmente pasado por alto en Java ¿Qué es un constructor? Necesitas comprender el concepto de constructor para entender este objetivo.out. el compilador inserta “fuera de escena” un constructor invisible con cero parámetros. En el examen puedes encontar preguntas sobre métodos que tengan el mismo nombre de la clase pero que retornan algún tipo. } } ¿Cuándo proporciona Java el constructor predefinido? Si no defines específicamente algún constructor. } Crowle(){ System. Brevemente.javaHispano. pero lo verdaderamente importante es que solo recibes el constructor predefinido con cero parámetros si no creas algún constructor propio. Tu comunidad. Ten cuidado y asegúrate que cualquier método que asumas que es un constructor no debe retornar algún tipo de dato. tu lenguaje. Los constructores tienen el mismo nombre de a clase y no retornan ningún valor. como int o String. public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(). frecuentemente esto solo es de importancia teórica. determinar si se debe crear un constructor predefinido. Nota de este objetivo Éste es un objetivo pequeño pero oportuno. Aquí hay un ejemplo de una clase con un constructor que muestra "Greetings from Crowle" cuando se crea una instancia de la clase. Para una clase dada. y si ese es el caso. es el código que se ejecuta automáticamente cuando se crea la clase.println("Greetings from Crowle"). Los constructores a menudo se usan para iniciar valores en la clase.

Así. } Base(){} } public class Cons { public static void main(String argv[]){ Base c = new Base(). sin pasarle algún parámetro (invocando la clase con el constructor con cero parámetros).println("single int constructor"). pierdes el constructor predefinido con cero parámetros. Cuando el compilador verifica la creación de la instancia c de la clase Base. En cuanto creas algún constructor propio. Así que tienes que especificarlo. Si intentas crear una instancia de una clase. //Advertencia: no se compilará class Base{ Base(int i){ System.2 Si creas tus propios constructores. crean un constructor con cero parámetros cuando generan el esqueleto de una clase. } } public class Cons { public static void main(String argv[]){ Base c = new Base(). Esto se puede arreglar creando en la clase Base un constructor con cero parámetros que “no haga nada”. } } 36 . obtendrás un error. Esta es una de las razones por las que generadores de código como Borland/Inprise o JBuilder.out.out.Tutorial para el examen de certificación: SCJP 1. } } //Esto si se compilará class Base{ Base(int i){ System. cuando crees algún constructor para una clase necesitarás crear el constructor con cero parámetros. El ejemplo siguiente muestra código que no compilará. el constructor con cero parámetros ya no esta disponible. Debido a que la clase Base tiene un constructor que recibe un entero.println("single int constructor"). Java ya no te proporciona el constructor predefinido con cero parámetros. inserta una llamada al constructor con cero parámetros.

java comenta las líneas que crean la instancia y llaman al método hello. Tu comunidad. sincronizados ni finales. Ejercicio 3) Descomenta las líneas que crean la instancia s1 y modifica el programa para que compile.javaHispano. Ejercicios Ejercicio 1) Crea una clase llamada Salwarpe con un método llamado hello que muestre la cadena “hello”. } 37 . El prototipo del constructor predefinido El objetivo te pide que estes consciente del prototipo del constructor predefinido. abstractos. ejecute y muestre ambos la cadena Hello y el numero 99.out. pero puedes definir un constructor como público o protegido. Ejercicio 2) Usando todavía el archivo Salwarpe. Crea una instancia de la clase llamada s2 proporciónale el valor de 99 al constructor. estáticos. public class Salwarpe { public static void main(String argv[]){ Salwarpe s1 = new Salwarpe(). } public void hello(){ System.println("Hello"). Los constructores no pueden ser nativos. En el método main de la clase crea una instancia de sí misma llamada s1 y llama al método hello desde la instancia.hello(). Compila y ejecuta el programa para que puedas ver el resultado. Solución sugerida para el ejercicio 1. Podrían aconsejarte que tuvieras disponible más de una versión del compilador de Java para verificar tu código y buscar los errores. La predefinición más evidente es no tener ningún especificador de alcance. He oído que el nuevo compilador de Java de IBM tiene un buen informador de errores. tu lenguaje. Naturalmente no debe tener ningún parámetro. Crea un constructor publico para la clase que tome un parámetro entero y muestre el valor del entero. Compila y ejecuta el programa para que puedas ver mostrado el resultado. s1. Parece que la calidad de los mensajes de error están mejorando con las nuevas versiones de Java. Ese pedazo de información se derivó directamente de un mensaje de error del compilador.

2 } Solución sugerida para el ejercicio 2. //s1. s1.out.println(99).out.println("Hello"). Salwarpe s2 = new Salwarpe(99). } public Salwarpe(int i){ System. Una vez que has creado algún constructor para una clase. } public void hello(){ System.hello(). } public void hello(){ System.hello().out. Salwarpe s2 = new Salwarpe(99). public class Salwarpe { public static void main(String argv[]){ Salwarpe s1 = new Salwarpe(). 38 . } } Solución sugerida para el ejercicio 3.out. public class Salwarpe { public static void main(String argv[]){ //Salwarpe s1 = new Salwarpe(). Java ya no te proporciona “tras escena” el constructor con cero parámetros que estaba disponible en el ejercicio 1.println("Hello"). } public Salwarpe(int i){ System.println(99). } public Salwarpe(){} } Observa como fue necesario crear el constructor con cero parámetros para este último ejercicio.Tutorial para el examen de certificación: SCJP 1.

2) this(). Tu comunidad.out.println("Greetings from Crowle"). 3) this(99). Preguntas Pregunta 1) Dada la siguiente definición de clase: class Base{ Base(int i){} } class DefCon extends Base{ DefCon(int i){ //XX } } ¿Cuál se las líneas siguientes será individualmente valida si se sustituye por la línea marcada con //XX? 1) super(). Pregunta 2) Dada la siguiente definición de clase: public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(). tu lenguaje. } } ¿Cuál es el tipo de dato retornado por el constructor? 1) null 2) integer 3) String 4) no es retornado algún tipo de dato Pregunta 3) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? 39 . 4)super(99). } Crowle(){ System.javaHispano.

} void Crowle(){ System. 4)Se compilara y no mostrará nada al ejecutarse.out. 2)El constructor predefinido toma como parámetro un valor tipo void. Pregunta 4) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? class Base{ Base(int i){ System.out.println("Greetings from Crowle"). } } 1)Se compilara y mostrará la cadena “Greetings from Crowle”. 3)Se compilara y mostrará la cadena “void”.2 public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(). } } 1)Se compilará al ejecutarse y mostrará la cadena “Seven”. 3)Se compilará y no mostrará nada al ejecutase 4)Se compilará y mostrará la cadena “Base” Pregunta 5) ¿Cuáles de las siguientes declaraciones son verdaderas? 1)El constructor predefinido retorna un tipo void. 40 . } void Severn(){ System.out. } } class Severn extends Base{ public static void main(String argv[]){ Severn s = new Severn(). 3)El constructor predefinido no toma parámetros.println("Base"). 2)Error en tiempo de compilación: un constructor no puede retornar un tipo de dato. 2)Error en tiempo de compilación.println("Severn").Tutorial para el examen de certificación: SCJP 1.

Por consiguiente. Una llamada a this() es un intento de llamar a un constructor con cero parámetros inexistente en la clase actual. Ocurre un error cuando la clase Severn intenta llamar al constructor con cero parámetros en la clase Base. por consiguiente la clase se compilará y al ejecutarse el método Crowle no se ejecutará – pues no ha sido llamado-. Tu comunidad. 4)El constructor predefinido no se crea si la clase contiene algún constructor propio Respuestas Respuesta 1) 4)super (99) Debido a que la clase Base tiene definido un constructor. Respuesta 5) 3)El constructor predefinido no toma parámetros. el compilador no insertará el constructor predefinido con cero parámetros. Respuesta 4) 2)Error en tiempo de compilación. 4)El constructor predefinido no se crea si la clase contiene algún constructor propio 41 . La llamada a this(99) causará una referencia circular y causará un error en tiempo de compilación. Respuesta 2) 4) no es retornado algún tipo de dato Debe ser bastante obvio de que ningún tipo de dato se retorna. llamar a super() causará un error. así como por definición los constructores no tienen tipos de datos Respuesta 3) 4)Se compilara y no mostrará nada al ejecutarse. Debido a que el método Crowle retorna un tipo de dato no es un constructor. tu lenguaje.javaHispano.

html Richard Baldwin cubre este tema en http://www.geocities.com/Athens/Acropolis/3797/Java042.2 Otras Fuentes de este tema: Esta tema es cubierto en el Tutorial de Sun : http://java.html#obj3 Bruce Eckel Thinking In Java Capítulo 4 42 .sun.com/SiliconValley/Network/3693/obj_sec1.com/docs/books/tutorial/java/javaOO/constructors.htm#default constructor Jyothi Krishnan en: http://www.Tutorial para el examen de certificación: SCJP 1.Geocities.

Es el orden de los parámetros y los tipos de los mismos los que distinguen entre cualquiera de dos versiones de un método sobrecargado a uno en especial. Nota de este objetivo La frase del objetivo parece ser bastante obscura. } public int amethod(int iOver){ System.amethod"). dada las declaraciones de todos lo métodos relacionados con este o con la clase padre. Esto se ve en la: Sección 6: Orientación a Objetos. Tu comunidad. Objetivo 4 Establecer los tipos de datos validos de retorno para cualquier método.javaHispano. } 43 . Parece estar pidiéndote que entiendas la diferencia entre sobrecarga y sobrescritura.out. tu lenguaje. El tipo de dato de retorno no contribuye a la distinción entre métodos. return 0.amethod(iBase). sobrecarga y sobreescritura en tiempo de ejecución Métodos en la misma clase Si dos o más métodos en la misma clase tienen el mismo nombre. int iBase=0. Para aprovechar mejor este objetivo necesitas una comprensión básica sobre la sobrecarga y sobrescritura de métodos. o. se dice que el método esta sobrecargado. } //Las siguientes definiciones generan un error al compilar public void amethod(int iOver){ System.out.println("Over. El código siguiente generará un error en tiempo de compilación. el compilador observa en amethod un intento por definir el mismo método dos veces. Causa un error que dirá algo como lo siguiente: method redefined with different return type: void amethod(int) was int amethod(int) class Same{ public static void main(String argv[]){ Over o = new Over().println("Over int return method"). Puedes tener dos métodos en una clase con el mismo nombre pero deben tener parámetros de diferente tipo y en diferente orden.

por ejemplo para reemplazar su funcionalidad completamente en una subclase. Esto incluye el tipo de dato de retorno. Preguntas Pregunta 1) Dada la siguiente definición de clase: public class Upton{ public static void main(String argv[]){ 44 .2 } El tipo de dato de retorno no contribuye a realizar la distinción entre un método y otro.Tutorial para el examen de certificación: SCJP 1. Todo lo que se requiere es que la nueva versión debe tener parámetros de diferente tipo y en diferente orden. Puedes sobrecargar un método en una subclase. Si vas a sobrescribir un método. la versión sobrescrita del método debe tener la misma definición que la versión de la clase base de la que esta descendiendo. Métodos en una subclase. Si creas un método en una subclase con el mismo nombre y definición pero retorna un tipo de dato distinto. Es decir: method redefined with different return type: void amethod(int) was int amethod(int) El compilador lo ve como un intento fallido por sobrecargar el método en lugar de verlo como una sobrescritura del método. generarás el mismo mensaje de error que en el ejemplo anterior. Los nombres de los parámetros o el tipo de dato retornado por el método no se toman en cuenta para la sobrecarga de métodos.

javaHispano.} Respuestas Respuesta 1) 45 .} 4) public void amethod(void){ System. h.out.out.} 3) public void amethod(){ System.out. } } public class Hay extends Base{ public static void main(String argv[]){ Hay h = new Hay().} 2) public void amethod(long l){ System.out. tu lenguaje.println("Hay").println("Hay").int j){return 99.out.println("Hay"). } } ¿Cuál de los siguientes método puede ser de la clase Hay para que compile y provoque que el programa muestre la cadena “Hay” ? 1) public int amethod(){ System.println("Hay").amethod().println("Base"). } public void amethod(int i){} //Here } ¿Cuáles de las líneas siguientes son válidas para ser colocadas después del comentario //Here? 1) public int amethod(int z){} 2) public int amethod(int i.} 3) protected void amethod(long l){ } 4) private void anothermethod(){} Pregunta 2) Dada la siguiente definición de clase: class Base{ public void amethod(){ System. Tu comunidad.

Respuesta 2) 3) public void amethod(){ System.println("Hay"). int j) {return 99. en Java no hay tal cosa: la utilización de void para indicar que no hay parámetros.} 3) protected void amethod (long l){} 4) private void anothermethod(){} La opción 1 no compilara por dos razones.com/SiliconValley/Network/3693/obj_sec1. El cambio de nombre del parámetro de i a z no tiene efecto y un método no puede ser sobrescrito dentro de la misma clase.Tutorial para el examen de certificación: SCJP 1.out.2 2) public int amethod(int i.} La opción 3 es una sobrescritura del método de la clase Base. Aunque la opción 2 compilará.html#obj4 En esta liga Jyothi sugiere que vayas al objetivo 19: http://www. La otra es que es evidente un intento por redefinir un método dentro de la misma clase. La opción 4 fue diseñada para sorprender a aquellos con una cabeza llena de C/C++. para alguna invocación de esta versión se utilizarán cero parámetros La opción 1 generará un error que indicará que se está intentando redefinir un método con un diferente tipo de dato de retorno.geocities. La primera es que obviamente exige que un entero sea retornado.geocities. Otras Fuentes de este tema: Jyothi Krishnan http://www.html#obj19 46 .y como podemos ver hace falta un return -. la llamada a amethod invocará el método de la clase Base y la salida sea la cadena “Base”.com/SiliconValley/Network/3693/obj_sec6.

las sentencias switch/case tienen unas peculiaridades.println("do something"). se hace esto } Java no tiene la palabra clave "then" como en Visual Basic. Las llaves son un indicador general en Java de una declaración compuesta que permite ejecutar múltiples líneas de código como resultado de alguna evaluación. Tu comunidad. Control de Flujo y Manejo de Excepciones. tu lenguaje. Una idiosincrasia de Java es que la sentencia if debe tomar un valor del tipo boolean. Ls sentencia if/else funciona en Java tal como podrías esperar que funcione en otros lenguajes. Así . Sección 2.javaHispano. Objetivo 1.println("do something"). Escribir código que use sentencias if y switch e identificar los tipos validos de argumentos para estas sentencias. en Java lo siguiente simplemente no compilará: int k =-1. if(k){//no se compilará! System. como en el ejemplo siguiente: if(k == -1){ System. La parte del "else" siempre es opcional.out. } Esto debido a que debes efectuar explícitamente una pregunta sobre la variable k que devuelva un valor tipo boolean. No puedes usar la convención de C/C++ donde cualquier valor distinto de cero es verdadero y 0 es falso. //compilación OK! } Así como en C/C++ puedes no utilizar las llaves: 47 . La sintaxis para la sentencia if/else es: if(condicion tipo_boolean){ //si el boolean es verdadero se hace esto }else { //sino.out. La sentencia if/else. Esto se conoce como bloque de código.

el compilador terminaría su descenso a través de la sentencia switch. short o un int. una sentencia case solo se detiene cuando se encuentran con una sentencia break.println("twenty").println("do something"). y habiéndose encontrado con otra sentencia case.Tutorial para el examen de certificación: SCJP 1. Esto a veces es considerado un mal estilo de programación. } El sentido común nos indicaría que después de ejecutar las instrucciones que siguen la primera sentencia case. char.out. La Sentencia switch La opinión de Peter van der Lindens sobre la sentencia switch se resume cuando dice: "Muerte a la sentencia switch" Este es un asunto al que le debes prestar atención extra. La segunda línea siempre se ejecutará. switch(k){ case 10: System. en el ejemplo anterior las cadenas: "ten" y "twenty" son mostradas. int k=10. por razones mejor conocidas solo por los diseñadores del lenguaje.println("ten"). El argumento de una sentencia switch debe ser un byte. porque si modificas el código después para incluir declaraciones adicionales estas quedarán fuera del bloque condicional (qué solo abarca una línea por no utilizar llaves) Así: if(k) System.out. Puedes encontrar un ejercicio en el examen que use un float o un long como argumento en una sentencia switch. Sin embargo.println("do something"). Como resultado.println("also do this"). System.out. if(k) System. case 20: System. Aquí hay un ejemplo de este tipo de pregunta. Una pregunta bastante común parece estar sobre el uso de la sentencia break en el proceso descendente a través de una sentencia switch. 48 . Otra pequeña peculiaridad que puede surgir en las preguntas es donde colocar la sentencia default.out.out.2 boolean k=true.

println("twenty").out. int k=10. El lugar convencional para la sentencia default está al final de las opciones case. El operador ternario ? 49 . Una vez que se han probado todas las posibilidades. short o un int. tu lenguaje. Así normalmente el código se escribirá como sigue: int k=10. break. } Esta aproximación refleja la manera en que piensa la mayoría de las personas. Sin embargo.println("twenty").out.println("ten").javaHispano. se realiza la sentencia default. switch(k){ default: //Coloca default hasta abajo y no acá System.out. break. break.out. char.println("This is the default output"). switch(k){ case 10: System.out. Como mencioné anteriormente una sentencia if puede tomar solo un valor tipo boolean y una sentencia switch puede tomar solamente un byte. default: System. Tu comunidad. break. pero no aconsejable. case 20: System. case 20: System.out. break. el código de una sentencia switch con la sentencia default hasta arriba es sintácticamente correcto. case 10: System.println("This is the default output"). } Argumentos validos para las sentencias if y switch.println("ten"). La cláusula default no necesita ir al final de una sentencia case.

out. } MyIf(){ boolean b = false.out.println("The value of b was false").Tutorial para el examen de certificación: SCJP 1. public static void main(String argv[]){ MyIf mi = new MyIf(). } } } 1) Error en tiempo de compilación: la variable b no fue inicializada 2) Error en tiempo de compilación: el parámetro para la sentencia if debe evaluar a un boolean 3) Error en tiempo de compilación: no se puede crear y asignar un valor simultáneamente a un boolean 4) Compilación y ejecución mostrando el segundo mensaje. No se menciona específicamente en los objetivos así que por favor háganme saber si aparece en su examen.2 Algunos programadores dicen que el operador ternario es útil. Pregunta 2) ¿Qué pasará cuando intentes compilar y ejecutar este código? public class MyIf{ public static void main(String argv[]){ MyIf mi = new MyIf(). } else{ System. Yo no considero para que. Pregunta 1) ¿Qué pasará cuando intentes compilar y ejecutar el siguiente código? public class MyIf{ boolean b. 50 .println("The value of b was true"). } MyIf(){ if(b){ System.

} public void amethod(){ char k=10. } } } 1) Ninguna de estas opciones 2) Error en tiempo de compilación: el valor para el switch debe ser de tipo entero 3) Se Compilará y ejecutará mostrando "This is the default output" 4) Se Compilará y ejecutará mostrando "ten" 51 . if(b=false){ System. break.println("This is the default output"). case 20: System. tu lenguaje.out.amethod().out.println("ten"). Pregunta 3) ¿Qué pasará cuando intentes compilar y ejecutar este código? public class MySwitch{ public static void main(String argv[]){ MySwitch ms= new MySwitch().out.println("twenty").out. case 10: System. break. } } } 1) Error en tiempo de ejecución: un boolean no puede agregarse con el operador + 2) Error en tiempo de compilación: el parámetro para la sentencia if debe evaluar a un boolean 3) Error en tiempo de compilación: no se puede crear y asignar un valor simultáneamente a un boolean 4) Compilación y ejecución sin salida.javaHispano. Tu comunidad. switch(k){ default: System. ms. break.println("The value of b is"+b).

2 Pregunta 4) ¿Qué pasará cuando intentes compilar y ejecutar el siguiente código? public class MySwitch{ public static void main(String argv[]){ MySwitch ms= new MySwitch().println("twenty"). 52 . case 20: System.out. } public void amethod(){ int k=10. break.amethod(). 2) int i=1. 3) boolean b=false. ms.println("This is the default output"). case 10: System.out.Tutorial para el examen de certificación: SCJP 1. break. not here System. 4) char c='c'. } } } 1) Ninguna de estas opciones 2) Error en tiempo de compilación: el valor para el switch debe ser de tipo entero 3) Se Compilará y ejecutará mostrando "This is the default output" 4) Se Compilará y ejecutará mostrando "ten" Pregunta 5) ¿ De las siguientes líneas.out. switch(k){ default: //Put the default at the bottom. Respuestas Respuesta 1) 4) Compilación y ejecución mostrando el segundo mensaje.println("ten"). cual podría usarse como parámetro para una declaración switch? 1) byte b=1.

Una sentencia if debe evaluar un valor boolean y así la variable b cumple este criterio.javaHispano.out. Respuesta 3) 4) Se Compilará y ejecutará mostrando "ten" Respuesta 4) 1) Ninguna de estas opciones Debido a la falta de una sentencia break después de la línea: System. la salida real será: "ten" seguido de "twenty" Respuesta 5) 53 . tu lenguaje. Si b fuera de cualquier otro tipo de dato hubiera ocurrido un error cuando intentaras realizar una asignación en lugar de una comparación. La expresión: if(b=false) es una asignación y normalmente representa un error del programador. A menudo el programador tenía en mente decir: if (b==false) Si el tipo de dato de b hubiera sido cualquiera menos boolean habría ocurrido un error al compilarse. Respuesta 2) 4) Compilación y ejecución sin salida. El requisito para la sentencia if es que devuelva un boolean y debido a que: if (b=false) devuelve un boolean (false). esto es aceptable (pero inservible). Debido a que la variable boolean b se creó al nivel de clase.println("ten"). Tu comunidad. Debido a que la variable b es un boolean no habrá ningún error causado por la sentencia if. no necesita ser inicializada explícitamente y en cambio toma el valor predefinido de un boolean que es falso.

html Richard Baldwin Cubre este tema en: http://www.geocities.com/SiliconValley/Network/3693/obj_sec2. Una sentencia switch puede tomar únicamente a un byte. Otras Fuentes para este tema: El tutorial de Sun http://java. 2) int i=1.2 1) byte b=1.htm#the if-else statement Jyothi Krishnan en: http://www. char short o a un int como parámetro.html#obj5 54 .com/docs/books/tutorial/java/nutsandbolts/while.com/Athens/Acropolis/3797/Java026.sun.Tutorial para el examen de certificación: SCJP 1. 4) char c='c'.Geocities.

K++){ System.out.} } } } Este código iterara 5 veces en el ciclo interno por cada iteración del ciclo externo.javaHispano. for(int L=0. Escribir código que use todas las formas de ciclos incluyendo el etiquetado y desetiquetado.amethod().println("Outer "+K). el uso de break y continue y conocer los valores tomados por las variables contadoras de los ciclos durante y después de la ejecución de cada ciclo. expresión condicional.println("Inner "+L). La sentencia for El método más común para enciclar es usar la sentencia for. El sentencia for es el equivalente del ciclo for/next en Visual Basic. Así la salida será: Outer Inner Inner Inner Inner inner Outer Inner Inner 0 0 1 2 3 4 1 0 2 Etc. incremento) 55 . tu lenguaje.out. Como en C++ y a diferencia de C. Debes tomar en cuanta que la sintaxis es: for(inicialización. Objetivo 2.L<5. Tu comunidad. etc.L++) {System. Así public class MyLoop{ public static void main(String argv[]){ MyLoop ml = new MyLoop(). la variable que controla el ciclo puede crearse e inicializarse dentro de la sentencia for. ml.K<5. } public void amethod(){ for(int K=0.

} Nota que si la variable i valiera 4 o más cuando se alcanzara la sentencia while no se produciría ningún resultado.2 La expresión condicional debe ser una expresión tipo boolean de una manera similar a la sentencia if.println("Loop value is :"i). Nota que en ninguna de las versiones se termina la línea del for con punto y coma. esta fue seguida por un bloque del código señalado por llaves. Así un while se ejecutará cero o más veces según la condición y el do se ejecutará una o más veces. una vez. } La condición es una expresión tipo boolean parecida al de una sentencia if. System. 56 . de esta manera: for(int i=0. La sintaxis ara el ciclo while es: while(condición){ cuerpodelciclo. Esto puede ser considerado una ventaja por lo que se refiere a mantener el alcance de las variables tan pequeño como sea posible. al menos. Por contraste un ciclo do siempre se ejecutará. En el código ejemplo sobre la sentencia for. el ciclo for solo iterara en esa línea hasta que la condición se cumpla y entonces el programa continuará en "línea recta".out. nada inesperado. De nuevo no puedes usar la convención de C/C++ donde 0 es verdadero y cualquier otro valor es falso. De manera que podrías crear un ciclo while de la siguiente manera: while(i<4){ i++. Si lo haces. No tienes que crear variable de inicialización(como en este caso) dentro del ciclo for. De la misma manera que un sentencia if no exige un bloque de código.i++) System.out. Los ciclos while y do.i<5. Los ciclos while y do funcionan mucho más de lo que esperarías de su equivalente en otros lenguajes.Tutorial para el examen de certificación: SCJP 1.println(i). pero si lo haces significará que la variable saldrá del alcance en cuanto se termine el ciclo. puedes tener una sentencia for que simplemente maneje una línea.

al ejecutar el código.println("i"+i+"\n"). Sin embargo. b. outer://<==Point of this example if(i>2){ break outer. inicialización.println("value of : "+i). prueba e incremento del contador.amethod(). Muchos programadores intentan usar el ciclo for en lugar del ciclo while cuando pueden concentrar en una sola línea la creación. Tienes que indicar que números se mostrarán. public class Br{ public static void main(String argv[]){ Br b = new Br(). Así con el código siguiente siempre conseguirás por lo menos una ejecución del cuerpo del ciclo no importando el valor de la variable i al entrar en el ciclo.out. difícil de mantener.//<==Point of this example 57 . su uso se ha reducido y es considerado como un mal estilo de programación.out. La sentencia goto. } while (i <4).javaHispano. Break y Continue Estas sentencias te permiten interrumpir condicionalmente ciclos. Tu comunidad. antes de que termine el ciclo debido al mecanismo de la sentencia break. Este es un ejemplo de la clase de preguntas irritables que probablemente te encuentres en el examen. tu lenguaje. cual espagueti. do{ System. } public void amethod(){ for(int i=0. Hay situaciones donde sería útil y para ayudar en esas situaciones Java ofrece las versiones etiquetadas y desetiquetadas de las palabras clave break y continue. ¿ciencia o religión? Los diseñadores de Java decidieron que ellos estaban de acuerdo con el gurú de la programación Edsger Dijkstra quien escribió un artículo famoso titulado "Goto considered harmful". no te permiten saltar a otra parte de programa.i <3. Es probable que el examen incluya este tema en la forma de un conjunto de ciclos anidados. Debido a que el uso indistinto de sentencias goto pueden dar como resultado un código.i ++){ System.

Puedes hacer esto etiquetando las sentencias break y continue.2 }//End of if for(int j=0. No puedes saltar a otro ciclo o a otro método pero una vez terminado el ciclo actual es muchas veces muy útil.out.i<2. Por supuesto.Tutorial para el examen de certificación: SCJP 1. } public void amethod(){ outer: for(int i=0. Poniendo el nombre de la etiqueta después del break o continue tu código saltará hasta la etiqueta. j++){ System. j <4 && i<3. Esto es conveniente para hacer condicional una parte de un ciclo. puedes hacer lo mismo con una sentencia if.i++){ for(int j=0.out.amethod(). A propósito el código “\n” (en caso de que aún no lo sepas) significa que se mostrará una línea en blanco.j++){ if(j>1) //prueba con break en lugar de continue continue outer. saltar de un ciclo interno a un ciclo externo dada una condición. Es deseable a menudo.println("j"+j). ml. 58 . Saltar a una Etiqueta. la sentencia continue abandona únicamente el proceso de la iteración activa del ciclo activo Tomando en cuenta el siguiente código: public class LabLoop{ public static void main(String argv[]){ LabLoop ml = new LabLoop(). System. La sentencia break abandona completamente el proceso del ciclo activo.j<3.println("i "+ i + " j "+j). pero una sentencia break es más conveniente. Una etiqueta es simplemente una palabra no reservada seguida de dos puntos. }//End of for }//End of for }//end of Br method } Tienes que elegir que combinación de letras se mostrará con la ejecución del código.

i<5. el contador i se detendría en cero ya que el proceso del ciclo externo se abandonaría en lugar de simplemente continuar al siguiente incremento. Tu comunidad.){ System.javaHispano. Pregunta 1) ¿Que pasará cuando intentes compilar y ejecutar el siguiente código en un método? for(int i=0.out. Pregunta 2) ¿Qué pasará cuando intentes compilar y ejecutar el siguiente código? public class LabLoop{ public static void main(String argv[]){ 59 .out. Error en tiempo de compilación: continue dentro de un for Error en tiempo de ejecución: sentencia continue no alcanzada. Se compilará y se ejecutará mostrando los valores del 0 al 4. } 1) 2) 3) 4) Error en tiempo de compilación. tu lenguaje.println(i). continue. }//fin de amethod } Se mostrará lo siguiente: i 0 j 0 i 0 j 1 i 1 j 0 i 1 j 1 Continuing Si sustituyeras la sentencia continue por break. i++. } }//fin del for externo outer System. sentencia for incorrecta.println("Continuing").

j<3. } public void amethod(){ outer: for(int i=0.out.j++){ if(j>1) break mainmethod.i++){ for(int j=0.amethod().i++){ 60 . ml. 4) i 0 j 0 i 0 j 1 i 1 j 0 i 1 j 1 i 2 j 1 Continuando Pregunta 3) ¿Qué pasará cuando intentes compilar y ejecutar el siguiente código? public void amethod(){ outer: for(int i=0.Tutorial para el examen de certificación: SCJP 1. System.2 LabLoop ml = new LabLoop().println("Continuing"). } }//End of outer for } } 1) i 0 j 0 i 0 j 1 Continuando 2) i 0 j 0 i 0 j 1 i 1 j 0 i 1 j 1 Continuando 3) Error en tiempo de Compilación. mainmethod: System.i<2.out.println("i "+ i + " j "+j).i<2.

out.println("Continuing with i set to ="+i). Tu comunidad.j<2. while(i>0){ System.out. } do{ System. tu lenguaje. } while (i <2).println("Value of i: "+i). 2) i=0 j= 0 i=0 j= 1 i=1 j= 0 3) i=0 i=0 i=1 i=2 j= j= j= j= 0 1 0 0 4) i=0 j= 0 i=0 j= 1 Pregunta 4) ¿Qué pasará cuando intentes compilar y ejecutar el siguiente código? int i=0. } } System. 1) Value of i: 0 Seguido de 0 1 2 2) 0 1 2 61 .println(i).println("i="+i + " j= "+j). if(i >0) break outer.out. for(int j=0.javaHispano.out. } 1)Error en tiempo de compilación.j++){ System.

Otras Fuentes para este tema El tutorial de Sun http://java.com/SiliconValley/Network/3693/obj sec2. Esta es una versión un tanto extraña de la sentencia for.geocities. Respuesta 4) 4)Mostrará una secuencia de 0’s El ciclo while no ejecutará nada en absoluto si la condición no es verdadera en su primera iteración y debido a que no hay ningún incremento de algún valor en el ciclo do se ejecutará infinitamente. Este código no se compilará porque la variable utilizada no existe fuera el ciclo for. la sentencia System.sun.println. causará un error en tiempo de compilación.Tutorial para el examen de certificación: SCJP 1. Respuesta 2) 3) Error en tiempo de Compilación. No puede saltar arbitrariamente a otro método. esto traerían consigo todo los males ya manifestados sobre la sentencia goto.html#obj6 62 . Respuesta 3) 1)Error en tiempo de compilación.com/docs/books/tutorial/java/nutsandbolts/while. Realmente esta no es una pregunta acerca del funcionamiento de break y continue.out.2 3) Value of i: 0 Seguido de una secuencia de 0’s 4) Mostrará una secuencia de 0’s Respuestas Respuesta 1) 4)Se compilará y se ejecutará mostrando los valores del 0 al 4.html Jyothi Krishnan http://www. pero es totalmente valida. Por lo tanto.

earthweb.shtml#Heading131 63 .com/Athens/Acropolis/3797/Java026. Tu comunidad.Geocities. Richard Baldwin http://www.javaHispano.htm#flow of control Bruce Eckel http://codeguru. tu lenguaje.com/java/tij/tij0045.

y Visual Basic soporta la captura de errores con On Error/Goto.println("Continuing"). Comparando con Visual Basic y C/C++ Esto es un poco más riguroso que en Visual Basic o en C/C++ que te permite lanzar "sucia y rápidamente" programas que fingen que están en un mundo donde los errores no 64 . pero el programador aun reconoce que puede ocurrir un error. public class Try{ public static void main(String argv[]){ Try t = new Try(). C++ soporta excepciones pero es de manera opcional. declarar métodos y sobreescribir métodos que lanzen excepciones.go(). }//End of main public void go(){ try{ InputStreamReader isr = new InputStreamReader(System. Las excepciones en Java son construidas como parte del lenguaje. br. Escribir código que haga un uso apropiado de las excepciones y las cláusulas del manejo de excepciones (try. Las sentencias try y catch son parte del manejo de excepciones construido en Java. El compilador sabe que los métodos de I/O pueden causar excepciones y exige código para manejar esas posibles excepciones.out. t. } catch(Exception e){ /*No se hace nada cuando ocurre la excepción*/ } //End of try System.in). BufferedReader br = new BufferedReader(isr). Ni C/C++ " ni Visual Basic tienen un equivalente directo a las excepciones construidas en Java. }//End of go } En este caso no se hace nada cuando ocurre un error.io. Puedes colocar por supuesto un manejador nulo que no haga nada.readLine(). Si quitas las cláusulas try y catch el código simplemente no compilará. Lo siguiente es una pequeña parte del código que he acostumbrado a usar con Borland/Inprise JBuilder para detener temporalmente la salida de la consola y esperar que cualquier tecla sea presionada import java. Por ejemplo si estas realizando instrucciones de Entrada y Salida (I/O) debes manipular excepciones.Tutorial para el examen de certificación: SCJP 1.*.2 Objetivo 3. catch y finally).

javaHispano.in). No te despistes. debes de intentar capturar primero las más especificas y luego las más generales) El siguiente código no se compilará: try{ DataInputStream dis = new DataInputStream(System. La Cláusula finally Una de las rarezas que probablemente te preguntarán en el examen. tu lenguaje. Hemos dicho que. La respuesta mas corta a esto es que la cláusula finally casi siempre se ejecuta. incluso cuando podrías pensar que no se ejecutaría. Así. dis. Tu comunidad. no puedes intentar capturar la excepción Exception. El examen tiende a no intentar sorprenderte con esta excepción a la regla. la cláusula finally casi siempre se ejecutará. ocurren.exit(0). antes de intentar capturar la excepción IOException que es más específica.(NT: en otras palabras. La cláusula try/catch debe capturar los errores en el orden natural de su jerarquía. es bajo qué circunstancias se ejecuta la cláusula finally de un bloque try/catch. la cláusula finally de un bloque try/catch siempre se ejecutará. las excepciones sólo te animan persuasivamente a "hacer las cosas correctamente". aun cuando haya cualquier sentencia de retorno en la parte try/catch Uno de las pocas ocasiones donde la cláusula finally no se ejecutará es si hay una llamada a: System.read(). la trayectoria de ejecución de las sentencias try/catch/finally es algo con lo que realmente necesitas jugar para convencerte de lo qué es lo que pasa bajo qué circunstancias. El examen es más propenso a dar ejemplos que incluyan declaraciones de retorno para engañarte y hacerte pensar que el código retornará sin ejecutar la sentencia finally. }catch (Exception ioe) { }catch (IOException e) { //error en tiempo de compilación }finally{} 65 . que es mas general. No es exactamente una programación esclavizada y disciplinada.

Un método sobrescrito en una subclase también puede lanzar excepciones. si un método tiene exactamente el mismo nombre y argumentos puede lanzar únicamente excepciones declaradas en la clase padre. Esto es sólo valido para métodos sobrescritos y no para métodos sobrecargados. recuerda que esto sólo se aplica a los métodos sobrescritos. De nuevo.2 Este código generará un mensaje de error en tiempo de compilación: IOException nunca se alcanzará.io. Sobrescribiendo métodos que lanzan excepciones Un método sobrescrito en una subclase solo puede lanzar excepciones declaradas en la clase padre o excepciones que sean hijas de las excepciones declarados en la clase padre. la excepción que se intenta lanzar no esta //en la versión del método amethod en la clase Padre(Base) public static void amethod()throws IOException{} } Si fuera el método de la clase padre el que estuviera lanzando a IOException y el método en la clase hijo el que estuviera lanzando a FileNotFoundException el código si compilaría(NT: debido a que FileNotFoundException es subclase de IOException).*.Tutorial para el examen de certificación: SCJP 1. No obstante puede lanzar ninguna o pocas excepciones. class Base{ public static void amethod()throws FileNotFoundException{} } public class ExcepDemo extends Base{ //No se compilara. Pregunta 1) 66 . o excepciones que son hijos de excepciones de la declaración de la clase padre. Así el ejemplo siguiente no se compilará: import java. no hay ninguna regla similar para los métodos sobrecargados. Así.

} public static void amethod(int i)throws IOException{} 67 . System.javaHispano. System.in).*. din. } public static void amethod(){} protected ExcepDemo(){ try{ DataInputStream din = new DataInputStream(System. 4)Se compilara y se ejecutara mostrando: “Pausing” y “Continuing” después de que una tecla es pulsada. 2)Error en tiempo de compilación causado por que amethod ha declarado excepciones.out. class Base{ public static void amethod()throws FileNotFoundException{} } public class ExcepDemo extends Base{ public static void main(String argv[]){ ExcepDemo e = new ExcepDemo(). Pregunta 2) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? import java. class Base{ public static void amethod()throws FileNotFoundException{} } public class ExcepDemo extends Base{ public static void main(String argv[]){ ExcepDemo e = new ExcepDemo(). ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? import java.amethod().out.println("Pausing").println("Continuing").*. 3)Error al ejecutar: amethod no ha declarado excepciones.io. Tu comunidad.readChar(). this. }catch(IOException ioe) {} } } 1)Error en tiempo de compilación causado por el constructor protegido. tu lenguaje.io.

println("Pausing"). 2)Error en tiempo de compilación: amethod ha declarado excepciones que no están en la versión de la clase base. } 68 . System.println("Pausing"). System. System.io. din.out. }catch(IOException ioe) {} } } 1)Error en tiempo de compilación causado por el constructor privado.out. return true.readChar(). 4)Se compilara y se ejecutara mostrando: “Pausing” y “Continuing” después de que una tecla es pulsada.out.println("Continuing").println("finally").readChar().out.*.in). this.in). class Base{ public static void amethod()throws FileNotFoundException{} } public class ExcepDemo extends Base{ public static void main(String argv[]){ ExcepDemo e = new ExcepDemo(). }catch(IOException ioe) { }finally{ System.amethod(). Pregunta 3) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? import java.println("Continuing").out. 3)Error al ejecutar: amethod ha declarado excepciones que no están en la versión de la clase base. din. } public static void amethod(int i)throws IOException{} private boolean ExcepDemo(){ try{ DataInputStream din = new DataInputStream(System.amethod(). System.2 private ExcepDemo(){ try{ DataInputStream din = new DataInputStream(System.Tutorial para el examen de certificación: SCJP 1. this.

System.in). class Base{ public static void amethod()throws FileNotFoundException{} } public class ExcepDemo extends Base{ public static void main(String argv[]){ ExcepDemo e = new ExcepDemo(). din. } return false.out. } } 69 . 4)Se compilara y se ejecutara mostrando: “Pausing” y “Continuing” después de que una tecla es pulsada.readChar().javaHispano.out. Pregunta 4) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? import java. } public boolean amethod(int i){ try{ DataInputStream din = new DataInputStream(System. return false.amethod(). “Continuing” y “Finally” 3)Error al ejecutar: amethod ha declarado excepciones que no están en la versión de la clase base.println("Continuing"). tu lenguaje. } ExcepDemo(){ amethod(99).*. System.println("Pausing"). }catch(IOException ioe) { }finally{ System. } } 1)Se compilara y se ejecutara sin mostrar algo. Tu comunidad. return true. 2)Mostrando: “Pausing”.out.println("Doing finally"). this.io.

Observa que lo que antes era un constructor ahora tiene un valor del retorno.geocities. Esto lo convierte en un método ordinario y por lo tanto no se llama cuando se crea una instancia de la clase.“Continuing” y “Doing finally” La cláusula finally siempre se ejecuta Otras Fuentes para este tema Este tema es cubierto en el Tutorial de SUN http://java.html Richard Baldwin cubre este tema en: http://www.com/Athens/Acropolis/3797/Java030. se ejecuta y muestra “Pausing” .“Continuing” y “Doing finally” 4)Error en tiempo de compilación. Respuesta 4) 3) Se compila. Respuesta 2) 4)Se compilara y se ejecutara mostrando: “Pausing” y “Continuing” después de que una tecla es pulsada. aquí me he salido un poco fuera del tema.Tutorial para el examen de certificación: SCJP 1. la cláusula finally nunca se alcanza. Un método sobrescrito en una subclase no debe lanzar Excepciones no lanzadas en la clase base.com/docs/books/tutorial/essential/exceptions/definition. se ejecuta y muestra “Pausing” y “Continuing” 3) Se compila. Respuestas Respuesta 1) 4)Se compilara y se ejecutara mostrando: “Pausing” y “Continuing” después de que una tecla es pulsada.2 1)Error en tiempo de compilación: amethod no lanza FileNotFounfException 2)Se compila. En el caso del método amethod este no lanza ninguna excepción y en consecuencia compilará. No hay razón alguna por la que un constructor no pueda protegerse. En este versión amethod se ha sobrecargado de manera que no hay ninguna restricción sobre qué excepciones pueden o no ser lanzadas. se ejecuta y muestra “Pausing” .sun.htm 70 . Respuesta 3) 1)Se compilara y se ejecutara sin mostrar algo. OK. así sin alguna indicación.

geocities. tu lenguaje. Tu comunidad.html#obj7 Bruce Eckel Thinking in Java Capítulo 9) 71 .htm Jyothi Krishnan en http://www.javaHispano.geocities.com/Athens/Acropolis/3797/Java056. y http://www.com/SiliconValley/Network/3693/obj_sec2.

Incluso la expresión recolección de basura es un poco rara. Java libera automáticamente las referencias que no se están utilizando. no necesita saber cómo asignar ó cómo saber el tamaño de un tipo de datos para asegurar la compatibilidad de la plataforma. Como resultado de esto. si escribes código que genere números muy grandes de objetos o de variables te puede ser útil saber cuando se liberan las referencias. En alguna parte. Ésta es una de las razones por las que algunas versiones de aplicaciones de Microsoft como Word o Excel. el rastro la asignación y desasignación de la memoria. Una de las grandes cualidades aclamadas de Java es que no tienes que preocuparte por la recolección de basura. de forma manual. Java y el recolector de basura. Recolector de basura –Garbage CollectorObjetivo 1. y que simplemente está desordenando espacio útil.Tutorial para el examen de certificación: SCJP 1. no cuide este detalle. A diferencia de C/C++. un programador asignó un bloque de memoria pero se le olvido asegurarse de liberarla. Cuando ya no se necesita una parte de la memoria asignada ésta puede considerarse como basura.2 Sección 3. finalmente hacen que el sistema entero se cuelgue y que te veas en la necesidad de pulsar ese gran interruptor luminoso. 72 . En este contexto significa la liberación de memoria que se ha asignado y que ya ha sido usada por el programa. Las fugas de memoria a la larga. por si mismo. En C/C++ el programador tiene que seguir. No tienes que pasar por el trauma de buscar asignaciones de memoria que nunca son liberadas y por consiguiente. se detienen apenas comienzan a ejecutarse. las "fugas de memoria" son una gran fuente de errores difíciles de rastrear. es decir algo que ya no se necesita. Esto no estaba en el folleto del SUN cuando lanzaron Java. Si lees algún newsgroups verás a personas informando en ocasiones de ciertas aplicaciones Java que agotan los recursos y hacen que todo se caiga. en esos centenares de miles de líneas de código en C++. Exponer el comportamiento que se garantiza por el sistema de recolección de basura y escribir código que explícitamente haga objetos elegibles para la recolección. Si vienes de programar con Visual Basic puede parecerte absurdo que algún sistema. Por ejemplo. ¿Por qué querrías utilizar el recolector de basura? Puedes ser un programador de Java muy experimentado y nunca haber tenido que familiarizarte con los detalles del recolector de basura. una es aprobar el examen y la otra es comprender lo que ocurre en circunstancias extremas. Así qué ¿Por qué querrías conocer mas los detalles del recolector de basura? Dos respuestas saltan a mi mente.

puedes sugerir o animar que la JVM realice la recolección de basura. Una vez que una variable no es referenciada en mucho tiempo está disponible para ser recolectada por el recolector de basura. tu lenguaje. pero no la puedes forzar. Cada vez que el método vuelve a estar en el alcance del programa las variables locales se vuelven a crear. Puedes sugerir la ejecución del recolector de basura con el método System. Siguiendo la filosofía de la recolección de basura automática. pero esto no garantiza que se ejecutará inmediatamente. Tu comunidad. Sin embargo si tienes recursos externos como un archivo de información. no puedes forzar la ejecución de la recolección de basura. Las variables locales en los métodos pierden su alcance cuando el método que las ocupa termina. } Debido a esto solo tienes que aprender las reglas. Escribir ejercicios o practicar con el recolector de basura es un poco complejo ya que no hay manera de conseguir código que indique cuando está disponible para la recolección de basura. No puedes escribir un fragmento de código con una sintaxis como la siguiente: if(EligibleForGC(Object){ //código no real System. puedes usar la finalización para liberarlos.javaHispano. sólo puedes sugerirla.out("Ready for Garbage"). Permíteme remarcar el punto. 73 . La diferencia es qué en Java los recursos internos no necesitan ser liberados durante la finalización porque el recolector de basura cuida la asignación de memoria.gc(). A primera vista el termino finalización me suena un poco como a los destructores en C++ usados para limpiar los recursos antes de que se destruya un objeto. A partir de ese momento esos métodos son elegibles para el recolector de basura.

2) System.free(). int j=2. } public void amethod(){ i=0. public static void main(String argv[]){ Rub r = new Rub(). int k=3.amethod().setGarbageCollection(). Pregunta 2) ¿Qué código puedes escribir para asegurarte que las variables tipo int son recolectadas en un punto particular en este código? public class Rub{ int i=1. j=0. } } 1) System.gc(). Respuesta 2) 4) Ninguno de los anteriores. 74 . 3) System.Tutorial para el examen de certificación: SCJP 1.gc(). 3) Fijar el valor de cada variable int a null.free().2 Pregunta 1) ¿Cual de las siguientes líneas tiene la sintaxis correcta para sugerir que la JVM ejecute la recolección de basura? 1) System. 2) System.gc(). 4) Ninguno de los anteriores. k=0. Respuestas Respuesta 1) 4) System. 4) System. r.gc().out.

tu lenguaje. por consiguiente no puedes estar seguro que se ejecutará en algún punto en particular de tu código.geocities.html#obj8 75 . Únicamente puedes sugerir la ejecución del recolector de basura. Otras Fuentes para este tema Jyothi Krishnan en http://www.com/SiliconValley/Network/3693/obj_sec3.javaHispano. Tu comunidad.

Si pones una declaración de un paquete en un archivo éste será sólo visible a otras clases en el mismo paquete.*.awt. conocer la sentencia import. La sentencia package La palabra package implica una colección de clases. un paquete es un poco semejante a un directorio. declaración de métodos (incluyendo el método main que se usa para comenzar la ejecución de una clase).MyPack.2 Sección 4. La sentencia package puede incluir la anotación punto para indicar la jerarquía del paquete. //Error: colocar una sentencia import antes de la declaración //del paquete causará un error al compilar. Parece estar pidiéndote que entiendas donde.Tutorial para el examen de certificación: SCJP 1. Fundamentos del lenguaje.lang. ésta debe ponerse antes de cualquier otra declaración aparte de los comentarios. 76 . Objetivo 1. Puedes poner un comentario antes de la declaración del paquete pero nada más. //Puedes colocar un comentario antes de la sentencia package package MyPack. algo parecido a una librería. En el uso. Identificar las declaraciones correctas para la construcción de paquetes. public class MyPack{} Si un archivo fuente tiene una sentencia package. Nota sobre este objetivo La frase de este objetivo es un poco extraña.Runnable u otra interfase descrita en el examen). las declaraciones de variables e identificadores. Así el siguiente código compilará sin el error: package myprogs. donde debes colocar la declaración de una interface y las declaraciones de las variables. conocer la declaración e implementación de interfaces (por ejemplo java. Puedes encontrar preguntas del examen en donde pongan una sentencia import antes de la declaración del paquete. public class MyPack{} Lo siguiente causará un error: import java. package MyPack. la declaración de clases (todas las formas para incluir clases internas). cómo y por qué puedes usar la sentencia import y package.

ni después de la declaración de la clase o en cualquier otra lugar. pero para ello requieres haber puesto al inicio del archivo fuente la siguiente línea: import java. tu lenguaje.Button normalmente se le referencia simplemente como Button. Toma en cuenta que aún usando la declaración completa de la clase no se afecta el desempeño ni se cambia el tamaño del archivo . public class MyPack{} Recuerda que si no pones una sentencia package al inicio del archivo fuente. Si intentas crear un archivo con más de una clase pública el compilador te indicará un error específico.awt.javaHispano. Clases y la declaración de clases internas Un archivo puede tener únicamente una clase con modificador public. La sentencia import La sentencia import debe ir después de cualquier sentencia package y antes de cualquier otra línea de código. Las clases internas se introdujeron con el JDK 1. Un ejemplo de esto es que a la clase java. Un archivo puede contener múltiples clases no públicas. Esto tiene algunos efectos interesantes.class separados por cada clase.class con los nombres: 77 . La sentencia import no puede ir dentro de las clases. para que ésta pueda ser definida dentro de un método y para la creación de clases internas anónimas. Tu comunidad.*. Lo siguiente es un ejemplo sencillo de una clase interna: class Outer{ class inner{} } Esto produce la generación de archivos . se considerará que éste forma parte del paquete predefinido que corresponde al directorio actual. particularmente en la visibilidad.1 La idea es permitir la definición de una clase dentro de otra.class generado. La sentencia import te permite usar una clase directamente con su nombre en lugar de especificarla totalmente incluyendo el nombre completo del paquete al que pertenece. pero ten presente que esto generara distintos archivos .awt.

en ese contexto la clase inner no existe. } public class Inner{} } Pero que pasa si el contexto de la instancia Outer no existe. puedes usar la palabra clave new como un método que pertenece a una clase exterior. class Outer{ public class Inner{} } 78 . Así. Así el siguiente código causará un error cuando se compile: class Outer{ class Inner{} } class Another{ public void amethod(){ Inner i = new Inner(). Ésta sólo puede existir en el contexto de una instancia de la clase Outer. Podrías cambiar la línea que crea la instancia por lo siguiente: Inner i = this. Así. ya que.2 Outer.class Outer$Inner. class Outer{ public void mymethod(){ Inner i = new Inner(). el siguiente código se compilará sin problemas ya que sé esta instanciando la clase Inner dentro del ámbito de la clase Outer. pensemos como podemos lograr el efecto anterior utilizando la palabra clave this. si necesitas crear una instancia de la clase Inner en un método estático o en alguna otra parte donde no tenga ámbito el objeto. } } De modo que la clase Another no se podría crear.new Inner(). Para entender mejor como conseguir lo anterior.class La definición de la clase interna es sólo visible dentro del contexto de la existente clase Exterior.Tutorial para el examen de certificación: SCJP 1.

no importa cuántas instancias se creen de la clase externa.javaHispano. } } A pesar de mis locas explicaciones. ésta tiene algunos efectos interesantes con la manera en que se tienen acceso a los campos o miembros de la clase que la contiene.Inner i = new Outer(). Por supuesto.new Inner(). Puedes acceder a una clase interna utilizando el siguiente código: Outer. Aquí hay un ejemplo de dicho código generado automáticamente: 79 .Inner i = new Outer(). Haciendo estática una clase interna. El efecto de hacer estáticos los recursos se refleja en que sólo hay una instancia de cualquier variable. tu lenguaje. los métodos de una clase interna estática pueden acceder a cualquier campo o miembro estático de la clase que lo contiene pero siempre será únicamente a una sola instancia de cualquiera de esos campos. una clase interna puede ser privada o estática. encuentro poco intuitiva esta sintaxis y hasta yo me olvido de ella cinco minutos después de aprendérmela.new Inner(). y así una clase interna estática no puede acceder variables de instancia de la clase que la contiene. class another{ public void amethod(){ Outer. Clases internas declaradas dentro de métodos Las clases internas se pueden crear dentro de los métodos. En esta situación ¿Cómo puede la clase interna estática saber qué variables puede acceder de su clase externa no estática?. así que préstale bastante atención. Esto es algo que las herramientas de desarrollo de aplicaciones como JBuilder de Borland hacen constantemente cuando generan un manejador de Eventos. Uno de los beneficios de las clases internas es que una clase interna generalmente consigue acceso a los campos la clase que lo contiene(o una externa) Al contrario de una clase externa. Es muy probable que encuentres preguntas referentes a esto en el examen. Por supuesto la respuesta es que no lo puede saber. Tu comunidad. Los examinadores pueden hacer preguntas molestas como "¿Puede una clase interna ser estática o privada?".

awt. es decir.addMouseListener(new java. Los Campos o miembros definidos dentro de una clase creada dentro de un método duran mas que el método que la contiene. es fácil confundirte por el número de niveles de las llaves y paréntesis. Una clase definida dentro de un método solo puede acceder a campos con el modificador final del método que la contiene Debido que una variable con modificador final no puede ser cambiada por la JVM puedes estar seguro que el valor permanecerá constante aun después de que el método exterior ha dejado de ejecutarse. Observa cómo la estructura completa finaliza con punto y coma. Míralo de esa manera. Este límite peculiar no parece ser tomado en cuenta en el examen. Esta clase normalmente podría definirse con un nombre que podría hacerla más fácil de leer. Fíjate en la palabra clave new que se encuentra justo después del primer paréntesis.MouseAdapter() { public void mouseClicked(MouseEvent e) { buttonControl1_mouseClicked(e). Es muy probable que encuentres preguntas referentes a esto en el examen. ya que es realmente ahí en donde finaliza la llamada al método. 80 . incluso preguntas que cuestionen el estado de las variables pasadas como parámetros al método. Una clase anónima puede heredar otra clase o implementar una única interface. sólo existen mientras el método se está ejecutando. Esto se debe a que las variables definidas dentro de un método normalmente se consideran variables automáticas. Visibilidad de campos para clases definidas dentro de un método Una clase definida dentro de un método puede acceder sólo a campos o miembros del método que la contiene si éstos se han definido con el modificador final. ¡Upss! Nosotros estamos hablando de clases sin nombres. Si creas tal código de manera manual. } }). darle un nombre no ayuda mucho.Tutorial para el examen de certificación: SCJP 1. pero cuando ese fragmento de código no se utiliza para algún otro proceso en cualquier otra parte. Esta indica que una clase interna anónima(sin nombre) está definiéndose dentro del método addMouseListener. un constructor es un método sin valor de retorno y con el mismo nombre de la clase. Como podrías suponer una clase anónima no puede tener un constructor.event.2 buttonControl1.

Tu comunidad. public static void main(String argv[]){ FinAc a = new FinAc(). c. a.mymethod(i). Creando una interface Las interfaces son la manera en que Java maneja la ausencia de la herencia múltiple. private int k=2. tu lenguaje. 81 .Well{ public } Pregunta 1) Dado el siguiente código: public class FinAc{ static int l = 4. una clase puede declararse de la siguiente manera: class Malvern implements Hill. Una interface se utiliza a través de la palabra clave implements.amethod(). Así.javaHispano. } public void amethod(){ final int i = 99. int j = 6. Curiosamente Visual Basic tiene la palabra reservada interface y maneja el concepto de manera similar a Java. El tema de las interfaces es conocido en ocasiones como programación por contacto. class CInMet{ public void mymethod(int q){ //Here }//fin de mymethod }//fin de CInMet CInMet c = new CInMet().

awt.Tutorial para el examen de certificación: SCJP 1. class Base().*.awt. 3) //Another comment package myprogs. public class MyPack{} 4) class Base{} import java.MyPack.2 }//fin de amthod } ¿Cuales de las siguientes variables son visibles en la línea marcada con el comentario //Here? 1)l 2)k 3)i 4)j Pregunta 2) ¿Cuales de los siguientes fragmentos de código compilarán correctamente? 1) //A Comment import java.*.*. public class Tiny{} Pregunta 3) ¿Cuales de las siguientes afirmaciones son verdaderas? 1)Una clase interna puede definirse como estática 2)Una clase interna no puede ser defina como privada 3)Una clase anónima puede tener sólo un constructor 4)Una clase interna puede heredar otra clase 82 . class Base{}.awt. package Spot. 2) import java.

incluyendo campos privados.new new Inner().javaHispano. Las clases internas pueden definirse como privadas.Inner i = new Outer().Inner().new(). 3) //Another comment package myprogs. class Base{}. 4)Outer i = Outer. Respuesta 3) 1)Una clase interna puede definirse como estática 4)Una clase interna puede heredar otra clase Las clases anónimas no pueden tener un constructor. Respuestas Respuesta 1) 1) l 2) k 3) i Una clase definida dentro de un método solo puede ver campos con el modificador final desde el método que la contiene. Pregunta 4) Desde código que no tenga activa la referencia this. El campo j no se definió como final.Inner i = Outer(). Respuesta 2) 1) //A Comment import java.MyPack. public class MyPack{} La declaración de un paquete debe ser la primera línea de código en un archivo (aparte de los comentarios). Sin embargo.new Inner(). Tu comunidad. 2)Sin una referencia this una clase interna no puede ser creada 3)Outer. Respuesta 4) 83 .awt. también puede ver los campos de la clase que contiene al método que la contiene a ella. ¿Como puedes crear una instancia de una clase interna? 1)Outer. Una declaración import debe estar después de cualquier declaración de un paquete y antes de cualquier otra línea de código.*. tu lenguaje.

htm y también http://www.Tutorial para el examen de certificación: SCJP 1.gsfc.html Richard Baldwin http://www.sun.com/Athens/7077/Java094.htm Jyothi Krishnan http://www.com/docs/books/tutorial/java/more/nested.com/Athens/7077/Java095.com/docs/books/jls/html/9.Geocities.doc.Geocities.com/SiliconValley/Network/3693/obj_sec4.Inner i = new Outer().html#238680 84 .html Especificaciones sobre interfaces en Java http://java.new Inner().geocities.html#obj9 Un Tutorial sobre paquetes http://v2ma09.sun.nasa.gov/JavaPackages.2 1)Outer. Otras Fuentes para este tema: El Tutorial de SUN http://java.

Veamos el siguiente código: public class MyParm{ public static void main(String argv[]){ String s1 = argv[1]. Declarar la correspondencia entre los valores del arreglo pasado como argumento al método main y los argumentos de la línea de comandos. los arreglos siempre empezarán desde el elemento cero. System. y no hello o MyParm Pregunta 1) 85 . Objetivo 2. en consecuencia. } } He asignado el argumento 1 a un String sólo para resaltar que argv es un arreglo de String's.out.println(s1). Tu comunidad. Java no contiene una opción equivalente a Option Base de Visual Basic y. Si ejecutas este programa de la manera siguiente: java MyParm hello there Se mostrará there. Nota: Este tema por sí solo difícilmente amerita ser tomado como un objetivo. Si vienes de programar en C/C++ podrías esperar que el contenido fuera "java".javaHispano. tu lenguaje. Así si un programa se ejecutara como sigue: java myprog myparm El elemento argv[0] contendría "myparm". Este objetivo puede sorprender al programador más experimentado en C/C++ ya que el primer elemento del arreglo argv[] es la primera cadena después del nombre del programa en la línea de comandos.

getParms() 2) asignando un elemento del argumento a un String 3) asignando un elemento del argumento a un arreglo de caracteres 4) ninguna de estas opciones Respuestas Respuesta 1) 3) one Respuesta 2) 2) asignando un elemento del argumento a un String Otras Fuentes para este tema: Este tema es cubierto en el tutorial de SUN en: http://java. } y una llamada desde la línea de comandos como la siguiente: java Cycle one two ¿Cuál será la salida? 1) Ninguna de estas opciones 2) Cycle 3) one 4) two Pregunta 1) ¿Cómo puedes recuperar los valores pasados desde la línea comandos al método main? 1) usando el método System.html 86 .sun.out.com/docs/books/tutorial/essential/attributes/cmdLineArgs.println(bicycle[0]).Tutorial para el examen de certificación: SCJP 1.2 Dado el siguiente método main en una clase llamada cycle: public static void main(String bicycle[]){ System.

Observa que todas las palabras reservadas están en minúsculas. particularmente C/C++. pero no en Java. El examen pone énfasis especial en el reconocimiento de las palabras reservadas. la cual es palabra reservada en C++. Hay un debate acerca de que si null es una palabra reservada. 87 . Tu comunidad. así for es una palabra reservada pero FOR no la es. Reconocerás la mayoría de la palabras reservadas de Java conforme uses el lenguaje. pero sugiero que para los propósitos del examen asumas que si la es. π NT: El autor utiliza esa expresión para referirse a la confusión que en ocasiones produce la palabra friend. Ejemplos de las palabras reservadas más raramente utilizadas (indudablemente para un principiante) son: • • • volatile transient native Palabras reservadas abstract char double for int package static throws boolean class else goto * interface private super transient break const * extends if long protected switch try byte continue final implements native public void case default finally import new return volatile catch do float instanceof null short throw while synchronized this Las palabras con asteriscos son reservadas y actualmente no son utilizadas. Identificar todas las palabras reservadas del lenguaje.javaHispano. Nota en este objetivo: Puedes asimilar fácilmente este objetivo en base a aprender las palabras reservadas frecuentemente menos utilizadas y asegurándote no tomar en cuenta a "falsos friendsπ" de otros lenguajes que puedes llegar a saber. Objetivo 3. y las palabras reservadas que podrían venir en el examen. pero en el uso personal del lenguaje raramente utilizamos las excepciones. tu lenguaje.

2 Pregunta 1) ¿Cuáles de las siguientes son palabras reservadas de Java? 1) double 2) Switch 3) then 4) instanceof Pregunta 2) ¿Cuáles de las siguientes no son palabras reservadas de Java? 1)volatile 2)sizeOf 3)goto 4)try Respuestas Respuesta 1) 1) double 4) instanceof Nota que la letra mayúscula S en switch hace que ésta no sea una palabra reservada y la palabra then es parte de Visual Basic pero no de Java.Tutorial para el examen de certificación: SCJP 1. Respuesta 2) 2)sizeOf 88 .

Otras Fuentes para este tema Michael Thomas http://www.com/java/JCP_Keywords.htm 89 . Esta es una palabra reservada en C/C++ para determinar el tamaño de un dato primitivo para una plataforma en particular. Tu comunidad. Debido a que los datos primitivos tienen el mismo tamaño en todas las plataformas en Java ésta palabra reservada no se necesita. tu lenguaje.michael-thomas.javaHispano.

j=p. int j = 10. para un boolean es false y una referencia a un objeto es el único tipo de datos que tiene como valor predefinido null. El valor predefinido para los tipos de datos numéricos es cero. Si intentas acceder a una variable sin asignar generarás un error. pero éste representa conocimiento valioso para el mundo real.println(j). Si p se hubiera definido al nivel de clase se le habría asignado su valor predefinido y no se habría generado algún error. así el código anterior mostrará 0.2 Objetivo 4.out. } } Este código producirá el siguiente error: "error variable p might not have been assigned" Esto puede verse como un cambio bienvenido de la tendencia de C/C++ de darle bastante cuerda a una variable sin asignar dejando un valor arbitrario en p. Esencialmente a una variable de nivel de clase siempre se le asignará un valor predefinido y a una variable miembro (una variable contenida dentro de un método) no se le asignará un valor predefinido.Tutorial para el examen de certificación: SCJP 1. Variables Podrías aprender a programar en Java sin realmente entender la importancia que representa este objetivo. System. Conocer el efecto de usar una variable o un elemento de un arreglo de cualquier tipo cuando no se le ha hecho alguna asignación explicita. } } El valor predefinido para un entero es 0. 90 . j=p. class MyClass{ static int p. public static void main(String argv[]){ int j = 10. Por ejemplo: class MyClass{ public static void main(String argv[]){ int p.

Tu comunidad. El valor de los elementos de un arreglo de cualquier tipo base siempre se inicializará con un valor predefinido. ¿Qué contendrá el elemento b[5]? public class MyVal{ public static void main(String argv[]){ MyVal m = new MyVal(). estos siempre son fijados para contener sus valores predefinidos. } } 1) 0 2) null 91 . dondequiera que se defina el arreglo. Arreglos Aprender esta parte del objetivo requiere comprender una sencilla regla. No importa si el arreglo se define a nivel de clase o método.amethod(). a los valores del arreglo siempre se le pondrán sus valores predefinidos. A menos que el arreglo sea de objetos. m.javaHispano. Una pregunta que puedes hacerte es ¿Qué contendrá un elemento en particular de un arreglo sin asignar?. la respuesta será distinta de null. donde quiera que sean creados. } public void amethod(){ boolean b[] = new boolean[5]. Pregunta 1) Dado el siguiente código. Antes de la inicialización de los arreglos. tu lenguaje.

2 3) "" 4) Ninguna de estas opciones Pregunta 2) Dado el siguiente código. System.println(i).Tutorial para el examen de certificación: SCJP 1. ¿Qué contendrá el elemento 1 del arreglo mycon? MyCon(){ int[] mycon= new int[5]. public static void main(String argv[]){ MyField m = new MyField(). } } 1)Se mostrará 99 2)Se mostrará 0 3)Se generará un error al compilar 4)Se generará un error al ejecutar Pregunta 4) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? public class MyField{ 92 . } 1) 0 2) null 3) "" 4) Ninguna de estas opciones Pregunta 3) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? public class MyField{ int i=99. } void amethod(){ int i. m.out.amethod().

tu lenguaje. por consiguiente. la variable de nivel de clase i es un caso extraño. m. Si intentas ejecutar: System. Respuesta 4) 4)Se mostrará null 93 . } } 1)Error al compilar: s no ha sido inicializada 2)Error al ejecutar: s no ha sido inicializada 3)Salida en blanco 4)Se mostrará null Respuestas Respuesta 1) 4) Ninguna de estas opciones Atención en este punto. Respuesta 2) 1)0 Un constructor actúa de manera parecida a cualquier otro método. String s. Los elementos de un arreglo comienzan a numerarse desde 0. Las variables de nivel de método no obtienen ninguna inicialización por omisión.javaHispano.out. así. no hay un elemento 5. para éste arreglo.out. Tu comunidad. un arreglo de enteros será inicializado conteniendo ceros dondequiera que sea creado. ya que es ensombrecida por su versión en el nivel del método. public static void main(String argv[]){ MyField m = new MyField().amethod(). Respuesta 3) 3)Se generará un error al compilar Generarás un error al compilar el código indicando que la variable i no ha sido inicializada.println(s).println(b[5]) Generarás una excepción. } void amethod(){ System.

println mostrará null.sun.htmll Richard Baldwin cubre el tema en: http://www.geocities.Tutorial para el examen de certificación: SCJP 1.com/SiliconValley/Network/3693/obj_sec4.geocities.out.com/docs/books/tutorial/java/nutsandbolts/vars.2 Una variable creada en el nivel de clase siempre tendrá un valor por omisión.html#obj12 94 .htm#variables Jyothi Krishnan en: http://www. Otras Fuentes para este tema: Este tema es cubierto ligeramente en el Tutorial de SUN en: http://java.com/Athens/Acropolis/3797/Java020. El valor por omisión para una referencia a un objeto es null y el método toString implícitamente llamado con System.

Tu comunidad. Tamaño de los tipos primitivos enteros Cuando este objetivo pide el rango de los tipos de datos primitivos asumo que para representarlo sólo se requiere el número 2 elevado a la potencia apropiada en lugar del número que representa. Como esperabas. en mi experiencia basada en PC. El tamaño de un byte es intuitivo: 8 bits. es un valor decimal. Aquí están las opciones φ NT: Algunos documentos utilizan el termino “sencillos” o “básicos” en lugar de “primitivos”. y no pases por alto el formato octal. En mi mente hay sólo tres tipos enteros a aprender ya que. Objetivo 5. 95 . Puedes escribir una gran cantidad de código Java sin conocer el rango de los tipos primitivos pero familiarizarte con ellos no debe tomarte mucho tiempo. Ten cuidado con este tema para que puedas usar todos los formatos. tu lenguaje. pero bastante fácil. Definir el rango de todos los tipos de datos primitivosφ. objetivos a cubrir.javaHispano. Nota en este objetivo Éste es uno de los ligeramente molestos. conocer las bases numéricas y sus representaciones. declarar valores literales para Strings y todos los tipos primitivos usando todos los formatos permitidos. Rango de los primitivos Enteros Nombre byte short int long Tamaño 8 bit 16 bit 32 bit 64 bit Rango -27 to 2 7-1 -215 to 215-1 -231 to 231-1 -2 63 to 2 63-1 Declarando literales enteros Hay tres maneras de declarar un literal entero. por defecto.

Tamaño de los tipos primitivos de coma flotante Los números de coma flotante son especimenes ligeramente extraños debido a que sus cálculos pueden tener algunos resultados inesperados.println(j). Citando a Peter Van Linden "La precisión exacta depende del número que se representa". } } Roberts y Heller describen 6 maneras de declarar literales enteros. (hasta que Linux alcance la dominación mundial total. observa que no se utilizan las letras de la A a la F para la notación hexadecimal.println(k). System.2 Declarando 18 como un literal entero Decimal Octal Hexadecimal 18 022 (Cero no la letra O) 0x12 Si compilas y ejecutas esta pequeña clase obtendrás en cada ocasión el valor 18. int j = 022. ya que para Java la letra X para la declaración de un hexadecimal extraordinariamente no es sensible a mayúsculas. A mí me es mas más fácil recordar únicamente las tres maneras descritas anteriormente y que las letras no son sensibles a mayúsculas. entonces un entero podrá hacer muy bien ese trabajo).out. Así una variable de tipo double puede almacenar un número como 17 seguido por 307 ceros.//Version Octal: dos veces ocho mas dos int k = 0x12.println(i). System. Como compensación a esta precisión variable logras conseguir casi jugar con números grandes más allá los que puedas imaginar.out. public class Lit{ public static void main(String[] argv){ int i = 18.//Version Hex: una vez dieciséis mas dos System. Un numero que sirve incluso para que puedas almacenar los estados financieros de Bill Gates. Rango de los tipo de coma flotante float double 32 bit 64 bit 96 .Tutorial para el examen de certificación: SCJP 1.out.

Indicando tipos de datos con un literal sufijo Como se mostró anteriormente puedes indicarle a Java que un literal numérico es de un tipo de dato en particular asignándole un literal sufijo. Si tienes experiencia programando con C/C++ presta atención particularmente al tipo boolean y a asegúrate de no traer contigo "falsos friends" de cualquiera de estos lenguajes. Tu comunidad. A un tipo boolean no se le puede asignarse otro valor distinto de true o false. Puedes encontrar preguntas en el examen similares a la siguiente: ¿Se compilará el siguiente código? float i = 1. Desgraciadamente el examen no esta diseñado para probar su intuición.0.0F. al -1 o a algún otro número. Esto causará un error en tiempo de compilación ya que estas intentando asignar un double a un float. tu lenguaje. Puedes arreglar este código de la manera siguiente: float i = 1. Tu intuición debería decirte que esto debe compilarse sin problemas. Estos son los sufijos disponibles: Sufijos para tipos de datos float long double F L D Los tipos boolean y char Los tipos de datos primitivos boolean y char son un poco curiosos. Los valores true o false no corresponden al 0.0. o incluso: float i = (float) 1. Ten presente que el tipo de dato predefinido para un literal con un componente decimal es un double y no un long. Esto es ligeramente confuso puesto que podrías pensar que el tipo predefinido para un número de coma flotante debería ser un float.javaHispano. 97 .

println("This"+c+"Is a space"). System. El tipo char se usa para denotar un carácter Unicode. es mejor que los 255 caracteres que nos proporciona el código ASCII. Nota que son comillas simples ‘ y no comillas dobles “. char c = '\u0020'. y el hecho de que puedas representar caracteres en chino o Vietnamés.println(i). éste será tomado como un carácter alfabético. Así. Esto te permite representar 65K caracteres. el espacio en blanco se representa de la siguiente manera: char c = ‘\u0020’. y no se le puede asignar un número como –1 o 0. no significa que se desplegarán correctamente si tienes un sistema operativo en inglés normal. qué aunque no es una cantidad suficientemente grande para cubrir todas las escrituras del mundo.out. Un literal de tipo char se crea encerrando el carácter con comillas simples: char a = 'z'. } } 98 . con la expresión completa encerrada con comillas simples. La internacionalización es un tema completo por si mismo. System. Si asignas un número sencillo a un char. Unicode es un código alternativo al ASCII que almacena caracteres en 2 bytes en lugar de 1 byte como lo hace el código ASCII.2 Un dato de tipo boolean únicamente puede recibir los valores de true o false. Así que el siguiente código mostrará la letra A(valor 65 del código ASCII) seguido de una espacio en blanco.out. Todo esto es funcional en mi pequeño mundo basado en el Ingles pero como Java es un sistema mundial un char puede contener cualquiera de los caracteres disponible en el sistema Unicode. public class MyChar{ public static void main(String argv[]){ char i = 65. El tipo de dato primitivo char es el único tipo de dato primitivo sin signo. Esto se hace usando cuatro dígitos hexadecimales precedidos por \u.Tutorial para el examen de certificación: SCJP 1.

2) float f=10. Asegúrate de recordar que las literales String son encerradas con comillas dobles mientras que un literal char utiliza comillas simples. Pregunta 3) 99 . Pregunta 2) ¿Cuáles de las siguientes líneas se compilarán correctamente? 1) short myshort=99S. 2) String name='Excellent tutorial Mr Green'. 3) char c=17c. 4) byte b=10b. Tu comunidad. Declarando literales String El tipo String no es un tipo de dato primitivo pero es tan importante que en ciertas áreas Java lo trata como si lo fuera.javaHispano. Así: String name = "James Bond" Pregunta 1) ¿Cuáles de las siguientes líneas se compilarán correctamente? 1) float f=10f. Las literales String son bastante sinceras.1f.1. tu lenguaje. 3) float f=10. Uno de estos rasgos es la habilidad de declarar literales String en lugar de usar new para instanciar una copia de la clase. 4) int z=015.

2) boolean b2=false. esa es la manera correcta de declarar un literal octal. Para la opción 4. y la opción 2 causará un error al compilarse debido a que el tipo de dato por omisión para un número con un componente decimal es double. Quizá sean un poco tramposas estas ultimas opciones.) 100 .2 ¿Cuáles de las siguientes líneas se compilarán correctamente? 1) boolean b=-1. La opción 3 es ligeramente más difícil de detectar como errónea. a un boolean únicamente se le pueden asignar los valores true y false. Respuesta 3) 2) boolean b2=false. Otras Fuentes para este tema: Este tema es cubierto en el Tutorial de SUN en: http://java.Tutorial para el examen de certificación: SCJP 1. No existe una literal b(byte). Respuestas Respuesta 1) 1) float f=10f.html (No encontraras mención alguna sobre las literales. 4) char c=99. Las letras c y s no existen como indicadores literales y un String debe estar encerrado por comillas dobles y no por comillas simples como en el ejemplo. Te debe ser bastante obvio que la opción 1 es errónea. pero no puedes usar el número 9 si estas en base 8 donde tienes números del 0 al 7. Respuesta 2) 4)int z=015. 3) float f=10.com/docs/books/tutorial/java/nutsandbolts/vars.1f. 3)int i=019. 4) char c=99.sun. ya que.

htm#primitive types (nuevamente no encontraras mención alguna sobre las literales.geocities.com/SiliconValley/Network/3693/obj_sec4. Richard Baldwin cubre este tema en: http://www.com/Athens/Acropolis/3797/Java020.html#obj13 Bruce Eckel's Thinking in Java Capítulo 2 "Caso Especial: Tipos primitivos” Capítulo 3 "Literales" 101 . Tu comunidad.javaHispano. tu lenguaje.) Jyothi Krishnan en: http://www.Geocities.

dependiendo de su alcance. Probablemente has escrito bastante código con Java y no has tenido la necesidad de usarlo. pero para propósitos del examen necesitas conocerlo.Tutorial para el examen de certificación: SCJP 1. quizá no le veas mucha utilidad: public class InOf { public static void main(String argv[]){ InOf i = new InOf(). accesibilidad. El siguiente código ilustra un ejemplo de esto: import java. Y efectivamente. desde mi punto de vista debería ser un método en lugar de un operador. a una etiqueta o a cualquier otra cosa. realizar una comparación y una conversión y así llamar al método más apropiado.println("It's an instance of InOf"). if(i instanceof InOf){ System. se usa para preguntar: ¿Es esta_clase instanciade esta_otra_clase? Si lo utilizas en casos triviales como el siguiente. }//End if }//End of main } Como habrás deducido el resultado será: It's an instance of InOf Sin embargo. sobre operandos de cualquier tipo de clase. el cual se refiere a algo que esta más arriba o más abajo en la jerarquía de clases del programa. Este operador retorna un valor booleano como resultado a una prueba sobre un tipo de clase en tiempo de ejecución.out. el operador instanceof se usa para examinar el tipo del objeto. como estas pensando.2 Sección 5. En estas circunstancias. Operadores y Asignaciones Objetivo 1 Determinar el resultado de aplicar cualquier operador. El operador instanceof El operador instanceof es una bestia extraña. pueden surgir situaciones donde únicamente tienes acceso a una referencia de un objeto. incluyendo los operadores de asignación y el operador instanceof.*.awt. 102 . Así puedes tener un método que tome como parámetro un componente que puede referirse a un botón. o de la combinación de estos.

103 .setText("Hello"). Observa que el operador instanceof se aplica a los nombres de las clases no a una referencia de un objeto para una clase. lc.javaHispano. el operador + adiciona 2 números entre si. } }//End of mymethod } Si en tiempo de compilación la examinacion del tipo de la clase y la conversión forzada no fueran realizadas.out. ya que el signo mas(+) se sobrescribe para ofrecer la concatenación de Strings. El operador + es un ejemplo raro de la sobrecarga de operadores en Java. System.setLabel("Hello").out. Tu comunidad. los programadores en C++ están acostumbrados a poder sobrecargar operadores para que estos signifiquen cualquier cosa que ellos definan. Esta facilidad no está disponible para un programador en Java. El operador + Como esperabas. sin embargo esta opción esta disponible para los Strings. Así la siguiente línea de código mostrará 10: int p=5. int q=5. tu lenguaje. bc. System. De esta manera el siguiente código sí se compilará: String s = "One". public class InOfComp { public static void main(String argv[]){ }//End of main public void mymethod(Component c){ if( c instanceof Button){ Button bc = (Button) c. s3 = s+s2. String s2 = "Two" String s3 = "".println(p+q).println(s3). los métodos setLabel y setText no estarían disponibles. }else if (c instanceof Label){ Label lc = (Label) c.

2 El resultado será "OneTwo". Si intentas utilizar sobre un String los operadores división y menos(/. Asignando variables primitivas de tipos diferentes Un booleano única y exclusivamente puede recibir otro valor de tipo booleano. Por ensanchamiento quiero decir que una variable como un byte que ocupa 1 byte (ocho bits) puede asignarse a una variable que ocupa más bits como por ejemplo un int. 104 . siempre y cuando no impliquen exactitud. Bajo ciertas circunstancias Java realiza una llamada implícita el método toString. Lo anterior se aprecia mejor en el siguiente código int p = 10. observa que no hay espacios entre las dos cadenas unidas.Tutorial para el examen de certificación: SCJP 1. s2 = s + p. el resultado será: Two10 Recuerda que para los Strings. Con esta principal excepción en el tipo de datos boolean.-) causaras un error. String s = "Two". int i = 0. únicamente el operador + esta sobrecargado. Este método. String s2 = "". intenta convertir a un String a el objeto que lo llama. como su nombre lo dice. Para un entero con valor 10. la llamada a toString retornara la cadena "10". b = i. Para los programadores C/C++.out. ya que en Java un booleano no es substituible por el numero cero o un valor distinto de cero. Sin embargo si intentas asignar un int a un byte conseguirás un error en tiempo de compilación: byte b= 10. el principio general para entender este objetivo esta en saber que las conversiones por "ensanchamiento" están permitidas en Java.printlns(s2). recuerden que esto significa que a un booleano no se le puede asignar -1 o 0. System.

Cuando asignamos referencias de objetos. } } el resultado es -120 Posiblemente no es un valor que te sea muy útil. Así. Integer k = new Integer(99). el siguiente código no es valido: int j=0. Los datos primitivos pueden ser asignados a tipos de datos mas "anchos". //Asignacion ilegal de un objeto un tipo primitivo. un booleano únicamente puede ser asignado a otro booleano.javaHispano. es que los tipos primitivos son revisados en tiempo de compilación mientras que los objetos son revisados en tiempo de ejecución. Como esperabas. Asignando referencias de objetos de diferentes tipos. Esto se cubrirá mas adelante ya que tiene implicaciones importantes cuando un objeto no esta completamente resuelto en tiempo de compilación. Tu comunidad. Por lo tanto el siguiente código se compilara y ejecutara sin problemas: public class Mc{ public static void main(String argv[]){ byte b=0.println(b). pero no de arriba hacia abajo. tu lenguaje. int i = 5000. Java utiliza la convención de C/C++ encerrando entre paréntesis () el tipo de datos al que se quiere convertir. System. Puedes ver esto de la siguiente manera. b = (byte) i. Por supuesto. Esto a menudo no es aconsejable ya que el resultado perderá precisión. Si tu asignas una instancia de una clase hija a la 105 . otra regla general es que puedes realizar la asignación de abajo hacia arriba en la jerarquía de clases. no puedes asignar datos primitivos a objetos y viceversa. puedes realizar una conversión forzada para hacer que una variable se ajuste a un tipo de datos mas estrecho.out. pero es valido si realmente lo quieres hacer. Una diferencia importante entre la asignación de objetos y la asignación de tipos primitivos. j=k.

Esto debe causar un error indicando que se requiere una conversion forzada para asignar una referencia de Base a ObRef */ } } Operadores de desplazamiento de bits. 16. 8. bienvenido a la programación de bajo nivel. El siguiente ejemplo muestra que ocurre cuando fuerzas la asignación de una referencia de un objeto hacia una clase de jerarquía superior: class Base{} public class ObRef extends Base{ public static void main(String argv[]){ ObRef o = new ObRef(). El resultado de usar estos operadores puede sorprenderte.2 clase Base. números que un programador quizá nunca utilizara. Puedes solucionar este problema usando la conversión forzada. Java sabrá qué métodos están en la clase hija.//Esta linea se compilara sin error /*o=b. En C/C++ el desplazamiento hacia la derecha puede ser con signo o sin signo dependiendo de la implementación del compilador. pues es poco probable que lo aprendas de otra manera. Si vienes de programar con Visual Basic. por ejemplo conocer el valor de un bit en cada posición: 32. Odio un poco esto de trabajar con desplazamientos de bits. es mejor tratar el tema.Tutorial para el examen de certificación: SCJP 1. 2. Sin embargo una clase hija puede tener métodos adicionales de los que le proporciona la clase Base. Base b = new Base(). 4. Pero debido a que todas las razones para aprenderlo son por que pueden aparecer en el examen. 106 . Para entenderlos tienes que tener un pensamiento binario bastante fluido. Las referencias de objetos se asignan hacia arriba en la jerarquía de clases. b=o. Ya que implica que llenes tu mente con una capacidad no intuitiva que es trabajar con números infinitamente pequeños. 1 Los programadores C/C++. pueden estar tranquilos ya que la manera de trabajar del operador de desplazamiento de bits en Java es menos ambigua que en C/C++.

El efecto de esto es que cada desplazamiento divide/multiplica el número negativo por dos. El complemento a dos funciona un poco como el odómetro físico que se encuentra en el tablero de los coches. Imagina que lo "rebobinas" hasta cero y después pasas a números negativos. sería uno por debajo del máximo que pudieras representar con las ruedecillas disponibles. debido al moviendo de los otros bits. System. y = x >>2. tu lenguaje.javaHispano. El resultado será 3. System. Operadores de desplazamiento con signo << y >> Los operadores de desplazamiento a la derecha y a la izquierda mueven el patrón de bits hacia la derecha o hacia la izquierda y dejan solo al bit de signo del número. Esto te mostrará el patrón de bits del número que hayas introducido. Esto te será fácil de entender hasta que te des cuenta de las implicaciones del almacenamiento de números binarios a través del complemento a dos.out.out.se pierde un bit y el resto del patrón de bits se inclina a la derecha int x = 14. 107 . ponla en modo científico.println(y). int y = 0. Para números positivos los resultados son bastante predecibles. El resultado será 56 De manera que. lo que sucede es que cada una de las posiciones. Si esto te suena improbable ejecuta la calculadora de Windows. El primer número que obtendrías no sería 1. introduce un número negativo y después pasa a modo binario. Si desplazamos 4 posiciones. int y = 0. Esto es también aplicable a un byte o a un short. Tu comunidad. Observa que el objetivo únicamente pide que comprendas el resultado de aplicar estos operadores sobre valores de tipo int. particularmente si el valor es negativo. ¿Qué esperarías obtener al realizar un desplazamiento a la izquierda a un numero negativo? Podrías esperar el mismo resultado obtenido al desplazar a la derecha un número positivo excepto que el resultado mantiene el signo negativo. Así el desplazamiento con signo para números positivos da los siguientes resultados: int x = 14. ya que se puede tener algunos resultados demasiado inesperados.println(y). y = x <<2. toman el valor del bit más significativo (el bit de signo).

de modo que pierde bits del lado derecho. ¿Cual crees que sea el resultado para la siguiente línea de código? System. puede ser una sorpresa. Así.println(-1 >>> 32).jchq.net/applets/BitShift/BitShiftAr.println(-1 >>>1).2 Si toda esta charla sobre patrones de bits y representación en complemento a dos "hace que tu cabeza heche humo". etc. También se incluye el código para que veas como trabaja. los 32 bits son desplazados el numero de veces que se le indique al operador y son rellenados los espacios de la izquierda con ceros. el resultado de la línea anterior. que es -1. y tendrás que elegir el resultado mas aproximado.out. La razón es que el modulo 32 se realiza sobre el operando antes del desplazamiento. Veamos la siguiente sentencia: System. Desplazamiento sin signo a la derecha >>> El desplazamiento sin signo a la derecha >>> realiza un desplazamiento sin tomar en cuenta el bit del signo. puedes revisarlo en: http://www. -1. podrías preferir pensar el desplazamiento de bits como un proceso repetitivo de multiplicación o división por dos. El resultado es el siguiente: 2147483647 El examen probablemente no te pedirá que des el resultado exacto pero podría darle algunas alternativas como 0. De tal manera que esto da el efecto de convertir un número negativo a positivo Este desplazamiento puede darnos algunos resultados muy raros. Así.out.Tutorial para el examen de certificación: SCJP 1. Applet BitShift 108 . Esta aproximación funciona bien hasta que empiezas a desplazar un numero negativo a la derecha. Si acabas de leer que el deslazamiento sin signo no toma en cuenta el bit del signo. si divides 32 entre 32 obtienes 0 y si realizas un desplazamiento sin signo de cero lugares hacia la derecha tendrás todavía como valor -1. en un int. No deseches esto como si fuera una peculiaridad irrelevante ya que puede venir en el examen.html Aquí hay una imagen que muestra el applet en funcionamiento. He creado un applet que te permite probar varias operaciones de desplazamiento y ver los resultados tanto en decimal como el patrón de bits.

Object o1 = new Object(). Tu comunidad. tu lenguaje. 109 . } } ¿Cuales de las siguientes líneas son válidas? 1) o1=o2.javaHispano. Base b = new Base(). IFace o2 = new CFace(). 2) b=ob. Pregunta 1) Dadas las siguientes clases: interface IFace{} class CFace implements IFace{} class Base{} public class ObRef extends Base{ public static void main(String argv[]){ ObRef ob = new ObRef().

3) i+=s. String s = "Hello". ¿Cuales de las siguientes líneas compilaran sin error? 1) j=i <<s. 4) o1=b. Pregunta 2) Dadas las siguientes declaraciones: String s = "Hello".11.2 3) ob=b. 3) j=i<<d. int j = 0. ¿Cuales de las siguientes líneas compilaran sin error? 1) c=c+i. long l = 99. 4) j=i<<l. double d = 1.Tutorial para el examen de certificación: SCJP 1. Pregunta 4) ¿Cual será el resultado de la siguiente sentencia? System. 2) s+=i. 2) j=i<<j. 4) c+=s.println(-1 >>>1).out. int i = 1. int i = 10. double d = 10. long l = 1. Pregunta 3) Dadas las siguientes variables: char c = 'c'. 1) 0 2) -1 3) 1 110 .

únicamente entendiendo al desplazamiento sin signo a la derecha te puedes dar cuenta que todas las otras opciones no son correctas. Respuesta 2) 2)j= i<<j. Respuesta 4) 4) 2147483647 Aún y cuando no logres grabarte este numero. 4)j=i<<l.println(1+1). String s= "on"+'one'. tu lenguaje. Tu comunidad.println(1 <<32). Respuesta 5) 111 . 4)o1=b. 4) 2147483647 Pregunta 5) ¿Cual será el resultado de la siguiente sentencia? System. 1) 1 2) -1 3) 32 4)-2147483648 Pregunta 6) ¿Cuales de las siguientes sentencias son validas? 1) 2) 3) 4) System.out. Respuesta 3) 2)s+=i. byte b=255. int i= 2+'2'.javaHispano. 2)b=ob.out. Respuestas Respuesta 1) 1)o1=o2.

out.geocities.2 1) 1 Con el desplazamiento a la izquierda.println(1 <<31). los bits son "envueltos alrededor" del patrón de bits.Tutorial para el examen de certificación: SCJP 1. el resultado de: System.html#obj15 112 .sun. 2) int i= 2+'2'.html No encontré nada relacionado con el operador instanceof Richard Baldwin http://home.att. La opción 4 no compilara ya que el valor 255 esta fuera del rango de un byte.com/SiliconValley/Network/3693/obj_sec5. Será: -2147483648 Respuesta 6) 1) System. Así. Otras Fuentes para este tema: El tutorial de Sun http://java.net/~baldwin.dick/Intro/Java022.htm#bitwiseoperations No encontré nada relacionado con el operador instanceof Jyothi Krishnan cubre este tema en: http://www.println(1+1). La opción 3 no es valida. ya que las comillas simples sirven para indicar un solo caracter constante y no a una cadena.out.com/docs/books/tutorial/java/nutsandbolts/operators.

por el contrario el operador = = realiza una comparación poco profunda. Tu comunidad. La utilización del método equals y el operador = = tiene extraños efectos laterales cuando se usa para comparar Strings. java. pero en el examen pueden haber preguntas que te exijan reconocer muy bien esta diferencia.Object. if (s = = s2){ 113 . while u otra sentencia de enciclamiento. Diferencia entre el método equals y el operador = = El método equals puede verse como la realización de una comparación profunda del valor de un objeto. Objetivo 2. Existen 2 maneras para crear un String en Java. La otra manera. Usando el método equals con Strings El método equals retorna un valor primitivo de tipo boolean. Puede usarse también en lugar del operador = = con una primitiva. normalmente un String se crea de la siguiente manera: String s = new String("Hello"). Veamos lo siguiente para comprender mejor lo anterior: String s = "Hello". Así.javaHispano.lang. El pool de Strings es la manera en que Java mantiene los recursos. es la siguiente: String s = "GoodBye". La creación de 2 cadenas con la misma secuencia de letras sin ocupar la palabra clave new creara 2 apuntadores a la misma cadena en el pool de Strings de Java. String s2 = "Hello". Esta es una de las ocasiones en donde la naturaleza inmutable de los Strings.lang. tu lenguaje.Boolean y java. puede crearte confusión. Generalmente la diferencia entre estas dos maneras de crear un String es mínima. Esto significa que se puede usar para manejar sentencias if. Determinar el resultado de aplicar el método booleano equals(Object) sobre Objetos. ligeramente más corta.lang. y la manera en que java maneja esta característica. Una de ellas implica la utilización del operador new. El método equals compara lo que un objeto apunta en lugar del apuntador en si (esto si consideramos que java tiene punteros ). y cualquier combinación de las clases java.String.

String u = new String("Hello"). Sin embargo. Y debido a que el operador = = únicamente compara la dirección del objeto. y no su valor. Prueba permutando cadenas idénticas creadas con y sin el operador new. } Tomando en cuenta lo que vimos en el objetivo anterior.out.2 System.out. La manera en que trabaja el pool de String y la diferencia entre usar el operador = = y el método equals no es muy obvio.lang. if (t == u){ System. particularmente si tienes antecedentes de programar con Visual Basic. nunca se mostrara ya que s y s2 son objetos distintos. sin importar la manera en que fueron creadas. Boolean es un objeto envolvente para la primitiva boolean De acuerdo a la documentación del JDK el método equals en la clase Boolean: "Retorna true si y solo si el argumento que recibe es distinto de null y si el objeto Boolean que recibe tiene el mismo valor booleano que éste objeto" 114 requerimiento . debido a la manera en que Java maneja los recursos con la re-utilización de cadenas idénticas que son creadas sin el operador new. no su valor. el operador new fuerza a Java a crear cadenas separadas.println("Equal with new operator"). ejecuta una comparación caracter a caracter. Usando el método equals con la Clase Boolean El para comprender el uso del operador equals sobre java.Tutorial para el examen de certificación: SCJP 1. es decir. } String t = new String("Hello"). en el segundo par de Strings t y u. s y s2 tiene la misma "direccion" y en consecuencia el código mostrará el mensaje: "Equal without new operator" Por otro lado. y además el operador = = examina lo que apunta a un objeto.Boolean es una confusión potencial. El método equals aplicado a Strings. t y u tienen diferentes direcciones y así el mensaje "Equal with new operator" nunca se mostrará. dos objetos distintos.println("Equal without new operator"). esperarías que el primer mensaje "Equal without new operator". La mejor manera de comprender esto es creando algunos ejemplos por ti mismo y viendo como es que trabajan.

if(b1. ya que el parámetro para la sentencia if es un booleano. System. Como Java no esta diseñado para manipular direcciones de memoria o apuntadores.equals(b2)){ System.Object. Tu comunidad. Usando el método equals con objetos Debido al diseño fundamental de Java una instancia de cualquier clase es también una instancia de la clase java. if(b1){ //do something in java } Aunque esta es una practica de programación bastante mala es sintácticamente correcta.println("We are equal").out. ésta no es una operación particularmente útil. pero no en Java Esto no funcionara en Java porque el parámetro para la sentencia if debe ser una evaluación booleana. Object m2 = new Object(). 115 . el método toString simplemente retorna la dirección de memoria. Boolean b2 = new Boolean(true). Sin embargo puedes realizar lo siguiente en Java : boolean b1=true. } Como un tema aparte sobre el uso de boolean y Boolean. una vez que te familiarices con la sentencia if en Java te darás cuenta que no puedes realizar la conversión implícita tan apreciada por los programadores C/C++. Esa conversión es del tipo: int x =1.lang. Para la clase Object. Veamos el siguiente ejemplo: public class MyParm{ public static void main(String argv[]){ Object m1 = new Object(). if(x){ //realiza } algo.println(m1).javaHispano. Examinaremos esto utilizando el método toString. ya que Java no tiene el concepto de C/C++ en donde cualquier valor no nulo se considera verdadero. tu lenguaje. Así el resultado es el equivalente de ejecutar una comparación con el operador = =. Ejemplo: Boolean b1 = new Boolean(true).out.

out. } } } 116 .println("String equals").out.out.println("Not Equals"). y probablemente no tienen nada que ver con lo que tu necesitas.Tutorial para el examen de certificación: SCJP 1.Object@16c80b java.out.lang. obtendrás algo similar a lo siguiente: java.2 System. String s2 = "One". boolean b2 = true.out.Object@16c80a Not Equals Estos valores son direcciones de memoria . }else{ System.equals(s2)){ System. if(s1. } boolean b1 = true.equals(b2)){ System.equals(m2)){ System.println(m2). if (m1. } } } Si intentas compilar y ejecutar lo anterior.lang. if(b1.println("true"). Pregunta 1) ¿Que pasará cuando intentes compilar y ejecutar el siguiente código? public class MyParm{ public static void main(String argv[]){ String s1= "One".println("Equals").

out.println("String equals"). } 1)Error al compilar 2)Mostrará "Equals" 3)No mostrará nada 4)Error al ejecutarse 117 .equals(o2)) System. if(b1==b2){ System. o1=o2. Tu comunidad. if(s1.println("Boolean Equals"). } 1)Error al compilar 2)Se mostrará únicamente "String equals" 3)Se mostrará "String equals" seguido de "Boolean Equals" 4)Se mostrará únicamente "Boolean Equals" Pregunta 3) ¿Cuál es el resultado de intentar compilar y ejecutar el siguiente código? Object o1 = new Object().javaHispano. seguido de "true" Pregunta 2) ¿Que pasará cuando intentes compilar y ejecutar el siguiente código? String s1= "One". } Boolean b1 = new Boolean(true). Object o2 = new Object().equals(s2)){ System. if(o1. tu lenguaje. 1)Error al compilar 2)No se mostrará ningún mensaje 3)Se mostrará únicamente el mensaje "String equals" 4)Se mostrará el mensaje "String equals".out. Boolean b2 = new Boolean(true).println("Equals").out. String s2 = new String("One").

Respuesta 3) 2)Mostrará "Equals" Debido a que una instancia de Object a sido asignada a la otra en la línea: o1=o2 Estas instancias apuntan ahora a la misma dirección de memoria y en consecuencia.com/SiliconValley/Network/3693/obj_sec5.htm#equals() 118 . la aplicación del método equals retornará verdadero.2 Respuestas Respuesta 1) 1)Error al compilar la línea b1. Respuesta 2) 2)Se mostrará únicamente "String equals" Probar una instancia de la clase Boolean con el operador = = únicamente examina la dirección de memoria.Tutorial para el examen de certificación: SCJP 1. no el valor de la instancia.michael-thomas.com/java/JCP_Operators.geocities.html#obj16 Michael Thomas http://www. Otras Fuentes para este tema Jyothi Krishnan cubre este tema en http://www.equals causará un error debido a que b1 es un valor primitivo y los valores primitivos no tienen métodos. Si b1 hubiera sido creado son la clase Boolean entonces si podrías ocupar el método equals.

y al estar aplicando el operador 119 . en C/C++. falso. Esto quizá te pueda sorprender si vienes de programar con Visual Basic ya que Visual Basic evalúa todos los operandos.javaHispano.&&. if((b1==true) && ((Output+=10)==20)) { System. y variables. si el primer operando es falso ya no es necesario evaluar el segundo operando. conocer el estado de los valores que son evaluados con estos operadores y el valor de la expresión.||. el resultado final será. El efecto corto circuito con los operadores lógicos. En una expresión que involucre a los operadores &. como ocurre de manera similar.out. asegúrate de reconocer la diferencia para el examen. con certeza. ||) tienen un ligero efecto peculiar en una operación lógica llamado "corto circuito”. Tu comunidad. debido a que retorna falso.println("We are equal "+Output). Lo mismo ocurre con el operador lógico OR. boolean b1 = false. Esto muestra que la operación Ouput+=10 jamás será realizada debido a que el proceso se detiene después de que se evalúa la primera operación. Objetivo 3. Los operadores lógicos (&&. Si eres nuevo con el uso de estos operadores vale la pena que te asegures no confundirte con los operadores a nivel de bits y los operadores lógicos.out. el cálculo global será verdadero ya que sólo un operando del OR debe retorna verdadero para que el resultado final sea verdadero. Es fácil olvidarse cuales son los símbolos que significan una operación lógica y cuales significan operaciones a nivel de bits. } } } El resultado de este código será "Not equal 10".println("Not equal! "+Output). Esto puede traer código un efecto especial con esos cálculos reducidos que dependen de efectos laterales. }else { System. En Java esto tiene sentido si consideras que en una operación AND. tu lenguaje.|. Veamos el siguiente ejemplo: public class MyClass1{ public static void main(String argv[]){ int Output=10. si el primer operando ha resultado verdadero.

pero puede tener un efecto lateral inesperado si no estás completamente familiarizado con el uso de estos operadores. Esto a veces puede ser conveniente cuando realmente no quieras procesar otras operaciones si una de ellas retorna falso. Este es un ejemplo típico ¿Cuál es el resultado de la siguiente operación? 3|4 El patrón binario para el decimal 3 es 11. Si estás 120 . Los objetivos no especifican que conozcas la operación XOR a nivel de bits. para realizar una operación OR a nivel de bits. puedes querer hacer algunos ejercicios para ayudarte a dominar este tema y también el relacionado con los operadores de desplazamiento de bits. la operación se realizará y el resultado será el que esperabas: "We are equal 20". Así para esta operación el resultado será: 011 100 -----111 y 111 es 7 en decimal. Operadores a nivel de bits. Pensando en binario Si no te siente muy cómodo pensando en binario (yo me siento mucho mas cómodo pensando en decimal). Puedes encontrarte preguntas en el examen que te den números en decimal y te pidan que realices operaciones AND o OR a nivel de bits. Si alguno de los bits es 1 el bit del numero resultante. pues el resultado será falso.2 AND (&&) ya no es necesario evaluar el resto de la expresión. Para hacer esto. realizada con el operador ˆ. en la posición que se esta comparando. Si cambias el valor de b1 a verdadero. cada bit es comparado con el bit que se encuentra en la misma posición del otro número.Tutorial para el examen de certificación: SCJP 1. Los operadores | y & se aplican para realizar operaciones AND y OR a nivel de bits. necesitas familiarizarte con la conversión de números decimales a binarios y conocer que ocurre con el patrón de bits. es también 1. el patrón binario para 4 es 100.

En modo científico puedes cambiar entre ver los números en formato decimal y binario. Para hacer esto solo elige la opción Ver y cambiar del modo Estándar predefinido al modo científico. por intentar realizar una comparación binaria sobre tipos de datos lógicos 2)Se compilara y mostrará la cadena "We are equal 10" 121 . y convierte el decimal 64 en su patrón de bits equivalente. utilizando la clase Integer. System. tu lenguaje.toString(64. he aquí un pequeño programa que muestra un ejemplo: public class BinDec{ public static void main(String argv[]){ System.parseInt("100".println(Integer. que es 4.out. } } Si lo compilas y ejecutas este será el resultado: 4 1000000 Observa que el programa convierte el patrón de bits 100 en su equivalente en decimal. Tu comunidad.javaHispano.println(Integer.println("We are equal "+Output). } 1)Error al compilar.2)). Pregunta 1) ¿Que pasará cuando intentes compilar y ejecutar el siguiente código? int Output=10. ejecutando Windows puedes encontrar útil usar la calculadora que proporciona este sistema operativo en modo científico. if((b1= =true) && ((Output+=10)==20)){ System. }else{ System. esto despliega el patrón de bits de los números.2)). Y si lo prefieres puedes realizar un programa que muestre el patrón de bits de un numero.out.println("Not equal! "+Output). boolean b1 = false.out.out.

2) int i=10. 4) boolean b1=true. Respuestas) Respuesta 1 4)Se compilara y mostrará la cadena "Not equal! 10" Respuesta 2) 122 . int j = 4.2 3)Se compilara y mostrará la cadena "Not equal! 20" 4)Se compilara y mostrará la cadena "Not equal! 10" Pregunta 2) Qué mostrará la siguiente línea de código System. boolean b2=true. System. System.println(b1||b2). System. int j = 4. System.println(b1|b2).Tutorial para el examen de certificación: SCJP 1.out.out.println(i||j). boolean b2=true.out.println(i|j). 3) boolean b1=true. 1) 14 2) 0 3) 6 4) 12 Pregunta 3) Cuales de los siguientes fragmentos de código se compilara sin errores 1) int i=10.out.println(010|4).out.

Tu comunidad. Otras Fuentes para este tema Tutorial de Sun: http://java.println(010|4) es equivalente a: System.com/docs/books/tutorial/java/nutsandbolts/operators.out.dick/Intro/Java022f.net/~baldwin.javaHispano. 010 es la notación octal para el numero 8 decimal. 4)12 La respuesta a esta pregunta requiere que conozcas la notación octal.out.4 La opción 1 no compilara ya que estas intentando ejecutar una aplicación OR lógica sobre tipos enteros. el cero que antecede al primer numero indica que dicho número esta en notación octal. tu lenguaje.println(8|4). Así. que en binario es: 1000 0100 ----1100 y 1100 en decimal es 12 Repuesta 3) 2.html Richard Baldwin http://home.htm 123 . la instrucción: System.att.3.sun. Y una operación lógica solo se puede realizar con argumentos de tipo boolean.

} public void amethod(){ ValHold v = new ValHold(). o. Si el código dentro del método modifica el valor de la variable. System.i=10. } public class ObParm{ public static void main(String argv[]){ ObParm o = new ObParm().i). En java no hay tal opción ya que todo es pasado por valor. Sin embargo esto no siempre es así. Veamos el siguiente ejemplo: class ValHold{ public int i = 10.println("After another = "+ v. si manipulas un campo de un objeto que se pasa a un método.Tutorial para el examen de certificación: SCJP 1.2 Objetivo 4 Determinar los efectos sobre los objetos y los valores primitivos al pasarlos como variables en métodos al aplicarles asignaciones u otras modificaciones dentro del método.println("In another = "+ v. System.amethod(). another(v). Referencias de Objetos como parámetros de métodos.println("Before another = "+ v. ¿El cambio es visible aun fuera del método? Si vienes de programar con C/C++ estarás familiarizado con el concepto "paso de parámetros por valor" y "paso de parámetros por referencia" con el operador &. }//End of amethod public void another(ValHold v){ v. el campo se comportara como si lo hubieras pasado por referencia (esto quiere decir que cualquier cambio mantendrá su efecto aún después de terminada la llamada al método).out. Nota sobre este objetivo El objetivo parece estarte pidiendo que entiendas lo que ocurre cuando pasas un valor a un método.out.out. System. Si pasas un objeto este es una referencia a un objeto y no puedes manipular directamente una referencia a un objeto. v.i = 20.i).i). }//End of another 124 . Así.

el método recibió una copia del manejador o referencia del objeto pero esa referencia actúa como un apuntador al valor real del objeto y las modificaciones se reflejan en los campos a los que apunta. Veamos el siguiente ejemplo: public class Parm{ public static void main(String argv[]){ Parm p = new Parm(). tu lenguaje. Esto es parecido a la desreferenciación automática de punteros en C/C++. Si java siempre pasa por valor. ¿Cómo se ha modificado? Bueno. estos pasan por valor. p.amethod().javaHispano.println("In another i= " + i). cualquier modificación no se refleja fuera del método.out. System.println("Before another i= " +i). }//End of another } La salida será: Before another i= 10 In another i= 20 After another i= 10 125 . System. Primitivas como parámetros de métodos Cuando pasas valores primitivos a métodos.out. El método obtiene su propia copia para utilizarla y en consecuencia. }//End of amethod public void another(int i){ i+=10.out. Tu comunidad.println("After another i= " + i). } El resultado será: Before another = 10 In another = 20 After another = 20 Observa como el valor de la variable i ha sido modificado. another(i). System. }//End of main public void amethod(){ int i=10.

20 126 .Tutorial para el examen de certificación: SCJP 1.i=30. }//End of amethod public void another(ValHold v.30 4)10. v. another(v. }//End of another } ¿Cual será la salida? 1)10. v = vh. int i){ i=0. ValHold vh = new ValHold().i). } public class ObParm{ public static void main(String argv[]){ ObParm o = new ObParm().0.20 Respuestas Respuesta 1 4)10.2 Pregunta 1) Dado el siguiente código: class ValHold{ public int i = 10.out.30 3)20.i = 20.i).99.out.i+ " "+i).0. 30 2)20. v.amethod(). System. System. ValHold v = new ValHold().0. } public void amethod(){ int i = 99. o.println(v.println(v.0.

tu lenguaje.geocities.sun.com/docs/books/tutorial/java/javaOO/arguments.html Jyothi Krishnan cubre este tema en: http://www.html#obj18 127 .com/SiliconValley/Network/3693/obj_sec5. Otras Fuentes para este tema: Tutorial de SUN: http://java. Tu comunidad.javaHispano.

Relaciones “es un” y “tiene un” Éste es un tema básico de OO y probablemente te encontrarás una pregunta sobre él en el examen. Esto significa que no se puede corromper el valor de un campo “accidentalmente”.2 Sección 6. Desde luego la distinción puede ser difusa. sobreescritura. La encapsulación conlleva a separar la interfaz de una clase de su implementación. Esencialmente busca descubrir si entiendes cuándo algo se refiere al tipo de estructura de clases a la que pertenece un objeto y cuándo se refiere a un método o campo que posee una clase. Sobrecarga. un gato ES UN tipo de animal y un gato TIENE UNA cola. Si fueras un zoólogo y conocieras los nombres correctos para los grupos de tipos de animales podrías decir que un gato ES UN: Largapalabraenlatínparagrupodeanimalesconcolas Pero en lo que al examen se refiere esto no es un requisito. Las preguntas del examen tienden a ser del tipo en las que se te da un texto que describe una jerarquía potencial y te hace preguntas como: qué debería ser un campo y qué debería ser un nuevo tipo de clase como hijo. hay que usar un método para cambiar un valor. A primera vista estas cuestiones pueden parecer complejas. La encapsulación conlleva esconder los datos de una clase y permitir el acceso solo mediante una interfaz pública. Así.Tutorial para el examen de certificación: SCJP 1. tipos en tiempo de ejecución y orientación a objetos Objetivo 1) Mostrar los beneficios de la encapsulación en el diseño orientado a objetos y escribir código que implemente clases fuertemente encapsuladas y entender las relaciones “es un” y “tiene un”. 128 . pero son bastante obvias si las lees con cuidado Encapsulamiento Los objetivos de Java 1.1 no mencionaban específicamente la encapsulación aunque sería raro estudiar Java y no encontrarse con el concepto.

sabiendo que no estropeará programas que la usen. si cambiaras el color de una figura podrías crear un par de métodos de la siguiente manera public void setColor(Color c){ cBack = c. La separación de la interfaz y la implementación hace más fácil modificar el código de una clase sin afectar a otro código que lo pueda usar. está diseñado para ayudar a evitar modificaciones no deseadas. Tu comunidad. El usuario final puede tener la confianza de que las actualizaciones en el código de la clase no romperán su código existente. Para el diseñador de clases esto lleva a la posibilidad de modificar una clase. Un campo privado sólo es visible desde la clase en cuestión. Esto significa que un programador no puede accidentalmente escribir código que cambie el valor desde otra clase. 129 . Esto puede ayudar a reducir la introducción de errores. Si un valor así se guarda en un campo simple como un entero. Si la edad es accesible sólo vía métodos set y get será posible insertar comprobaciones de edades cero o negativas de forma que no quede afectado código existente. Esto usualmente conlleva la creación de variables privadas (campos) cuyo valor se actualiza y recupera mediante métodos. Desde luego a medida que el desarrollo continúa se pueden descubrir más situaciones que necesiten chequeo. La convención estándar para dar nombre a estos métodos es: • SetNombreCampo • GetNombreCampo Por ejemplo. no hay un lugar obvio en el que se puedan guardar rutinas de comprobación. } public Color getColor(){ return cBack. tu lenguaje. Un diseñador de clases puede añadir rutinas de comprobación adicionales para realizar “chequeos de cordura” relacionados con modificaciones de campos. Para el usuario final de la clase esto significa que no tiene que comprender el funcionamiento interno y que se le presenta una interfaz claramente definida para manejar los datos. He trabajado en proyectos de seguros en los que era posible que el cliente tuviera una edad menor de cero.javaHispano. Este no está diseñado para evitar que un programador acceda a variables. El enfoque estándar al usar el ejemplo de arriba de color sería hacer privado el campo CBack de Color. } Las principales palabras claves para controlar el acceso a las variables son: • • • public private protected No te confundas pensando que el sistema de control de acceso tiene que ver con la seguridad.

out. class Base { int i=99. Véase el siguiente ejemplo. edad. Estás diseñando una clase para representar un tipo de persona llamada paciente. a veces no es obvio cuál será el método ejecutado. } } Nótese cómo el tipo de la referencia es la variable b es la clase Base pero el tipo de la clase de hecho es RType. La llamada a amethod invocará la versión en RType pero la salida b.i). Pregunta 1) Supón que te han entregado el siguiente diseño: “Una persona tiene nombre. public void amethod(){ System.Tutorial para el examen de certificación: SCJP 1.println("Base. Dado que la clase persona ya ha sido creada. } } public class RType extends Base{ int i=-1.//<= Nótese el tipo System.amethod()"). b. public static void main(String argv[]){ Base b = new RType(). Este tipo de persona puede recibir un diagnóstico.i referenciará el campo i en la clase Base.amethod().out. qué de entre lo siguiente sería apropiado incluir cuando se diseñe la clase paciente? 130 . dirección y sexo.2 Tipos en Tiempo de ejecución Como el polimorfismo permite seleccionar en tiempo de ejecución la versión que se ejecuta de un método.println("RType.amethod()"). } public void amethod(){ System.out. tener cónyuge y está vivo".println(b.

amethod 3) 99 RType. Tu comunidad.amethod()"). } Base(){ amethod().println("RType. } } public class RType extends Base{ int i=-1.println("Base. public void amethod(){ System.amethod()").out.i). b. } public void amethod(){ System. } } 1) RType.amethod 99 RType.out.out. public static void main(String argv[]){ Base b = new RType(). System.println(b.amethod -1 RType.amethod().javaHispano. 1)fecha de registro 2)edad 3)sexo 4)diagnóstico Pregunta 2) ¿Qué sucederá cuando intentes compilar y ejecutar el siguiente código? class Base { int i=99.amethod 131 . tu lenguaje.amethod 2) RType.

Tutorial para el examen de certificación: SCJP 1. Bajo WindowsPC hay dos subclases. Pregunta 4) Dada la siguiente clase class Base{ int Edad=33. La principal diferencia entre las dos es que una ejecuta el Sistema Operativo Linux y la otra ejecuta el sistema Windows (desde luego otra diferencia es que una necesita ser rearrancada constantemente y la otra funciona fiablemente). ¿Cómo valorarías el trabajo de tu diseñador? 1)Dar la luz verde para posteriores diseños usando el esquema actual 2)Pedir un rediseño de la jerarquía cambiando el Sistema Operativo a un campo de la clase antes que a un tipo de clase 3)Pedir que la opción WindowsPC se elimine ya que pronto quedará obsoleta 4) Cambiar la jerarquía para eliminar la necesidad de la superflua clase Ordenador. } ¿Cómo mejorarías la clase con respecto al acceso al campo Edad? 1)Definir la variable Edad como privada 2)Definir la variable Edad como protegida 3)Definir la variable Edad como privada y crear un método ‘get’ que la devuelva y un método ‘set’ que la actualice 4)Definir la variable Edad como protegida y crear un método ‘set’ que la devuelva y un método ‘get’ que la actualice Pregunta 5) ¿Cuáles de los siguientes son beneficios de la encapsulación? 1)Todas las variables pueden manipularse como objetos en vez de con primitivas 2)Haciendo todas las variables protegidas están protegidas de una corrupción accidental 3)Se puede cambiar la implementación de una clase sin estropear el código que la usa 4)Hacer todos los métodos protegidos previene la corrupción accidental de datos. Una se llama LinuxPC y la otra WindowsPC.2 4) Error en tiempo de compilación Pregunta 3) Tu jefe diseñador de software te ha mostrado un esquema del nuevo sistema de partes de ordenador que está a punto de crear. En lo alto de la jerarquía está una clase llamada Ordenador y bajo ella hay dos clases hijas. una llamada Server y la otra llamada Workstation. 132 .

herencia. y el diseño específicamente dice que un paciente debería tener un diagnóstico. intenta compilar y ejecutar el código. En esta situación una referencia a cualquiera de los campos como es el caso de ‘i’se referirá al valor en la clase Base. Respuestas Respuesta 1) 1) fecha de registro 4) diagnóstico La fecha de registro es razonable como campo adicional para un paciente. Respuesta 3) 2) Pedir un rediseño de la jerarquía cambiando el Sistema Operativo a un campo de la clase antes que a un tipo de clase Respuesta 4) 133 .amethod 99 RType. sobrecarga. herencia. Tu comunidad. redefinición 3)Encapsulación. ligadura dinámica. pero una llamada a un método hará referencia al método en la clase Rtype antes que a su manejador de referencia. debería tener disponibles los campos edad y sexo (asumiendo que no fueran declarados como privados). polimorfismo 2)Polimorfismo. Como el paciente es un tipo de persona. Respuesta 2) 2) RType. La razón es que este código crea una instancia de la clase Rtype pero la asigna a una referencia a la clase Base. ligadura dinámica 4)Encapsulación. polimorfismo Pregunta 7) ¿Como implementas la encapsulación en una clase? 1)Haciendo todas las variables protegidas y sólo permitiendo el acceso vía métodos 2)Haciendo todas las variables privadas y sólo permitiendo el acceso vía métodos 3)Asegurando que todas las variables son representadas por clases envolventes 4)Asegurando que todas las variables son accedidas a través de métodos de una clase ancestra.amethod Si esta respuesta te parece improbable. tu lenguaje.javaHispano. Pregunta 6) Nombre tres características principales de la Programación Orientada a Objetos: 1)Encapsulación.

obj19 134 .htm#an initial description of oop (Esto es material general sobre OOP más que sobre "es un" / "tiene un") Jyothi Krishnan sobre este tema en: http://www.html Richard Baldwin cubre este tema en: http://www.com/SiliconValley/Network/3693/obj_sec6.geocities.2 3) Definir la variable Edad como privada y crear un método get que la devuelva y un método set que la actualice.com/reference/library/1575212986/htm/ch05. polimorfismo Me hicieron esta pregunta en una entrevista de trabajo una vez.com/SiliconValley/Network/3693/obj_sec6.com/docs/books/tutorial/java/concepts/index.itlibrary. herencia.com/Athens/Acropolis/3797/Java004.Tutorial para el examen de certificación: SCJP 1.geocities. Conseguí el trabajo. Respuesta 7) 2)Haciendo todas las variables privadas y sólo permitiendo el acceso vía métodos Otras Fuentes para este tema: Este tema se cubre en el Tutorial de Sun en: http://java. No puedes tener la seguridad de encontrar algo así en el examen. pero bien viene saberlo.1 Unleashed http://www. Respuesta 5) 3) Se puede cambiar la implementación de una clase sin estropear el código que la usa.sun.html#obj19 Java 1.html . Respuesta 6) 4) encapsulación.htm (Ver la sección sobre encapsulación) http://www.Geocities.

Una respuesta podría venir como un entero. redefinido o sobrepasado) son en inglés lo bastante similares como para llevar a la confusión. Comentario sobre el objetivo Los términos overloaded (sobrecargado) y overriden (sobrescrito. Entonces. tu lenguaje. Esto es sólo un pequeño truco para distinguir a ambos. Algo que ha sido sobrecargado todavía se mueve pero está cargado con montones de funcionalidades que le causan un gran esfuerzo. Tu comunidad. No hay palabras claves que recordar para sobrecargar métodos. un booleano o una cadena de texto. Objetivo 2) Escribir código para invocar métodos sobrecargados y sobrescritos. constructores paternos o sobrecargados y describir el efecto de invocar estos métodos. Mi forma de recordarlo es imaginar que algo que ha sido redefinido o sobrepasado es algo a lo que le ha pasado encima un vehículo pesado y ya no existe por sí mismo. no tiene ninguna relación con la realidad del funcionamiento de Java. parte de lo cual se conoce como polimorfismo. sólo se crean múltiples métodos con el mismo nombre pero distinto número y/o tipo de parámetros. Sobrecarga de métodos La sobrecarga de métodos es un truco del compilador para permitirte usar el mismo nombre para realizar acciones distintas dependiendo de los parámetros. Sería más útil si pudieras usar un solo nombre de método y el compilador resolviera a qué código llamar según el tipo y el número de parámetros de la llamada. Este es el núcleo de la sobrecarga de métodos. Los nombres 135 . imagina que estás diseñando la interfaz para un sistema que haga exámenes de certificación de Java falsos (¿quién podría saber?). Podrías crear una versión del método para cada tipo de parámetro y darle el nombre correspondiente como: marcarespuestaboolean(boolean respuesta){ } marcarespuestaint(int respuesta){ } marcarespuestaString(String respuesta){ } Esto funcionaría pero supone que los futuros usuarios de tus clases tendrán que saber más nombres de métodos de lo estrictamente necesario.javaHispano.

Los métodos se diferencian sólo en el número. no en el tipo de retorno del método Sobrescritura de métodos Sobrescribir un método significa que se reemplaza su funcionalidad entera. Por tanto. Se hace en una clase hija con un método definido en una clase padre. void marcarespuesta(String respuesta){ } void marcarespuesta(String titulo){ } El tipo de retorno no forma parte de la identificación en cuanto a la sobrecarga.2 de los parámetros no son importantes pero el número y los tipos sí deben ser diferentes. Java proporciona un ejemplo de redefinición en el caso del método equals que cada clase hereda de la gran clase antecesora Object. tipo y orden de los parámetros. el siguiente es un ejemplo de un método marcarespuesta sobrecargado void marcarespuesta(String respuesta){ } void marcarespuesta(int respuesta){ } El siguiente no es un ejemplo de sobrecarga y causará un error en tiempo de compilación indicando una declaración duplicada de método. Así. Esto tiene el efecto de obscurecer el método en la clase padre y de que la funcionalidad de éste ya no sea directamente accesible. cambiárselo a uno de los métodos de arriba por int aún producirá un error en tiempo de compilación. Los métodos sobrecargados no tienen restricciones en cuanto a qué excepciones se pueden hacer lanzar (hacer throw). Esto sí es algo a tener en cuenta con la redefinición. La versión heredada de equals 136 .Tutorial para el examen de certificación: SCJP 1. Para redefinir un método se define uno nuevo en la clase hija con exactamente la misma identificación que el de la clase padre. pero esta vez indicando que no se puede redefinir un método con un tipo de retorno distinto.

el siguiente código no compilará class Base{ public public } Base(){} Base(int i){} public class MiRedef extends Base{ public static void main(String argvp[]){ MiRedef m = new MiRedef(10). Un constructor puede recibir parámetros como cualquier otro método y puedes necesitar diferentes parámetros según cómo quieras que la clase se inicialice.// NO compilará } } La palabra mágica que necesitas para acceder a un constructor de un ancestro es super. En este ejemplo modificado del código previo se usa la palabra clave super para llamar a la versión con el entero del constructor en la clase base y el código se compila sin problemas. Invocando constructores de clases base Un constructor es un método especial que se ejecuta automáticamente cada vez que se crea una instancia de una clase. Así. Para una cadena generalmente querrías una comparación carácter a carácter para ver si las dos cadenas son la misma. Así si te fijas en el ejemplo en la clase Button del paquete AWT su constructor está sobrecargado para que tenga dos versiones. • • Button() Button(String label) Así. Sin embargo. Tu comunidad. Para permitir esto la versión de equals que viene con String es una versión redefinida que efectúa esta comparación carácter a carácter. 137 . A menudo esto no es lo que se desea. los constructores no se heredan. así que si quieres sacar un constructor útil de una clase ancestro no está disponible por defecto. particularmente en el caso de un String. o usar la opción más común y asignarle la etiqueta en el momento de la creación. puedes crear un botón sin etiqueta y dársela después. tu lenguaje. simplemente compara a qué lugar de la memoria referencia la instancia de la clase. Java sabe que un método es un constructor porque tiene el mismo nombre que la clase misma y no tiene valor de retorno.javaHispano. Esta palabra clave se puede usar como si fuera un método y recibir parámetros que concuerden con la versión deseada del constructor padre.

} 138 .// Causa un error en tiempo de compilación.2 class Base{ public Base(){} public Base(int i){} } public class MiRedef extends Base{ public static void main(String arg[]){ MiRedef m = new MiRedef(10). } } Invocando constructores con this() De la misma forma que se puede llamar al constructor de una clase base usando super() se puede llamar a otro constructor de la clase en cuestión usando this como si fuera un método. MiRedef (String s. Como habrás adivinado esto llamará al otro constructor de la clase actual que toma un solo entero como parámetro. super(). int i){ this(i). no puedes usar a la vez super() y this() en un constructor.Tutorial para el examen de certificación: SCJP 1. Así en el ejemplo anterior se podría definir otro constructor de la siguiente manera MiRedef(String s. } MiRedef(int i){ super(i). lo siguiente causará un error en tiempo de compilación. Si usas super() o this() en un constructor debe ser la primera llamada a un método. } Tanto this como super se pueden llamar en la primera línea desde un constructor. int i){ this(i). Como sólo uno de los dos puede ser el primer método llamado. pero no ambos a la vez. Así.

Basándonos en el conocimiento de que los constructores no se heredan. } } public class Humano extends Mamífero { public static void main(String argv[]){ Humano h = new Humano().out. Si tienes una clase llamada Base y creas una clase hija que la extiende.out. Los constructores se llaman desde la base (ancestro) de la jerarquía hacia abajo Sea el siguiente ejemplo: class Mamífero{ Mamífero (){ System.println("Creando Mamífero "). Tu comunidad. debe resultar obvio que la redefinición es irrelevante. class Base{} class Base extends Base{} // ¡Error en tiempo de compilación! El constructor y la jerarquía de clases Los constructores siempre se llaman hacia abajo desde lo alto de la jerarquía. } } 139 .javaHispano. Aquí hay un ejemplo de esta jerarquía absurda. para la clase que la extiende redefinir el constructor debe tener el mismo nombre. Esto causaría un error en tiempo de compilación.println("Creando Humano"). Ten cuidado con las preguntas en las que tienes una jerarquía compleja que resulta irrelevante a causa de un constructor que hace una llamada tanto a this como a super y por tanto se produce un error en tiempo de compilación. tu lenguaje. Es muy probable que en el examen te hagan preguntas relativas a una jerarquía de clases con varias llamadas a this y super y tengas que elegir cuál será el resultado. } Humano(){ System.

2 Cuando se ejecute este código la cadena “Creando Mamífero” aparece primero debido a la llamada implícita al constructor sin argumentos de la base de la jerarquía. ¿cuál de los siguientes métodos podría colocarse legalmente después del comentario con la palabra comentada “//Aquí”? 140 . Pregunta 1) Dada la siguiente definición de clase. int i){} 2) public int amethod(int i. String s) {} Pregunta 2) Dada la siguiente definición de clase.Tutorial para el examen de certificación: SCJP 1. String s){} 3) public void amethod(int i. String s){} //Aquí } 1) public void amethod(String s. String mystring){} 4) public void Amethod(int i. ¿cuál de los siguientes métodos podría colocarse legalmente después del comentario con la palabra comentada “//Aquí”? public class Rid{ public void amethod(int i.

} } public class Collie extends Perro { public static void main(String argv[]){ Collie c = new Collie().10). int i){ this(i).println("Collie"). Pregunta 3) Dada la siguiente definición de clases: class Mamífero{ Mamífero (){ System. } MyOver(String s. public class MyOver extends Base{ public static void main(String arg[]){ MyOver m = new MyOver(10). //Aquí } } 1) MyOver m = new MyOver(). Tu comunidad. } Collie(){ this("Buen Perro").out.out. 141 .javaHispano. 2) super(). } } class Perro extends Mamífero { Perro(){ System.println("Perro").out. } MyOver(int i){ super(i).println("Mamífero "). tu lenguaje. System. 4) Base b = new Base(10). 3) this("Hola".

} } public class Child extends Base{ int i. String s){ System. } void amethod(int i. c.2 } Collie(String s){ System. Perro. Collie 3)Buen Perro.println(s). Perro.Tutorial para el examen de certificación: SCJP 1.println("Base amethod"). Mamífero 4)Buen Perro Collie Pregunta 4) ¿Cuáles de las siguientes sentencias son verdaderas? 1)Los constructores no se pueden heredar 2)Un constructor se puede sobrescribir 3)Un constructor padre se puede invocar utilizando this 4)Cualquier método puede contener una llamada a this o super Pregunta 5) ¿Qué pasara cuando intentes compilar y ejecutar el siguiente código? class Base{ public void amethod(int i.out.println("Base Constructor"). Collie. Buen Perro. String Parm="Hello". String Parm){ 142 . public static void main(String argv[]){ Child c = new Child().amethod(). } } ¿Cuál será la salida? 1)Error al compilar 2)Mamífero.out. } Base(){ System.out.

Three 4) Error al compilar Respuestas Respuesta 1) 143 .println("Two"). Scottie h = new Scottie(). Two. System. Three.amethod(i.println("Three"). Four.out. } } public class Scottie extends Dog{ public static void main(String argv[]){ System. Tu comunidad. tu lenguaje. } } 1) One.Parm).javaHispano. Two 3) One. Two. } public void amethod(){} } 3)Mostrará “Base Constructor” super.out. super.amethod(i. Pregunta 6) ¿Cuál será la salida del siguiente código si intentas compilarlo y ejecutarlo? class Mammal{ Mammal(){ System.out.ears(). } public void ears(){ System. 4)Error causado por los nombres incorrectos de los parámetros en la llamada a.Parm).println("Four"). Four. Three. Four 2) One. } } class Dog extends Mammal{ Dog(){ super.println("One").amethod 1)Error al compilar 2)Error causado por la sintaxis ilegal en: super.out.

Three Las clases son creadas desde la raíz del la jerarquía de herencia hacia abajo. ninguna otra opción puede ser utilizada Respuesta 3) 2) Mamífero. Respuesta 6) 3) One. Como en el método ya se utilizó this. Cualquier llamada a this o super debe estar en la primera línea del constructor. Buen Perro.2 1) public void amethod(String s. int i){} 4) public void Amethod(int i. amethod en la clase Base esta definido como privado. Two.Tutorial para el examen de certificación: SCJP 1. estas intentando alterar el modificador public. 144 . String s) {} La letra A mayúscula en Amethod nos indica que es un método distinto a amethod Respuesta 2) 4) Base b = new Base(10). Perro. Four. y en Child al no ponerle modificador de acceso antes de void. Collie Respuesta 4) 1)Los constructores no se pueden heredar Los constructores padres con invocados utilizando this o super Repuesta 5) 1)Error al compilar Esto causa un error que indica algo como lo siguiente: “no puedes sobrescribir métodos para hacerlos privados”.

htm#polymorphism in general (Material sobre POO concerniente a "es un" y “tiene un") Jyothi Krishnan en: http://www.html#obj20 145 .sun.Geocities.geocities.com/Athens/Acropolis/3797/Java004.javaHispano. Tu comunidad. Otras Fuentes para este tema: Este tema es cubierto el Tutorial de SUN en: http://java.html Richard Baldwin cubre este tema en: http://www. tu lenguaje.com/SiliconValley/Network/3693/obj_sec6.com/docs/books/tutorial/java/javaOO/methoddecl.

una clase abstracta no puede ser instanciada y por lo tanto no se puede crear una referencia a un objeto. La manera para instanciar una clase es usando la palabra clave new. clases internas estáticas y clases anónimas. Recuerda que una clase que contiene un método abstracto es abstracta por si misma y no puede ser instanciada. Instanciando una clase Concretamente. Nota sobre este objetivo Parte de este material es cubierto en la sección 4. Sin embargo aunque el tipo de la referencia es frecuentemente el mismo que el tipo de la clase instanciada. Así. La sintaxis anterior indica que el tipo de la referencia de b es Object en lugar de Button. Clases internas 146 . La sintaxis indica que la variable name es del tipo Button y contiene una referencia a una instancia de Button.Tutorial para el examen de certificación: SCJP 1. De esta manera. El siguiente código es valido: Object b = new Button(). Típicamente se utiliza de la siguiente manera: Button b = new Button(). La declaración e instanciación puede no ocurrir en la misma línea. incluyendo clases de nivel superior. las clases pueden ser instanciadas como una referencia a un objeto (también llamada simplemente objeto). puedes construir una instancia de una clase de la siguiente manera: Button b. clases internas. esto no necesariamente tiene que se así. b=new Button().2 Objetivo 3) Escribir código que construya instancias de una clase en concreto.

Sun introduce una nueva sintaxis para 147 . El primero. También tienen beneficios para controlar el alcance de las variables. Este es un ejemplo sencillo: class Nest { class NestIn{} } La salida cuando este código se compile serán dos archivos . Clases Miembro Veo una clase miembro como una “clase interna ordinaria”. Debido a la necesidad que tiene la clase interna de ser asociada con una instancia de la clase externa.class.class el otro es Nest$NestIn. debes instanciar la clase exterior antes de crear una instancia de la clase interna. Debido a que la clase es estática no requiere una instancia de la clase externa para existir. Clases Anidadas de nivel Superior (Top Level) Una clase anidada de nivel superior es un miembro estático contenido dentro de una clase de nivel superior. Tu comunidad. Las clases internas permiten definir clases dentro de otras clases. class Nest{ static class NestIn{} } Este tipo de anidamiento es usado frecuentemente para agrupar de una manera sencilla clases que guardan una relación entre si. Con certeza encontraras en el examen preguntas acerca de las clases anidadas y del alcance de ellas.1. Las clases internas fueron introducidas con la liberación del JDK 1. tu lenguaje.1. Una clase miembro es semejante a otros miembros de una clase. Son usadas extensivamente a partir del modelo de eventos de JDK 1. Las clases internas te permite hacer una agrupación lógica de clases. que es el que esperas es: Nest.class Esto ilustra que el anidamiento de clases es generalmente una convención para nombrar clases en lugar de una nueva clasificación de archivos . en ocasiones estas clases son conocidas como clases anidadas.class.javaHispano.

Tutorial para el examen de certificación: SCJP 1.2 permitir la creación simultánea de una instancia de la clase externa y al mismo tiempo la creación de la clase interna. Es de esta forma:
Outer.Inner i = new Outer().new Inner();

Para darle sentido a esta nueva sintaxis, intenta pensar que la primera aparición de la palabra clave new es usada en el ejemplo anterior para designar la pertenencia a la instancia actual this. Así, podrías cambiar la línea que crea la instancia de ésta clase y leer lo siguiente:
Inner i = this.new Inner();

Debido a que una clase miembro no puede existir sin un instancia de la clase exterior, ésta puede tener acceso a las variables de la clase exterior.

Clases creadas dentro de métodos
Un nombre más correcto para este tipo de clases es clase local.

Las clases locales solo pueden acceder a campos finales o parámetros del método que la contiene

Una clase local es visible únicamente dentro del bloque de código del método. El código dentro de la clase local puede usar únicamente variables locales que tengan el modificador final en el bloque del método o parámetros del método. Es muy probable que te encuentres con preguntas de este tipo en el examen.

Clases anónimas
Tu primera reacción con la idea de una clase anónima debe ser "¿por qué querría yo tener una clase sin nombre? y ¿cómo podría referirme a una clase si no tiene nombre?" Para contestar estas preguntas, considera lo siguiente. Podrías estar en una situación en donde constantemente tienes que pensar en nombres para instancias de clases en donde el nombre es por si mismo evidente. Por ejemplo en el manejo de eventos las dos cosas mas importantes que necesitas saber para manejar el evento son: el evento que se va a manejar y el nombre del componente que esta utilizando dicho manejador. Tener el nombre de la instancia la clase que maneja el evento no aporta mucho valor.

148

javaHispano. Tu comunidad, tu lenguaje. Acerca de la pregunta de como puedes hacerle referencia, pues, simplemente no puedes y si necesitas referirte a la clase por su nombre, entonces no deberías crear una clase anónima. La falta del nombre de la clase tiene efectos adicionales, como el hecho de que no puedes darle a la clase anónima un constructor.

Las clases anónimas no pueden tener constructores

Este es un ejemplo de una clase interna anónima:
class Nest{ public static void main(String argv[]){ Nest n = new Nest(); n.mymethod(new anon(){}); } public void mymethod(anon i){} } class anon{}

Nota que la declaración y definición de la clase anónima se realiza dentro de los paréntesis de la llamada a mymethod.

Pregunta 1) ¿Cuáles de las siguientes afirmaciones son verdaderas? 1)Una clase definida dentro de un método puede únicamente acceder métodos estáticos del método que la contiene 2)Una clase definida dentro de un método puede únicamente acceder variables finales del método que la contiene 3)Una clase definida dentro de un método no puede acceder a algún campo del método que la contiene

149

Tutorial para el examen de certificación: SCJP 1.2 4)Una clase definida dentro de un método puede acceder cualquier campo accesible del método que la contiene Pregunta 2) ¿Cuáles de las siguientes afirmaciones son verdaderas? 1)Una clase anónima no puede tener un constructor 2)Una clase anónima puede ser creada únicamente dentro del cuerpo de un método 3)Una clase anónima puede únicamente acceder a campos estáticos del método que la contiene 4)El tipo de clase de una clase anónima puede ser obtenido utilizando el método
getName

Pregunta 3) ¿Cuáles de las siguientes afirmaciones son verdaderas? 1)Una clase interna no puede ser marcada como privada 2) Una instancia de una clase anidada de nivel superior puede crearse sin necesidad de crear una instancia de la clase que la contiene 3)Un archivo que contenga una clase externa y una interna únicamente producirá un único archivo .class 4) Para crear una instancia de una clase miembro se requiere crear una instancia de la clase que la contiene Respuestas Respuesta 1) 2)Una clase definida dentro de un método puede únicamente acceder variables finales del método que la contiene Respuesta 2) 1)Una clase anónima no puede tener un constructor Respuesta 3) 2) Una instancia de una clase anidada de nivel superior puede crearse sin necesidad de crear una instancia de la clase que la contiene 4) Para crear una instancia de una clase miembro se requiere crear una instancia de la clase que la contiene

150

javaHispano. Tu comunidad, tu lenguaje. Una clase anidada genera por si misma un archivo .class, usando el formato: Outer$Inner.class Una clase anidada de nivel superior es como una clase estática así que no requiere una instancia de la clase que la contiene. Una clase miembro es como una clase no estática, por consiguiente se requiere una instancia de la clase que la contiene,.

Otras Fuentes para este tema: Tutorial de Sun: http://java.sun.com/docs/books/tutorial/java/more/nested.html Richard Baldwin http://www.geocities.com/Athens/7077/Java094.htm Jyothi Krishnan en: http://www.geocities.com/SiliconValley/Network/3693/obj_sec6.html#obj21

151

A diferencia de los procesos un thread comparte memoria y datos con el resto del programa.lang. MyClass mc = new MyClass().lang. Threads Objetivo 1) Escribir código para definir. probablemente no quieras que el programa principal se detenga hasta que finalice la impresión. pero puede ser separado de la principal y ser manipulado por si solo. Las dos formas de crear un Hilo (Thread) De las dos maneras de crear un Hilo (algunos documentos ocupan la palabra hebra en lugar de hilo) el uso de Runnable es probablemente el mas común. El siguiente es un ejemplo de una clase creada con la interface Runnable. puedes imaginar una cuerda. A diferencia de otros lenguajes el threading esta embebido en el corazón de Java. La Palabra Thread es una contracción de “Thread de ejecución” (Hilo de ejecución). mucho de él al nivel de la ultima clase ancestro llamada Object. seria que el proceso de impresión comenzara a ejecutarse en segundo plano y te permitiera continuar usando la parte principal del programa.Runnable.Tutorial para el examen de certificación: SCJP 1. 152 . ¿Qué es un Thread ? Los Threads son procesos ligeros que aparentan correr en paralelo con tu programa principal. Un ejemplo común utilizado para ilustrar los threads es el crear una aplicación GUI que lanzara una pelota rebotando cada vez que un botón es presionado.2 Sección 7. class MyClass implements Runnable { public void run() { //Blank Body } } Creando el hilo de ejecución. es en la impresión. Cuando das un click en el botón imprimir. También sería útil si el programa principal pudiera responder si el hilo (thread) de impresión encontrara algún problema.Thread y java. pero debes de conocer las dos para propósitos del examen. Lo deseable. Un ejemplo de donde pueden ser útiles los threads. a la cual le has deshilachado el final y has tomado un hilo. El hilo todavía es parte de la misma cuerda. instanciar y comenzar nuevos threads usando java.

javaHispano. Tu comunidad, tu lenguaje.

Cualquier clase que implemente una interfase debe crear un método correspondiente por cada uno de los que se encuentren en la interfase. No es necesario que los métodos realicen algo, pueden tener el cuerpo del método en blanco, pero deben estar ahí. De esta manera incluí el método run incluso en este pequeño ejemplo, ya que si implementas Runnable debes incluir el método run No incluir el método run causaría un error en tiempo de compilación. Para hacer algo útil cuando se crea un hilo de ejecución de una clase deberías de, por supuesto, colocar algo de código donde puse : //Blank body La otra manera de crear un hilo es crear una clase que descienda de Thread. Esto es fácil de hacer pero significa que no puedes heredar de ninguna otra clase, debido a que Java solo soporta herencia simple. De esta manera, si estas creando un botón no le puedes agregar threading a de esta manera porque un botón hereda de la clase AWT Button y eso utiliza tu única opción de herencia. Existe debate sobre cual de las dos formas de crear un hilo es verdaderamente más orientada a objetos, pero no necesitas llegar a esa conclusión para propósitos del examen.

Instanciando e Iniciando un hilo.
Aunque el código que se ejecuta en tu thread esta en un método llamado run, no necesitas llamar a este método directamente, en vez de eso llamas al método start de la clase Thread. La interfase Runnable no contiene un método start, entonces, para llegar a este método y a los otros útiles métodos para threads (sleep, suspend, etc), pasas tu clase con la interfase Runnable como el constructor de una instancia de la clase Thread. De este modo para hacer que el hilo se ejecute desde una clase que implemente
Runnable deberás llamar lo siguiente: MyClass mc = new MyClass(); Thread t = new Thread(mc); t.start();

De nuevo observa que fue una llamada al método start, no una llamada al método run, aunque es el código en el método run en tu clase el que actualmente se ejecuta. Aunque es el método run el que ejecuta, un hilo se inicia a través del método start.

153

Tutorial para el examen de certificación: SCJP 1.2

Si creas una clase que sea una subclase de Thread simplemente tienes que llamar al método start. El inconveniente de heredar de la clase Thread, es que debido al soporte de herencia simple no puedes heredar funcionalidad de ninguna otra clase.

Preguntas Pregunta 1) ¿Qué ocurrirá cuando intentes compilar y ejecutar el siguiente código?
public class Runt implements Runnable{ public static void main(String argv[]){ Runt r = new Runt(); Thread t = new Thread(r); t.start(); } public void start(){ for(int i=0;i<100;i++) System.out.println(i); }

}

1)Compila y tiene como salida una cuenta de 1 a 99 2)Compila pero no tiene salida 3)Error en tiempo de compilación: La clase Runt es una clase abstracta. No puede ser instanciada 4)Error en tiempo de compilación, el método start no puede ser llamado directamente Pregunta 2) ¿Cuáles de las siguientes frases es cierta? 1)Heredar directamente de la clase Thread te da acceso a más funcionalidad de las capacidades de tareas de Java que implementar la interfase Runnable 2)Usar la interfase Runnable significa que no tienes que crear una instancia de la clase Thread y llamar al método run directamente.

154

javaHispano. Tu comunidad, tu lenguaje. 3)Utilizando ambas, La interfase Runnable y heredar de la clase Thread requiere el llamado al método start para comenzar la ejecución 4)La interfase Runnable requiere únicamente implementar un método, que es llamado
run

Pregunta 3) ¿Qué ocurrirá cuando intentes compilar y ejecutar el siguiente código?
public class Runt extends Thread{ public static void main(String argv[]){ Runt r = new Runt(); r.run(); } public void run(){ for(int i=0;i<100;i++) System.out.println(i); }

}

1)Compila y tiene como salida una cuenta de 1 a 99

2)Compila pero no tiene salida 3)Error en tiempo de compilación: La clase Runt es una clase abstracta. No puede ser instanciada 4)Error en tiempo de compilación, el método start no ha sido definido Pregunta 4) ¿Cuáles de las siguientes frases es cierta? 1)Para implementar el Threading en un programa debes importar la clase
java.io.Thread

2)El código que se ejecuta cuando inicias un hilo es colocado en el método run 3)Los Threads pueden compartir datos entre unos y otros 4)Para comenzar la ejecución de un Thread, llamas al método start y no al método run.

Respuestas Respuesta 1) 3) Error en tiempo de compilación: La clase Runt es una clase abstracta. No puede ser instanciada

155

Tutorial para el examen de certificación: SCJP 1.2 La clase implementa Runnable pero no define el método run. Respuesta 2) 3) Usar la interfase Runnable significa que no tienes que crear una instancia de la clase Thread y llamar al método run directamente. 4) La interfase Runnable requiere únicamente implementar un método, que es llamado
run

Respuesta 3) 1)Compila y tiene como salida una cuenta de 1 a 99 Sin embargo, observa que este código no inicia la ejecución del hilo y el método run no debe ser llamado de esta forma. Respuesta 4) 2)El código que se ejecuta cuando inicias un hilo es colocado en el método run 3)Los Threads pueden compartir datos entre unos y otros 4)Para comenzar la ejecución de un Thread, llamas al método start y no al método run. No necesitas importar ninguna clase ya que el Threading es una parte integral de Java.

Otras Fuentes sobre este tema Este tema esta cubierto en el tutorial de sun en http://java.sun.com/docs/books/tutorial/essential/threads/customizing.html Richard Baldwin cubre este tema en http://www.Geocities.com/Athens/Acropolis/3797/Java058.htm#two ways to thread Jyothi Krishnan sobre este tema en http://www.geocities.com/SiliconValley/Network/3693/obj_sec7.html#obj22 La parte de Threads del Tutorial de Elliot Rusty Harold http://www.ibiblio.org/javafaq/course/week11/index.html

156

El hilo: public class TSleep extends Thread{ public static void main(String argv[]){ TSleep t = new TSleep(). aunque encuentro difícil de creer que alguien pueda trabajar en una máquina o implementación de Java que trabaje a ese nivel de precisión. nota como el método sleep lanza InterruptedException. El siguiente es un ejemplo para poner a dormir un hilo. El método sleep es estático y detiene la ejecución de un hilo por un número fijo de milisegundos.javaHispano.start(). tu lenguaje. } }catch(InterruptedException ie){} } } 157 . Objetivo 2) Reconocer las condiciones que puedan impedir que un Thread se ejecute Comentario de este objetivo La expresión “impedir que un thread se ejecute” es ligeramente ambigua. o también incluye hilos que han muerto?. ¿significa que un hilo ha sido pausado deliberadamente. Tu comunidad.println("looping while"). t. } public void run(){ try{ while(true){ this.out. Se dice que un hilo a sido bloqueado cuando se le ha impedido ejecutarse.sleep(1000). System. y wait/notify son probablemente las más importantes de las situaciones por las que un hilo pueda ser bloqueado. Para propósitos del examen sleep(). y se volverá ejecutable con un mensaje notify o notifyAll. Existe una versión que supuestamente debe pausar por un número fijo de nanosegundos. Razones por las que un thread puede ser bloqueado Un hilo puede ser bloqueado por que: Ha sido puesto a dormir por una cantidad de tiempo • Ha sido suspendido por una llamada al método suspend() y estará bloqueado hasta una llamada al método resume() • El hilo ha sido suspendido por una llamada al método wait().

Si el hilo objetivo mantiene un bloqueo sobre el monitor protegiendo un recurso de sistema crítico cuando queda suspendido.Tutorial para el examen de certificación: SCJP 1. System. Si el Hilo que intenta resumir al hilo objetivo intenta realizar un bloqueo antes de llamar a resume(). El bloqueo del Thread vía el protocolo wait/notify es cubierto en el siguiente tema Pregunta 1) ¿Qué ocurrirá cuando intentes compilar y ejecutar el siguiente código? public class TGo implements Runnable{ public static void main(String argv[]){ TGo tg = new TGo().sleep(1000).println("looping while"). } public void run(){ while(true){ Thread. ningún otro hilo puede acceder a este recurso hasta que el hilo objetivo es reiniciado. los métodos de la clase Thread : stop.start(). no se recomienda que se usen y al utilizarlos se envía una advertencia en tiempo de compilación).stop.resumen? //End Quote Una fuente generalmente confiable (Kathy Kozel) ha indicado que tienes que estar conciente de esto para propósitos del examen. t. Las notas del JDK indican lo siguiente: //Quote Obsoleto. Tales deadlocks típicamente se manifiestan como procesos “congelados”. ya que es inherentemente propenso a crear deadlocks. ocurre un deadlock.out. suspend y resume han quedado obsoletos (depracated. Thread.2 Con la salida de Java 2. Yo asumiré que actualmente no necesitas conocer como usarlos. } } } 1)Compila y no tiene salida 158 .currentThread(). Thread t = new Thread(tg). Para mas información vea ¿Por que son Obsoletos los métodos: Thread. Este método ha sido censurado.suspend y Thread.

2)Compila y tiene como salida el texto “looping while” repetidamente 3)Compila y tiene como salida el texto “looping while” una sola vez 4)Error en tiempo de compilación Pregunta 2) ¿Cuál de las siguientes formas es una manera recomendada para que un Thread pueda ser bloqueado? 1)sleep() 2)wait/notify 3)suspend 4)pause Pregunta 3) ¿Cuáles de las siguientes frases son verdaderas? 1)El método sleep toma parámetros del Hilo y el número de segundos que debe dormir 2)El método sleep toma un solo parámetro que indica el número de segundos que debe dormir 3)El método sleep toma un solo parámetro que indica el número de milisegundos que debe dormir 4)El método sleep es un método estático de la clase Thread Respuestas Respuesta 1) 4 )Error en tiempo de compilación El método sleep lanza InterruptedException y de esta manera este código no compilara hasta que el ciclo while quede envuelto en un bloque try/catch Respuesta 2) 1)sleep() 2)wait/notify Para la plataforma Java 2 el método suspend ha sido censurado y de esta manera es válido pero no recomendado. Respuesta 3) 159 . Tu comunidad.javaHispano. tu lenguaje.

geocities.com/docs/books/tutorial/essential/threads/waitAndNotify.html#obj23 Comentario de métodos deprecados en http://java.0/preview/threads.htm#the notify() and wait() methods Jyothi Krishnan sobre este tema en http://www.com/Athens/Acropolis/3797/Java058.html Richard Baldwin cubre este tema en http://www.2 3)El método sleep toma un solo parámetro que indica el número de milisegundos que debe dormir 4)El método sleep es un método estático de la clase Thread Otras Fuentes sobre este tema Este tema esta cubierto en el tutorial de sun en http://java.geocities.Tutorial para el examen de certificación: SCJP 1.sun.com/SiliconValley/Network/3693/obj_sec7.com/docs/books/tutorial/post1.html 160 .sun.

y notifyAll. Es generalmente más común sincronizar un método que un bloque de código. Así un usuario podría obtener los datos. notify. Para un método la palabra clave synchronized se coloca antes de la definición del método: synchronized void amethod() { /* method body */} Para un bloque de código la palabra va antes de la apertura y cerradura de llaves. Nota que el bloqueo esta basado en el objeto y no en el método. y notifyAll. Si en el entretanto alguien más ha recuperado los datos. e imaginar que es un campo en una base de datos.javaHispano. Se asigna un bloqueo al objeto y así se asegura que únicamente un hilo a la vez pueda acceder al código. para proteger el código contra los problemas de acceso concurrente y la comunicación entre los hilos. wait. La entrada al código esta protegida por un supervisor o monitor de bloqueos. notify. Objetivo 3) Escribir código utilizando: synchronized. realizar un cálculo y escribir los datos. Así cuando un hilo empieza a ejecutar un bloque sincronizado este adopta el bloqueo. Cualquier otro hilo no podrá ejecutar el código hasta que el primer hilo haya finalizado y liberado el bloqueo. ha realizado un cálculo y lo ha escrito. los segundos cálculos de los usuarios se perderán cuando la primera persona escriba en la base de datos. Tu comunidad. por ejemplo una variable entera. wait. synchronized La palabra clave synchronized se utiliza para marcar una sentencia o bloque de código e indicar que únicamente un hilo a la vez puede ejecutar una instancia del código. Este proceso es implementado por un sistema de bloqueos. ¿Por qué necesitarías el protocolo wait/notify? Una manera de pensar en una utilidad para el protocolo wait/notify es imaginar un dato. Si no tienes algún mecanismo de bloqueo en la base de datos existe la posibilidad de corromper los datos. synchronized (ObjectReference) { /* Block body */ } El valor entre paréntesis indica el objeto o clase que necesita obtener el supervisor. tu lenguaje. Definir la interacción de bloqueos entre hilos y entre hilos y objetos cuando ejecutan los métodos: synchronized. 161 .

Tutorial para el examen de certificación: SCJP 1. Esto normalmente ocurre para permitir a otro hilo obtener el bloqueo y continuar algún proceso. cada objeto es hijo de una gran clase ancestro llamado Object desde la cual obtienen la capacidad de comunicación entre hilos. El método wait sin embargo 162 . el código a primera vista muestra que el ciclo será infinito. De esta manera el beneficio por la sincronización es mayor que colocando la palabra reservada synchronized antes de un bloque de código. cada objeto tiene un sistema que le permite hacer una pausa o esperar (wait) aunque otro hilo tome el bloqueo. wait y notify deben colocarse dentro del código sincronizado para asegurar que el código actual posee al supervisor de threads. }catch (InterruptedException e) {} } // alguna otra accion va aqui notifyAll(). synchronized void second().2 Cuando un bloque de código sincronizado se ejecuta. wait/notify Además de tener un bloqueo que puede fijarse y luego liberarse. Como la condición a evaluar es notoriamente verdadera esta permanecerá así. como el siguiente: //codigo producto while(true){ try{ wait(). Un ejemplo típico del uso del protocolo wait/notify es para permitir la comunicación entre los Hilos que aparentemente involucran un ciclo infinito. Esto permite a los hilos poder comunicarse la condición de disponible para poder ejecutarse Debido a la naturaleza de herencia simple en Java. El método wait es incoherente sin el uso de notify o notifyAll los cuales permiten que el código que está esperando ser notificado pueda despertarse y continuar ejecutándose. el objeto es bloqueado y no puede ser llamado por cualquier otro código hasta que el bloqueo sea liberado: synchronized void first(). Una llamada a wait dentro del código sincronizado causa que el hilo active su bloqueo y se ponga a dormir.

Por supuesto esto no siempre es posible y tendrás que intentar probar tu código en tantas plataformas como te sea posible. la planificación de hilos es dependiente de la plataforma. Tu comunidad.javaHispano. efectivamente significa activa el bloqueo sobre el objeto y espera hasta que el método notify o notifyAll sea llamado para liberarlo. . Si tienes en espera múltiples hilos entonces se levantara el hilo que lleva más tiempo esperando. A diferencia del resto de Java. ya que las prioridades de los hilos influirán en el resultado. Sin embargo no puedes asegurarlo. El método notify despertará un hilo que espera ser reactivado por el supervisor de hilos para el objeto. En el segundo sistema cada hilo consigue un "pedazo" del tiempo de CPU y entonces se mueve al estado de listo. Esto asegura que un solo hilo no pueda obtener todo el tiempo del CPU. La desventaja es que no puedes estar seguro cuánto tiempo tardará un Hilo en ejecutarse. tu lenguaje. Preguntas Pregunta 1) ¿Cuales de las siguientes palabras claves indican a un hilo que libere el objeto que esta bloqueando? 163 . Si tienes sólo un hilo en espera entonces no tendrás ningún problema. de la mas baja 1 a la más alta que es 10. debes tomar en cuenta que algunas plataformas reconocerán estas prioridades con precisión pero otras no. Aunque Java define prioridades para los hilos. La planificación de hilos es dependiente de la implementación y no puede asegurarse una actuación similar en cada JVM. Como resultado generalmente se te aconseja que uses notifyAll en lugar de notify para no hacer suposiciones con la planificación o las prioridades. No puedes estar seguro de qué hilo se levantara. Existen dos maneras conocidas para la planificación de hilos: • • Preemtive (Preventivo o apropiativo) Time Slicing (Division o fragmentación de tiempos) En el primer sistema un programa puede "apropiarse" de otro para conseguir su porción de tiempo de CPU.

Pregunta 3) ¿Que pasará cuando intentes compilar y ejecutar el siguiente bloque de código? public class WaNot{ int i=0. } public void amethod(){ while(true){ try{ wait(). 3)Da acceso exclusivo al monitor a las palabras clave notify/notifyAll. }//End of while }//End of amethod }//End of class 1)Error en tiempo de compilación. public static void main(String argv[]){ WaNot w = new WaNot(). w. }catch (InterruptedException e) {} i++.2 1) release 2) wait 3) continue 4) notifyAll Pregunta 2) ¿Cuál de las siguientes frases define mejor la función de la palabra clave synchronized? 1)Permite que más de un Hilo acceda a un método simultáneamente. pero se crea un ciclo infinito dentro del ciclo while 3)Se compila y ejecuta 4)Se genera un error en tiempo de Ejecución: “IllegalMonitorStatException” Pregunta 4) 164 . no hay una llamada a notify() dentro del método 2)Se compila y ejecuta.Tutorial para el examen de certificación: SCJP 1.amethod(). 4)Significa que sólo un hilo en un momento puede acceder a un método o bloque de código. 2)Permite que más de un Hilo obtenga el bloqueo de un Objeto sobre una referencia.

En este caso la llamada al código no tiene bloqueo sobre el objeto y de esta manera se generará un error en tiempo de compilación. Cómo puedes especificar qué hilo es el notificado con el protocolo wait/notify 1)Pasando la referencia del objeto como parámetro al método notify 2)Pasando el nombre del método como parámetro al método notify 3)Usando el método notifyAll y pasando la referencia del objeto como referencia 4)Ninguna de las anteriores Pregunta 5) ¿Cuáles de las siguientes afirmaciones son verdaderas? 1)Java usa un sistema de planificación basado en la división de tiempos para determinar qué Hilo se ejecutará 2)Java usa un sistema apropiativo cooperativo para determinar qué Hilo se ejecutará 3)La planificación de hilos en Java es dependiente de plataforma y puede variar de una implementación a otra 4)Tu puedes fijar la prioridad de un hilo en el código Respuestas Respuesta 1) 2) wait Respuesta 2) 4)Significa que sólo un hilo en un momento puede acceder a un método o bloque de código. Tu comunidad. tu lenguaje. Respuesta 3) 4)Se genera un error en tiempo de Ejecución: “IllegalMonitorStatException” El protocolo wait/notify se puede usar solamente dentro del código sincronizado.javaHispano. Respuesta 4) 4)Ninguna de las anteriores 165 .

com/Athens/Acropolis/3797/Java058.geocities.com/docs/books/tutorial/essential/threads/waitAndNotify.htm Jyothi Krishnan en: http://www.Tutorial para el examen de certificación: SCJP 1.sun.2 El protocolo wait/notify no ofrece un método para especificar que hilo se notificará.com/SiliconValley/Network/3693/obj_sec7.html Richard Baldwin Covers lo cubre en: http://www. Respuesta 5) 3)La planificación de hilos en Java es dependiente de plataforma y puede variar de una implementación a otra 4)Tu puedes fijar la prioridad de un hilo en el código Otras Fuentes para este tema: Este tema es cubierto en tutorial de Sun: http://java.html#obj24 Bruce Eckel Thinking in Java Capítulo 14 166 .geocities.

1. Éste tema es lo referente al GridBaglayout. Si se acaba el espacio hacia la derecha entonces envuelve los componentes a la próxima línea El siguiente código crea una aplicación sencilla y agrega una serie de botones. Comparando la disposición de componentes de Java y Visual Basic Comparada con herramientas como Visual Basic o Delphi.javaHispano. Core Java dice: "el uso de GridBagLayout puede ser increíblemente complejo". Tu comunidad. Visual Age. La filosofía de los administradores de disposición El administrador de disposición FlowLayout es un buen lugar para empezar ya que es el administrador de disposición por defecto para los applets. La mayoría de las herramientas de diseño usan una filosofía basada en la posición XY de píxeles para colocar un componente.awt para presentar interfaces graficas de usuario (GUI) con una apariencia especifica. JBuilder etc etc. Aunque es complejo utilizarlo de manera manual. Peter va der Linden en su libro "Just Java and Beyond" 3a Edición lo describe como algo excesivamente complicado y no lo recomienda. Nota sobre este objetivo Aunque el enunciado anterior no lo menciona específicamente. El administrador de disposición FlowLayout simplemente coloca los componentes sobre el fondo uno después de otro de izquierda a derecha. pero debido a la utilidad que proporciona puede ser un poco complejo su aprendizaje.awt y su disposición Objetivo 1. El paquete java. varias herramientas de desarrollo como VisualCafe. Java usa una filosofía distinta para la disposición de componentes. redimensionar su comportamiento y distinguir las responsabilidades entre los administradores de disposición y los contenedores. lo hacen más fácil de entender. Sección 8. Escribir código que use las clases administradoras de disposición (Layout Manager) y los contenedores (Container) de componentes del paquete java. En contraste Java usa clases de disposición para controlar donde será colocado un componente de acuerdo a la pantalla actual. Así en Visual Basic puedes tomar una caja de texto de la paleta de componentes y colocarla en una posición especifica en la forma o área de diseño. Tiene sentido cubrirlo ya que es un administrador de disposición muy útil. este objetivo involucra un nuevo tema comparado con el examen para la versión1. 167 . tu lenguaje. y esa posición será fija.

} FlowAp(){ add(new Button("One")).awt.300). add(new Button("Three")).Tutorial para el examen de certificación: SCJP 1.setSize(400. fa. add(new Button("Four")).2 import java. add(new Button("Eight")). add(new Button("Two")).setLayout(new FlowLayout()).*.setVisible(true). }//End of constructor }//End of Application La siguiente imagen tiene la apariencia por defecto que tendrá la aplicación cuando la ejecutes desde la línea de comandos: Apariencia por defecto de la aplicación FlowAp 168 . add(new Button("Six")). fa. add(new Button("Nine")). public class FlowAp extends Frame{ public static void main(String argv[]){ FlowAp fa=new FlowAp(). //Change from BorderLayout default fa. add(new Button("Seven")). add(new Button("Ten")). add(new Button("Five")).

Para los propósitos del examen por lo menos debes familiarizarte con el manejo de los administradores de disposición para la creación de GUI. Si haces el Frame más pequeño FlowLayout cambiaría la disposición para que los botones se envuelvan alrededor en varias filas. Apariencia de la aplicación FlowAp después de redimensionar su tamaño. Cuando te encuentras por primera vez con estos administradores de componentes pueden parecerte un poco arbitrarios. Administradores de disposición que debes conocer para el examen. El administrador de disposición FlowLayout automáticamente cambia la disposición de los componentes cuando el Frame se redimensiona. Ten presente que ambas imágenes visualizan exactamente el mismo código Java. Para el examen. Algunas herramientas de desarrollo de aplicaciones como Symantec Visual Café o Borland/Inprise Jbuilder ofrecen maneras para especificar la posición de los componentes. debes conocer los siguientes administradores de disposición: • • • • FlowLayout BorderLayout GridLayout GridBagLayout Responsabilidades de los Administradores de Disposición VS los Contenedores 169 .javaHispano. tu lenguaje. Tu comunidad. Lo único que ha cambiado es la anchura del Frame.

2 Los contenedores y los administradores de disposición trabajan en equipo. public class FlowAp extends Frame{ public static void main(String argv[]){ FlowAp fa=new FlowAp(). add(new Button("Four")). Los administradores de disposición generalmente controlan donde se colocarán los componente. add(new Button("Eight")). fa. // fa. Aquí una muestra que ilustra esto: import java. puedes conseguir resultados inesperados. add(new Button("Five")).setLayout(new FlowLayout()). add(new Button("Two")).300). }//End of constructor }//End of Application Usando el administrador BorderLayout por defecto 170 .awt. Un componente puede asignarse una fuente especifica para sí mismo. Un contenedor controlará la fuente predefinida para estos componentes. add(new Button("Ten")).setSize(400. fa. add(new Button("Nine")). Curiosidades del administrador BorderLayout Si agregas múltiples componentes a un contenedor que utiliza el administrador BorderLayout pero no pasas una de sus constantes como parámetro (North. South. add(new Button("Six")). Te pueden dar un texto que describa la configuración de un contenedor de componentes y preguntarte que color de fondo y que fuente tendrá un botón o una etiqueta al visualizarse. add(new Button("Seven")).Tutorial para el examen de certificación: SCJP 1.setVisible(true). } FlowAp(){ add(new Button("One")). etc).*. add(new Button("Three")).

tu lenguaje.*. Como resultado la apariencia es que sólo tienes un botón. import java.300). Así en el ejemplo anterior cada botón se ha colocado encima del botón anterior y ha ocupado enteramente el área disponible.javaHispano.5)). La razón por la que obtienes este botón grande en el centro es que el administrador de disposición BorderLayout usa un conjunto de coordenadas al colocar los componentes. En cambio los diseñadores decidieron hacer a el centro del área del esquema el valor por defecto. Tu comunidad. A diferencia de BorderLayout y de FlowLayout ignora cualquier tamaño predefinido del componente. Divide el área de la superficie en una cuadrícula y cuando agregas componentes los pone uno después el otro de izquierda a derecha y de arriba hacia abajo. Sin embargo necesitas conocerlo para el examen y necesitas ser consciente de que tiene como valor predefinido poner todos los componentes en el centro. //definimos el GridLayout con 2 filas y 5 columnas fa. El administrador FlowLayout intenta asegurarse que un botón mantenga su tamaño predefinido. El administrador de disposición GridLayout El administrador GridLayout hace aproximadamente lo que esperabas que hiciera. El GridLayout de la única cosa de la que se preocupa es asegurarse que el componente se ajuste en la cuadrícula El código siguiente pone un conjunto de botones dentro de un Frame que utiliza un GridLayout que ha sido fijado para tener 2 filas y 5 columnas. Por ejemplo el tamaño predefinido de un botón será el ancho suficiente para mostrar su texto. public class GridAp extends Frame{ public static void main(String argv[]){ GridAp fa=new GridAp(). fa. Divide el área de la superficie en: • • • • • North (Norte) South (Sur) East (Este) West (Oeste) Center (Centro) Podrías suponer que el valor por defecto para los componentes cuando los vas colocando es irse colocando en el sentido de las agujas del reloj alrededor de los puntos de su circunferencia o en algún otro orden similar. el último agregado.setLayout(new GridLayout(2.setSize(400. no es el más utilizado de los administradores de disposición.awt. 171 . Debido a que el administrador de disposición BorderLayout sólo divide el área en las cinco coordenadas mencionadas anteriormente.

Tutorial para el examen de certificación: SCJP 1.2
fa.setVisible(true); } GridAp(){ add(new Button("One")); add(new Button("Two")); add(new Button("Three")); add(new Button("Four")); add(new Button("Five")); add(new Button("Six")); add(new Button("Seven")); add(new Button("Eight")); add(new Button("Nine")); add(new Button("Ten")); }//fin del constructor }//fin de la Aplicacion

Ejemplo con GridLayout

Observa como los botones son alargados para ocupar todo el espacio disponible del Frame.

GridBagLayout
Peter van der Linden en su libro Just Java and Beyond describe al administrador de disposición GridBagLayout como “excesivamente complicado”. Core Java solo dice: “usar GidBagLayout puede ser increíblemente complicado”. Aunque es complejo manejarlo manualmente, varias herramientas de desarrollo como Visual Café, Visual Age, JBuilder, etc. Lo hacen más fácil de usar, sin tener que entenderlo. JBuilder

172

javaHispano. Tu comunidad, tu lenguaje. modifica fácilmente el método add para incluir los detalles siguientes en una instancia de la clase GridBagLayout.
add(pAps,new GridBagConstraints2(1, GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, 3, 0.0, 0.0,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), -3, 45));

Pero cuando creas tu código manualmente no necesita parecer tan complejo como este. Comentarios de las personas que han realizado el examen indican que las preguntas sobre GridBagLayout no son muy profundas y una comprensión básica de los distintos campos de la clase GridBagConstraints puede ser adecuada para realizar el examen.
GridBagLayout es un poco parecido a GridLayout sólo que las filas de la cuadrícula

pueden tener alturas diferentes, y las columnas pueden tener anchuras distintas. La documentación de Java2 viene con un applet de demostración que muestra lo que puede hacerse con el administrador de disposición GridBagLayout.. Uno de los problemas con el GridBagLayout es que en lugar de estar basado estrictamente en la cuadrícula subyacente, Java intenta definir las celdas de acuerdo a la información dada. El administrador de disposición GridBagLayout usa una clase auxiliar llamada GridBagConstraints que tiene un conjunto de variables miembro que pueden ajustarse para afectar la apariencia de cada componente agregado. Los campos que modificas en la clase GridBagConstraints "sugieren" donde irán los componentes. Una instancia de GridBagConstraints se pasa como un parámetro al método add, en la forma:

add(component, GridBagConstraint);

GridBagConstraints contradice la convención general en Java, ya que tu esperarías

poder configurarlo con el método:
setFooParam()

Donde FooParam podría ser el valor X/Y o un relleno entre los componentes. En cambio toma la forma:
GridBagLayout gbl=new GridBagLayout(); gbl.weightx=100;

173

Tutorial para el examen de certificación: SCJP 1.2 Si usas GridBagLayout sin usar la clase GridBagConstraints éste actúa un poco como FlowLayout, colocando simplemente uno por uno los componentes en el fondo. He creado un applet de demostración sencillo con su código fuente que muestra cómo no cambia la apariencia a menos que juegues con los valores de la clase
GridBagConstraints http://www.software.u-net.com/applets/GridBagDemo/GridBagTest.htm

El administrador GridBagLayout actúa un poco más como GridLayout si usas las clases GridBagConstraints y utilizas los campos gridx y gridy para asignar una posición en una cuadrícula "virtual" para cada componente que agregues. El applet demuestra esta posibilidad. Esto todavía es un poco torpe y muy parecido a los otros administradores de disposición. Las cosas empiezan a ponerse mucho más interesante cuando empiezas a modificar otros campos de la clase GridBagConstraints para modificar la apariencia de los distintos componentes dentro de esta cuadrícula "virtual". Recuerda que aunque necesitas entender esto para los propósitos del examen, podría ser más fácil que cuando estés programando en el mundo real una combinación de controles de contenedores con otros administradores de disposición. Un ejemplo de cuando esto no es una buena opción es cuando necesita redimensionar dinámicamente componentes. Ésta es una situación en donde herramientas de desarrollo como Visual Cafe o JBuilder no son de mucha ayuda y una buena comprensión del GridBagLayout puede ser esencial. He creado un applet de demostración: http://www.software.u-net.com/applets/GridBagDemo/GridBagDynamic.htm que muestran el efecto de cambiar los parámetros de relleno dinámicamente para un solo botón en un grupo de botones desplegados con GridbagLayout Los campos de la clase GridBagConstraints son:
• • • • • • •

gridx gridy gridwidth y gridheight fill ipadx e ipady insets anchor weightx y weighty

Hojeando el excelente libro de Bill Brogdens Java2 Exam Cram, encontré una demostración comprensiva del GridBagLayout en: http://www.austria.eu.net/java/programs/applets/missgable/index.htm

174

javaHispano. Tu comunidad, tu lenguaje.

Usando gridx y gridy para sugerir la posición de un componente
Para este ejemplo supondremos que estas escribiendo el código necesario para diseñar el programa de una agenda. Mostrarás la hora de la cita abajo a la izquierda y los detalles de la cita abajo a la derecha. Las unidades de tiempo serán de media hora. Debido que una cita puede cubrir más de una unidad de tiempo; por ejemplo puede durar una hora y media, necesitaras poder cambiar la altura de los detalles de la cita dinámicamente para cubrir más de una unidad de tiempo. Debido a este requerimiento, de tener una altura variante para los detalles de las citas, utilizar GridLayout no es muy conveniente. Estarás poniendo paneles en el Frame como contenedores. El primer paso es asegurarse que cada panel este lado a lado en el Frame principal de la Aplicación.
import java.awt.*; import java.awt.event.*; public class GBCal extends Frame{ Panel pTimes=new Panel(); Panel pAps=new Panel(); TextField txTimes=new TextField("09.00"); TextField txAps=new TextField("Meet the boss"); GridBagLayout gbl=new GridBagLayout(); GridBagConstraints gbc=new GridBagConstraints(); public static void main(String argv[]){ GBCal gbc=new GBCal(); gbc.setLayout(new FlowLayout()); } public GBCal() { pTimes.add(txTimes); pAps.add(txAps); setLayout(gbl); gbc.gridx=0; gbc.gridy=0; pTimes.setBackground(Color.pink); add(pTimes,gbc); gbc.gridx=1; gbc.gridy=0; pAps.setBackground(Color.lightGray); add(pAps,gbc); setSize(300,300); setVisible(true); } }

175

Tutorial para el examen de certificación: SCJP 1.2 Observa cómo las clases GridBagLayout y GridBagConstraints trabajan juntas. La instancia de GridBagConstraints gbc se reutiliza cada vez que se agrega un componente. En ningún punto especificas el número de filas y columnas para la cuadrícula, puesto que la clase GridBagLayout lo deduce de los campos gridx y gridy de la instancia de la clase GridBagConstraints.

Este es el resultado:

ipadx y ipady para controlar el relleno interior de los componentes
El código ha puesto un color del fondo distinto para que puedas ver la magnitud de cada panel en lugar de ver simplemente la anchura de los campos de texto. Esto está bien, pero pensemos que ahora quieres que los campos de texto se estiren y abarquen de izquierda a derecha todo el Frame de la aplicación principal. Esto se puede realizar modificando el campo ipadx de la clase GridBagConstraints. Esto puede ejecutarse poniendo:
gbc.ipadx=30; para las horas y gbc.ipadx=100; para los detalles

El código queda:
import java.awt.*; import java.awt.event.*;

176

javaHispano. Tu comunidad, tu lenguaje.
public class GBCal extends Frame{ Panel pTimes=new Panel(); Panel pAps=new Panel(); TextField txTimes=new TextField("09.00"); TextField txAps=new TextField("Meet the boss"); GridBagLayout gbl=new GridBagLayout(); GridBagConstraints gbc=new GridBagConstraints(); public static void main(String argv[]){ GBCal gbc=new GBCal(); gbc.setLayout(new FlowLayout()); } public GBCal() { pTimes.add(txTimes); pAps.add(txAps); setLayout(gbl); gbc.gridx=0; gbc.gridy=0; gbc.ipadx=30; pTimes.setBackground(Color.pink); add(pTimes,gbc); gbc.gridx=1; gbc.gridy=0; gbc.ipadx=100; pAps.setBackground(Color.lightGray); add(pAps,gbc); setSize(300,300); setVisible(true); } }

y este es el resultado:

177

Tutorial para el examen de certificación: SCJP 1.2

Componentes dentro de un panel utilizando GridBagLayout
Para el próximo paso quiero proporcionar a cada panel su propio administrador de disposición GridBagLayout y agregar hendiduras para unidades de tiempo adicionales. Para propósitos de este ejemplo agregaré solo una hendidura de tiempo mas y simplemente estiraré el cuadro de texto del detalle de la cita para cubrir las hendiduras de las unidades de tiempo entre las 9.00 y 9.30. Para hacer esto crearé una nueva instancia de la clase GridBagLayout llamada gbBut y la usare para preparar la cuadrícula para el panel pTimes para colocar las hendiduras de las unidades de tiempo una encima de otra verticalmente. El código para realizar lo anterior es el siguiente:
//Controlar el panel de los tiempos con GridBagLayout pTimes.setLayout(gbBut); gbc.gridx=0; gbc.gridy=0; pTimes.add(txTimes9,gbc); gbc.gridx=0; gbc.gridy=1; pTimes.add(txTimes930,gbc);

Y este es el código completo:
import java.awt.*; import java.awt.event.*; public class GBCal extends Frame{ Panel pTimes=new Panel(); Panel pAps=new Panel(); TextField txTimes9=new TextField("09.00"); TextField txTimes930=new TextField("09.30"); TextField txAps=new TextField("Meet the boss"); GridBagLayout gbl=new GridBagLayout(); GridBagLayout gbBut=new GridBagLayout(); GridBagConstraints gbc=new GridBagConstraints(); public static void main(String argv[]){ GBCal gbc=new GBCal(); gbc.setLayout(new FlowLayout()); } public GBCal() { setLayout(gbl); //Controlar el panel de tiempo con //GridBagLayout pTimes.setLayout(gbBut);

178

gbc).gridy=0.gridx=0.gbc). gbc.add(txTimes9. pTimes.gbc). pTimes. setSize(300. gbc. add(pAps. gbc.ipadx=30. gbc.gridx=0. pero desafortunadamente el espacio para el detalle de la cita tiene 179 .gridy=1. gbc.gridy=1.gridx=0.lightGray). gbc.add(txAps.gridx=0. gbc.javaHispano. //Reutilizamos gbc para la disposición del panel principal gbc.gbc).setBackground(Color.300). pAps. add(pTimes.add(txTimes930. gbc. gbc. tu lenguaje. pAps.setBackground(Color. pTimes. setVisible(true). gbc.gridx=1. } }// fin de la clase El resultado es el siguiente: Esto esta trabajando bien hasta cierto punto. Tenemos ahora dos hendiduras para las unidades de tiempo.gbc).setLayout(gbBut).pink).ipadx=100.gridy=0.gridy=0. Tu comunidad. pAps. gbc.

TextField txTimes930=new TextField("09. Lo que quiero ahora es fijarla hasta arriba y estirarla para que cubra las dos hendiduras de tiempo. Fijando componentes dentro de la cuadrícula Si un componente no-llena el área completa. import java. public static void main(String argv[]){ GBCal gbc=new GBCal().SOUTHWEST GridBagconstraints. } public GBCal() { setLayout(gbl). Panel pAps=new Panel().WEST GridBagconstraints.2 como valor predefinido el centro del campo de las citas y obtenemos una fila gruesa.00"). GridBagLayout gbl=new GridBagLayout().setLayout(new FlowLayout()). TextField txTimes9=new TextField("09.NORTHWEST En este caso quiero posicionar los campos en la parte superior (North) de los paneles que los contienen. gbc.awt.SOUTHEAST GridBagconstraints.NORTH GridBagconstraints.event. //Controlamos el panel de tiempos con GridBagLayout pTimes.setLayout(gbBut).*. 180 . public class GBCal extends Frame{ Panel pTimes=new Panel().Tutorial para el examen de certificación: SCJP 1. puedes especificar en que parte del área lo quieres usando el campo anchor de la clase GridBagConstraints. GridBagConstraints gbc=new GridBagConstraints().*. Aquí esta el código: import java.awt.30"). TextField txAps=new TextField("Meet the boss"). Los posibles valores son: GridBagconstraints. He aumentado el espesor del campo del detalle de la cita aumentando el valor de ipady para la dirección del campo.NORTHEAST GridBagconstraints.SOUTH GridBagconstraints.EAST GridBagconstraints.CENTER GridBagconstraints. GridBagLayout gbBut=new GridBagLayout().

gbc). pTimes.gridx=0. } }//fin de la clase Y este es el resultado: 181 .gridx=1. gbc. pAps.gridy=1. add(pAps.ipadx=30. //Aseguramos que los components se coloques //en la parte superior gbc.gridy=0. gbc. gbc. gbc. //Reutilizamos gbc para el panel principal gbc.300).gbc). gbc. pAps.ipady=12. Tu comunidad.gridx=0. gbc.setBackground(Color. pTimes.gridy=0. gbc. gbc.gridx=0. setVisible(true). tu lenguaje.add(txAps.anchor=GridBagConstraints.gridx=0.add(txTimes9.pink). gbc.gbc).gbc).gbc). setSize(300.ipadx=100. pAps.gridy=0. gbc.javaHispano.setBackground(Color.NORTH. gbc. gbc.gridy=1.setLayout(gbBut). add(pTimes. pTimes.add(txTimes930.lightGray).

HORIZONTAL GridBagConstraints.VERTICAL GridBagConstraints. Éstas son: GridBagConstraints.2 Elementos GridBag no cubiertos por este ejercicio Este ejercicio ha cubierto los siguientes campos de la clase GridBagConstraints : • • • ipadx/y gridx/y anchor La clase GridBagConstraints tiene los siguiente campos importantes: • • • • weightx/y fill gridwidth/height insets Los campos weightx/y controlan cómo un área crece o se contrae más allá de su tamaño inicial.Tutorial para el examen de certificación: SCJP 1. El campo insets indica el relleno "externo" que tendrá a lo largo de los límites de la celda de la cuadrícula.BOTH Los campos del gridwidth/height determinan cuántas columnas y filas tendrá un componente. Así que si pones el campo weighty a cero el campo seguirá manteniendo su altura constante aun cuando redimensiones la ventana. 182 . El campo fill controla cómo un componente se estira para llenar el área.NONE GridBagConstraints. Al igual que el campo anchor puedes definir los valores del campo fill usando constantes ya definidas de la clase GridBagConstraints.

el administrador FlowLayout posicionará el componente 183 . } FlowAp(){ add(new Button("One")). "Two"."Four" colocados de arriba hacia abajo 3)Un Frame con un botón grande etiquetado con "Four" en el Centro 4)Se generará un error al momento de la ejecución indicando que no has puesto un LayoutManager Pregunta 2) ¿Cómo indicas dónde se posicionará un componente utilizando Flowlayout? 1)Utilizando las constantes North. Tu comunidad. South. add(new Button("Three")).javaHispano. fa. public class FlowAp extends Frame{ public static void main(String argv[]){ FlowAp fa=new FlowAp().*.300). West 2)Asignando una referencia fila/columna 3)Pasando un porcentaje X/Y como parámetro al método add 4)No es necesario indicarlo.awt. fa. tu lenguaje. add(new Button("Two")). add(new Button("Four")). }//fin del constructor }//fin de la Application 1)Un Frame con botones etiquetados con "One"."Four" colocados encada esquina 2)Un Frame con botones etiquetados con "One".setSize(400. Preguntas Pregunta 1) ¿Cuál será la apariencia de un applet con el código siguiente? import java. "Two". "Three". East.setVisible(true). "Three".

2 Pregunta 3) ¿Cómo le haces para cambiar al administrador de disposición actual a un contenedor? 1)Usando el método setLayout 2)Una vez creado no puedes cambiar el administrador de disposición de un componente 3)Usando el método setLayoutManager 4)Usando el método updateLayout Pregunta 4) ¿Qué pasa si agregas una Scrollbar en la parte Norte de un Frame? 1)El Frame se agrandará para permitir que el Scrollbar ocupe su tamaño predefinido. 2)El Scrollbar se colocará en la parte Norte del Frame.Tutorial para el examen de certificación: SCJP 1. muy grueso y no muy útil 3)No puedes agregar un Scrollbar en la parte Norte de un Frame. será muy ancho. sólo al Este o al Oeste 4)El Scrollbar se estirará desde arriba hasta abajo del Frame Pregunta 5) ¿Qué pasa si agregas más botones de los que definiste en un GridLayout y las etiquetas de cada botón son demasiado largas? 1)El tamaño del contenedor se aumentara para permitir que las etiquetas de cada botón se desplieguen completamente 2)El GridLayout ignorará el largo de cada etiqueta y éstas se truncarán 3)Se generará un error al compilar indicando que los botones no pueden alcanza su tamaño predefinido 4)Se generará un error al ejecutarse indicando que los botones no puede alcanzar su tamaño predefinido Pregunta 6) ¿Cuales de las siguientes declaraciones son verdaderas? 184 .

*. p.p). p.300). setSize(300. setVisible(true).pink).javaHispano.add(new Button("Two")).add(new Button("Three")).setBackground(Color.add(new Button("One")). } CompLay(){ Panel p = new Panel(). tu lenguaje. 1)Puedes controlar la posición un componente llamando al método setLayout(new GridBagConstraints ()) 2)El administrador de disposición FlowLayout puede ser usado para controlar la posición de componentes utilizando GridBagLayout 3)El administrador de disposición GridBagLayout toma las constantes North. public class CompLay extends Frame{ public static void main(String argv[]){ CompLay cl = new CompLay(). Tu comunidad.awt. South. p. add("South". West y Center 4)Ninguna de estas respuestas es verdadera Pregunta 7) ¿Cuales de los siguiente son campos de la clase de GridBagConstraints? 1) ipadx 2) fill 3) insets 4) width Pregunta 8) ¿Cual será la apariencia mas probable del siguiente código después de ejecutarse? import java. setLayout(new FlowLayout()). East. } } 1)Los botones se colocarán de izquierda a derecha a lo largo de la parte inferior del Frame 2)Los botones se colocarán de izquierda a derecha a lo largo de la parte superior del Frame 3)Los botones no se desplegarán 185 . p.

El administrador de disposición de un Frame por omisión es BorderLayout.Tutorial para el examen de certificación: SCJP 1. el administrador FlowLayout posicionará el componente Respuesta 3 1)Usando el método setLayout Respuesta 4 186 . cualquier componente agregado a un contenedor que utilice el administrador de disposición BorderLayout se colocará en el centro. Es esto : 1)Verdadero 2)Falso Respuestas Respuesta 1 3)Un Frame con un botón grande etiquetado con "Four" en el Centro Si no especificas una constante. cada nuevo componente agregado requiere una nueva instancia de la clase GridBagConstraints.2 4)Solo se mostrarán los tres botones ocupando todo el Frame Pregunta 9) ¿Cuáles de estas declaraciones son ciertas respecto al campo anchor? 1)Es un campo del administrador de disposición GridBagLayout para controlar la colocación de componentes 2)Es un campo de la clase GridBagConstraints para controlar la colocación de componentes 3)Una constante valida para el campo anchor es GridBagConstraints. Respuesta 2 4)No es necesario indicarlo.NORTH 4)El campo anchor controla la altura de los componentes agregados a un contenedor Pregunta 10) Al usar el administrador de disposición GridBagLayout.

javaHispano.com/docs/books/tutorial/uiswing/layout/using.geocities.htm GridLayout 187 .geocities. tu lenguaje. Respuesta 9 2)Es un campo de la clase GridBagConstraints para controlar la colocación de componentes 3)Una constante valida para el campo anchor es GridBagConstraints. será muy ancho.sun. 2)El Scrollbar se colocará en la parte Norte del Frame.NORTH Respuesta 10 2)Falso Otras Fuentes para este tema: Este tema es cubierto por el tutorial de sun en: http://java. Tu comunidad.com/Athens/7077/Java116.html Richard Baldwin cubre este tema en: BorderLayout http://www.htm FlowLayout http://www. muy grueso y no muy útil Respuesta 5 2)El GridLayout ignorará el largo de cada etiqueta y éstas se truncarán Respuesta 6 4)Ninguna de estas respuestas es verdadera Respuesta 7 1) ipadx 2) fill 3) insets Respuesta 8 2)Los botones se colocarán de izquierda a derecha a lo largo de la parte superior del Frame Cuando un administrador de disposición se cambia a FlowLayout el BorderLayout predefinido no se aplica y el panel se coloca en la parte superior del Frame.com/Athens/7077/Java114.

geocities.html#obj25 188 .edu.com/Athens/7077/Java118.htm Richard parece no cubrir el GridBagLayout Jan Newmarsh en Australia a creado esta pagina http://pandonia.au/java/xadvisor/gridbag/gridbag.Tutorial para el examen de certificación: SCJP 1.2 http://www.html Jyothi Krishnan en http://www.com/SiliconValley/Network/3693/obj_sec8.geocities.canberra.

Esto favorece a las herramientas de desarrollo de aplicaciones GUI para que generen automáticamente código que maneje los eventos.javaHispano.de eventos Para escribir cualquier aplicación útil con interfaz gráfica de usuario (GUI) utilizando Java necesitas entender el funcionamiento las clases oyentes y la manera de extraer información de los eventos que ellas procesan. qué simplemente implementan las interfaces del evento. El modelo oyente -Listener. Uno de los factores complicados para la gestión de eventos es que ésta se basa en Interfaces. Si examinas el código generado por una de estas herramientas puede que te parezca confuso.0x y 1. así el uso directo de la interface EventListener requiere la creación de métodos con cuerpos σ NT.1 involucra el uso de clases oyentes -Listenerque son eficazmente "ligadas" a los componentes para procesar eventos específicosσ. En la versión 1.1. Objetivo 2. Escribir código que implemente clases oyentes (Listener) y en métodos oyentes extraer información del evento para determinar el componente afectado ya sea para conocer la posición actual del ratón o el número de veces que se llama a un evento. tu lenguaje. En teoría. El sistema de manejo o gestión de eventos en Java cambió significativamente entre las versiones 1.event. El modelo de la versión 1. El sistema de gestión de eventos de Java 1. Este sistema es bastante sencillo de entender para ejemplos triviales pero no es recomendable para programas más grandes.1 se conoce en algunos documentos como gestión de eventos delegados. Requería la creación de grandes sentencias case donde colocabas el código para procesar un evento en particular de acuerdo con los parámetros pasados. 189 . Tu comunidad.. Cuando usas una interface necesitas implementar todos sus métodos. pero es mucho más fácil de usar utilizando una serie de clases conocidas como las clases Adaptadoras -Adapter.0x para el manejo de eventos debe trabajar bien en versiones posteriores del JDK.1 no es compatible con versiones anteriores. el código escrito con el estilo de código de la versión 1.1. esto es en parte debido a que tienden a involucrar clases internas creadas dentro de los métodos. es decir bastante horrible.0x el código para manejar eventos se parecía bastante al código C llano para Windows. Tengo la impresión de que lo más relevante que necesita saber para el examen es que la gestión de eventos de la versión 1. El modelo de eventos del JDK 1. Determinar el nombre de clase de un evento para cualquier interface oyente especificada en el paquete java. Con el propósito de aprenderlo puedes manejar las clases de gestión de eventos como si fueran clases de alto nivel.awt.

La manera más simple de destruir la ventana es usando la línea: System.awt. pero la certificación no cubre los componentes Swing.2 vacíos para cualquier evento de la interface que no se utilice. Si crea una aplicación que herede un Frame.event. ir a la línea de comandos y pulsar CTRL-C. Uno de los eventos esenciales más manejados para una aplicación sencilla es la habilidad de cerrar la aplicación como respuesta a seleccionar la opción cerrar proporcionada por el sistema operativoγ. Usando las clases Adaptadoras sólo necesitas crear los cuerpos de los métodos de los eventos que realmente utilizas. } ShutHello(){ γ NT: en Windows es la x que aparece en la esquina superior derecha o la pulsación de las teclas ALT-F4 190 . Aquí un ejemplo de una aplicación sencilla que muestra un Frame que responderá desapareciéndose cuando se accione la opción cerrar proporcionada por el sistema operativo: import import public public java. el JFrame procesa su cierre como una acción predefinida. Las clases Adaptadoras -Adapter.awt. Los métodos para manejar los eventos de las ventanas (WindowEvent) no son tan intuitivos como los métodos de otros eventos.exit(0). Así al principio no es obvio a cual de los métodos siguientes necesitas responder para cerrar el Frame: windowClosed o windowClosing De hecho es el método windowClosing el que necesita ser procesado. class ShutHello extends Frame{ static void main(String argv[]){ ShutHello h = new ShutHello(). Te puede sorprender que el manejo de este evento no venga ya implementado por omisión en un Frame.*.te permiten usar las Interfaces oyentes sin tener que crear un cuerpo para cada uno de los método de la interface. pero no creas código para cerrarlo.Tutorial para el examen de certificación: SCJP 1.*. El equivalente Swing del componente Frame es el JFrame. en Windows. tendrás qué o bien terminar el proceso desde el gestor de tareas o. // necesario para el manejo de eventos java. El funcionamiento del Frame de AWT es un buen lugar para comenzar a cubrir el tema de gestión de eventos.

Existen 11 interfaces oyentes en total. setVisible(true).add(b). } } class WindowCloser extends WindowAdapter{ //sobreescribimos uno de los metodos del Adaptador public void windowClosing(WindowEvent e){ System. //creamos una instancia de la clase WindowCloser WindowCloser wc = new WindowCloser().exit(0). Button b = new Button("ShutHello"). etc. Tu comunidad. Como lo relevante de los adaptadores es eliminar la necesidad de implementar métodos en blanco. etc. sólo se implementan las clases Adaptadoras para estas 7 Interfaces Éstas son las siguientes: • ContainerAdapter 191 . //Ligamos el oyente con el programa addWindowListener(wc). etc. La tabla que aparece mas adelante lista todas las interfaces oyentes junto con sus métodos. Así todos los métodos de ActionListener toman un parámetro de tipo ActionEvent. los métodos de ComponentListener toman un tipo de ComponentEvent. tu lenguaje.300). setSize(300. } } La segundo mitad del objetivo pide que conozcas el nombre de clase por cada evento de cada interface oyente. un ContainerListener toma un ComponentEvent. pero sólo 7 de ellas tienen múltiples métodos. this. Así la interface MouseListener ofrece métodos para los eventos: • • • • • clicked pressed released entered exited Si comparas estos con los eventos manejados en Visual Basic 5 la única área significante que no se cubre es un conjunto de métodos para manejar los eventos de arrastre con el ratón(Drag&Drop) El nombre de la clase del Evento pasado a cada método es bastante intuitivo y basado en el nombre de la clase Oyente.javaHispano.

Interfaces para la gestión de eventos ActionListener AdjustmentListener ComponentListener actionPerformed(ActionEvent) addActionListener() addComponentListener() adjustmentValueChanged(AdjustmentEvent) addAdjustmentListener() componentHidden(ComponentEvent) componentMoved(ComponentEvent) componentResized(ComponentEvent) componentShown(ComponentEvent) ContainerListener componentAdded(ContainerEvent) componetRemoved(ContainerEvent) FocusListener focusGained(FocusEvent) focusLost(FocusEvent) ItemListener itemStateChanged(ItemEvent) KeyListener keyPressed(KeyEvent) keyReleased(KeyEvent) keyTyped(KeyEvent) MouseListener mouseClicked(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent) MouseMotionListener mouseDragged(MouseEvent) mouseMoved(MouseEvent) TextListener textValueChanged(TextEvent) WindowListener windowActivated(WindowEvent) windowClosed(WindowEvent) windowClosing(WindowEvent) windowDeactivated(WindowEvent) windowDeiconified(WindowEvent) windowIconified(WindowEvent) |windowOpened(WindowEvent) addContainerListener() addFocusListener() addItemListener() addKeyListener() addMouseListener() addMouseMotionListener() addTextListener() addWindowListener() 192 .2 • • • • • FocusAdapter KeyAdapter MouseAdapter MouseMotionAdapter WindowAdapter La siguiente tabla muestra la lista completa de interfaces para gestionar eventos.Tutorial para el examen de certificación: SCJP 1.

} MClick(){ this.event. tu lenguaje. Preguntas Pregunta 1) ¿Cuáles de las siguientes afirmaciones son ciertas? 1)Para un componente dado sus eventos se procesará en el orden en que los oyentes fueron agregados.println(e. } } 1)Se generará un error al compilar.addMouseListener(this). Pregunta 2) ¿Cuáles de las siguientes líneas son métodos validos para el manejo de eventos? 1) 2) 3) 4) mousePressed(MouseEvent e){} MousePressed(MouseClick e){} functionKey(KeyPress k){} componentAdded(ContainerEvent e){} Pregunta 3) ¿Que pasara cuando intentes compilar y ejecutar el siguiente código? import java.*. 193 . public class MClick extends Frame implements MouseListener{ public static void main(String argv[]){ MClick s = new MClick(). import java.awt.*. Tu comunidad.out. 3)Un componente puede tener múltiples oyentes asociados a él 4)Pueden quitarse oyentes una vez agregados.getWhen()). } public void mouseClicked(MouseEvent e){ System.awt.javaHispano. 2)Usar las clases Adaptadoras para el manejo de eventos significa crear cuerpos vacíos para todos los métodos que no se utilicen.

0x se ejecutará sin problemas sobre la versión 1. son verdaderas? 1) El modelo de Eventos de la versión 1. Respuesta 4) 2)El código escrito para el manejo de eventos en la versión 1. 194 .1 está particularmente ajustado a las herramientas para la construcción de aplicaciones GUI.1 del modelo de manejo de eventos. Este código causará errores que advierten que MClick es una clase abstracta. 3)El modelo de Eventos de la versión 1.1 de la JVM. se deben crear cuerpos vacíos para cada uno de los métodos de la interface. 3)El modelo de Eventos de la versión 1.Tutorial para el examen de certificación: SCJP 1. Debido a que este código utiliza una interface oyente de eventos.0 2)El código escrito para el manejo de eventos en la versión 1.1 está particularmente ajustado a las herramientas para la construcción de aplicaciones GUI. Respuestas Respuesta 1) 3)Un componente puede tener múltiples oyentes asociados a él 4)Pueden quitarse oyentes una vez agregados.1 es totalmente compatible con modelo de evento de la versión 1. respecto al manejo de eventos. 3)Se compilará y durante su ejecución mostrara la fecha y la hora por cada click 3)Se compilará y durante su ejecución la hora por cada click Pregunta 4) ¿Cuáles de las siguientes afirmaciones. Respuesta 2) 1)mousePressed(MouseEvent e){} 4)componentAdded(ContainerEvent e){} Respuesta 3) 1)Se generará un error al compilar.2 2)Se generará un error al ejecutarse. 4) El manejo del evento DragDrop fue agregado con la versión 1.1 de la JVM.0x se ejecutará sin problemas sobre la versión 1.

El método DragDrop no existe. yo lo invente.html 195 .1 delegation Jyothi Krishnan http://www. El código para el modelo de manejo de eventos de la versión 1.html#obj25 David Reilly http://www.htm#design goals of the jdk 1. Tu comunidad.com/docs/books/tutorial/uiswing/events/intro.javaHispano.com/Athens/7077/Java080.Geocities.com/jcb/java107/java107.geocities.com/SiliconValley/Network/3693/obj_sec8. Otras Fuentes sobre este tema: Tutorial de Sun http://java.html Richard Baldwin http://www.sun.0x de la JVM. tu lenguaje.1 no funcionara con la versión 1.davidreilly.

Así la siguiente línea de código mostrará simplemente 99. tan y sqrt.0. random.Math Objetivo 1. sin. Esto es probablemente favorable ya que reduce la posibilidad de ambigüedad.lang.out.1) El resultado sea 2.1) el resultado será -1 196 . Con certeza encontraras preguntas sobre estos métodos y sería una verdadera pena que no las contestes correctamente simplemente porque los pasaste por alto. round. min.println(Math. por consiguiente sus métodos son estáticos. ceil.lang. System. Si tienes lo siguiente: ceil(1. abs Hasta que comencé ha estudiar para el examen de certificación no tenía ni idea de lo que hace el método abs. max.Tutorial para el examen de certificación: SCJP 1. Si cambias lo anterior por: ceil(-1.lang. El paquete java.2 Sección 9.Math tiene el modificador final. Si el número es positivo obtendrás como resultado el mismo número. Esto significa que no puedes heredar la clase para crear o modificar las versiones de estos métodos. Escribir código que utilice los siguientes métodos de la clase java. ceil Este método retorna el próximo número entero hacia arriba. cos. Nota sobre este objetivo La clase java. floor.abs(-99)).Math: abs. Elimina el signo de un número y retorna el numero simplemente.

println(Math.println(Math.out. System.min(1.0 max y min Toma nota de lo siguiente: los siguientes dos métodos toman dos parámetros.floor(-99)). System.1)).println(Math.println(Math.println(Math. System.println(Math.out. Como podrías esperar estos métodos son el equivalente de decir: "Cual es más grande: ESTE parámetro o ESTE parámetro" El siguiente código muestra como funcionan estos métodos: public class MaxMin{ public static void main(String argv[]){ System.out. System. System. System.floor(-.out.max(1.out.println(Math. System.0 -99.println(Math.out.-10)).max(-1. Tu comunidad. aquí hay un pequeño programa y sus resultados: public class MyMat{ public static void main(String[] argv){ System.0 -1.println(Math.floor(0.1)).min(1. } } 197 .min(-1.println(Math. tu lenguaje.out.0 0. Puedes encontrar preguntas con ejemplos incorrectos que les pasan sólo un parámetro.floor(99)).01)).0 99.-10)). System. floor De acuerdo a la documentación del JDK este método devuelve: El valor double más grande que no sea mayor que el argumento pasado y que sea igual a un entero.1)). } } los resultados son: -100.2)). Si tienes aun dudas de lo que significa lo anterior.javaHispano.floor(-99.out.out.out.2)).

Así los resultados de una típica secuencia de ejecuciones podrían ser: 0.0 Aquí hay otros ejemplo con sus resultados: System.println(Math.0 (0. Si por ejemplo el valor a redondear es x entonces: 2.2 Estos son los resultados: -1 2 1 -10 1 random Retorna un número aleatorio entre 0.round(x)==3.println(Math. System.out.9151633320773057 0. el valor es redondeado al entero siguiente.1)).10070205341831895 A menudo un programa necesita producir un número aleatorio entre 0 y 10 o 0 y 100.out.round(1.println(Math. si el valor tiende más de la mitad hacia el entero más alto. System.out. 198 .5 <=x < 3.round(-2.Tutorial para el examen de certificación: SCJP 1.0. round Redondea al entero más cercano. Para qué.0 <=x < 2. System.01)).println(Math.5.round(x)==2.out.0 y 1. El código siguiente combina código matemático para producir un número aleatorio entre 0 y 100.25135231957619386 0.random()*100)).round(20)). En caso contrario el valor retornado es el entero anterior. Para propósitos del examen uno de los aspectos importantes a considerar de este método es que el valor de retorno está entre 0.0 entonces Math.0 <=n<1) A diferencia de algunos sistemas que generan números aleatorios Java no parece ofrecer la funcionalidad de pasar un número como semilla para aumentar la aleatoriedad.0 2. entonces Math.0 y 1.round(Math.

println(Math.round(20)). tu lenguaje. nunca he usado una de estas funciones.println(Math. sqrt Retorna un valor tipo double que es la raíz cuadrada del valor pasado como parámetro. Pregunta 1) ¿Cuales de las siguientes líneas se compilarán correctamente? 1) 2) 3) 4) System.out.out. 199 .out.random(10.println(Math. System.javaHispano.max(x)). Así quizás lo único que debemos recordar es que el parámetro que recibe es de tipo double. pero conserva el signo del número. Resumen Los métodos max y min toman dos parámetros El método random retorna un valor entre 0 y 1 El método abs elimina el signo del valor pasado como parámetro El método round redondea un numero eliminando así la parte que esta después del punto decimal.println(Math.out. System. System. Tu comunidad. 1 -2 20 sin cos tan Estos métodos elegantes toman un parámetro de tipo double y hacen justo las mismas funciones elegantes que realizarían en cualquier otro lenguaje que hayas usado.sqrt(10)). En mi caso. que son 12 años de programación.3)).

0 3) -3 4) -3.1)).out.out.random()* 10)).println(Math.ceil(-2.println(Math.Tutorial para el examen de certificación: SCJP 1. 1) -2.0 2) -2. Ninguna de las anteriores Pregunta 3) ¿Cuál será la salida de la siguiente línea? System. 1) -2 2) 2.1 4) 1.0 2) -2.println(Math.random() *10).println(Math.2 Pregunta 2) ¿Cuál de las siguientes líneas mostrara un valor aleatorio con valor entre 1 y10? 1) 2) 3) 4) System.out.abs(-2.round(Math.floor(-2.out.1)).1 3) 2.0 Pregunta 5) ¿Cuál será la salida de la siguiente línea? System.out.println(Math. System. 1) -2. System.1 200 .round(Math.0 Pregunta 4) ¿Cuál será la salida de la siguiente línea? System.println(Math.1)).out.random() % 10)).

round(iTemp). System.1 3) 1.javaHispano.println(Math.random()).sqrt(10)). 3) 2. y la opción 2 es incorrecta ya que el método random recibe solo un parámetro no dos Respuesta 2) 4) Ninguna de las anteriores La opción más cercana a la correcta es la 1 pero el detalle esta en recordar que el método random incluye el 0 y la pregunta pide valores entre 1 y 10. } } 1)Se generará un error al compilarse 2)Se generará un error al ejecutarse 3)Se ejecutará y mostrara un valor aleatorio entre 0 y 1 4) Se ejecutará y mostrara un valor aleatorio entre 1 y 10 Respuestas Respuesta 1) 3) System.0 Pregunta 6) ¿Qué pasará cando intentes compilar y ejecutar el siguiente código? class MyCalc extends Math{ public int random(){ double iTemp.println(Math.round(20)). Tu comunidad.out. } } public class MyRand{ public static void main(String argv[]){ MyCalc m = new MyCals().println(m. 4) System.out. 201 . tu lenguaje.out. iTemp=super(). La opción 1 es incorrecta porque el método max recibe dos parámetros no uno. return super.

geocities. Otras Fuentes para este tema Jyothi Krishnan en http://www.Tutorial para el examen de certificación: SCJP 1.com/SiliconValley/Network/3693/obj_sec9.0 Respuesta 4) 3) 2.0 Respuesta 6) 1)Se generará un error al compilarse La clase Math tiene el modificador final y por eso no puede ser heredada.1 Respuesta 5) 1) -2.html#obj28 202 .2 Respuesta 3) 4) -3.

String s2 = new String("There"). Veamos el siguiente código: public class ImString{ public static void main(String argv[]){ String s1 = new String("Hello"). } } ¿Si un String no puede cambiarse entonces s1 debería mostrar siempre "Hello" .out. el String que contiene "Hello" deja de ser referenciado y ahora s1 apunta a la misma referencia que s2. El objetivo te pide que reconozcas las implicaciones de la inmutabilidad de las cadenas.println(s1). Generalmente la inmutabilidad de la clase String no altera nuestra programación diaria. Cuando se asignan s2 a s1 en el ejemplo. s1=s2.out. un String nunca puede modificarse. System. Tu comunidad.println(s1). una vez creado un String no puede cambiarse aún cuando la referencia a él se cambie para apuntar a algún otro String. System. Entonces ¿Que pasa? La inmutabilidad se refiere realmente a los puntos de referencia de los Strings. Recuerda que de cualquier manera que te hagan la pregunta. En nuestra experiencia programando con Java en la vida real nos damos cuenta que esto no es del todo cierto. pero se cuestionará en el examen. pero si pruebas el código te darás cuenta que en la segunda ejecución del println se muestra la cadena "There". De hecho la cadena "Hola" realmente no se ha modificado es solo que teóricamente ya no puedes "llegar a ella". puede haber un desempeño poco eficiente si estás manipulando grandes cantidades de Strings. Objetivo 2 Nota sobre este objetivo La teoría de la inmutabilidad de la clase String dice que una vez creado.javaHispano. como sucede al leer un archivo con gran cantidad de texto. y la principal parece ser qué si quieres eliminar y cambiar el contenido de cadenas de texto debes utilizar la clase StringBuffer que viene construida con más métodos para esos propósitos. tu lenguaje. Debido a que la concatenación de Strings causa que un nuevo String sea instanciado "fuera de escena". Aunque ni los objetivos específicos del 203 .

Tutorial para el examen de certificación: SCJP 1. tristemente. StringBuffer lname=new StringBuffer(lname). ¿Cuál es probablemente la explicación? 204 . Cada nueva línea leída se agrega a un objeto String pero te estás dando cuenta que. 4) Ninguna de las anteriores Pregunta 2) Estás creando un programa para leer en archivo del texto de 8 MB. lname="Jones". estoy bastante seguro que algunas preguntas requieren conocimiento sobre la clase StringBuffer. le falta desempeño. String lname=new String("Jones").1 lo mencionan. 3) StringBuffer fname=new StringBuffer(fname). Así: String fname="John". 2) String fname=new String("Fred"). Preguntas Pregunta 1) Has creado dos Strings que contienen nombres. String lname="String" ¿Cómo puedes cambiar estos Strings para que tomen nuevos valores dentro del mismo bloque de código? 1) fname="Fred".2 examen para Java2 ni para Java 1.

javaHispano.com/SiliconValley/Network/3693/obj_sec9.geocities. Respuesta 2) 3)Debido a que los Strings son inmutables un nuevo String se crea con cada línea leída. Otras Fuentes para este tema: Este tema es cubierto en el tutorial de Sun en: http://java. Cambiándolo por un StringBuffer puedes aumentar el desempeño. un arreglo de caracteres sería más conveniente. Respuestas Respuesta 1) 4) Ninguna de las anteriores Una vez creado un String sólo se puede leer y no puede modificarse. Espero que ninguno de los programadores en C hayan sugerido un arreglo de caracteres.sun. 1)El sistema de Entrada/Salida(I/O) de Java se diseña alrededor de un común denominador de mas bajo nivel y es inherentemente lento 2)La clase String es inapropiada para operaciones de I/O. Tu comunidad.com/docs/books/tutorial/essential/strings/stringsAndJavac. Cambiándolo por un StringBuffer puedes aumentar el desempeño. 4)Ninguna de las anteriores.html#obj29 205 . 3)Debido a que los Strings son inmutables un nuevo String se crea con cada línea leída.html (no entra mucho en detalle) Jyothi Krishnan cubre este tema en: http://www. tu lenguaje.

Las primeras versiones de Java incluyeron: vector hashtable array BitSet De éstos.Tutorial para el examen de certificación: SCJP 1. El paquete java. en lugar de conocer detalladamente sus campos y métodos. Las colecciones antiguas La API Java 2 incluye nuevas interfaces y clases para reforzar las colecciones ya disponibles. Hacer una selección apropiada de las clases/interfaces de colecciones para satisfacer requisitos de comportamientos específicos Nota sobre este objetivo Aunque no lo menciona específicamente. Las nuevas colecciones La raíz de la API de colecciones es la interface Collection. Una de las omisiones notables de Java 1. sólo el array era incluido en los objetivos para el examen de certificación de la versión 1. Probablemente nunca crearas tu propia clase para implementar la interface Collection ya que Java te proporciona una serie de subclases y clases que usan esta interface.1 era el soporte para ordenar.util Objetivo 1. Esta te proporciona una serie de métodos comunes que tendrán todas las clases de colecciones.2 Sección 10. conocer las clases de colecciones. Java 2 incluye las siguiente nuevas clases de colecciones: Sets Maps Y una nueva clase llamada Set. pide un conocimiento sobre donde y cómo podrías usarlas.1. 206 . un requisito muy común en cualquier situación de programación. este objetivo involucra uno de los nuevos objetivos para la versión del examen de Java 2. Lo que el examen cuestiona sobre estas nuevas clases es bastante básico.

Set Set es una interface de colecciones que no puede contener elementos duplicados. List List es una interface de colecciones ordenadas que puede contener elementos duplicados. Parte de la magia de la interface Set esta en el método add. La mayoría de los métodos similares en Java lanzan una Excepción en este tipo de situaciones. Esto también significa que las colecciones no verifican que los elementos sean todos el mismo tipo. Algunos de sus métodos más importantes son: add remove clear La documentación de JDK da como ejemplo usar List para manejar una GUI que controle una lista que contiene todos los nombres de los Planetas.javaHispano. Todo esto tiene inconvenientes ya que la creación de objetos reduce el rendimiento y a los elementos antes de usarse se les aplica un cast. Si la clase ya contiene éste objeto la llamada al método add no modifica el contenido y retorna false. tu lenguaje. las clases que la implementen no pueden tener llaves duplicadas y es similar a Hashtables. Tu comunidad. Las clases que implementan la interface Collection más que almacenar tipos de datos primitivos. De esta manera se presta para manejar conceptos como el de un conjunto de registros retornados de una base de datos relacional. para que puedan ser utilizarlos. almacenan objetos. add(Object o) Cualquier objeto pasado al método add puede implementar el método equals para que el valor pueda compararse con objetos existentes en la clase. La idea de retornar false cuando intentas agregar un elemento que ya existe se parece más a la manera en que trabaja C/C++ que la manera en que trabaja Java. Map Map es una interface. ya que un objeto puede ser casi cualquier cosa. ¿Por qué utilizar colecciones en lugar de arreglos? 207 . al tipo apropiado.

import java.2 La gran ventaja de las colecciones sobre los arreglos es que las colecciones son desarrollables . pero esto puede ser superado usando los métodos estáticos de las colecciones. Arrays. s[2]="c". Los arreglos no soportan directamente el ordenamiento.*. no tienes que asignarles un tamaño al momento de crearlas. es decir. s[1]="b".length.amethod(). for(int i=0. }//fin de main public void amethod(){ 208 . Usando Vectores El siguiente ejemplo muestra cómo puedes agregar objetos de diferentes clases a un Vector. public class Sort{ public static void main(String argv[]){ Sort s = new Sort().Tutorial para el examen de certificación: SCJP 1. } } Las colecciones Set y Map aseguran la individualidad de sus elementos.awt. Aquí hay un ejemplo: import java.i< s. v.util. implícitamente se accede al método toString() de cada objeto.*. El código avanza por cada objeto mostrando su contenido.out. List no asegura esta individualidad pero permite que sus elementos se ordenen. s[3]="a".println(s[i]). public class Vec{ public static void main(String argv[]){ Vec v = new Vec(). Esto contrasta con los arreglos donde cada elemento debe ser del mismo tipo. import java.sort(s).i++) System. s[0]="z". El inconveniente de las colecciones es que sólo guardan objetos y no tipos primitivos e inevitablemente afectan el rendimiento de la aplicación. Al mostrarse el contenido.util. } Sort(){ String s[] = new String[4].*.

Vector mv = new Vector().out. si estás buscando un acceso eficaz. //nota como un Vector puede almacenar //objetos de distintos tipos mv. } }//fin de amethod } Antes de Java2 el uso de la clase del Vector era la manera principal de crear una estructura de datos re-dimensionable. te refieres a ellos por una llave. mv. mv. Un BitSet puede ser útil para el almacenamiento eficaz de bits.size().println(mv. No te confundas por la parte "set" de su nombre. tu lenguaje.red). 209 . Actúa como un Vector. su rapidez BitSet Un BitSet como su nombre lo indica.javaHispano. Usando Hashtables Las Hashtables son parecidas al concepto en Visual Basic de una colección que usa una llave.addElement(new Integer(99)). Según Bruce Eckel en “Thinking in Java” Sólo es eficaz desde el punto de vista del tamaño. es ligeramente más lento que el uso de un arreglo de algún tipo primitivo. sólo que en lugar de referirte a los elementos por un número.addElement("Hello"). i++){ System. La alternativa de usar alguna clase de colecciones que contenga valores tipo Boolean puede ser menos eficaz. no es un conjunto matemático o algo relacionado con bases de datos. Tu comunidad.addElement(99) //Ahora avanzamos por cada elemento del vector for(int i=0.addElement(Color. Una Hashtable puede ofrecer un beneficio superior sobre un Vector. La palabra hash de su nombre se refiere a un término matemático que hace referencia al manejo de índices. en donde los bits se usen para representar los valores de true/false. Es más apropiado pensar en él como un vector de bits. //la siguiente linea causaría un error //ya que un vector no almacena tipos primitivos //mv. i< mv.elementAt(i)). almacena una secuencia de bits. Los elementos de esta clase pueden quitarse con el método remove . tampoco se relaciona con los conjuntos(Sets) disponibles en Java2.

Pregunta 3) ¿Cuáles de las siguientes declaraciones son verdaderas? 1)La interface Set se diseño para asegurar que la implementación de clases tengan miembros únicos 2)Las clases que implementan la interface List no pueden contener elementos duplicados 210 . Pregunta 1) ¿Cuáles de las siguientes clases son colecciones? 1) Collection 2) Iterator 3) HashSet 4) Vector Pregunta 2) ¿Cuáles de los siguientes enunciados son verdaderos respecto a la interface Collection? 1)La clase Vector a sido modificada para implementar la interface Collection 2)La interface Collection ofrece métodos individuales y métodos colectivos como addAll 3)La interface Collection es compatible con versiones anteriores y todos sus métodos están disponibles dentro de las clases del JDK 1. Por favor avísame si te encuentras con alguna pregunta relacionada con esta clase en el examen. Sospecho que podría ser conveniente para propósitos criptográficos o para el procesamiento de imágenes.Tutorial para el examen de certificación: SCJP 1.2 Un BitSet es un poco una clase novedosa de la que nunca puedes llegar a necesitar.1. 4)Las clases de colecciones hacen innecesario el uso de arreglos.

la singularidad no es un problema y los datos permanecerán bastante estáticos ¿Qué estructura de datos podría ser la mas conveniente para este requisito? 1)TreeSet 2)HashMap 3)LinkedList 4)Un arreglo Pregunta 6) ¿Cuales de las siguientes son clases Collection? 1) ListBag 2) HashMap 3) Vector 4) SetList 211 .javaHispano. tu lenguaje. 3) la interface Set se diseño para almacenar registros retornados de una consulta a una base de datos 4) la Interface Map no es parte del marco de trabajo de las colecciones Pregunta 4) ¿Cuáles de las siguientes declaraciones son verdaderas? 1) los elementos de clase de colecciones pueden ser ordenados usando el método sort de la interface Collection 2)Puedes crear una colección ordenada instanciando una clase que implemente la interface List 3)El método sort de la interface Collection toma como parámetros una A o una D para indicar el orden. No necesitaras que los datos sean ordenados. Ascendente/Descendente 4)Los elementos de una clase de colecciones pueden ser ordenados usando el método order de la interface Collection Pregunta 5) Deseas almacenar una cantidad pequeña de datos y hacerlos disponibles para un acceso rápido. Tu comunidad.

Respuesta 4) 2)Puedes crear una colección ordenada instanciando una clase que implemente la interface List Respuesta 5) 212 .2 Pregunta 7) ¿Cómo puedes remover un elemento de un Vector? 1)Con el Método delete 2)Con el Método cancel 3)Con el Método clear 4)Con el Método remove Respuestas Respuesta 1) 3) HashSet 4) Vector Las otras 2 son interfaces.Tutorial para el examen de certificación: SCJP 1. conseguirás un error en tiempo de compilación. Respuesta 2) 1)La clase Vector a sido modificada para implementar la interface Collection 2)La interface Collection ofrece métodos individuales y métodos colectivos como addAll Las clases de colecciones son nuevas en Java 2. Aunque una clase que implementa la interface Set podría usarse para guardar archivos retornados por una consulta a una base de datos. si ejecutas cualquiera de las Colecciones a través de un JDK antiguo. Respuesta 3) 1)La interface Set se diseño para asegurar que la implementación de clases tengan miembros únicos Los elementos de una clase que implementa la interface List pueden contener elementos duplicados. no se diseño particularmente para ese propósito. Con excepción de las clases que han sido actualizadas como Vector y BitSet.

com/docs/books/tutorial/collections/index.html Jyothi Krishnan cubre este tema en http://www.sun. Respuesta 6) 2) HashMap 3) Vector A partir de Java 2 la clase Vector fue actualizado para ser parte del marco de trabajo de las colecciones. Respuesta 7) 4)Con el Método remove Otras Fuentes para este tema: El tutorial de SUN http://java.geocities.html#obj30 213 .javaHispano.com/SiliconValley/Network/3693/obj_sec10. Tu comunidad. tu lenguaje. 4)Un arreglo Para semejante requisito sencillo probablemente un arreglo será la mejor solución.

En su excelente libro "Just Java and Beyond" Peter van der Linden comienza su capítulo sobre I/O de ficheros diciendo: "No es justo remarcar. y así. es un área en la que hay que redoblar la comprobación de tu conocimiento antes de ir al examen. Puedes tener un stream viniendo de una sola salida y de ahí aplicarle un filtro para procesarlo. 214 . Cuando lo estas aprendiendo te queda al menos la compensación de que comprenderás un área útil del lenguaje. Así el examen podría hacerte preguntas sobre la habilidad de crear y eliminar archivos y directorios. Yo creo que él estaba indicando que es levemente importante.Tutorial para el examen de certificación: SCJP 1.io Objetivo 1 Escribir código que utilice objetos de la clase File para navegar dentro del sistema de archivos. El termino computacional stream fue popularizado primeramente por el sistema operativo UNÍX y puedes considerar tomarlo como analogía de un flujo de agua. Los nombres de las clases de flujos de I/O no son intuitivos y las cosas no siempre funcionan como las podrías imaginar. como han hecho algunos. Desafortunadamente la clase File no tiene ése método y parece que simplemente tienes que crear una nueva instancia de File con un directorio diferente en su constructor. Crear una instancia de la clase File no crea un archivo en el sistema operativo subyacente. El sistema I/O de java esta basado en el concepto de flujos – streams – . La clase File La clase File no es del todo descriptiva. Mi primera suposición al pedírseme navegar en un sistema de archivos sería buscar un método para cambiar de directorio. que el soporte para I/O en Java es un punto muy importante". puesto que una instancia de la clase File representa el nombre de un archivo o directorio más que el archivo en si mismo.2 Sección 11. El paquete java. qué podría ser considerado bajo la cabecera de "navegación por el sistema de ficheros".

*") Independencia de plataforma La clase File esta escrita en Java puro. La clase File contiene el método list(). Tu comunidad.*. pero también significa que esta escrito para funcionar independientemente de la plataforma sobre la cual se ejecute. Un libro que recomiendo ampliamente.separator en lugar de obtenerlo con alguna codificación compleja. 215 .javaHispano. Aquí una muestra del programa en funcionamiento. que devuelve un arreglo de String´s conteniendo todos los archivos de un directorio. Esta inspirado en parte en código del libro "Java in a Nutshell" de O´reilly. public class FileNav{ public static void main(String argv[]){ String[] filenames. tu lenguaje. en UNÍX es la barra normal “/” y sobre MAC es otro. Puedes saber cual es este carácter dependiente de la plataforma utilizando la constante File.println(filenames[i]). i++) System. necesitaras conocer la mayoría de los objetivos que se explican en esta sección. mkdir() y mkdirs() Para crear directorios. filenames = f. Esto es muy practico para comprobar si un archivo esta disponible antes de intentar abrirlo. La clase File ofrece el método: delete() Para borrar un archivo o directorio. Debido a las diferencias en la manera en que trabajan los distintos sistemas de archivos es importante estar consciente de particularidades de la plataforma como el carácter separador de los directorios. Un programa para navegar por el sistema de archivos El siguiente archivo es bastante largo (más de 90 líneas) pero para entenderlo.").out. Un ejemplo del uso de list(): import java. File f = new File(".length.io. i< filenames. for(int i=0. El programa te permite navegar entre los archivos de un directorio y cambiar de directorio. } } Esto sencillamente muestra una lista de todos los archivos en el directorio actual ("*. Esto significa que no incluye código nativo.list(). En Win/DOS es la barra invertida “\” .

import java. Addressing the objective to be able to use the File class to navigate the File system.setSize(300.awt.io.*.awt. public static void main(String argv[]){ Filer f = new Filer(). f.event. } 216 .*.jchq.Tutorial para el examen de certificación: SCJP 1.net. f. public class Filer extends Frame implements ActionListener{ /************************************************************** Marcus Green October 2000 Part of the Java Programmer Certification tutorial available at http://www.separator to allow this to work on Unix or PC (and maybe even the Mac) ****************************************************************/ List lstFiles. File currentDir. int iRootElement = 0. import java.400).setVisible(true).2 import java.*.This program will show a list of files in a directory . int iElementCount = 20. int iEntryType = 6.Clicking on a directory will change to the directory and show the contentsNote the use of File. String[] safiles.

listDirectory(dir). }else{ String sCurFile = lstFiles.separator . lstFiles. return. if(i==iRootElement){ upDir(currentDir). String sparent = fullPath.substring(iEntryType. if(fCurFile.getAbsolutePath()).list(). lstFiles = new List(iElementCount).separator+" ".remove(iRootElement). //set the current directory File dir = new File(System.getSelectedIndex().dir")).getAbsoluteFile(). if(sparent == null) { //At the root so put in the dir separator to indicate this lstFiles. currentDir = dir.iNameLen).getItem(i). addWindowListener( new WindowAdapter(){ public void windowClosing(WindowEvent e){ System. lstFiles.toString()+File. Filer(){ setLayout(new FlowLayout()). listDirectory(fparent).iRootElement).isDirectory()){ listDirectory(fCurFile). tu lenguaje. File fCurFile = new File(currentDir.javaHispano.getParent().exit(0). //Get the directorie entries safiles = dir. Tu comunidad. //remove the previous lis and add in the entry //for moving up a directory + 217 .addActionListener(this). }else{ File fparent = new File(sparent). //Find the length of the file name and then //chop of the filetype part (dir or file) int iNameLen = sCurFile.getProperty("user.add(" "+File.length().getAbsolutePath()+File. sCurFile = sCurFile. add(lstFiles). } public void actionPerformed(ActionEvent e){ int i = lstFiles. } } } public void upDir(File currentDir){ File fullPath = new File(currentDir.separator sCurFile). } } ). } } public void listDirectory(File dir){ String sCurPath = dir.

isDirectory()){ sFileName = "[dir ]" + safiles[i]. i< safiles.addItem("[ . ]"). lstFiles. String sFileName = new String(). }else{ sFileName = "[file]"+safiles[i]. if(curFile.removeAll(). } lstFiles. currentDir=dir. } } Preguntas Pregunta 1) ¿Cuál de los métodos siguientes sirve para distinguir entre un directorio y un archivo? 1) FileType() 2) isDir() 3) isDirectory() 4) getDirectory() Pregunta 2) ¿Cuál de los siguientes métodos de la clase File borrará un directorio o un archivo al ejecutarse? 1) La clase File no te permite borrar un archivo o un directorio 2) remove() 3) delete() 4) del() Pregunta 3) 218 .length.. //loop through the file names and //add them to the list control for(int i=0.addItem(sFileName).2 lstFiles. } add(lstFiles). i++){ File curFile = new File(sCurPath + safiles[i]).Tutorial para el examen de certificación: SCJP 1.

.txt” en el sistema operativo subyacente? 1) f. ¿Qué método creará el archivo “myfile.list() 2) dir. File(".files() 4) dir."). Tu comunidad.").*"). 3) f. File('*. 3) up(). 4) Ninguno de los anteriores Pregunta 6) ¿Cuál de las siguientes líneas cambiará el directorio actual al que se encuentra en un nivel superior? 1) chDir(". tu lenguaje.").list 3) dir. Cómo puedes obtener los nombres de los archivos contenidos dentro de una instancia de la clase File con el contenido del directorio actual 1) dir.flush(). 2) f. File("*.write().txt"). 4) Ninguno de los anteriores Pregunta 7) 219 . Pregunta 5) Dada la siguiente línea de código: File f = new File("myfile.javaHispano.*'). 2) cd(".close().FileNames() Pregunta 4) ¿Cuál de las siguientes líneas llenará una instancia de la clase File con el contenido del directorio actual? 1) File 2) File 3) File 4) File f f f f = = = = new new new new File().

Respuesta 5) 4) Ninguno de los anteriores La clase File principalmente describe un archivo que debe de existir."). Respuesta 6) 4) Ninguno de los anteriores 220 .Tutorial para el examen de certificación: SCJP 1. Respuesta 4) 4) File f = new File(".list() El método list retorna un arreglo de String´s que contendrá el contenido del directorio actual. Respuestas Respuesta 1) 3) isDirectory() Respuesta 2) 3) delete() Respuesta 3) 1) dir. Para crear un archivo en el sistema operativo subyacente necesitas pasar una instancia de la clase File a una instancia de una de las clases OutputStream. Este constructor para la clase File obtendrá el contenido del directorio actual sobre sistemas de archivos como DOS o UNIX.2 ¿Cuáles de los siguientes son métodos o campos de la clase File? 1) getParent() 2) separator 3) dirname 4) getName(). pero no estoy seguro que ocurrirá sobre otros sistemas con una estructura de archivos exótica como Mac OS.

com/products/jdk/1. Una manera indirecta es crear una nueva instancia de la clase File apuntando al directorio deseado.com/SiliconValley/Network/3693/io.caltech. Respuesta 7) 1) getParent() 2) separator 4) getName(). Otras Fuentes para este tema: Puedes darle un vistazo a los ejemplos del libro de I/O de O'Reilly: http://metalab.geocities.htm Joyothi tiene varias útiles tablas sobre las clases de I/O en http://www.html Este tema se cubre en el tutorial de SUN en http://java.edu/javafaq/books/javaio/index. un poco académico http://www.javaHispano.att. Java no tiene una manera directa para cambiar el directorio actual.edu/resources/langspec-1.infospheres.2/docs/api/java/io/File. Tu comunidad.com/docs/books/tutorial/essential/io/ La API de la clase File http://java. tu lenguaje.net/~baldwin.sun.sun.0/javaio.rg/Intermediate/Java060.html 221 .html Richard Baldwin sobre I/O http://home.html El JLS sobre IO.unc.doc.

identificadores y otro texto dentro del programa. Esto significa que puede manipular chino y japonés.2 Objetivo 2 Escribir use objetos de las clases InputStreamReader y OutputStreamWriter para traducir entre códigos de caracteres UNICODE y el nativo de plataforma o el ISO 8859-1. Me sorprendió que este objetivo no se enfatizara en el examen de JDK 1.Tutorial para el examen de certificación: SCJP 1. uno que tenga el concepto de conjunto de caracteres. Si solo te las tienes que ver con conjuntos de caracteres de tipo ASCII. no es un método eficiente de codificación para programar. la mayoría de este puede guardarse fácilmente dentro de un byte. Java fue diseñado desde abajo para tenérselas que ver con caracteres multibyte y puede tratar con inmensos números de caracteres que pueden guardarse usando el sistema de codificación UNICODE. Es bonito vender software a mil millones de europeos y americanos pero mil millones de chinos serían un agradable mercado adicional (incluso si sólo el 10% lo compran) Éste es el tipo de objetivo con el que ni siquiera los programadores de Java experimentados pueden tener poca experiencia. y casi cualquier otro conjunto de caracteres conocido. La mayoría del texto dentro de un programa usa el código ASCII. Estarás agradecido de saber que no tienes que dar ejemplos de nada de esto en el examen. ¡Así qué toma nota!.2 puesto que se había introducido la internacionalización y ésta es una de las grandes características de Java. Las clases StreamReader La clase StreamReader convierte una entrada de bytes (no relacionada con un conjunto de caracteres) en un flujo de entrada de caracteres. Aunque UNICODE puede representar casi cualquier carácter que llegues a usar en tu vida. Esto le permite ser usado con alfabetos no occidentales. probablemente solo usarás clases Reader en la forma de: InputStreamReader(InputStream in) código que 222 . Java utiliza un sistema de codificación llamado UTF8 para las literales de cadena. Los caracteres UNICODE son almacenados en 2 bytes permitiendo almacenar arriba de 65K caracteres. Por razones de tamaño. Codificación de caracteres en Java: UTF y UNICODE Java utiliza dos sistemas muy parecidos de codificación UTF y UNICODE. Esto puede dar como resultado un ahorro considerable de espacio comparándolo con el uso de UNICODE donde cada carácter requiere 2bytes.

debido que los caracteres no pueden mostrarse correctamente si el entorno no se configura apropiadamente.*. class GreekWriter { public static void main(String[] args) { String str = "\u03B1\u03C1\u03B5\u03C4\u03B7". Así si intentas mostrar un carácter del conjunto de caracteres chinos tu sistema quizá no lo soportará Si te las tienes que ver con otros conjuntos de caracteres puedes usar InputStreamReader(InputStream in. tu lenguaje. Experimentar con otros juegos de caracteres es problemático.encoding. Cuando el buffer se llena.txt con un editor. Ejemplo.io.1 este valor por defecto se identifica por medio de la propiedad del sistema file.javaHispano. La suposición parece ser: si todo lo demás falla. el contenido se escribe en el stream de bytes de salida. Recuerda que el InputStream viene primero y el código de caracteres después. En el JDK1. Esta versión usa el código de caracteres nativo de la plataforma. String encoding). try { Writer out = new OutputStreamWriter( 223 . debes volver al inglés. Si esta propiedad del sistema no esta definida. Las clases StreamReader y Writer pueden tomar cualquier codificación de caracteres como parámetro o puedes usar la codificación predeterminada. GreekWriter El código para esta clase escribe un archivo de salida contiene algunas letras en alfabeto griego. Cuando se llama al método read este lee bytes desde el stream de entrada y los convierte a caracteres UNICODE usando la codificación especificada en el constructor del stream. el identificador del código estándar es 8859_1 (ISO-LATIN-1). import java. Tu comunidad. Cuando se llama al método write() los caracteres que vienen del stream son convertidos en su correspondiente byte codificado y es almacenado en un buffer interno. Los métodos read y write La clase InputStreamReader tiene un método llamado read() y la clase OutputStreamWriter tiene un método llamado write() que permiten leer y escribir caracteres respectivamente. La codificación predeterminada generalmente es ISO-Latin 1 excepto en Mac donde es MacRoman. Si intentas abrir el archivo Out. veras algo parecido a basura.

y = insets. public static void main(String[] args) { GreekReader gr = new GreekReader().append((char)ch).io. // 8859_7 is the ISO code for ASCII plus greek.printStackTrace(). gr. } } public void paint(Graphics g) { //paint method automatically called by the system Insets insets = getInsets().write(str).Tutorial para el examen de certificación: SCJP 1. “8859_7"). GreekReader import java. while ((ch = in. //Add 30 to y or we will only see the 224 .2 new FileOutputStream("out.*. gr. import java.txt").awt.read()) > -1) { buf.toString().printStackTrace(). } } } Ejemplo.top.close(). class GreekReader extends Frame{ /******************************************************* *Companion program to GreekWriter to illustrate *InputStreamReader and OutputStreamWriter as part *of the objectives for the Sun Certified Java Programmers *exam. StringBuffer buf = new StringBuffer(). str = buf.*. } catch (IOException e) { e."8859_7").go(). int ch. } in.setWin(). // although this // example also works on my machine if it is set to UTF8 out. int x = insets. Reader in = new BufferedReader(isr). } catch (IOException e) { e.close(). } public void go(){ try { FileInputStream fis = new FileInputStream("out. InputStreamReader isr = new InputStreamReader(fis.left.txt"). out. Marcus Green 2000 *********************************************************/ String str.

59). //Show the frame show(). x. } public void setWin(){ //Nice big font so we can see the characters. } } GreekReader en ejecución. Font. Tu comunidad. y +30).javaHispano. Pregunta 2) ¿Cuales de las siguiente sentencias son verdaderas? 225 . 4) La clase InputStreanReader puede tomar un stream como uno de sus constructores.200). tu lenguaje. setVisible(true). setFont(font). Font font = new Font("Monospaced". //downstrokes of the letters g. setSize(200. 2) La codificación predefinida para la clase OutputStreamWriter es ASCII 3) Las clases InputStreamWriter y OuputStreamWriter puede tomar como parámetro para su constructor una codificación de caracteres.drawString(str. Preguntas Pregunta 1) ¿Cuales de las siguientes sentencias son verdaderas? 1) La clase OutputStream debe tomar una codificación de caracteres como parámetro para su constructor.BOLD.

Pregunta 4) ¿Cuales de los siguientes son métodos de la clase InputStreamReader? 1) read() 2) write() 3) getBuffer() 4) getString() Pregunta 5) ¿Cuales de las siguientes son sentencias son verdaderas? 1) Java utiliza UNICODE para almacenar internamente literales de cadena 2) Java utiliza ASCII para almacenar internamente literales de cadena 3) Java utiliza UTF-8 para almacenar internamente literales de cadena 4) Java utiliza la codificación nativa de la plataforma para almacenar internamente literales de cadena Respuestas Respuesta 1) 2) La codificación predefinida para la clase OutputStreamWriter es ASCII 4) La clase InputStreanReader puede tomar un stream como de sus constructores.2 1) Java puede desplegar conjuntos de caracteres independientemente del sistema operativo subyacente. 2) La clase InputStreamReader puede tomar una instancia de otra clase InputStream como constructor. Pregunta 3) ¿Cuales de las siguientes son firmas validas para la clase InputStreamReder? 1) InputStreamReader(InputStream in. 4) Java usa el código ASCII para almacenar cadenas internamente. Respuesta 2) 1) Java puede desplegar conjuntos de caracteres independientemente del sistema operativo subyacente. 2) La clase InputStreamReader puede tomar una instancia de otra clase InputStream como constructor. String encoding). 2) InputStreamReader(String encoding.File f). 3) InputStreamReader(String encoding. 226 . 3) Un InputStreamReader puede actuar como constructor de un OutputStreamReader para hacer conversiones entre juegos de caracteres. 4) InputStreamReader(InputStream in).InputStream in).Tutorial para el examen de certificación: SCJP 1.

2/docs/api/java/io/InputStreamReader. Generalmente los streams son unidos con otros streams.unicode. Respuesta 3) 1) InputStreamReader(InputStream in. el conjunto de caracteres apropiado debe instalarse para poder desplegar esos caracteres.org/ 227 . 4) InputStreamReader(InputStream in).sun.html JavaCaps: http://www. String encoding).html Todo lo que puedes querer saber sobre UNICODE: http://www. Aunque Java puede guardar caracteres independientemente del sistema operativo subyacente. Java utiliza el sistema de codificación UTF para almacenar internamente cadenas.com/products/jdk/1. por ejemplo un InputStream toma como constructor a otro InputStream y un OutputStream toma como constructor a otro OutputStream. Si no especificas una codificación la JVM asumirá como codificación la predeterminada de la plataforma.2/docs/api/java/io/OutputStreamWriter. Tu comunidad.com/products/jdk/1. Respuesta 4) 1) read() Respuesta 5) 3) Java utiliza UTF-8 para almacenar internamente literales de cadena Otras Fuentes para este tema: La documentación de Sun sobre las clases InputStreamReader y OutputStreamWriter: http://java. tu lenguaje.sun.com/sjpc_io_obj2.javaHispano.html http://java.javacaps.

Con esto quiero decir que algunos puritanos podrían tomar la actitud de que siempre deberías especificar el código de conversión de caracteres porque nunca sabes donde. o si necesitas manipular distintos códigos de caracteres. Si tu código de caracteres por defecto no es ISO-LATIN-1 y consideras que el inglés es el lenguaje estándar para los negocios.com/docs/books/tutorial/i18n/index. entonces aprovéchate de la posibilidad de hacer conversiones específicas.html 228 .2 Objetivo 3 Distinguir entre las condiciones bajo las cuales se usaría conversión al código nativo de plataforma y las condiciones bajo las cuales se usaría una conversión específica.sun.1/docs/guide/intl/ http://java. Esto es porque muchos programadores asumieron que su código nunca tendría que vérselas con el problema del año 2000 por el que hubo tanto lío. es un buen pago para algunos programadores. Bien. Otras Fuentes para este tema: La documentación de Sun sobre la internacionalización: http://java. vuelve a leer la sección anterior sobre las clases de lectura y escritura de archivos.sun.html http://java.sun. este objetivo te pide identificar si tu código esta preparado para enfrentarse a un código de caracteres no estándar. cuando y como se usará tu programa. Si algo de esto no significa nada para ti.com/products/jdk/1.Tutorial para el examen de certificación: SCJP 1. Este podría ser un objetivo de "bondad y disciplina". Si tomas un punto de vista más benigno.com/docs/books/tutorial/i18n/text/stream.

*.java"). Así en el examen te pueden preguntar si alguna de ellas puede tomar una instancia de la clase File.append((char)ch). tu lenguaje. public class Fis{ public static void main(String argv[]){ try{ FileInputStream in = new FileInputStream("Fis. El énfasis en este objetivo es que conozcas los argumentos validos para los constructores de estas clases. InputStreamReader isr = new InputStreamReader(in). Un constructor valido será algún tipo de stream más otros posibles parámetros. una instancia de la clase File o una instancia de la clase FileDescriptor. Tu comunidad.io. Lo mas relevante que se puede mencionar es que la clase RandomFile no toma algún stream como argumento para alguno de sus constructores. import java. para ver si realmente conoces los argumentos válidos para sus constructores. Estas clases toman instancias de otros streams como argumentos.out. FileInputStream and OutputStream Las clases FileInputStream y FileOuputStream tomen como parámetro principal para sus constructores alguna referencia a un archivo. } } catch (IOException e){System. int ch=0. while((ch = in. Este es un ejemplo de como se liga la clase FileInputStream con la clase InputStreamReader. System. Típicamente una instancia de la clase FileInputStream recibe una referencia a un archivo-cualquiera de las que mencionamos anteriormente-. Esta puede ser un String que contenga el nombre del archivo.javaHispano. y se conecta con una instancia de la clase InputStreamReader para leer los caracteres que contiene dicho archivo. Este programa mostrará su propio código fuente. Estas clases a menudo se utilizan como el primer paso para ligar clases de streams. buf. un String con el nombre del archivo o la ruta del archivo. Objetivo 4 Seleccionar los argumentos validos para los constructores de una lista de clases contenidas en el paquete java.io.println(e. este tipo de situaciones te permite implementa fácilmente la 229 .out.} } } Lo anterior es aconsejable cuando programas en el “mundo real” y utilizas la clase InputStreamReader.print(buf.read())> -1){ StringBuffer buf = new StringBuffer().toString()).getMessage()).

Esto te da acceso a varios métodos como readDouble o readInt que funcionarán de la misma manera sobre distintas plataformas. } } }catch(IOException e){System. puedes ajustar el tamaño del buffer que vas a utilizar. import java. 230 . System. Así. Observa el ejemplo GreekReader. observa como el código es similar con el ejemplo anterior únicamente se substituye la línea del InputStreamReader por BufferedInputStream.Tutorial para el examen de certificación: SCJP 1. while((ch=bin. En el JDK 1. Esas clases toman una instancia de la clase Stream como parámetro de su constructor.java mostrado anteriormente para ver un ejemplo de esto.0 está era una de las principales maneras de acceder a texto UNICODE. BufferedInputStream y BufferedOutputStream Estas clases descienden directamente de las clases FilterInputStream y FilterOutputStream respectivamente.java").append((char)ch).getMessage()).2 internacionalización.toString()). BufferedInputStream bin = new BufferedInputStream(fin).print(buf. Un ejemplo puede ser cuando estés procesando varias decenas de Megabytes de texto. Este es un ejemplo de uso de las clases BufferedInputStream.1 del JDK ha sido substituido por las clases Reader . Las clases BufferedInputStream y BufferedOutputStream toman una instancia de las clases InputStream y OutputStream respectivamente como parámetro para alguno de sus constructores.io. Esto incrementa la eficiencia. Permiten leer más información de manera inmediata colocándola en un buffer.read())> -1){ StringBuffer buf = new StringBuffer(). ya que es mucho más rápido leer desde la memoria que desde el disco.out.out. public class BufIn{ public static void main(String argv[]){ try{ FileInputStream fin = new FileInputStream("BufIn.}. buf.println(e. Este tipo de lectura es particularmente útil si tienes que estar leyendo una gran cantidad de datos. } DataInputStream y DataOutputStream Las clases DataInputStream y DataOuputStream se usan para leer de una manera portable representaciones binarias de los tipos de datos primitivos de java. pero desde la versión 1. int ch=0. pero también pueden tomar un parámetro adicional que defina el tamaño del buffer.*.

dos. El primer constructor que toma un String recibe el nombre de un archivo. Los tres son muy similares y realizan la misma función.io. El siguiente ejemplo escribe un carácter en un archivo y después lo lee y muestra en la consola.io.} } } //Read import public public the file java. DataOutputStream dos = new DataOutputStream(fos).writeChar('J'). }catch(IOException e){System. public class Dos{ public static void main(String argv[]){ try{ FileOutputStream fos = new FileOutputStream("fos. Más adelante se explica con detalle. Tu comunidad. RandomAccesFile Lo más importante que debes saber sobre los constructores de esta clase. //Write the file import java.readChar()).javaHispano.out. File(String path.out.*. 231 . en forma de cadena.getMessage()).dat"). es que toman 2 parámetros para sus constructores y que el segundo parámetro es un String que contiene el modo de apertura del archivo. Estos son: File(String path).*. incluyendo su ruta. System.dat"). DataInputStream dis = new DataInputStream(fis).println(e.println(e. class Dis{ static void main(String argv[]){ try{ FileInputStream fis= new FileInputStream("fos. String name). Esta ruta puede ser absoluta o relativa. }catch(IOException e){System. El segundo toma por separado la ruta y el nombre del archivo y el tercer constructor es casi igual al primero excepto que el primer parámetro que indica el directorio del archivo es del tipo File en lugar del tipo String.getMessage()).} } } La clase File La clase File tiene tres versiones de constructores. String name) File(File dir.out. tu lenguaje.println(dis.

io. int size) 2) BufferedInputStream(FileInputStream in) 3) BufferedInputStream(FileOutputStream fos) 4) BufferedInputStream(RandomAccessFile ram) Pregunta 3) ¿Cuáles de los siguientes constructores son validos para la clase DataInputStream? 1) DataInputStream(FileInputStream in.*. public class Dos{ public static void main(String argv[]){ FileOutputStream fos = new FileOutputStream("fos.dat"). BufferedOutputStream bos = new BufferedOutputStream(dos). DataOutputStream dos = new DataOutputStream(fos). 232 .Tutorial para el examen de certificación: SCJP 1.2 Preguntas Pregunta 1) ¿Cuáles de las siguientes clases con parámetros validos para los constructores de la clase FileInputStream? 1) File 2) String 3) FileDescriptor 4) RadomAccessFile Pregunta 2) ¿Cuáles de los siguientes constructores son validos para la clase BufferedInputStream? 1) BufferedInputStream(FileInputStream in. int size) 2) DataInputStream(FileInputStream in) 3) DataInputStream(File f) 4) DataInputStream(String s) Pregunta 4) Dado el siguiente código: import java.

println("Continuing").javaHispano. } } ¿Cuál de las siguientes sentencias es verdadera? 1) El código no se compilará 2) No compilará debido a que la clase BufferedOutputStream no tiene un constructor que tome como parámetro una instancia de la clase DataOutputStream 3) Se compilara y escribirá el byte 8 en el archivo 4) Se compilara y escribirá la cadena “8” en el archivo Pregunta 5) ¿Cuáles de los siguientes son constructores validos? 1) File(String path). } } ¿Cuál de las siguientes sentencias es verdadera? 1) El código se compilará y al ejecutarse se detendrá hasta que se pulse una tecla 2) El código no se compilará debido a que System. p.out.in). tu lenguaje. String name) 3) RandomAccessFile(File) 4) File(RandomAccesFile name) Pregunta 6) Dado el siguiente código: import java. } public void go(){ try{ DataInputStream dis = new DataInputStream(System. public class Ppvg{ public static void main(String argv[]){ Ppvg p = new Ppvg().read(). dos.io. }catch(Exception e){} System.*.in es una clase estática 3) El código se compilará y se ejecutará sin generar ninguna salida 4) El código no se compilará debido a que System.go(). 2) File(String path.write('8'). Tu comunidad.in no es parámetro para un constructor valido para la clase DataInputStream Respuestas 233 . dis.

html 234 .sun.html http://java.sun.2/docs/api/java/io/BufferedOutputStream.2 Respuesta 1) 1) File 2) String 3) FileDescriptor Respuesta 2) 1) BufferedInputStream(FileInputStream in.sun.com/products/jdk/1.2/docs/api/java/io/BufferedInputStream. 2) File(String path.html Data I/O http://java. String name) Respuesta 6) 1) El código se compilará y al ejecutarse se detendrá hasta que se pulse una tecla Otras Fuentes para este tema La documentación de las API´s en SUN Buffered I/O http://java.com/products/jdk/1.html http://java.Tutorial para el examen de certificación: SCJP 1.2/docs/api/java/io/DataOutputStream.com/products/jdk/1. int size) 2) BufferedInputStream(FileInputStream in) Respuesta 3) 2) DataInputStream(FileInputStream in) Respuesta 4) 1) El código no se compilará El código no se compilará debido a que no se encuentra dentro de un bloque try/catch Respuesta 5) 1) File(String path).com/products/jdk/1.2/docs/api/java/io/DataInputStream.sun.

descendiente de FilterOutputStream. solo verás caracteres extraños.txt y escribe el texto "Hello" en él.javaHispano. import java.amethod().writeChars(s). public static void main(String argv[]){ Fos f = new Fos(). public class Fos{ String s = new String("Hello"). Si este ejemplo solo usara métodos de FileOutputStream estarías limitado a escribir bytes o enteros. public class Fis{ 235 . tu lenguaje. los 8 bits de más peso dan como resultado un carácter en blanco. //DataOutputStream te permite escribir caracteres DataOutputStream dos = new DataOutputStream(fos). } public void amethod(){ try{ FileOutputStream fos = new FileOutputStream("Out. Date cuenta de que puesto que el programa anterior generó el fichero como UNICODE.*. f.io. dos. Objetivo 5 Escribir el código adecuado para leer. el siguiente código probablemente sólo mostrará caracteres extraños. import java. Si abres el fichero resultante verás que contiene el texto "H e l l o" (con un espacio en blanco entre cada letra). escribir o actualizar ficheros usando objetos FileInputStream. si creas un fichero de texto con un editor de textos conteniendo una cadena de caracteres como "Hello". Sospecho que es porque un carácter en Java es de 16 bits y uno en ASCII son 8 bits.io. FileOutputStream y RandomAccessFile. FileInputStream and FileOutputStream El siguiente ejemplo crea un fichero de texto llamado Out. Tu comunidad.*. Esto permite que sean escritos los caracteres legibles para el ser humano. Si haces esto y muestras el resultado por la consola. }catch(IOException ioe) {} } } El siguiente ejemplo leerá el fichero de texto producido en el ejemplo anterior y mostrará el texto en la consola.txt"). Esto también muestra el objetivo previo de usar la clase DataOutputstream.

println(c).txt creado por el ejemplo anterior Fos. "ro" o "r+w". Y si pasas como parámetro el modo "rw" se intentará crear el archivo desde el sistema operativo. y un argumento indicando el modo de apertura. si intentas pasar el nombre de un archivo al constructor.java.2 public static void main(String argv[]){ Fis f = new Fis().readChar(). El argumento referente al modo de apertura puede ser "r" para solo lectura o "rw" para lectura y escritura. no bit). A diferencia de la clase File. f. Por culpa del byte superior en blanco (byte. Si en el examen encuentras respuestas que mezclan instancias de RandomAccessFile con otros flujos de datos. System. 236 .Tutorial para el examen de certificación: SCJP 1. La clase RandomAccessFile no toma un stream como un parámetro para alguno de sus constructores. Memoriza estas dos opciones.txt"). Este ejemplo leerá el fichero Out.. while(true){ char c =dis. } }catch(IOException ioe) {} } } RandomAccessFile La clase RandomAccessFile esta desarrollada libremente y no encaja fácilmente dentro de las clases de flujos de I/O. casi seguramente son respuestas erróneas. El constructor de RandomAccessFile toma una instancia de la clase File o una cadena de caracteres.amethod(). DataInputStream dis = new DataInputStream(fis). el resultado muestra un signo de interrogación con cada letra. } public void amethod(){ try{ FileInputStream fis = new FileInputStream("Out. Si pasas únicamente el modo "r" como parámetro y el archivo no existe se lanzará una excepción.out. RandomAccessFile intentará abrir el archivo. que no te engañen en el examen con modos como "w".

Pregunta 2) ¿Cuales de las siguientes sentencias son verdaderas? 1) La clase RandomAccessFile permite moverte hacia adelante y hacia atrás de un archivo sin tener que re-abrirlo. los superiores System.io.readChar().amethod().out. tu lenguaje. for(int i=0.javaHispano. RandomAccessFile( new File("myfile. } public void amethod(){ try{ RandomAccessFile raf = new RandomAccessFile("Out.seek(i).txt"). char myc = raf."rw"). import java."+rw"). RandomAccessFile( new DataInputStream()).txt". r. //? mostrado para los bytes de mas peso.i++){ raf.txt")). } } catch(IOException ioe) {} } } Pregunta 1) Asumiendo que se ha escrito código para el manejo de excepciones. i<10. 2) Una instancia de la clase RandomAccessFile puede ser usada como parámetro para un constructor de la clase FileInputStream 237 . RandomAccessFile("myfile.*.txt". Tu comunidad.println(myc). ¿Cuáles de las siguientes sentencias creará una instancia de la clase RandomAccessFile? 1)RandomAccessFile 2)RandomAccessFile 3)RandomAccessFile 4)RandomAccessFile raf raf raf raf = = = = new new new new RandomAccessFile("myfile. public class Raf{ public static void main(String argv[]){ Raf r = new Raf().

238 .txt"). f. public static void main(String argv[]){ Fos f = new Fos(). 2) El método read de la clase FileinputStream lee un número definido de bytes. 3) El método get de la clase FileInputStream lee un número definido de bytes.Tutorial para el examen de certificación: SCJP 1.io. 3) Los métodos de la clase FileInputStream son apropiados especialmente para manipular archivos de texto.*.txt Pregunta 5) ¿Cuales de las siguientes sentencias son verdaderas? 1) El método seek de la clase FileInputStream define la posición actual del puntero del archivo. Pregunta 4) ¿Que pasará cuando intentes compilar y ejecutar el siguiente código? import java.amethod().write(10). } } 1) Error al compilar 2) Error al ejecutar 3) Se creará un archivo llamado Out. fos.2 3) Los métodos de la clase RandomAccessFile no lanzan excepciones 4) Crear una instancia de la clase RandomAccessFile lanzará una excepción si el archivo no existe Pregunta 3) ¿Cuales de las siguientes sentencias son verdaderas? 1) La Clase FileInputStream puede tomar el nombre de un archivo o una instancia de la clase File como parámetros para alguno de sus constructores 2) La Clase FileInputStream lanzará una excepción si el nombre del archivo pasado como parámetro al constructor no existe. } public void amethod(){ FileOutputStream fos = new FileOutputStream("Out.txt conteniendo el texto "10" 4) Se creará un archivo llamado Out. 4) El método delete de la clase FileInputStream elimina un archivo desde el sistema operativo. public class Fos{ String s = new String("Hello").

txt"). 4) Una instancia de la clase FileOuputStream se puede cerrar utilizando en método close. Respuesta 5) 2) El método read de la clase FileinputStream lee un número definido de bytes. Tu comunidad. tu lenguaje.java:10: Exception java.IOException must be caught. 4) Una instancia de la clase FileOuputStream se puede cerrar utilizando en método close. FileOutputStream fos = new FileOutputStream("Out.txt".javaHispano. Respuestas Respuesta 1) 1) RandomAccessFile raf = new RandomAccessFile("myfile. Respuesta 3) 1) La Clase FileInputStream puede tomar el nombre de un archivo o una instancia de la clase File como parámetro para alguno de sus constructores 2) La Clase FileInputStream lanzará una excepción si el nombre del archivo pasado como parámetro al constructor no existe. 239 . Respuesta 2) 1) La clase RandomAccessFile permite moverte hacia adelante y hacia atrás de un archivo sin tener que re-abrirlo. Desciende directamente de Object y no es parte de la arquitectura de flujos de datos. Respuesta 4) 1) Error al compilar Fos. 4) Crear una instancia de la clase RandomAccessFile lanzará una excepción si el archivo no existe.io. La clase RandomAccessFile es una anomalía en la arquitectura de I/O de Java."+rw"). or it must be declare in the throws clause of this method. Las clases FileInputStream y FileOutputStream están diseñadas para leer y escribir bytes más que texto.

edu/resources/langspec-1.rg/Intermediate/Java060.html Richard Baldwin sobre I/O http://home. Probablemente entra en más detalle que el necesario para el examen de certificación pero navegar por los ejemplos online te puede ayudar.sun.com http://www.html 240 .amazon.com/docs/books/tutorial/essential/io/ El JLS sobre Java IO.infospheres.net/~baldwin.geocities.com/SiliconValley/Network/3693/io.att.caltech.com/catalog/javaio/ Joyothi tiene varias útiles tablas sobre las clases de I/O en http://www.2 Otras Fuentes para este tema Este tema esta cubierto por el tutorial de Sun en http://java. El libro tiene generalmente buenas críticas en www.0/javaio.Tutorial para el examen de certificación: SCJP 1.htm O’reilly ha publicado un libro específico sobre Java I/O.doc.oreilly. un poco académico http://www.