Tutorial Java Certificacion (1)

Tutorial para el Examen de certificacion: SCJP 1.2

Traduccin del tutorial de Marcus Green.

RuGI Isaac Ruiz Guerra

[email protected]

javaHispano Tu lenguaje, tu comunidad.

Versin Julio del 2003.

Tutorial para el examen de certificacin: SCJP 1.2

2

El presente documento es una traduccin/adaptacin del tutorial de Marcus Green correspondiente a la versin 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 versin 1.4 nicamente se deben pasar por alto las secciones 8 y 11, y agregar el tema de Aserciones. Esta traduccin se realiz con la colaboracin de: Nombre: Seccin: Isaac Ruiz Guerra 1, 2, 3, 4, 6, 8, 9, 10 Joslyn Flores Romero 7 Francisco Fernndez Miser 5 Alberto Molpeceres 11 Puedes hacer cualquier comentario sobre la traduccin a [email protected] La direccin del tutorial de Marcus Green: http://www.jchq.net/certkey/index.htm Un artculo de Emili Miedes de Elas sobre Aserciones: http://www.javahispano.org/articles.article.action?id=57 Este documento forma parte del proyecto Examen de Certificacin: http://www.javahispano.org/text.viewer.action?file=proyectos Copyright (c) 2003,Isaac Ruiz Guerra. Este documento puede ser distribuido solo bajo los trminos y condiciones de la licencia de Documentacin de javaHispano v1.0 o posterior (la ltima versin se encuentra en http://www.javahispano.org/licencias/).

javaHispano. Tu comunidad, tu lenguaje.

3

Seccin 1. Declaracin y control de Acceso ......................7

Objetivo 1........................................................................................................................ 7 Arreglos. .................................................................................................................. 7 Declaracin sin asignacin. ........................................................................................ 7 Creacin y Declaracin Simultanea............................................................................ 8 Arreglos Java VS Arreglos C/C++ . .................................................................... 8 Los arreglos conocen su tamao. ........................................................................... 9 Arreglos Java VS Arreglos VB............................................................................ 9 Combinar declaracin con inicializacin.................................................................. 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 ms sencilla................................................................................................. 16 Creando una clase sencilla- HelloWorld................................................................... 16 La magia del nombre main ....................................................................................... 16 Creando una instancia de una Clase.......................................................................... 17 Creando Mtodos. ..................................................................................................... 18 Variables Automticas .............................................................................................. 19 Modificadores y Encapsulamiento............................................................................ 20 Usando modificadores en combinacin .................................................................... 26

Objetivo 3...................................................................................................................... 35 Nota de este objetivo................................................................................................. 35 Qu es un constructor? ............................................................................................ 35 Cundo proporciona Java el constructor predefinido?............................................ 35 El prototipo del constructor predefinido ................................................................... 37

Objetivo 4...................................................................................................................... 43 Nota de este objetivo................................................................................................. 43 Mtodos en la misma clase ....................................................................................... 43 Mtodos en una subclase. ......................................................................................... 44

Seccin 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 religin? ..................................................................... 57 Break y Continue ...................................................................................................... 57 Saltar a una Etiqueta. ................................................................................................ 58

Objetivo 3...................................................................................................................... 64 Comparando con Visual Basic y C/C++................................................................... 64 La Clusula finally .................................................................................................... 65 Sobrescribiendo mtodos que lanzan excepciones ................................................... 66


4

Seccin 3. Recolector de basura Garbage Collector- ............72 Objetivo 1...................................................................................................................... 72

Por qu querras utilizar el recolector de basura? ................................................... 72 Java y el recolector de basura. .................................................................................. 72

Seccin 4. Fundamentos del lenguaje. ...........................76 Objetivo 1...................................................................................................................... 76

Nota sobre este objetivo............................................................................................ 76 La sentencia package ................................................................................................ 76 La sentencia import ............................................................................................... 77 Clases y la declaracin de clases internas................................................................. 77 Clases internas declaradas dentro de mtodos .......................................................... 79 Visibilidad de campos para clases definidas dentro de un mtodo........................... 80 Creando una interface ............................................................................................... 81

Objetivo 2...................................................................................................................... 85 Objetivo 3...................................................................................................................... 87 Objetivo 4...................................................................................................................... 90

Variables ................................................................................................................... 90 Arreglos..................................................................................................................... 91

Objetivo 5...................................................................................................................... 95 Tamao de los tipos primitivos enteros .................................................................... 95 Declarando literales enteros...................................................................................... 95 Tamao 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

Seccin 5. Operadores y Asignaciones ..........................102 Objetivo 1.................................................................................................................... 102

El operador instanceof....................................................................................... 102 El operador + .......................................................................................................... 103 Asignando variables primitivas de tipos diferentes ................................................ 104 Asignando referencias de objetos de diferentes tipos. ............................................ 105 Operadores de desplazamiento de bits. ................................................................... 106 Operadores de desplazamiento con signo >................................................. 107 Desplazamiento sin signo a la derecha >>>............................................................ 108 Applet BitShift ........................................................................................................ 108

Objetivo 2.................................................................................................................... 113 Diferencia entre el mtodo equals y el operador = =.............................................. 113 Usando el mtodo equals con Strings ..................................................................... 113 Usando el mtodo equals con la Clase Boolean ..................................................... 114 Usando el mtodo equals con objetos..................................................................... 115

Objetivo 3.................................................................................................................... 119 El efecto corto circuito con los operadores lgicos. ............................................... 119 Operadores a nivel de bits....................................................................................... 120 Pensando en binario ................................................................................................ 120

Objetivo 4.................................................................................................................... 124 Nota sobre este objetivo.......................................................................................... 124 Referencias de Objetos como parmetros de mtodos. .......................................... 124


5

Primitivas como parmetros de mtodos ................................................................ 125 Seccin 6. Sobrecarga, sobreescritura, tipos en tiempo de ejecucin y orientacin a objetos .............................128

Objetivo 1) .................................................................................................................. 128 Relaciones es un y tiene un.............................................................................. 128 Encapsulamiento ..................................................................................................... 128 Tipos en Tiempo de ejecucin ................................................................................ 130

Objetivo 2) .................................................................................................................. 135 Comentario sobre el objetivo .................................................................................. 135 Sobrecarga de mtodos ........................................................................................... 135 Sobrescritura de mtodos....................................................................................... 136 Invocando constructores de clases base.................................................................. 137 Invocando constructores con this() ..................................................................... 138 El constructor y la jerarqua de clases..................................................................... 139

Objetivo 3) .................................................................................................................. 146 Nota sobre este objetivo.......................................................................................... 146 Instanciando una clase ............................................................................................ 146 Clases internas ........................................................................................................ 146 Clases Anidadas de nivel Superior (Top Level) ..................................................... 147 Clases Miembro ...................................................................................................... 147 Clases creadas dentro de mtodos........................................................................... 148 Clases annimas...................................................................................................... 148

Seccin 7. Threads ............................................152 Objetivo 1) .................................................................................................................. 152

Qu es un Thread ?................................................................................................ 152 Las dos formas de crear un Hilo (Thread) .............................................................. 152 Instanciando e Iniciando un hilo. ............................................................................ 153

Objetivo 2) .................................................................................................................. 157 Comentario de este objetivo.................................................................................... 157 Razones por las que un thread puede ser bloqueado............................................... 157

Objetivo 3) .................................................................................................................. 161 Por qu necesitaras el protocolo wait/notify? ...................................................... 161 synchronized ........................................................................................................... 161 wait/notify ............................................................................................................... 162

Seccin 8. El paquete java.awt y su disposicin ...............167 Objetivo 1.................................................................................................................... 167

Nota sobre este objetivo.......................................................................................... 167 Comparando la disposicin de componentes de Java y Visual Basic..................... 167 La filosofa de los administradores de disposicin ................................................. 167 Administradores de disposicin que debes conocer para el examen. ..................... 169 Responsabilidades de los Administradores de Disposicin VS los Contenedores . 169 Curiosidades del administrador BorderLayout ....................................................... 170 El administrador de disposicin GridLayout .......................................................... 171 GridBagLayout ....................................................................................................... 172 Usando gridx y gridy para sugerir la posicin de un componente.......................... 175 ipadx y ipady para controlar el relleno interior de los componentes ...................... 176 Componentes dentro de un panel utilizando GridBagLayout................................. 178


