SCJP 6 (Sun Certified Programmer for Java 6)

Sun Java Certification Program, es el programa de certificación mundial relacionada a la tecnología Java. Esta se enfoca en la certificación de personas en que desempeñan los roles en desarrollo y arquitectura en aplicación de software. Estas certificaciones acreditan el conocimiento y experiencia en el lenguaje Java. Por otro lado, Sun ofrece las siguientes certificaciones profesionales Java:

- Sun Certified Java Associate (SCJA)
- Sun Certified Java Programmer (SCJP)
- Sun Certified Java Developer (SCJD)
- Sun Certified Web Component Developer (SCWCD)
- Sun Certified Business Component Developer (SCBCD)
- Sun Certified Developer For Java Web Services (SCDJWS)
- Sun Certified Mobile Application Developer (SCMAD)
- Sun Certified Enterprise Architect (SCEA)

En esta oportunidad hablaremos sobre la certificación SCJP (Sun Certified Programmer for the Java Platform), Standard Edition 6. Este es un examen para programadores experimentados en la programación en el lenguaje Java. Esta certificación provee una clara evidencia en el entendimiento de estructura, sintaxis, etc., en la programación en el lenguaje y acredita el conocimiento en la creación de aplicaciones Java que corran en Escritorio y Servidor a nivel mundial usando Java SE 6.

Para la gente que este por dar el examen SCJP (Sun Certified Programmer for Java 6 Exam) , este es el libro que contiene todo lo necesario para una preparación por excelencia ya que contiene todos los temas al detalle:



El libro se llama 'Sun Certified Programmer for Java 6 Study Guide', esta en Ingles, muy bien detallado, con ejemplos, Quiz de prueba al final de cada capìtulo y esta dividido de la siguiente manera:

Temas:
---------
* Independientes:
Pag#1 (1 Hoja)
Pag#6 (1 Hoja)

* Contents:
Pag#15 - Pag#21 (6 Hojas)

* Cap#1: Declarations and Acces Control:
Pag#39 - Pag#122 (83 Hojas)

* Cap#2: Object Orientation:
Pag#123 - Pag#220 (97 Hojas)

* Cap#3: Assignments:
Pag#221 - Pag#324 (97 Hojas)

* Cap#4: Operators:
Pag#325 - Pag#364 (39 Hojas)

* Cap#5: Flow Control, Exceptios and Assertios:
Pag#365 - Pag#462 (97 Hojas)

* Cap#6: String, I/O, Formatting and Parsing:
Pag#463 - Pag#578 (115 Hojas)

* Cap#7: Generics and Collectios:
Pag#579 - Pag#698 (119 Hojas)

* Cap#8: Inner Classes:
Pag#699 - Pag#738 (39 Hojas)

* Cap#9: Threads:
Pag#739 - Pag#827 (88 Hojas)

* Cap#10: Threads:
Pag#828 - Pag#868 (40 Hojas)

II.- Capítulos Faltantes:

* Cap#11.pdf:
Pag#1 - Pag#15 (15 Hojas)

* Cap#12.pdf:
Pag#1 - Pag#14 (14 Hojas)

* Cap#13.pdf:
Pag#1 - Pag#17 (17 Hojas)

* Cap#14.pdf:
Pag#1 - Pag#22 (22 Hojas)

* Cap#15.pdf:
Pag#1 - Pag#8 (8 Hojas)

* Cap#16.pdf:
Pag#1 - Pag#6 (6 Hojas)

* Cap#17.pdf:
Pag#1 - Pag#19 (19 Hojas)

* Cap#18.pdf:
Pag#1 - Pag#11 (11 Hojas)

TOTAL HOJAS A IMPRIMIR: 934 Hojas


Para descargar El Libro para la Certificación Java SCJP 6 pulsar:
AQUÌ.

Para descargar El Libro OCP Java SE 6 Programmer Practice Exams pulsar:
AQUÌ.

Luego de leer todo el El Libro para la Certificación Java SCJP 6 a conciencia, aquí comparto estos SIMULADORES del examen, para que uno se pueda probar antes de rendir el dicho exàmen de certificación. Los Simuladores pertenecen a las entidades:

- Simulador 'TechFaq360'
- Simulador 'Sybex'
- Simulador 'Whizlabs'
- Simulador 'KillTest'

Para descargarlos pulsar: AQUI.

MULTI MANEJADOR JAPPLET - JFRAME (SIMULTANEO)

Esta es una solución en JAVA para un problema muy común que se da cuando trabajamos aplicaciones J2SE Desktop y que por x motivos nos se requiere que este colgada en un navegador.

