style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

blog de Jhanno

Rumbo a nuestra Certificación (Segunda entrega)

Hola a todos, cómo están?

Pues como lo habiamos comentado anteriormente, mi hermana y un servidor se estàn preparando para la Certificaciòn de "Expert Java Programmer" y estamos compartiendo los ejercicios y textos resumidos de varios libros para tal efecto.

Ésta sería la segunda entrega para todos los novatos, esperamos sea de su ayuda como lo es para nosotros.

Dicha entreda contempla los siguientes temas:

a) Constantes.
b) Operadores aritméticos.
c) Operadores de asignación.
d) Asignación de referencia y asignación de valores.
e) Operadores condicionales.
f) Comparación de tipos básicos.

Saludos y felices compilaciones.

---------------------------------------------------------------------------

Constantes.

Una constante es una variable cuyo valor no puede ser modificado. Para declarar una constante utilizaremos la palabra reservada "final", delante de la declaración de tipo, siguiendo la expresión:

final tipo nombre_constante = valor;

Ejemplo:

final double pi = 3.1416;

Las constantes pueden declararse dentro de una clase o un método.

Rumbo a nuestra Certificación (Sintaxis del lenguaje)

Hola a todos los programadores de esta comunidad.

Mi hermana y yo estamos en vías de nuestra certificación en "Expert Java Programmer", es por eso que abordaremos varios temas para los novatos.

Todos los ejercicios que publicaremos están basados en varios libros de certificación.

Esta entrega contempla los siguientes temas:

a) Sintaxis básica.
b) Secuencias de escape.
c) Tipos de datos primitivos.
d) Variables.
e) Declaración de variables.
f) Asignación.
g) Literales.
h) Ámbito de las variables.
i) Valores por defecto de una variable.
j) Conversiones de tipo.
k) Conversión implícita.
l) Conversión explícita.

Cualquier duda, comentario o aclaración a través del panel de respuestas.

Saludos y felices compilaciones.

---------------------------------------------------------------------------

Sintaxis del Lenguaje Java.

Algunos de los aspectos generales de J2SE son:

a) Lenguaje sensible a mayúsculas y minúsculas.
b) Las sentencias finalizan con punto y coma (;).
c) Los bloques de instrucciones se delimitan con llave ({...}).
d) Comentarios de una línea y multilínea.

Ejemplo:

Más ejercicios para los que comenzamos

Hola a todos! Qué tal su fin de semana?

Aquí les dejo la segunda entrega de ejercicios que un servidor ha realizado via el Primer Examen de Certificación...

Actualización por jb***

Espero les ayude a los novatos para una comprensión mejor de los conceptos básicos del lenguaje...

Cualquier duda, comentario o aclaración por favor sólo háganmelo saber...

Saludos y que tengan un excelente inicio de semana...

Capítulo 002 Ejercicio 022 (Límites Aleatorios)

// ¿Produce Math.random() los valores de 0.0 y 1.0?

/** Hay una segunda cuestión que concierne a Math.random(). ¿Produce un valor de cero a uno,
* inlcluyendo o excluyendo el valor "1"? En el lingo matemático ¿es (0,1) ó [0,1], ó (o,1] ó [0,1)?
* (El corchete significa "incluye" mientras que el paréntesis significa "excluye"). De nuevo, la
* solución la puede proporcionar un programa de prueba:
*
*/

public class LimitesAleatorios{

static void uso(){
System.out.println("Utilización: \n\t" +
"Limites Aleatorios inferior\n\t" +
"Limites Aleatorios superior");
System.exit(1);
}

public static void main(String args[]){
if(args.length != 1)
uso();

if(args[0].equals("inferior")){
while(Math.random() != 0.0)
; // Seguir intentándolo
System.out.println("Produjo 0.0!");
}else if(args[0].equals("superior")){
while(Math.random() != 1.0)
; // Seguir intentándolo
System.out.println("Produjo 1.0!");
}
else
uso();
}
}

/** Para ejecutar el programa se teclea una línea de comando como:
*
* java LimitesAleatorios inferior
*
* o
*

Capítulo 002 Ejercicio 021 (Convertir Números)

// ¿Qué ocurre cuando se convierte un float o un double a un valor entero?

/** La sentencia
*
* char c = (char)(Math.random() * 26 + 'a');
*
* merece una mirada más detallada. Math.random() produce un double, por lo que se convierte el
* valor 26 a double para llevar a cabo la multiplicación, que también produce un double. Esto
* significa que debe convertirse la 'a' a double para llevar a cabo la suma. El resultado double
* se vuelve a convertir en char con un molde.
*
* ¿Qué es lo que hace la conversión a char? Es decir, si se tiene el valor de 29.7 y se convierte
* a char, ¿cómo se sabe si el valor resultante es 30 ó 29? La respuesta a esta pregunta se puede ver
* en este ejemplo:
*
**/