6

Fijando componentes dentro de la cuadrcula......................................................... 180 Elementos GridBag no cubiertos por este ejercicio............................................... 182

Objetivo 2.................................................................................................................... 189 El modelo oyente -Listener- de eventos.................................................................. 189 El modelo de eventos del JDK 1.1.......................................................................... 189

Seccin 9. El paquete java.lang.Math ..........................196 Objetivo 1.................................................................................................................... 196

Nota sobre este objetivo.......................................................................................... 196 abs ........................................................................................................................... 196 ceil........................................................................................................................... 196 floor......................................................................................................................... 197 max y min ............................................................................................................... 197 random .................................................................................................................... 198 round ....................................................................................................................... 198 sin cos tan................................................................................................................ 199 sqrt........................................................................................................................... 199 Resumen.................................................................................................................. 199

Objetivo 2.................................................................................................................... 203 Nota sobre este objetivo.......................................................................................... 203

Seccin 10. El paquete java.util ..............................206 Objetivo 1.................................................................................................................... 206

Nota sobre este objetivo.......................................................................................... 206 Las colecciones antiguas......................................................................................... 206 Las nuevas colecciones ........................................................................................... 206 Set ........................................................................................................................... 207 List .......................................................................................................................... 207 Map ......................................................................................................................... 207 Usando Vectores ..................................................................................................... 208 Usando Hashtables.................................................................................................. 209 BitSet....................................................................................................................... 209

Seccin 11. El paquete java.io ................................214 Objetivo 1.................................................................................................................... 214 Objetivo 2.................................................................................................................... 222 Objetivo 3.................................................................................................................... 228 Objetivo 4.................................................................................................................... 229

FileInputStream and OutputStream ........................................................................ 229 BufferedInputStream y BufferedOutputStream...................................................... 230 DataInputStream y DataOutputStream ................................................................... 230 La clase File......................................................................................................... 231 RandomAccesFile ................................................................................................... 231

Objetivo 5.................................................................................................................... 235 FileInputStream and FileOutputStream .................................................................. 235 RandomAccessFile ................................................................................................. 236


7

Seccin 1. Declaracin y control de Acceso

Objetivo 1. Escribir cdigo que declare, construya e inicie arreglos de cualquier tipo base, usando cualquiera de las formas permitidas, para declaracin y para inicializacin.

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

Declaracin sin asignacin. La declaracin de un arreglo no asigna almacenamiento alguno, sta solo anuncia la intencin de crear un arreglo. Una diferencia significativa con la manera en que C/C++ declara un arreglo es que el tamao no se especifica con el identificador. Por lo tanto lo siguiente causara un error durante la compilacin int num[5]; El tamao de un arreglo se da cuando este se crea realmente con el operador new: int num[]; num = new int[5];


8

Creacin y Declaracin Simultanea. Lo anterior puede ser compactado en una sola lnea as: int num[] = new int[5]; Adems los corchetes pueden ser tambin colocados despus del tipo de dato o despus del nombre del arreglo. Por lo tanto son legales las siguientes declaraciones: int[] num; int num[]; Puedes leer esto de la siguiente manera:

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

Arreglos Java VS Arreglos C/C++ .

Una gran diferencia entre java y C/C++ es que en java se conocen de que tamao son los arreglos, y el lenguaje proporciona proteccin para no sobrepasar los limites del arreglo.

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


9

Los arreglos conocen su tamao. Solo en caso de que te hayas saltado la comparacin con C/C++ -hecha anteriormente- los arreglos en Java siempre conocen cual es su tamao, y este se representa en el campo length. As, puedes llenar dinmicamente un arreglo con el cdigo siguiente: int myarray[] = new int [10]; for(int j=0; j


10

Combinar declaracin con inicializacin. En vez de ciclarse a travs de un arreglo para llevar a cabo la inicializacin, un arreglo puede ser creado e inicializado a la vez en una sola declaracin. Esto es particularmente recomendable para arreglos pequeos. La siguiente lnea creara un arreglo de enteros y lo llenara con los nmeros 0 hasta el 4. int k[] = new int[] {0,1,2,3,4}; Observa que en ninguna parte necesitas especificar el nmero de elementos en el arreglo. Puedes analizar esto, preguntndote si el siguiente cdigo es correcto: Int k = new int[5]{0,1,2,3,4}; // error, no compilara !!! Puedes crear y llenar arreglos simultneamente con cualquier tipo de dato, por lo tanto puedes crear un arreglo de cadenas, de la siguiente manera: String s[] = new String [] {Zero,One,Two,Three,Four}; Los elementos de un arreglo pueden ser direccionados como lo haras en C/C++: String s[] = new String [] {Zero,One,Two,Three,Four}; System.out.println(s[0]); Esto mostrar la cadena Zero.

Ejercicio 1) Crea una clase con un mtodo que simultneamente cree e inicialize un arreglo de cadenas. Inicializa el arreglo con cuatro nombres, despus muestra el primer nombre contenido en el arreglo.

Ejercicio 2) Crea una clase que cree un arreglo de cadenas de 5 elementos llamado Fruit en el nivel de clase, pero no lo inicializes con cualquier valor. Crea un mtodo llamado amethod. En amethod inicializa los primeros cuatro elementos con nombres de frutas. Crea otro mtodo llamado modify y cambia el contenido del primer elemento del arreglo Fruit para que contenga la cadena bicycle. Dentro del mtodo modify crea un ciclo for que imprima todos los elementos del arreglo. Solucin sugerida para el ejercicio 1. public class Bevere{ public static void main(String argv[]){ Bevere b = new Bevere(); b.Claines();


11

} public void Claines(){ String[] names= new String[]{"Peter","John","Balhar","Raj"}; System.out.println(names[0]); } } Nota: La sintaxis para la creacin e inicializacin simultanea no es evidente y vale la pena practicarla. Se pregunt por el primer nombre del arreglo para asegurar que no utilizars names[1].

Solucin Sugerida para el ejercicio 2. public class Barbourne{ String Fruit[]= new String[5]; public static void main(String argv[]){ Barbourne b = new Barbourne(); b.amethod(); b.modify(); } public void amethod(){ Fruit[0]="Apple"; Fruit[1]="Orange"; Fruit[2]="Bannana"; Fruit[3]="Mango"; } public void modify(){ Fruit[0]="Bicycle"; for(int i=0; i< Fruit.length; i++){ System.out.println(Fruit[i]); } } } Nota: Cuando el ciclo ejecute la salida de elemento final este ser null.


12

Preguntas. Pregunta 1) Cmo puedes redimensionar un arreglo con una declaracin sencilla manteniendo el contenido original?

Pregunta 2) Quieres averiguar el valor del ltimo elemento de un arreglo. Escribiendo el siguiente Cdigo.Qu pasara cuando lo compiles y ejecutes? public class MyAr{ public static void main(String argv[]){ int[] i = new int[5]; System.out.println(i[5]); } }

Pregunta 3) Quieres hacer un ciclo a travs de un arreglo y detenerte cuando llegues al ultimo elemento. Siendo un buen programador en Java, y olvidando lo que alguna vez conociste sobre C/C++, sabes que los arreglos contienen informacin acerca de su tamao. Cul de las siguientes sentencias puedes usar? 1)myarray.length(); 2)myarray.length; 3)myarray.size 4)myarray.size();

Pregunta 4) Tu jefe esta complacido por que escribiste el programa Hello World y te ha dado un aumento. 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. Cul de las siguientes lneas realizan el trabajo? 1) int i=new int[3][3]; 2) int[] i=new int[3][3]; 3) int[][] i=new int[3][3]; 4) int i[3][3]=new int[][]; Pregunta 5)


13

Quieres encontrar una manera ms elegante para llenar un arreglo que a travs de un ciclo con la sentencia for. Cul de las siguientes lneas usaras? 1) myArray{ [1]="One"; [2]="Two"; [3]="Three"; end with 2)String s[5]=new String[] {"Zero","One","Two","Three","Four"}; 3)String s[]=new String[] {"Zero","One","Two","Three","Four"}; 4)String s[]=new String[]={"Zero","One","Two","Three","Four"};

Respuestas Respuesta 1) No puedes redimensionar un arreglo. Necesitas crear un nuevo arreglo temporal con un tamao 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 .

