Publicado el Dejar un comentario

Exámen SCJP 1.5. Seccion 2. Control de flujo.

1. Estatuto if.

  • Sintaxis:
    a) if ( expresión_boolena ) sentencia_a_ejecutar;
    b) if ( expresión_booleana ) { sentencias_a_ejecutar }
    c) if ( expresión_booleana ) { sentencias_a_ejecutar } else { sentencias_a_ejecutar }
    d) if ( expresión_booleana_1 ) { sentencias_a_ejecutar } else if ( expresion_boolena_2 ) { sentencias_a_ejecutar } else if ( expresion_boolena_3 ) { sentencias_a_ejecutar } ….
  • Notas:
    En la estructura if..else if.. sólo ejecutará el bloque de sentencias de la primera condición o expresión que de verdadera, el resto de las condiciones y sentencias serán ignoradas. 

2. Estatuto switch.

  • Sintaxis:
    switch (expresión) { case constante1: sentencias_a_ejecutar; [break;] case constante2:; default: sentencias_a_ejecutar; }
  • Notas:
    expresión debe ser una variable, expresión o literal (número) entera: byte, short, char, int, enumeración (enum), excepto long. La constante debe ser una literal o variable final. El bloque default no necesariamente debe ir al final. La sentencia break envía el flujo del programa hasta la siguiente línea después del término de la sentencia switch. Si la expresión coincide con una constante case las sentencias en este bloque case se ejecutarán, si no existe una sentencia break en este bloque de sentencias el flujo pasará por el resto de las sentencias de los bloques case o bloque default siguientes sin importar si la expresión coincide con la constante. Esto también aplica para el bloque default. Sólo puede haber un bloque default en una sentencia switch. Los valores en los case deben ser únicos, si no se marcará error al compilar.

3. Estatuto for.

  • Sintaxis:
    for ( estatuto ; condición ; expresión ) { sentencias_a_ejecutar; [break; ] }
    for (
    tipo variable  : colección ) { sentencias_a_ejecutar; [break;] }
  • Notas:
    estatuto se ejecuta solo una vez y al inicio del ciclo, si la condición es verdadera se ejecutan las sentencias del bloque for y por último se ejecuta expresión. Si existe una sentencia break el flujo del programa continúa en la siguiente línea despues del fin del bloque for. estatuto debe ser una sentencia o código válido y puede contener dos expresiones no declarativas separadas por comas ( i++, y++), pero no se puden combinar sentencias declarativas (int x= 0, int y = 0) ó sentencias declarativas con no declarativas (int i = 0, r = r +1 ). Los tres componentes entre paréntesis pueden ser omitidos, pero los punto y coma no ( for ( ; ; ) {}  es válido). La segunda forma llamada for-each asigna uno por uno los elementos en colección a variable de la clase o tipo tipo en cada iteración, es decir habrá tantas iteraciones como elementos haya en colección. Colección puede ser un arreglo (array) u otra colección (collection). Debe especificarse forzosamente el tipo (String, int, etc) de la variable dentro del for, si nó el compilador marcará error.

4. Estatuto while.

  • Sintaxis:
    while ( expresión ) { sentencias_a_ejecutar; [ break; ] }
  • Notas:
    Si expresión es verdadera se ejecutarán las sentencias dentro del bloque. Si existe un sentencia break dentro del bloque while terminará el ciclo y el flujo continuará en la siguiente línea después del término del bloque while.

5. Estatuto do.

  • Sintaxis:
    do { sentencias_a_ejecutar [ break; ] } while ( expresión );
  • Notas:
    Las sentencias se ejecutarán al menos una vez y hasta que la expresión sea falsa. Si encuentra una sentencia break el ciclo se interrumpe y continúa en la siguiente instrucción después del bloque do.

6. Estatutos break y continue.

  • Sintaxis:
    break [identificador];
    continue [identificador];
  • Notas:
    Se usan para romper el flujo normal de los ciclos. break termina el ciclo y continua en la linea siguiente del bloque, continue ignora las sentencias siguientes a la instrucción y vuelve al principio del ciclo. Identificador representa el nombre de una etiqueta de un bloque de ciclo exterior, si está presente salta al bloque con esta etiqueta. continue sólo puede estar dentro de un ciclo, si no, el compilador marcará error. break puede encontrarse en un ciclo o en un switch, si no, el compilador marcará error. break con identificador sólo es válido dentro de los ciclos. En caso de break con etiqueta, si salta a un ciclo exterior, termina el ciclo exterior; en el caso de continue, incrementa el ciclo exterior y continua si la expresión de control de este ciclo sigue siendo verdadero.

7. Estatuto assert.

  • Sintaxis:
    assert condición [: mensaje ];
  • Notas:
    Ayuda a saber si los valores de las variables o condición del programa estan entre los parámetros permitidos. Condición debe ser una expresión boolena, que si es verdadera, el flujo del programa continua normalmente, si no, el programa arrojará una excepción del tipo AssertionError. Si mensaje está presente, ésta se pasa al constructor de la excepción y se imprime junto con el mensaje de excepción. Se debe llamar el comando java con el parámetro -enableassertions ó -ea para que el compilador tome en cuenta y compruebe las aserciones. Recomendado su uso sólo para pruebas y depuración. Usando el parámetro -disableassertions ó -da con el comando java desactiva la comprobación de las aserciones. -ea:clase1 -ea:clase2 … habilita sólo la comprobación de aserciones en las clases especificadas; lo mismo aplica para el parámetro -da.