public class ConvertirNumeros{
public static void main(String args[]){
double
encima = 0.7,
debajo = 0.4;
System.out.println("Encima: " + encima);
System.out.println("Debajo: " + debajo);
System.out.println("(int)encima: " + (int)encima);
System.out.println("(int)debajo: " + (int)debajo);
System.out.println("(char)('a' + encima): " + (char)('a' + encima));

Capítulo 002 Ejercicio 020 (Vocales y Consonantes)

/** La orden switch suele clasificarse como sentencia de selección. La sentencia switch selecciona de entre fragmentos
* de código basados en el valor de una expresión entera. Es de la forma:
*
* switch(selector - entero){
* case valor - entero 1 : sentencia; break;
* case valor - entero 2 : sentencia; break;
* case valor - entero 3 : sentencia; break;
* case valor - entero 4 : sentencia; break;
* case valor - entero 5 : sentencia; break;
* // ...
* default: sentencia;
* }
*
* El selector entero es una expresión que produce un valor entero. El switch compara el resultado de selector entero
* con cada valor entero. Si encuenta un valor que coincida, ejecuta la sentencia (simple o compuesta) correspondiente.
* Si no encuentra ninguna coincidencia, ejecuta la sentencia default.
*
* Observese en la definición anterior que cada case acaba con break, lo que causa que la ejecución salte al final de
* la sentencia switch. Ésta es la forma convencional de construir una sentencia switch, pero el break es opcional. Si
* no se pone, se ejecutará el código de las sentencias "case" siguientes, hasta encontrar un break. Aunque este

Capítulo 002 Ejercicio 019 (While etiquetado)

// El bucle While Etiquetado de Java

public class WhileEtiquetado{

public static void main(String args[]){
int i = 0;
externo:
while(true){
visualizar("Bucle While externo");
while(true){
i++;
visualizar("i = " + i);

if(i == 1){
visualizar("Continuar");
continue;
}

if(i == 3){
visualizar("Continuar externo");
continue externo;
}

if(i == 5){
visualizar("Salir");
break;
}

if(i == 7){
visualizar("Break externo");
break externo;
}
}
}
}

static void visualizar(String s){
System.out.println(s);
}

}

/** Las mismas reglas son ciertas para while:
*
* 1. Un continue sin más va hasta el comienzo del bucle más interno y continúa.
* 2. Un continue etiquetado va a la etiqueta, y vuelve a entrar en el bucle situado justo después de la etiqueta.
* 3. Un break "abandona" el bucle.
* 4. Un break etiquetado abandona el final del bucle marcado por la etiqueta.
*
* La salida de este método lo deja claro:
*
* --------------------Configuration: --------------------

Capítulo 002 Ejercicio 018 (For etiquetado)

// Programa que muestra el bucle "for etiquetado" de Java

/** La palabra clave "goto" ha estado presente en los lenguajes de programación desde los comienzos.
* Sin duda, el "goto" era la genésis del control de los programadores en el lenguaje ensamblador:
* "Si se da la condición A, entonces saltar aquí, sino, saltar ahí". Si se lee el código ensamblador
* generado al final por cualquier compilador, se verá que el control del programa contiene muchos saltos.
* Sin embargo, un "goto" es un salto a nivel de código fuente, y eso es lo que le ha traido tan mala
* reputación. Si un programa salta siempre de un lado a otro, ¿no hay forma de reorganizarlo de manera que
* el flujo de control no dé tantos saltos? "goto" cayó en desgracia con la publicación del famoso artículo
* "El Goto considerado dañino", de Edsger Dijkstra, y desde entonces, la prohibición del "goto" ha sido
* un deporte popular, con los partidarios de la palabra clave repudiada buscando guarida.
*
* Como es típico en situaciones como ésta, el terreno imparcial es el más fructífero. El problema no es

Capítulo 002 Ejercicio 017 (Break y Continue)

/** Dentro del cuerpo de cualquier sentencia de iteración también se puede controlar el flujo del bucle
* utilziando break y continue. Break sale del bucle sin ejecutar el resto de las sentencias del bucle.
* Continue detiene la ejecución de la iteración actual y vuelve al principio del bucle para comenzar la
* siguiente iteración.
**/

// Muestra el funcionamiento de las palabras clave "break" y "continue"
public class BreakyContinue{

public static void main(String args[]){

for(int i = 0; i < 100; i++){

if(i == 74)
break; // Sale del bucle for

if(i % 9 != 0)
continue; // Siguiente iteración

System.out.println(i);
}

int i = 0;
// Un "bucle infinito":
while(true){
i++;
int j = i * 27;

if(j == 1269)
break; // Sale del bucle

if(i % 10 != 0)
continue; // Parte superior del bucle

System.out.println(i);

}
}

}

/** En el bucle for el valor de "i" nunca llega a 100 porque la sentencia break rompe el bucle cuando "i"
* vale 74. Normalmente, el break sólo se utilizaría de esta manera si no se supiera cuándo va a darse la

Capítulo 002 Ejercicio 016 (Operador coma)

/** Anteriormente se mencionó que el operador coma (no el separador coma, que se usa para separar
* definiciones y parámetros de funciones) sólo tiene un uso en Java: en la expresión de control
* de un bucle for. Tanto en la inicialización como en las porciones de "paso" de las expresiones
* de control, se tiene determinado número de sentencias separadas por comas, y estas sentencias
* se evaluarán secuencialmente.
**/

public class OperadorComa{
public static void main(String args[]){
for(int i = 1, j = i + 10; i < 5; i++, j = i * 2 )
System.out.println("i= " + i + " j = " + j );
}
}

/* La salida en pantalla es:
*
* i= 1 j = 11
* i= 2 j = 4
* i= 3 j = 6
* i= 4 j = 8
*
* Process completed.
*
* Se puede ver que tanto en la inicialización como en las porciones de "paso" se evalúan las
* sentencias en orden secuencial. Además, la porción de inicialización puede tener cualquier
* número de definiciones de un tipo
*
**/

Distribuir contenido

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">