Respuesta 2) Intentar avanzar mas all del final del arreglo genera un error en tiempo de ejecucin. Debido a que los arreglos son indexados desde 0, el elemento final ser i[4] y no i[5].

Respuesta 3) 2) myarray.length;

Respuesta 4) 3) int[][] = new int[3][3];

Respuesta 5) 3) String s[] = new String[]{Zero,One,Two,Three,Four};


14

Otras Fuentes de este tema:

Este tema es cubierto en el Tutorial de Sun en: http://java.sun.com/docs/books/tutorial/java/data/arraysAndStrings.html Richard Baldwin trata este tema en: http://www.Geocities.com/Athens/Acropolis/3797/Java028.htm Jyothi Krishnan en: http://www.geocities.com/SiliconValley/Network/3693/obj_sec1.html#obj1 Bruce Eckel Thinking In Java Captulo 8


15

Objetivo 2. Declarar clases, clases internas, mtodos, variables de instancia estticas, variables y variables automticas(mtodos locales), haciendo un uso apropiado de todos los modificadores permitidos (como son: public, final, static, abstract, y dems). Conocer importancia de cada uno de estos modificadores ya sea solos o en combinacin

Comentario sobre este objetivo Encuentro un poco molesto que en el objetivo se use la frase y dems. 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. Debido a que Java fue diseado para facilitar que programadores C++ lo aprendieran, este tiene muchas similitudes en la manera en que ambos lenguajes trabajan con las clases. Ambos lenguajes tienen herencia, polimorfismo, y ocultamiento de datos usando modificadores de visibilidad. Algunas de sus diferencias fueron hechas para hacer de Java un lenguaje ms fcil de aprender y usar. El lenguaje C++ implementa la herencia mltiple y as una clase puede tener ms de un padre (o clase base) Java nicamente permite la herencia simple, es decir, las clases pueden tener nicamente un padre. Para sobreponer esta limitacin, Java tiene una caracterstica llamada: Interfaces, a la cual los diseadores del lenguaje le decidieron dar algunas de las ventajas de la herencia mltiple, pero sin las desventajas. Todas las clases en Java son descendientes de una gran clase antecesora llamada Object.

El rol de las clases en Java Las clases son el corazn de Java, todo el cdigo en Java ocurre dentro de una clase. No hay un concepto de cdigo llano y de posicin libre. Hasta la ms sencilla aplicacin HelloWorld involucra la creacin de una clase. Para indicar que una clase desciende de otra clase se usa la palabra clave extends. Si no se usa extends, la clase descender de la clase Object lo cual proporciona a la clase creada, algunas funciones bsicas incluyendo la habilidad para mostrar su nombre y algunas de las capacidades requeridas en los Threads.


16

La clase ms sencilla. Los requerimientos mnimos para definir una clase son: la palabra clave class, el nombre de la clase y las llaves de apertura y cerradura. Entonces: class classname {} es una definicin sintacticamente correcta para una clase, pero no es una clase particularmente til (sorprendentemente, me he encontrado definiendo clases como esta, cuando creo ejemplos para ilustrar la herencia) Normalmente una clase tambin incluir un especificador de acceso antes de la palabra clave class y por supuesto, el cuerpo de la clase entre las llaves. As, 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- HelloWorld Este es un sencillo programa HelloWorld que mostrar: la cadena hello world en la pantalla. public class HelloWorld{ public static void main(String argv[]){ System.out.println("hello world"); } }//Fin de la Definicin de la clase La palabra clave public es un modificador de visibilidad que indica que la clase deber ser visible para cualquier otra clase. Solo una clase por archivo puede ser declarada publica. Si declaras mas de una clase en un archivo como publica, ocurrir un error en tiempo de ejecucin. Observa que Java es sensible a maysculas en todos los aspectos. El archivo que contenga esta clase deber llamarse HelloWorld.java La palabra clave class indica que una clase comienza a ser definida y HelloWorld es el nombre de la clase. Observa que la llave de cierre que finaliza la definicin de la clase no involucra un punto y coma de cerradura. El comentario: //Fin de la Definicin de la clase Usa el estilo de comentario de una sola lnea que esta disponible en C/C++. Java tambin comprende los comentarios multilneas de la forma /* */.

La magia del nombre main


17