8. Excepciones (Exception).

  • Las expeciones son errores que ocurren cuando un programa está corriendo. Se controlan con la sentencia try { sentencias1 } catch (tipo_excepción variable) { sentencias2 [ catch …n ] [ finally { sentencias3 } ]. Sentencias1 son las sentencias a ejecutar que probablemente arrojen o arrojan una excepción, tipo_excepción es la clase de excepción que catch controlará, variable el objeto que se inicializará de tipo tipo_excepción, sentencias2 son las sentencias que se ejecutarán si existió la excpeción especificada, sentencias3 son sentencias que se ejecutarán ocurra o no excepción. Checked Exceptions (excepciones revisadas), son excepciones que el compilador exigirá que sean controladas, las Runtime Exceptions (excepciones al momento de ejecución) deben de ser controladas más no las exige el compilador, éstas extienden de la clase java.lang.RunTimeException que a su vez extiende de java.lang.Exception. Para que un método lance excepciones es necesario indicar ésto con el estatuto throws a nivel método y dentro del método colocar la sentencia throw que arrojará la excepción. Todas las excepciones son de la subclase java.lang.Throwable.
  • Hay errores que no son controlables, estos son subclases de java.lang.Error.
  • Las excepciones más conocidad son:
    ArrayIndexOutOfBoundsException, ClassCastException, IllegalArgumentException, IllegalStateException, NumberFormatException, NullPointerException; todas ellas subclase de RunTimeException. AssertionError, ExceptionInitalizeError, StackOverflowError, NoClassDefFoundError; de la subclase Error.
Publicado el Dejar un comentario

Exámen SCJP 1.5. Seccion 1. Declaraciones, Inicialización y Alcances.

1. Clases:

  • Un archivo java (archivo que contiene código java) puede contener la definición de una o más clases (class), pero sólo una de ellas puede ser pública (tener el modificador de acceso public), el resto de ellas deben tener el modificador default.
  • El nombre del archivo java debe de ser el mismo nombre de la clase pública que contiene y preferentemente o por convención debe iniciar con mayúscula.
  • Una clase puede tener, además de los modificadores de acceso public y default, los modificadores de final, abstract y strictfp. Los modificadores final y abstract no deben ir juntos, se especifica uno u otro. sctrictfp puede combinarse con cualquiera.
  • Una clase declarada abstract no puede ser instanciada.
  • Los miembros de una clase, es decir sus métodos y/o propiedades, pueden tener cuatro modificadores de acceso: public, protected, default y private.
  • Las propiedades o atributos de una clase siempre son inicializados implícitamente a sus valores por omisión.
  • Una clase sólo puede heredar de una sola clase (extends) , pero puede implementar (implements) de varias interfaces. Una clase heredada tiene acceso sólo a los métodos y atributos declarados como public y protected de la clase que se hereda y únicamente tendrá acceso a los métodos y atributos declarados como default, si la clase heredada está en el mismo paquete.
  • Una interface sólo declara sus métodos, no los implementa (no contienen código) y son, por omisión, public, static y final. En una interface se pueden declarar constantes con los modificadores public, static y final. Las interfaces pueden heredar de varias intefaces (llamado herencia múltiple) utilizando extends.
  • Si una clase normal implementa una interface, esta clase debe implementar todos los métodos de dicha interface. Si la clase que implementa una interface es abstracta, no es obligatorio implementar dichos métodos. Sin emargo la clase que extienda de la clase abstracta debe implementar todos lo métodos tanto los abstractos .
  • Toda clase tiene un constructor, aún las abstractas. Si en la clase no se implementa el compilador inserta uno, por defecto el cosntructor de la superclase. Si se implementa en la clase, este constructor por defecto no es insertado. Un constructor siempre tiene el mismo nombre que la clase. El constructor no regresa valores. Sólo se puede llamar o invocar un constructor dentro de otro constructor, no desde métodos.
  • Una clase interna es la que se definen o declaran dentro de otra clase. La clase externa tiene acceso a al interna instanciándola, la interna tiene acceso a todos los miembros de la extrena, aún a los privados.Para acceder a una clase interna desde otra clase, se debe anteponer el nombre de la clase y la clase interna a lo smetodos y propiedades. Las clases también pueden definirse dentro de un método de una clase, ésta clase interna no puede acceder a los miembros de la clase externa, sólo a los declarados con final.
  • Las clases internas anónimas se definen dentro de la instanciación de una clase.
  • Las clases internas estáticas se definen declarándolas static, y sólo tienen acceso a los miembros estáticos de la clase contenedora.
  • Java organiza las clases en paquetes (package). Esos paquetes son accesados utilizando la palabra o estatuto import. Si una clase pertenece a un paquete, la palabra package debe ser la primera linea de código en la clase, antes de cualquier estatuto import o declaración de la clase (class). Si no pertenece a algún paquete y necesita accesar a un paquete, la primera línea en el archivo de la clase debe ser el estatuto import. Si la clase no pertenece a ningún paquete y no accesa a otros paquetes, la primera línea de archivo java debe contener la declaración de la clase (class).
  • Importación estática se usa para poder llamar los miembros estáticos de una clase directamente sin necesidad de anteponer el nombre de la clase. Se declara de la siguiente forma:
    import static paquete.Clase.*;
    donde paquete es el paquete (package) donde se encuentra la clase y Clase es el nombre de la clase con miembros (métodos o propiedades) estáticos (static).

2. Modificadores:

  • Los modificadores de acceso, en orden de restricción mayor a menor, son 4: public (público) es el menos restrictivo, permite el acceso desde cualquier paquete; protected (protegido) permite el acceso desde el mismo paquete y desde subclases de la clase; default (por omisión) sólo permite acceso desde clases del mismo paquete y, por último, private (privado) sólo permite el acceso desde la misma clase. El modificador default no se escribe, se toma implícitamente o  por omisión, si no se especifica alguno de los otros tres modificadores.
  • El modificador (no de acceso) final, a nivel de clase, especifica que otras clases no se pueden extender (ser subclase) de ésta clase. A nivel propiedad o variable de clase, indica que la variable sólo pude ser asignada una vez, sin embargo, si la variable apunta a un objeto, los atributos de ese objeto sí pueden ser cambiados, pero la variable siempre referencía al mismo objecto. A nivel método, final, indica que el método no puede ser sobreescrito. Una interface no pude ser declarada final.
  • El modificador (no de acceso) abstract sólo puede ser especificado a nivel clase y a nivel método, una variable no pude declararse abstract. Una interface también puede declararse abstract. A nivel clase, abstract especifica que la clase no puede ser instanciada (no se pueden crear objetos de ella). El compilador obliga a declarar abstracta a una clase si esta tiene métodos abstractos. Un método declarado abstracto no s debe implementar (escribir código dentro de él). La clase que se hereda de una clase abstracta debe implementar los método abstractos de la clase padre, a menos que la clase se declare también abstracta.
  • El modificador static en la declaración de un método o atributo de la clase indica que ese atributo o método es de clase, es decir, que el valor del atributo y/o el método, será compartida entre todas las instancias u objetos creadas de esa clase.
  • strictfp indica que los métodos de la clase siguen las reglas del IEEE 745 para los números de punto flotante si se especifica a nivel clase. Si se especifica al declarar un método, sólo se aplica a ese método. 

3. Lenguaje:

  • Los identificadores en java pueden comenzar solamente por una letra, un guión bajo o el signo de pesos. No deben comenzar con números. Los identificadores son los nombres que se les da a las variables, clases y métodos. Después del primer caracter, son válidos cualquier letra, número, guión bajo y signos de moneda. No se pueden utilizar keywords (palabras reservadas) de java como un identificador. Los identificadores son sensistivo a mayúsculas y minúsculas.
  • Los keywords son palabras reservadas de java. no se pueden usar para delcarar o nombrar ninguna clase, variable o método. Las keywords son: abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchornized, this, throw, throws, transient, try, void, volatile, while. goto no se usa.
  • Toda variable declarada dentro de los métodos debe ser inicializada explícitamente, si no el compilador marcará error. Las constantes se definen con el modificador final.
  • Las enumeraciones se declaran con la palabra enum. Sólo permiten el modificador de acceso public y default. Pueden ser declaradas como clase independiente o dentro de una clase, pero jamás dentro del un método de una clase. Por convención los elementos de la enum se escriben con mayúsculas.
  • Hay algunos métodos que aceptan un número variable de argumentos y no argumentos fijos, también llamados argumentos variables.  Se utiliza poniendo entre lso paréntesis del método el tipo de dato, tres puntos () y por último el nombre del arreglo (array) que contrendrá las variables: void nombreMetodo (int … nombreArreglo) { }. Sólo puede aceptar un argumento variable y se puede combinar con otros argumentos, siempre y cuando el argumento variable se especifique al final de la lista.
Publicado el Dejar un comentario

Exámen SCJP 1.5. Apuntes.

Los siguientes artículos que irán apareciendo en este blog, tratarán de ser un pequeño aporte de conocimiento para aquellas personas que estén preparándose para el exámen SCJP (Sun Certified Java Programmer) con Java 1.5.
Cada artículo pretende ser un resumen de los puntos más importantes de cada una de las secciones en que se dividen los objetivos de éste exámen:

Sección 1. Declaraciones, Inicialización y Alcances.
Sección 2. Control de flujo.
Sección 3. Contenidos de la API.
Sección 4. Concurrencia.
Sección 5. Conceptos de Programación Orientada a Objetos
Seccion 6. Colecciones / Genéricos
Sección 7. Fundamentos.

Espero que los artículos sean de su utilidad.