Recordemos que en J2SE uno puede trabajar con AWT y SWING en el desarrollo de aplicaciones Desktop y a su vez crear dichas aplicaciones como JFRAMES, si se requiere que la aplicación a desarrollar corra en la red LAN y o también desarrollarlas como JAPPLET para que dicha aplicación este embebida en un navegador. Bueno una solución a este problema común en los desarrolladores es que se tenga dos proyectos idénticos, pero orientados uno a cada ambiente (Uno con JFRAME y otro con JAPPLET).

La solución a presentar elimina esa tendencia, ya que permite su manejo de ambos ambientes en una misma aplicación. Que quiero decir, que permite que ya no se desarrolle dos sino solo una aplicación y que esta corra tanto como aplicación Desktop (JFRAME) y como JAPPLET.

El ejemplo a mostrar continuación es algo simple pero que da una plantilla inicial para un desarrollo, que a la larga permitirá que dicha solución corra en ambos ambientes.

Ejemplo:
El árbol internamente del comprimido adjuntado es el siguiente:



- Importante.txt: Explica a todo el contenido del comprimido y de la solución.
- Fuentes Demo en Eclipse: Fuentes de la solución (Plantilla Inicial) en Eclipse.
- MultiManejadorJAppletJFrame.jar: .Jar dinámico que al dar doble click levanta la aplicación Desktop (JFRAME).
- Index_MultiManejador.html: Navegador que posee embebido un JAPPLET que es cargado del mismo MultiManejadorJAppletJFrame.jar.

Demo en 'JFRAME':

Demo en 'JAPPLET':


Para descargar MultiManejadorJAppletJFrame pulsar:
AQUÌ.

LECTURA DE FICHEROS CON 'JAVA.UTIL.SCANNER'

El otro día me encontré una clase JAVA bien interesante, se llama java.util.Scanner y buscando su significado supe que utiliza comúnmente para una scanero de ficheros línea por línea y obtención de sus datos, tiene bastante métodos interesantes y la verdad su manejo me trajo a la mente la clase java.util.StringTokenizer ya que trabaja casi idénticamente solo que java.util.Scanner aparece en JAVA en la versión 1.5. Aquí muestro un ejemplito en donde leo un Fichero línea por línea y sus datos separados por el símbolo "–" me permiten diferenciar cada dato y con esto amarrar los datos a un objeto usuario para hacerlo mas interesante el ejemplo y de paso orientar a objetos el demo. El código es el siguiente:

//Test_Scanner.java

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

/**
* @author: cguerra.
* @clase: Test_Scanner.java
* @descripción: descripción de la clase.
* @author_web: http://frameworksjava2008.blogspot.com -
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 22-10-2009.
* @fecha_de_ultima_actualización: 22-10-2009.
* @versión: 1.0
*/
public class Test_Scanner{

/**
* @param args
* @throws IOException
*/
public static void main( String... argumentos ) throws IOException{

Test_Scanner scanner = new Test_Scanner();
scanner.manejoScanner();
}

/**
* manejoScanner
*/
public void manejoScanner(){
try{
File archivo = new File( "C:\\MiArchivo.txt" );
Scanner lectorLinea = new Scanner( archivo );
Scanner lectorDatos = null;
Usuario usuario = null;

for( ; lectorLinea.hasNext(); ){

//Obtiene las lineas del 'Fichero'.
String linea = lectorLinea.nextLine();
//Escanea cada linea del 'Fichero'.
lectorDatos = new Scanner( linea ); lectorDatos.useDelimiter( "-" );

for( ; lectorDatos.hasNext(); ){

String codigo = ( lectorDatos.next() );
String nombres = ( lectorDatos.next() );
String apellidos = ( lectorDatos.next() );
String edad = ( lectorDatos.next() );
String dni = ( lectorDatos.next() );

Usuario = new Usuario(
Integer.parseInt( codigo ),
nombres,
apellidos,
Integer.parseInt( edad ),
dni );

//Crea un Nuevo Usuario.
System.out.println( "" );
System.out.println( "Codigo: " + usuario.getId() );
System.out.println( "Nombres: " + usuario.getNombres() );
System.out.println( "Apellidos: " + usuario.getApellidos() );
System.out.println( "Edad: " + usuario.getEdad() );
System.out.println( "Dni: " + usuario.getDni() );
System.out.println( "" );

}
}
}
catch( IOException e ){
e.printStackTrace();
}
catch( Exception e ){
e.printStackTrace();
}
}
}


//Usuario.java

import java.io.Serializable;