Dando a un mtodo la siguiente forma, est obtiene cierta significancia (o magia) cuando indica a Java que es aqu en donde el programa debe empezar a ejecutarse. (similar al main del lenguaje C). public static void main(String argv[]){ Esta lnea indica que esta definindose un mtodo llamado main, y que toma como parmetros (o argumentos) a un arreglo de cadenas. Este mtodo es publico, es decir es visible desde cualquier parte de la clase. La palabra clave static indica que este mtodo puede ejecutarse sin crear una instancia de la clase. Si eso no significa nada para ti, no te preocupes, en su momento se cubrirn con detalle los mtodos estticos (static) en otra parte de este tutorial. La palabra clave void indica el tipo de dato retornado por el mtodo cuando se llama. Usar void indica que ningn valor ser retornado. El parmetro del mtodo main: String argv[] Indica que el mtodo toma un arreglo de tipo String. Los corchetes indican como ya vimos- un arreglo. Observa que el tipo de dato String comienza con una S mayscula. Esto es importante ya que Java es totalmente sensible a las maysculas. Sin estas exactitudes, la Maquina virtual de Java (JVM) no reconocer el mtodo como el lugar en donde se debe comenzar la ejecucin del programa.

Creando una instancia de una Clase La aplicacin HelloWorld, como describ anteriormente, es til para ilustrar la ms sencilla de las aplicaciones que puedes crear. Pero le falta mostrar uno de los elementos ms cruciales al usar las clases, la palabra clave new. La cual indica la creacin de una nueva instancia de la clase. En la aplicacin HelloWorld esto no era necesario ya que el nico mtodo que se llam era System.out.println que es un mtodo esttico y no requiere la creacin de una clase que utilice la palabra new. Los mtodos estticos pueden acceder solo a variables estticas, de las que slo puede existir una instancia por la clase. La aplicacin de HelloWorld puede modificarse ligeramente para ilustrar la creacin de una nueva instancia de una clase. public class HelloWorld2{ public static void main(String argv[]){ HelloWorld2 hw = new HelloWorld2(); hw.amethod(); } public void amethod(){ System.out.println("Hello world"); } }


18

Este cdigo crea una nueva instancia de si mismo en la lnea:

HelloWorld2 hw = new HelloWorld2(); Esta sintaxis para crear una nueva instancia de una clase es bsica para el uso de clases. Observa cmo el nombre de la clase aparece dos veces. La primera vez indica el tipo de dato de la referencia a la clase. Esta necesidad no es la misma que el tipo actual de la clase puesto que sta se indica despus de usar la palabra clave new. El nombre de esta instancia de la clase es hw. ste simplemente es un nombre escogido para una variable. Este es un nombramiento convencional (es decir, utilizando la convencin para escritura de cdigo Java)ya que una instancia de una clase empieza con una letra minscula, considerando que la definicin de una clase empieza con una letra mayscula. El parntesis vaco para el nombre de la clase HelloWorld() indica que la clase est crendose sin algn parmetro en su constructor. Si estuvieras creando una instancia de una clase que se inicializa con un valor o un arreglo como la clase Label o Button el parntesis contendra uno o mas valores de inicializacin.

Creando Mtodos. Como ilustro en el ltimo ejemplo HelloWorld2, un mtodo en Java es similar a una funcin en C/C++ y a una funcin o sub funcin en Visual Basic. El mtodo llamado amethod en este ejemplo se declara como: public que indica que puede accederse desde cualquier parte. Retorna el tipo: void Indicando que ningn valor ser retornado. Y los parntesis vacos indican que no toma parmetros. El mismo mtodo se podra haber definido de estas maneras alternativas: private void amethod(String s) private void amethod(int i, String s) protected void amethod(int i) Estos ejemplos ilustran algunas otras firmas tpicas de declaracin de mtodos. El uso de las palabras clave private y protected se cubrir en otro apartado. La diferencia entre los mtodos de Java y mtodos en lenguajes no orientados a objetos como C es que los mtodos pertenecen a una clase. Esto significa que se llaman usando la anotacin del punto que indica la instancia de la clase a la que el mtodo pertenece (Los mtodos estticos son una excepcin a esto pero no te preocupes sobre ellos por el momento)


19

As en HelloWorld2 el mtodo amethod se llamo as: HelloWorld hw = new HelloWorld(); hw.amethod(); Si se hubieran creado otras instancias de la clase HelloWorld el mtodo podra llamarse desde cada instancia de la clase. Cada instancia de la clase tendra acceso a sus propias variables. As lo siguiente involucrara la llamada al cdigo del mtodo amethod de las diferentes instancias de la clase. HelloWorld hw = new HelloWorld(); HelloWorld hw2 = new HelloWorld(); hw.amethod(); hw2.amethod(); Las dos instancias de la clase: hw y hw2 podran tener acceso a variables diferentes.

Variables Automticas Las variables automticas son las variables de los mtodos. Estas entran en el alcance del programa cuando empieza a ejecutarse el cdigo del mtodo y dejan de existir una vez que el mtodo deja de ejecutarse. Son slo visibles dentro del mtodo y son tiles principalmente para la manipulacin de datos temporales. Si quieres que un valor permanezca entre las llamadas de un mtodo entonces la variable necesita ser creada al nivel de la clase. Una variable automtica ser la "sombra" de una variable de nivel de clase. As el cdigo siguiente mostrar 99 y no 10: public class Shad{ public int iShad=10; public static void main(String argv[]){ Shad s = new Shad(); s.amethod(); }//fin de main public void amethod(){ int iShad=99; System.out.println(iShad); }//fin de amethod }


20

Modificadores y Encapsulamiento.

Los modificadores de visibilidad son parte del mecanismo de encapsulamiento para Java. El encapsulamiento permite la separacin de la interfase y la implementacin de mtodos.

A menudo estos mtodos son para recuperar y actualizar los valores de una variable local privada. Son conocidos como mtodos accessor (acceder o obtener el valor de la variable) y mutator (modificar el contenido de una variable). La convencin para nombrar a estos mtodos es setFoo para modificar y getFoo para obtener el contenido de una variable. As si estuvieras almacenado una variable llamada age deberas hacerla privada y actualizarla con: setAge y recuperar su valor con: getAge Usando cdigo para modificar variables; el valor de la variable tambin puede verificarse, por ejemplo: si el valor esta dentro de un rango en particular o revisar si es un numero positivo. Private Las variables privadas son slo visibles dentro de la misma clase donde se crean. Esto significa que NO son visibles dentro de las subclases. Esto permite que la variable sea aislada de ser modificada por cualquier mtodo, exceptuando aquellos en la clase actual. Como se dijo anteriormente, esto es til para separar la interfase de la implementacin. class Base{ private int iEnc=10; public void setEnc(int iEncVal){ if(iEncVal < 1000){ iEnc=iEncVal; }else System.out.println("Enc value must be less than 1000"); //Or Perhaps thow an exception }//End if } public class Enc{ public static void main(String argv[]){ Base b = new Base(); b.setEnc(1001); }//End of main }


21

Public El modificador public puede aplicarse a una variable (campo) o una clase. Es probablemente el primer modificador que conociste aprendiendo Java. Si revisas el cdigo para HelloWorld.Java, que se program en un principio, la clase se declar como: public class HelloWorld Esto es porque para iniciar el mtodo mgico la JVM, slo revisa en una clase declarada como publica: public static void main(String argv[]) Una clase pblica tiene alcance global, y una instancia puede crearse desde cualquier parte dentro o fuera de un programa. nicamente una clase en un archivo puede definirse con la palabra clave public. Si defines ms de una clase en un archivo con la palabra clave public el compilador generar un error class Base { public int iNoEnc=77; } public class NoEnc{ public static void main(String argv[]){ Base b = new Base(); b.iNoEnc=2; System.out.println(b.iNoEnc); }//End of main } Observa que generalmente sta no es la manera sugerida ya que no permite ninguna separacin entre la interfase y implementacin del cdigo. Si decidieras cambiar el tipo de dato de iNoEnc, tendras que modificar la implementacin de cada parte del cdigo externo que lo modifica. Protected El modificador protected es una pequea rareza. Una variable protegida es visible dentro de una clase, en una subclase, y en el mismo paquete, pero no en otra parte. La cualidad de ser visible dentro del mismo paquete puede darle ms visibilidad de la que podras sospechar. Cualquier clase que est en el mismo directorio se considera que est en el paquete predefinido, y as las clases protegidas sern visibles. Esto significa que una variable protegida tiene ms visibilidad que una variable definida sin modificador de acceso.


22

Se dice que una variable definida sin modificador de acceso tiene visibilidad predefinida. La visibilidad predefinida significa que una variable puede verse dentro de la clase, y desde otra parte dentro del mismo paquete, pero no desde una subclase que no est en el mismo paquete. Static Static no es directamente un modificador de visibilidad, aunque en la prctica tiene este efecto. El modificador static puede aplicarse a una clase, a un mtodo y una variable. Marcando una variable como esttica se indica que slo una copia de esa variable existir por 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. As en el ejemplo siguiente existirn tres instancias de la variable integer iMyVal y cada instancia podra contener un valor diferente. class MyClass{ public int iMyVal=0; } public class NonStat{ public static void main(String argv[]){ MyClass m1 = new MyClass(); m1.iMyVal=1; MyClass m2 = new MyClass(); m2.iMyVal=2; MyClass m3 = new MyClass(); m3.iMyVal=99;

//Esto mostrar 1. Ya que cada instancia de // la clase tiene su propia copia de MyVal System.out.println(m1.iMyVal);

}//End of main } El Ejemplo siguiente muestra que pasa cuando tienes mltiples instancias de una clase que contiene una variable esttica, en este ejemplo la variable esttica es iMyEval. class MyClass{ public static int iMyVal=0; }//End of MyClass public class Stat{ public static void main(String argv[]){ MyClass m1 = new MyClass(); m1.iMyVal=0; MyClass m2 = new MyClass(); m2.iMyVal=1; MyClass m3 = new MyClass(); m2.iMyVal=99;

//Debido a que iMyVal es static, //hay slo una copia de l no importa


23

//cuantas instancias de la clase se creen. //Este cdigo mostrar el valor de 99 System.out.println(m1.iMyVal);

}//End of main } Ten presente que no puedes acceder a variables no estticas desde dentro de un mtodo esttico. As lo siguiente causar un error en tiempo de compilacin. public class St{ int i; public static void main(String argv[]){ i = i + 2;//Causar un error al compilar } }

Un mtodo esttico no puede ser sobreescrito para ser no esttico en una clase hija.

Un mtodo esttico no puede ser sobreescrito para ser no esttico en una clase hija. No hay ninguna regla similar con referencia a la sobrecarga. El cdigo siguiente causar un error cuando intentes sobreescribir el mtodo amethod de la clase Base para ser no esttico. class Base{ public static void amethod(){ } } public class Grimley extends Base{ public void amethod(){}//Causa un error en tiempo de compilacin } El compilador Jikes de IBM produce el siguiente error: Found 1 semantic error compiling "Grimley.java": 6. public void amethod(){} *** Error: The instance method "void amethod();" cannot override the static method "void amethod();" declared in type "Base" Native El modificador native slo se usa para los mtodos e indica que el cuerpo del cdigo esta escrito en un lenguaje que no es Java como C y C++. Se escriben a menudo mtodos


24

nativos para propsitos especficos de la plataforma como acceder a algn elemento de hardware del cual la Maquina Virtual de Java no este consciente. Otra razn es utilizarlo donde se requiere mayor desempeo. Un mtodo nativo termina con punto y coma en lugar de un bloque del cdigo. As lo siguiente llamara una rutina externa, escrita quizs en C++, public native fastcalc(); Abstract Es fcil 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. El modificador abstracto puede aplicarse a las clases y a los mtodos. Cuando se aplica a un mtodo indica que ste no tendr cuerpo y el cdigo slo puede ejecutarse cuando se implemente en una clase hija. Sin embargo hay algunas restricciones sobre cuando y donde puedes tener mtodos abstractos y reglas sobre las clases que los contienen. Cuando se aplica a una clase, indica que la clase tiene un por lo menos mtodo abstracto.

Si una clase tiene algn mtodo abstracto esta debe ser asimismo declarada abstracta .

Sin embargo, no te distraigas pensado que una clase abstracta no puede tener mtodos no abstractos. Cualquier clase que descienda de una clase abstracta debe implementar los mtodos abstractos de la clase base o debe declararlos abstractos ella misma. Tienden estas reglas a generar la pregunta por qu querras crear mtodos abstractos? Los mtodos abstractos son principalmente beneficiosos a los diseadores de clases. Ofrecen al diseo de una clase una manera de crear un prototipo para mtodos que han de ser implementados, pero la implementacin real queda a las personas que usan las clases despus. Aqu hay un ejemplo de una clase abstracta con un mtodo abstracto. De nuevo nota que la propia clase se declara abstracta, de otra manera habra ocurrido un error en tiempo de compilacin. La siguiente clase es abstracta y se compilar sin problemas: public abstract class abstr{ public static void main(String argv[]){ System.out.println("hello in the abstract"); } public abstract int amethod();


25

} Final El modificador final indica que un mtodo no puede ser heredado. Otra manera de entender esto es que una clase final no puede ser una clase padre. Cualquier mtodo en una clase final es automticamente final. Esto puede ser til si no quieres que otros programadores "hechen a perder tu cdigo". Otro beneficio es la eficacia puesto que el compilador tiene menos trabajo al trabajar con un mtodo final. Esto se cubre mejor en el Volumen 1 de Core Java. El cdigo siguiente ilustra el uso del modificador final en una clase. Este cdigo mostrar la cadena "amethod": final class Base{ public void amethod(){ System.out.println("amethod"); } } public class Fin{ public static void main(String argv[]){ Base b = new Base(); b.amethod(); } } Shynchronized La palabra clave synchonized se usa para prevenir que ms de un thread acceda a un bloque de cdigo a la vez. Ve la seccin 7 sobre threads para entender ms cmo funciona esto. Transient La palabra clave transient es uno de los modificadores frecuentemente menos usados. Indica que una variable no debe escribirse fuera cuando una clase es serializada. Volatile Probablemente no conseguirs realizar alguna pregunta sobre la palabra clave volatile. Lo peor que conseguirs es reconocer que realmente es un palabra clave de Java. Segn Barry Boone: "le dice al compilador que una variable puede cambiar asincrnicamente debido a los threads"


26

Acepta que es parte del lenguaje y entonces mejor preocpate por otras cosas.

Usando modificadores en combinacin Los modificadores de visibilidad no pueden usarse en combinacin, as una variable no puede ser privada y pblica, pblica y protegida o protegido y privada. Puedes tener combinaciones de los modificadores de visibilidad y los modificadores mencionados, por supuesto, en mi lista "y dems".

native transient synchronized volatile

As puedes tener un mtodo public static native.

Donde pueden usarse los modificadores Modificador Mtodo Variable clase public si si si private si si si(anidable)protected si si si(anidable)abstract si no si final si si si transient no si no native si no no volatile no si no

Ejercicio 1) Crea un archivo llamado Whitley.java. En este archivo define una clase llamada Base con un mtodo abstracto llamado lamprey que retorne un valor de tipo int. En el mismo archivo crea una clase llamada Whitley que descienda de la clase Base. Proporciona a la clase Whithley un mtodo llamado lamprey con el cdigo necesario para mostrar en pantalla la cadena lamprey. Crea un mtodo nativo para la clase llamado mynative. Ahora compila y ejecuta el cdigo. Ejercicio 2)


27

Crea una clase publica llamada Malvern. Crea una clase interna y privada llamada Great que tenga un mtodo llamado show de la forma public void. Haz que este mtodo muestre en pantalla la cadena Show. Proporciona a la clase Malvern un mtodo publico llamado go que cree una instancia de Great y despus de ser instanciada llame al mtodo show. En el mtodo main de la clase Malvern crea una instancia de s misma. Haz que esta instancia llame al mtodo go. Compila y ejecuta el cdigo.

Solucin sugerida para el ejercicio 1. abstract class Base{ abstract int lamprey(); } public class Whitley extends Base{ public static void main(String argv[]){ } public int lamprey(){ System.out.println("lamprey"); return 99; } native public void mynative(); } Solucin sugerida para el ejercicio 2. public class Malvern{ public static void main(String argv[]){ Malvern m = new Malvern(); m.go(); } public void go(){ Great g = new Great(); g.show(); } private class Great{ public void show(){ System.out.println("Show"); } } }


28

Preguntas. Pregunta 1) Qu pasar cuando intentes compilar y ejecutar este cdigo? abstract class Base{ abstract public void myfunc(); public void another(){ System.out.println("Another method"); } } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(); a.amethod(); } public void myfunc(){ System.out.println("My func"); } public void amethod(){ myfunc(); } }

1) El cdigo se compilar y se ejecutar, mostrando la cadena My func 2) El cdigo indicara que la clase Base no tiene mtodos abstractos. 3) El cdigo se compilara pero indicar un error en tiempo de ejecucin (run time

error): la clase base no tiene mtodos abstractos 4) El compilador indicara que el mtodo myfunc en la clase Base no tiene cuerpo.

Pregunta 2) Qu pasara cuando intentes compilar y ejecutar este cdigo? public class MyMain{ public static void main(String argv){ System.out.println("Hello cruel world"); } }


29

1) El compilador indicara que main es una palabra reservada y no puede ser usada para nombrar una clase.

2) El cdigo se compilar y cuando se ejecute mostrara en pantalla la cadena Hello cruel world.

3) El cdigo se compilara pero indicar un error en tiempo de ejecucin: el constructor no esta definido.

4) El cdigo se compilara pero indicara que la funcin main no esta definida correctamente.

Pregunta 3) De los siguientes cuales son modificadores de Java?

1) public 2) private 3) friendly 4) transient

Pregunta 4) Qu pasar cuando intentes compilar y ejecutar este cdigo?

class Base{ abstract public void myfunc(); public void another(){ System.out.println("Another method"); } } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(); a.amethod(); } public void myfunc(){ System.out.println("My func"); } public void amethod(){ myfunc();

} }

1) El cdigo se compilar y se ejecutar, mostrando la cadena My func 2) El compilador indicar que la clase Base no esta declarada como abstracta. 3) El cdigo se compilar pero indicar un error en tiempo de ejecucin: la clase

base no tiene mtodos abstractos 4) El compilador indicar que el mtodo myfunc en la clase Base no tiene cuerpo.


30

Pregunta 5) Para que defines un mtodo como nativo?

1) Para conseguir acceder a Hardware desconocido por Java 2) Para definir un nuevo tipo de dato como un entero sin signo. 3) Para escribir cdigo optimizado para el mejor desempeo en un lenguaje como

C/C++. 4) Para superar la limitacin del alcance privado de un mtodo

Pregunta 6) Qu pasar cuando intentes compilar y ejecutar este cdigo? class Base{ public final void amethod(){ System.out.println("amethod"); } } public class Fin extends Base{ public static void main(String argv[]){ Base b = new Base(); b.amethod(); } }

1) Un error en tiempo de compilacin indicando que una clase con algn mtodo final debe ser declarado final por si misma.

2) Un error en tiempo de compilacin indicar que no puedes heredar de una clase con mtodos final

3) Un error en tiempo de ejecucin indicando que Base no esta definida como final

4) xito en la compilacin y al ejecutarse mostrar en pantalla amethod.

Pregunta 7) Qu pasar cuando intentes compilar y ejecutar este cdigo? public class Mod{ public static void main(String argv[]){ } public static native void amethod(); }

1) Error en la compilacin: mtodo nativo no puede ser static.


31

2) Error en la compilacin: mtodo nativo debe retornar algn valor. 3) Compilacin correcta pero habr un error en tiempo de ejecucin a menos que

hallas hecho cdigo para hacer til el mtodo nativo. 4) Compilacin y ejecucin sin error.

Pregunta 8) Qu pasar cuando intentes compilar y ejecutar este cdigo? private class Base{} public class Vis{ transient int iVal; public static void main(String elephant[]){ } }

1) Un error en tiempo compilacin: la clase Base no puede ser privada. 2) Un error en tiempo de compilacin indicando que un entero no puede ser

transient 3) Un error en tiempo de compilacin indicando que transient no es un tipo de

dato. 4) Un error en tiempo de compilacin indicando que el mtodo main esta deformado