/**
* @author: cguerra.
* @clase: Usuario.java
* @descripción: descripción de la clase.
* @author_web: http://frameworksjava2008.blogspot.com -
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 22-10-2009.
* @fecha_de_ultima_actualización: 22-10-2009.
* @versión: 1.0
*/
public class Usuario implements Serializable{

private static final long serialVersionUID = 936463798820971716L;

private int id;
private String nombres;
private String apellidos;
private int edad;
private String dni;

//Constructores ...
public Usuario(){
}

public Usuario( int id, String nombres, String apellidos,
int edad, String dni ){
this.id = id;
this.nombres = nombres;
this.apellidos = apellidos;
this.edad = edad;
this.dni = dni;
}

public int getId(){
return id;
}

public void setId( int id ){
this.id = id;
}

public String getNombres(){
return nombres;
}

public void setNombres( String nombres ){
this.nombres = nombres;
}

public String getApellidos(){
return apellidos;
}

public void setApellidos( String apellidos ){
this.apellidos = apellidos;
}

public int getEdad(){
return edad;
}

public void setEdad( int edad ){
this.edad = edad;
}

public String getDni(){
return dni;
}

public void setDni( String dni ){
this.dni = dni;
}

public static long getSerialVersionUID(){
return serialVersionUID;
}

}

//MiArchivo.txt
001-Cesar Ricardo-Guerra Arnaiz-26-41816133
002-Catherine Magaly-Cotrina Vasquez-24-49866233

ACTIVAR Y DESACTIVAR 'ASSERT' EN ECLIPSE

Algo raro y común que sucede, cuando se desea trabajar con ASSERT en ECLIPSE es que por defecto no esta habilitado y la pregunta es como habilitarlo ???. Aqui la soluciòn:

Windows -> Preferences -> Java -> Installed JREs.

Luego selecciona tu JDK y click el boton Edit y en el textfield "Default VM Arguments" agregar los còdigos siguientes, dependiendo como se desee trabajar:

-ea
Activa las 'Aserciones' de mi programa.

-da
Desactiva Las 'Aserciones' de mi programa.

-ea:class
Activa las 'Aserciones' de mi programa, pero sólo en la clase class.

-da:class
Desactiva las 'Aserciones' de la clase class.

-ea:package...
Activa las 'Aserciones' de mi programa; pero sólo en el paquete package.

-da:package...
Desactiva las 'Aserciones' del paquete package.

LABELED & UNLABELED EN BUCLES

Un gran aporte que da Java 1.6 es el manejo de Labels por cada ‘For’ utilizado, estos Labels son etiquetas que están directamente relacionadas a cada ‘For’ y la gran ventaja que te da es la facilidad de poder hacer un Break or Continue de un ‘For’ anidado Hijo a Otro ‘For’ que esta como Padre. El manejo es de la siguiente forma:

public class Test{

//Descomentar el ejemplo que se quiera ejecutar.
public static void main( String… args ){
Test test = new Test();
test.forUnLabeled (); //Habilitar el 1er ejemplo.
//test.forLabeled (); //Habilitar el 2do ejemplo.
}

/**
* forUnLabeled se muestra un For anidado simple.
*/
public void forUnLabeled(){

String cadena = "Ricardo X Guerra";
String newCadena = "";

//Forzando un bucle infinito.
for( int i=0; i Character caracter_01 = (Character)cadena.charAt( i );
newCadena += caracter_01;

System.out.println( "'FOR' [PAPA]==>: " + caracter_01 );

if( caracter_01 == 'X' ){

for( int j=10; j>=0; j-- ){
System.out.println( "'FOR' [HIJO]==>: " + j );
}
}
}
}

/**
* forLabeled se muestra un For anidado con una Etiqueta (Labeled) en su interior que
* esta asignada un cada 'For', permitiendo con esto desde un 'For' hijo hacer
* un Break a un 'For' Padre.
*/
public void forLabeled(){

String cadena = "Ricardo X Guerra";
String newCadena = "";

TagForPapa: //Etiqueta del 1er 'For'
//Forzando un bucle infinito.
for( int i=0; i Character caracter_01 = (Character)cadena.charAt( i );
newCadena += caracter_01;

System.out.println( "'FOR' [PAPA]==>: " + caracter_01 );

if( caracter_01 == 'X' ){

TagForHijo: //Etiqueta del 2do 'For'
for( int j=5; j>=0; j-- ){
System.out.println( "'FOR' [HIJO]==>: " + j );
}

break TagForPapa; //Manda a parar el 1er 'For' desde el 2do 'For'.
}
}
}

MANEJO BUCLE 'FOR' COMO 'WHILE'.

Java te da la verdad muchas ventajas a comparación de otros lenguajes de programación, una de ella es el trabajar los bucles de distintas maneras una de ellas y de la que hablaré a continuación es sobre el manejo de un bucle For pero trabajado de una forma distinta a la comúnmente conocida ya que un For lo trabajar para iterar: cadenas, arrays, listas, etc pero siempre como un limitante en su interior peroahora vamos a ver una forma distinta de trabajar el For sin dicho limitante, un trabaja que normalmente esta destinado a un While o a un Do While. El manejo es de la siguiente manera:

public class Test{

//Descomentar el ejemplo que se quiera ejecutar.
public static void main( String… args ){
Test test = new Test();
test.forWhileIliminado(); //Habilitar el 1er ejemplo.
//test.forWhileLimitado(); //Habilitar el 2do ejemplo.
}

/**
* forWhileIliminado aqui se muestra el manejo de un FOR/WHILE Ilimitado, ya que dicho For iterará infinitamente, porque no tiene una confición de Stop en su interior.
*/
public void forWhileIliminado(){

int contador = 0;

//Forzando un bucle infinito.
for( ; ; ){

contador += 1;

System.out.println( "CONTANDO ... " + contador );
}
}

/**
* forWhileLimitado aqui se muestra el manejo de un FOR/WHILE limitado, ya que en dicho For estamos
* condicionando un toque que es '654321' y si se llega a ese numero el Bucle
* para ( break,System.exit( 0 ), return ) sino continua su recorrido infinito
* (continue) .
*/
public void forWhileLimitado(){

int contador = 0;

//Forzando un bucle infinito.
for( ; ; ){

contador += 1;

if( contador == 654321 ){
System.out.println( "EL 'CONTADO' LLEGO A SU [FIN] EN: " + contador + " ...!!! " );
break; //Parar el 'LOOP'.
//System.exit( 0 ); //Parar el 'LOOP'.
//return; //Parar el 'LOOP'.
}
else{
System.out.println( "CONTANDO ... " + contador );
continue; //Continuar el 'LOOP'.
}
}

}

}

JAVA REFLEXION

Hace unos días estuve indagando en el manejo de interno que comúnmente los Frameworks de JAVA utilizan y me tope con el tema de Reflexion. Este tema de Reflexion. es uno de los temas más avanzados que JAVA y su programación orientada a objetos maneja, la reflexión es comúnmente utilizada cuando se quiere examinar o modificar en tiempo de ejecución el comportamiento de las aplicaciones. Por ejemplo, sabiendo el nombre de una clase, podríamos saber:

Propiedades, campos, constructores, métodos, clases, interfaces, etc.
Este es un concepto que permite la programación dinámica, es como cuando uno obtiene la metadata de una tabla, pero en este caso es la metadata de una clase.

Se puede instanciar objetos, solo con saber el nombre de la clase, o ejecutar sus métodos en tiempo de ejecución.

El demo presentando preparado es una clase utilitaria que maneja el concepto de un POJO, esta clase brinda mediante métodos de acceso una seria de métodos como estos:

• public Method[] getArrayMetodos( Class claseProcesar ) ...
• public Method[] getArrayMetodos( String rutaClaseProcesar ) ...
• public Class[] getArrayInterfaces( Class nombreClaseProcesar ) ...
• public Class[] getArrayInterfaces( String rutaClaseProcesar ) ...
• public Field[] getArrayCamposDeclarados( Class nombreClaseProcesar ) ...
• public Field[] getArrayCamposDeclarados( String rutaClaseProcesar ) ...
• public String getClasePadre( String rutaClaseProcesar ) ...
• public String getClasePadre( Class nombreClaseProcesar ) ...
• public String getClasePadre( String rutaClaseProcesar ) ...
• public String getRutaPaquete( Class nombreClaseProcesar ) ...
• etc ...


Para descargar el demo pulsar:
AQUÌ.

LIBERACIÓN DE MEMORIA CON JAVA Y EL GARBAGE COLECTOR

Estudiando un día mi libro de certificación llegue al tema del manejo del Garbage Colector en JAVA y encontré temas muy importantes e interesantes que no sabía como que el Garbage Colector uno no puede ser forzado a pasar y liberar memoria, sino que cuando uno cuando en su aplicación genera X procesos que son muy pesados la memoria puede incrementarse a tal punto que le puede aparecer una Excepcion [java.lang.OutOfMemoryError] refiriéndose que ya no hay memoria suficiente y automaticamente tu aplicación se cuelga, para ello este método que acontinuación implemento puede ser llamado. Dicho ejemplo muestra un simple Test, en el que se imprime el total de memoria que se maneja al inicio, el total de memoria libre que queda luego de ejecutar un 'For' GIGANTE y el total de memoria que queda luego de ejecutar el método de liberacion de memoria que hace una solicitud a la JVM, para que el Garbage Colector pase:


import java.sql.Date;

/**
* @author: Ricardo Guerra.
* @clase: TestGarbageColector.java
* @descripción: Clase utilizada para probar el manejo del Garbage Colector en casos que las aplicaciones
* consuman mucha memoria.
* @author_web: http://frameworksjava2008.blogspot.com
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 05-08-2009.
* @fecha_de_ultima_actualización: 20-03-2009.
* @versión: 1.0
*/
public class TestGarbageColector{

/**
* @param args
*/
public static void main( String[] args ){
TestGarbageColector test = new TestGarbageColector();
test.testGarbageColector();
}

/**
* testGarbageColector Método que prueba un incremento de memoria para ver el manejo de la
* liveracion de esta al solicitar a la 'JVM' el 'GC'.
*/
public void testGarbageColector(){

Date fecha = null;

for( int i=0; i<1000000; i++) {
fecha = new Date( 10, 10, 2009 );
fecha = null;
}

//Solicitamos a la 'JVM' el 'GC', para liverar memoria.
this.getSolicitaGarbageColector();
}

/**
* getSolicitaGarbageColector Método que invoca al Garbage Colector( NO LO FUERZA a venir,
* envia una solicitud a la JVM para su proceso..!!! )
*
*/
public void getSolicitaGarbageColector(){

try{
System.out.println( "********** INICIO: 'LIMPIEZA GARBAGE COLECTOR' **********" );
Runtime basurero = Runtime.getRuntime();
System.out.println( "MEMORIA TOTAL 'JVM': " + basurero.totalMemory() );
System.out.println( "MEMORIA [FREE] 'JVM' [ANTES]: " + basurero.freeMemory() );
basurero.gc(); //Solicitando ...
System.out.println( "MEMORIA [FREE] 'JVM' [DESPUES]: " + basurero.freeMemory() );
System.out.println( "********** FIN: 'LIMPIEZA GARBAGE COLECTOR' **********" );
}
catch( Exception e ){
e.printStackTrace();
}
}
}

El resultado en CONSOLA obtenido es el siguiente:


********** INICIO: 'LIMPIEZA GARBAGE COLECTOR' **********
MEMORIA TOTAL 'JVM': 4194304
MEMORIA [FREE] 'JVM' [ANTES]: 1137312
MEMORIA [FREE] 'JVM' [DESPUES]: 3749208
************ FIN: 'LIMPIEZA GARBAGE COLECTOR' ***********

DBHelper v2.0

Pensando en los diferentes problemas de sintaxis que a diario se presentan cuando uno trabaja en el Àrea de Sistemas como: P, AP, DBA en la creaciòn y manipulaciòn de datos en diferentes Motores de Datos, creè DBHelper v2.0.

DBHelper v2.0 es una aplicación hecha en JAVA SWING con la finalidad de brindar ayuda a los desarrolladores, DBA's, etc. en lo que respecta a la sintaxis para la construcción de:

Stores Procedure, Fuction, View, Trigger, Package, Sequence.

En los diferentes y muy conocidos Motores de Datos:

Oracle, MySql, Postgres, SqlServer.

Ya que dicha sintaxis varìa según el Motor de Datos utilizado, en lo que respecta a delaraciòn de variables, nombres de funciones internas, asignaciones, etc. Ya que todos los Motores de Datos estàn orientados a un mismo Lenguaje de Programaciòn como base que es el SQL y de ese ya nacen los personalizados que varian un poco como son:

PLSQL, TRANSACSQL, PGSQL, etc.

DB_JavaHelper esta orientado a ayudar en lo que a sintaxis por Motor de Datos respecta y muestra tambien como probar cada uno, dando una plantilla base para cada Motor de Datos para cada procediento a realizar.



Requisitos Previos: DB_JavaHelper, esta creado para trabajar con JAVA 1.6 y es IMPORTANTE el NO cambiar los nombres de las carpetas y ejecutables encontrados dentro del comprimido. Simplemente se descomprime el .zip, se guarda un una ruta respectiva y se crea un acceso directo al ejecutable (DB_JavaHelper.jar).

- NOMBRE CARPETA RAIZ = DB_JavaHelper
- NOMBRE CARPETA_SCRIPT = Script
- NOMBRE EJECUTABLE = DB_JavaHelper.jar

Desde DB_JavaHelper tambien se puede descargar los Script por BD, los cuales sirvieron de base para las plantillas mostradas en los ejemplos.

Para descargar DB_JavaHelper pulsar:
AQUÌ.