Pregunta 9) Qu pasara cuando intentes compilar y ejecutar estos dos archivos en el mismo directorio? //Archivo P1.java package MyPackage; class P1{ void afancymethod(){ System.out.println("What a fancy method"); } } //Archivo P2.java public class P2 extends P1{ afancymethod(); }

1) Ambos se compilarn y P2 mostrar en pantalla Wath a fancy method cuando se ejecute.

2) No se compilar ninguno. 3) Ambos se compilarn pero P2 tendr un error en tiempo de ejecucin. 4) P1 se compilar limpiamente pero P2 tendr un error al compilarse.


32

Pregunta 10) Cules de las declaraciones siguientes son legales?

1) public protected amethod(int i) 2) public void amethod(int i) 3) public void amethod(void) 4) void public amethod(int i)

Respuestas. Respuesta 1)

1) El cdigo se compilara y se ejecutara, mostrando la cadena My func Una clase abstracta puede tener mtodos no abstractos, pero cualquier clase que descienda de ella, debe implementar todos los mtodos abstractos. Respuesta 2)

1) El cdigo se compilara pero indicara que la funcin main no esta definida correctamente.

La funcin main recibe un String en lugar de un arreglo de String que es lo correcto. Respuesta 3)

1) public 2) private 4) transient

Aunque algunos textos usan la palabra friendly cuando tratan el tema de visibilidad, esta no es una palabra reservada de Java. Toma en cuenta que ser casi seguro que el examen contenga problemas que te pidan que identifiques palabras claves de Java en una lista. Respuesta 4)

2) El compilador indicara que la clase Base no esta declarada como abstracta. El mensaje de error utilizando JDK 1.1. es: Abs.java:1: class Base must be declared abstract. It does not define void myfunc () from class Base. class Base{


33

^ 1 error Respuesta 5) 1) Para conseguir acceder a hardware desconocido por Java 3) Para escribir cdigo optimizado para el mejor desempeo en un lenguaje como C/C++ Aunque la creacin de cdigo PURE JAVAes altamente conveniente, particularmente para permitir la independencia de plataforma, no debe de tomarse como una religin, y hay ocasiones en que se requiere el cdigo nativo. Respuesta 6)

4)xito en la compilacin y al ejecutarse mostrar en pantalla amethod. Este cdigo llama a una versin de amethod de la clase Base. Si intentas implementar una versin sustituida del mtodo en la clase Fin conseguirs un error en tiempo de compilacin. Respuesta 7)

4)Compilacin y ejecucin sin error. Esta lnea no es una llamada a un mtodo nativo solo se esta declarando- y por lo tanto no ocurre un error en la ejecucin. Respuesta 8)

1)Un error en tiempo compilacin: la clase Base no puede ser privada. Una clase de un nivel alto, al igual que una clase base, no puede ser declarada como privada Respuesta 9)

4)P1 se compilar limpiamente pero P2 tendr un error al compilarse. Aunque P2 esta en el mismo directorio que P1, debido a que P1 fue declarado como parte de un paquete, P1 no esta visible para P2. Respuesta 10)

2)public void amethod(int i) Si pensaste que la opcin 3 es legal utilizando como parmetro el argumento void, debes quitarte un poco de C/C++ de la cabeza.


34

La opcin 4 no es legal porque el tipo de datos debe aparecer despus de cualquier especificador de acceso.

Otras Fuentes para este tema. Este tema es cubierto en el tutorial de Sun como Modificadores de clases: http://java.sun.com/docs/books/tutorial/reflect/class/getModifiers.html Controlando el acceso a los miembros de una clase: http://java.sun.com/docs/books/tutorial/java/javaOO/accesscontrol.html Richard Baldwin Cubre este tema en http://www.Geocities.com/Athens/Acropolis/3797/Java040.htm Jyothi Krishnan en: http://www.geocities.com/SiliconValley/Network/3693/obj_sec1.html#obj2 Bruce Eckel Thinking in Java Chapter 5 (aunque tiene la cabeza llena de C++ e insiste en incluir el modificador friendly)


35

Objetivo 3. Para una clase dada, determinar si se debe crear un constructor predefinido, y si ese es el caso, declarar el prototipo de ese constructor.

Nota de este objetivo ste es un objetivo pequeo pero oportuno, que se concentra en un aspecto fcilmente pasado por alto en Java

Qu es un constructor? Necesitas comprender el concepto de constructor para entender este objetivo. Brevemente, es el cdigo que se ejecuta automticamente cuando se crea la clase. Los constructores a menudo se usan para iniciar valores en la clase. Los constructores tienen el mismo nombre de a clase y no retornan ningn valor. En el examen puedes encontar preguntas sobre mtodos que tengan el mismo nombre de la clase pero que retornan algn tipo, como int o String. Ten cuidado y asegrate que cualquier mtodo que asumas que es un constructor no debe retornar algn tipo de dato. Aqu hay un ejemplo de una clase con un constructor que muestra "Greetings from Crowle" cuando se crea una instancia de la clase. public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(); } Crowle(){ System.out.println("Greetings from Crowle"); } }

Cundo proporciona Java el constructor predefinido? Si no defines especficamente algn constructor, el compilador inserta fuera de escena un constructor invisible con cero parmetros, frecuentemente esto solo es de importancia terica, pero lo verdaderamente importante es que solo recibes el constructor predefinido con cero parmetros si no creas algn constructor propio.


36

Si creas tus propios constructores, Java ya no te proporciona el constructor predefinido con cero parmetros. As que tienes que especificarlo.

En cuanto creas algn constructor propio, pierdes el constructor predefinido con cero parmetros. Si intentas crear una instancia de una clase, sin pasarle algn parmetro (invocando la clase con el constructor con cero parmetros), obtendrs un error. As, cuando crees algn constructor para una clase necesitars crear el constructor con cero parmetros. Esta es una de las razones por las que generadores de cdigo como Borland/Inprise o JBuilder, crean un constructor con cero parmetros cuando generan el esqueleto de una clase. El ejemplo siguiente muestra cdigo que no compilar. Cuando el compilador verifica la creacin de la instancia c de la clase Base, inserta una llamada al constructor con cero parmetros. Debido a que la clase Base tiene un constructor que recibe un entero, el constructor con cero parmetros ya no esta disponible. Esto se puede arreglar creando en la clase Base un constructor con cero parmetros que no haga nada. //Advertencia: no se compilar class Base{ Base(int i){ System.out.println("single int constructor"); } } public class Cons { public static void main(String argv[]){ Base c = new Base(); } } //Esto si se compilar class Base{ Base(int i){ System.out.println("single int constructor"); } Base(){} } public class Cons { public static void main(String argv[]){ Base c = new Base(); } }


37

El prototipo del constructor predefinido El objetivo te pide que estes consciente del prototipo del constructor predefinido. Naturalmente no debe tener ningn parmetro. La predefinicin ms evidente es no tener ningn especificador de alcance, pero puedes definir un constructor como pblico o protegido. Los constructores no pueden ser nativos, abstractos, estticos, sincronizados ni finales. Ese pedazo de informacin se deriv directamente de un mensaje de error del compilador. Parece que la calidad de los mensajes de error estn mejorando con las nuevas versiones de Java. He odo que el nuevo compilador de Java de IBM tiene un buen informador de errores. Podran aconsejarte que tuvieras disponible ms de una versin del compilador de Java para verificar tu cdigo y buscar los errores. Ejercicios Ejercicio 1) Crea una clase llamada Salwarpe con un mtodo llamado hello que muestre la cadena hello. En el mtodo main de la clase crea una instancia de s misma llamada s1 y llama al mtodo hello desde la instancia. Compila y ejecuta el programa para que puedas ver el resultado. Ejercicio 2) Usando todava el archivo Salwarpe.java comenta las lneas que crean la instancia y llaman al mtodo hello. Crea un constructor publico para la clase que tome un parmetro entero y muestre el valor del entero. Crea una instancia de la clase llamada s2 proporcinale el valor de 99 al constructor. Compila y ejecuta el programa para que puedas ver mostrado el resultado. Ejercicio 3) Descomenta las lneas que crean la instancia s1 y modifica el programa para que compile, ejecute y muestre ambos la cadena Hello y el numero 99. Solucin sugerida para el ejercicio 1. public class Salwarpe { public static void main(String argv[]){ Salwarpe s1 = new Salwarpe(); s1.hello(); } public void hello(){ System.out.println("Hello"); }


38

} Solucin sugerida para el ejercicio 2. public class Salwarpe { public static void main(String argv[]){ //Salwarpe s1 = new Salwarpe(); //s1.hello(); Salwarpe s2 = new Salwarpe(99); } public void hello(){ System.out.println("Hello"); } public Salwarpe(int i){ System.out.println(99); } } Solucin sugerida para el ejercicio 3. public class Salwarpe { public static void main(String argv[]){ Salwarpe s1 = new Salwarpe(); s1.hello(); Salwarpe s2 = new Salwarpe(99); } public void hello(){ System.out.println("Hello"); } public Salwarpe(int i){ System.out.println(99); } public Salwarpe(){} } Observa como fue necesario crear el constructor con cero parmetros para este ltimo ejercicio. Una vez que has creado algn constructor para una clase, Java ya no te proporciona tras escena el constructor con cero parmetros que estaba disponible en el ejercicio 1.


39

Preguntas Pregunta 1) Dada la siguiente definicin de clase: class Base{ Base(int i){} } class DefCon extends Base{ DefCon(int i){ //XX } } Cul se las lneas siguientes ser individualmente valida si se sustituye por la lnea marcada con //XX? 1) super(); 2) this(); 3) this(99); 4)super(99);

Pregunta 2) Dada la siguiente definicin de clase: public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(); } Crowle(){ System.out.println("Greetings from Crowle"); } } Cul es el tipo de dato retornado por el constructor? 1) null 2) integer 3) String 4) no es retornado algn tipo de dato

Pregunta 3) Qu pasara cuando intentes compilar y ejecutar el siguiente cdigo?


40

public class Crowle{ public static void main(String argv[]){ Crowle c = new Crowle(); } void Crowle(){ System.out.println("Greetings from Crowle"); } } 1)Se compilara y mostrar la cadena Greetings from Crowle. 2)Error en tiempo de compilacin: un constructor no puede retornar un tipo de dato. 3)Se compilara y mostrar la cadena void. 4)Se compilara y no mostrar nada al ejecutarse.

Pregunta 4) Qu pasara cuando intentes compilar y ejecutar el siguiente cdigo? class Base{ Base(int i){ System.out.println("Base"); } } class Severn extends Base{ public static void main(String argv[]){ Severn s = new Severn(); } void Severn(){ System.out.println("Severn"); } } 1)Se compilar al ejecutarse y mostrar la cadena Seven. 2)Error en tiempo de compilacin. 3)Se compilar y no mostrar nada al ejecutase 4)Se compilar y mostrar la cadena Base

Pregunta 5) Cules de las siguientes declaraciones son verdaderas? 1)El constructor predefinido retorna un tipo void. 2)El constructor predefinido toma como parmetro un valor tipo void. 3)El constructor predefinido no toma parmetros.


41

4)El constructor predefinido no se crea si la clase contiene algn constructor propio

Respuestas Respuesta 1) 4)super (99) Debido a que la clase Base tiene definido un constructor, el compilador no insertar el constructor predefinido con cero parmetros. Por consiguiente, llamar a super() causar un error. Una llamada a this() es un intento de llamar a un constructor con cero parmetros inexistente en la clase actual. La llamada a this(99) causar una referencia circular y causar un error en tiempo de compilacin. Respuesta 2) 4) no es retornado algn tipo de dato Debe ser bastante obvio de que ningn tipo de dato se retorna, as como por definicin los constructores no tienen tipos de datos Respuesta 3) 4)Se compilara y no mostrar nada al ejecutarse. Debido a que el mtodo Crowle retorna un tipo de dato no es un constructor, por consiguiente la clase se compilar y al ejecutarse el mtodo Crowle no se ejecutar pues no ha sido llamado-. Respuesta 4) 2)Error en tiempo de compilacin. Ocurre un error cuando la clase Severn intenta llamar al constructor con cero parmetros en la clase Base. Respuesta 5) 3)El constructor predefinido no toma parmetros. 4)El constructor predefinido no se crea si la clase contiene algn constructor propio


42

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


43

Objetivo 4 Establecer los tipos de datos validos de retorno para cualquier mtodo, dada las declaraciones de todos lo mtodos relacionados con este o con la clase padre.

Nota de este objetivo La frase del objetivo parece ser bastante obscura. Parece estar pidindote que entiendas la diferencia entre sobrecarga y sobrescritura. Para aprovechar mejor este objetivo necesitas una comprensin bsica sobre la sobrecarga y sobrescritura de mtodos. Esto se ve en la: Seccin 6: Orientacin a Objetos, sobrecarga y sobreescritura en tiempo de ejecucin

Mtodos en la misma clase Si dos o ms mtodos en la misma clase tienen el mismo nombre, se dice que el mtodo esta sobrecargado. Puedes tener dos mtodos en una clase con el mismo nombre pero deben tener parmetros de diferente tipo y en diferente orden. Es el orden de los parmetros y los tipos de los mismos los que distinguen entre cualquiera de dos versiones de un mtodo sobrecargado a uno en especial. El tipo de dato de retorno no contribuye a la distincin entre mtodos. El cdigo siguiente generar un error en tiempo de compilacin, el compilador observa en amethod un intento por definir el mismo mtodo 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(); int iBase=0; o.amethod(iBase); } //Las siguientes definiciones generan un error al compilar public void amethod(int iOver){ System.out.println("Over.amethod"); } public int amethod(int iOver){ System.out.println("Over int return method"); return 0; }


44

}

El tipo de dato de retorno no contribuye a realizar la distincin entre un mtodo y otro.

Mtodos en una subclase. Puedes sobrecargar un mtodo en una subclase. Todo lo que se requiere es que la nueva versin debe tener parmetros de diferente tipo y en diferente orden. Los nombres de los parmetros o el tipo de dato retornado por el mtodo no se toman en cuenta para la sobrecarga de mtodos. Si vas a sobrescribir un mtodo, por ejemplo para reemplazar su funcionalidad completamente en una subclase, la versin sobrescrita del mtodo debe tener la misma definicin que la versin de la clase base de la que esta descendiendo. Esto incluye el tipo de dato de retorno. Si creas un mtodo en una subclase con el mismo nombre y definicin pero retorna un tipo de dato distinto, generars el mismo mensaje de error que en el ejemplo anterior. 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 mtodo en lugar de verlo como una sobrescritura del mtodo.

Preguntas Pregunta 1) Dada la siguiente definicin de clase: public class Upton{ public static void main(String argv[]){


45

} public void amethod(int i){} //Here } Cules de las lneas siguientes son vlidas para ser colocadas despus del comentario //Here? 1) public int amethod(int z){} 2) public int amethod(int i,int j){return 99;} 3) protected void amethod(long l){ } 4) private void anothermethod(){} Pregunta 2) Dada la siguiente definicin de clase: class Base{ public void amethod(){ System.out.println("Base"); } } public class Hay extends Base{ public static void main(String argv[]){ Hay h = new Hay(); h.amethod(); } } Cul de los siguientes mtodo puede ser de la clase Hay para que compile y provoque que el programa muestre la cadena Hay ? 1) public int amethod(){ System.out.println("Hay");} 2) public void amethod(long l){ System.out.println("Hay");} 3) public void amethod(){ System.out.println("Hay");} 4) public void amethod(void){ System.out.println("Hay");} Respuestas Respuesta 1)


46

2) public int amethod(int i, int j) {return 99;} 3) protected void amethod (long l){} 4) private void anothermethod(){} La opcin 1 no compilara por dos razones. La primera es que obviamente exige que un entero sea retornado- y como podemos ver hace falta un return -. La otra es que es evidente un intento por redefinir un mtodo dentro de la misma clase. El cambio de nombre del parmetro de i a z no tiene efecto y un mtodo no puede ser sobrescrito dentro de la misma clase. Respuesta 2) 3) public void amethod(){ System.out.println("Hay");} La opcin 3 es una sobrescritura del mtodo de la clase Base, para alguna invocacin de esta versin se utilizarn cero parmetros La opcin 1 generar un error que indicar que se est intentando redefinir un mtodo con un diferente tipo de dato de retorno. Aunque la opcin 2 compilar, la llamada a amethod invocar el mtodo de la clase Base y la salida sea la cadena Base. La opcin 4 fue diseada para sorprender a aquellos con una cabeza llena de C/C++, en Java no hay tal cosa: la utilizacin de void para indicar que no hay parmetros.

Otras Fuentes de este tema: Jyothi Krishnan http://www.geocities.com/SiliconValley/Network/3693/obj_sec1.html#obj4 En esta liga Jyothi sugiere que vayas al objetivo 19: http://www.geocities.com/SiliconValley/Network/3693/obj_sec6.html#obj19


47

Seccin 2. Control de Flujo y Manejo de Excepciones.

Objetivo 1. Escribir cdigo que use sentencias if y switch e identificar los tipos validos de argumentos para estas sentencias.

La sentencia if/else. Ls sentencia if/else funciona en Java tal como podras esperar que funcione en otros lenguajes. las sentencias switch/case tienen unas peculiaridades. La sintaxis para la sentencia if/else es: if(condicion tipo_boolean){ //si el boolean es verdadero se hace esto }else { //sino, se hace esto } Java no tiene la palabra clave "then" como en Visual Basic. Las llaves son un indicador general en Java de una declaracin compuesta que permite ejecutar mltiples lneas de cdigo como resultado de alguna evaluacin. Esto se conoce como bloque de cdigo. La parte del "else" siempre es opcional. Una idiosincrasia de Java es que la sentencia if debe tomar un valor del tipo boolean. No puedes usar la convencin de C/C++ donde cualquier valor distinto de cero es verdadero y 0 es falso. As , en Java lo siguiente simplemente no compilar: int k =-1; if(k){//no se compilar! System.out.println("do something"); } Esto debido a que debes efectuar explcitamente una pregunta sobre la variable k que devuelva un valor tipo boolean, como en el ejemplo siguiente: if(k == -1){ System.out.println("do something"); //compilacin OK! } As como en C/C++ puedes no utilizar las llaves:


48

boolean k=true; if(k)

System.out.println("do something"); Esto a veces es considerado un mal estilo de programacin, porque si modificas el cdigo despus para incluir declaraciones adicionales estas quedarn fuera del bloque condicional (qu solo abarca una lnea por no utilizar llaves) As: if(k) System.out.println("do something"); System.out.println("also do this"); La segunda lnea siempre se ejecutar.

La Sentencia switch La opinin 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 atencin extra. El argumento de una sentencia switch debe ser un byte, char, short o un int. Puedes encontrar un ejercicio en el examen que use un float o un long como argumento en una sentencia switch. Una pregunta bastante comn parece estar sobre el uso de la sentencia break en el proceso descendente a travs de una sentencia switch. Aqu hay un ejemplo de este tipo de pregunta. int k=10; switch(k){ case 10: System.out.println("ten"); case 20: System.out.println("twenty"); } El sentido comn nos indicara que despus de ejecutar las instrucciones que siguen la primera sentencia case, y habindose encontrado con otra sentencia case, el compilador terminara su descenso a travs de la sentencia switch. Sin embargo, por razones mejor conocidas solo por los diseadores del lenguaje, una sentencia case solo se detiene cuando se encuentran con una sentencia break. Como resultado, en el ejemplo anterior las cadenas: "ten" y "twenty" son mostradas. Otra pequea peculiaridad que puede surgir en las preguntas es donde colocar la sentencia default.


49

La clusula default no necesita ir al final de una sentencia case.

El lugar convencional para la sentencia default est al final de las opciones case. As normalmente el cdigo se escribir como sigue: int k=10; switch(k){ case 10: System.out.println("ten"); break; case 20: System.out.println("twenty"); break; default: System.out.println("This is the default output"); } Esta aproximacin refleja la manera en que piensa la mayora de las personas. Una vez que se han probado todas las posibilidades, se realiza la sentencia default. Sin embargo, el cdigo de una sentencia switch con la sentencia default hasta arriba es sintcticamente correcto, pero no aconsejable. int k=10; switch(k){ default: //Coloca default hasta abajo y no ac System.out.println("This is the default output"); break; case 10: System.out.println("ten"); break; case 20: System.out.println("twenty"); break; }

Argumentos validos para las sentencias if y switch. Como mencion anteriormente una sentencia if puede tomar solo un valor tipo boolean y una sentencia switch puede tomar solamente un byte, char, short o un int.

El operador ternario ?


50

Algunos programadores dicen que el operador ternario es til. Yo no considero para que. No se menciona especficamente en los objetivos as que por favor hganme saber si aparece en su examen.

Pregunta 1) Qu pasar cuando intentes compilar y ejecutar el siguiente cdigo? public class MyIf{ boolean b; public static void main(String argv[]){ MyIf mi = new MyIf(); } MyIf(){ if(b){ System.out.println("The value of b was true"); } else{ System.out.println("The value of b was false"); } } } 1) Error en tiempo de compilacin: la variable b no fue inicializada 2) Error en tiempo de compilacin: el parmetro para la sentencia if debe evaluar a un boolean 3) Error en tiempo de compilacin: no se puede crear y asignar un valor simultneamente a un boolean 4) Compilacin y ejecucin mostrando el segundo mensaje.

Pregunta 2) Qu pasar cuando intentes compilar y ejecutar este cdigo? public class MyIf{ public static void main(String argv[]){ MyIf mi = new MyIf(); } MyIf(){ boolean b = false;


51

if(b=false){ System.out.println("The value of b is"+b); } } } 1) Error en tiempo de ejecucin: un boolean no puede agregarse con el operador + 2) Error en tiempo de compilacin: el parmetro para la sentencia if debe evaluar a un boolean 3) Error en tiempo de compilacin: no se puede crear y asignar un valor simultneamente a un boolean 4) Compilacin y ejecucin sin salida.

Pregunta 3) Qu pasar cuando intentes compilar y ejecutar este cdigo? public class MySwitch{ public static void main(String argv[]){ MySwitch ms= new MySwitch(); ms.amethod(); } public void amethod(){ char k=10; switch(k){ default: System.out.println("This is the default output"); break; case 10: System.out.println("ten"); break; case 20: System.out.println("twenty"); break; } } } 1) Ninguna de estas opciones 2) Error en tiempo de compilacin: 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"


52

Pregunta 4) Qu pasar cuando intentes compilar y ejecutar el siguiente cdigo? public class MySwitch{ public static void main(String argv[]){ MySwitch ms= new MySwitch(); ms.amethod(); } public void amethod(){ int k=10; switch(k){ default: //Put the default at the bottom, not here System.out.println("This is the default output"); break; case 10: System.out.println("ten"); case 20: System.out.println("twenty"); break; } } } 1) Ninguna de estas opciones 2) Error en tiempo de compilacin: 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 lneas, cual podra usarse como parmetro para una declaracin switch? 1) byte b=1; 2) int i=1; 3) boolean b=false; 4) char c='c'; Respuestas Respuesta 1) 4) Compilacin y ejecucin mostrando el segundo mensaje.


53

Debido a que la variable boolean b se cre al nivel de clase, no necesita ser inicializada explcitamente y en cambio toma el valor predefinido de un boolean que es falso. Una sentencia if debe evaluar un valor boolean y as la variable b cumple este criterio. Respuesta 2) 4) Compilacin y ejecucin sin salida. Debido a que la variable b es un boolean no habr ningn error causado por la sentencia if. Si b fuera de cualquier otro tipo de dato hubiera ocurrido un error cuando intentaras realizar una asignacin en lugar de una comparacin. La expresin: if(b=false) es una asignacin y normalmente representa un error del programador. A menudo el programador tena en mente decir: if (b==false) Si el tipo de dato de b hubiera sido cualquiera menos boolean habra ocurrido un error al compilarse. 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). Respuesta 3) 4) Se Compilar y ejecutar mostrando "ten" Respuesta 4) 1) Ninguna de estas opciones Debido a la falta de una sentencia break despus de la lnea: System.out.println("ten"); la salida real ser: "ten" seguido de "twenty" Respuesta 5)


54

1) byte b=1; 2) int i=1; 4) char c='c'; Una sentencia switch puede tomar nicamente a

Tutorial Java Certificacion (1)

Documents

Transcript of Tutorial Java Certificacion (1)