Implementando un Singleton Manager de Conexión

En aplicaciones cliente/servidor se acostumbra a tener una conexión a BD única por usuario, para poder hacerlo vamos a implementar un manager de conexión.

1.- Este es el código del manager:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Carlos Rojas
*/
public class ConnectionManager {

private static String driver = "com.mysql.jdbc.Driver";
private static String url = "jdbc:mysql://localhost:3306/Prueba";
private static String user = "prueba";
private static String password = "prueba";
private static Connection con;

/**
* Inicializa una nueva conexión con parámetros nuevos
* @param driver
* @param url
* @param user
* @param password
*/
private ConnectionManager(String driver, String url, String user, String password) {
ConnectionManager.driver = driver;
ConnectionManager.url = url;
ConnectionManager.user = user;
ConnectionManager.password = password;
}

/**
* Retorna una conexión por defecto
* @return
*/
public static Connection getConnection() {
if (con == null) {
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(url, user, password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("Se genero una nueva instancia de Connection");
}
System.out.println("Se retorno una instancia de Connection");
return con;
}

/**
* Retorna una conexión unica a partir de los parametros de conexion, en caso que la instancia de la conexión
* no sera nula, retornara la instancia
* @param driver
* @param url
* @param user
* @param password
* @return
*/
public static Connection getConnection(String driver, String url, String user, String password) {
if (con == null) {
new ConnectionManager(driver, url, user, password);
try {
Class.forName(ConnectionManager.driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(ConnectionManager.url, ConnectionManager.user, ConnectionManager.password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

public static void closeConnection() {
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}

2.- Ahora vamos a utilizar la clase TestConnectionManager de prueba para usar el manager:

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
*
* @author Carlos Rojas
*/
public class TestConnectionManager {
public TestConnectionManager(int x){
Connection con = ConnectionManager.getConnection();
try {
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select "+x);
while(rs.next()){
System.out.println(rs.getObject(1));
}
} catch (SQLException ex) {
Logger.getLogger(TestConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}

public static void main(String[] args) {
new TestConnectionManager(1);
new TestConnectionManager(2);
new TestConnectionManager(3);
new TestConnectionManager(4);
}
}

3.- La salida del programa será la siguiente:

Se genero una nueva instancia de Connection
Se retorno una instancia de Connection
1
Se retorno una instancia de Connection
2
Se retorno una instancia de Connection
3
Se retorno una instancia de Connection
4

4. La primera vez que se ejecuta el método getConnection() la instancia de la variable "con" es nula, por lo tanto se inicializa el singleton. Las llamadas posteriores solo devuelve la instancia ya previamente creado.

Singleton Connection Manager

En algunos casos para aplicaciones cliente/servidor se acostumbra a mantener una conexión a BD activa por usuario, para hacer esto es necesario crear una conexión que funcione como un singleton. Así de esta manera:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author carlos
*/
public class ConnectionManager {

private static String driver = "com.mysql.jdbc.Driver";
private static String url = "jdbc:mysql://localhost:3306/Prueba";
private static String user = "prueba";
private static String password = "prueba";
private static Connection con;

/**
* Inicializa una nueva conexión con parámetros nuevos
* @param driver
* @param url
* @param user
* @param password
*/
private ConnectionManager(String driver, String url, String user, String password) {
ConnectionManager.driver = driver;
ConnectionManager.url = url;
ConnectionManager.user = user;
ConnectionManager.password = password;
}

/**
* Retorna una conexión por defecto
* @return
*/
public static Connection getConnection() {
if (con == null) {
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(url, user, password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

/**
* Retorna una conexión unica a partir de los parametros de conexion, en caso que la instancia de la conexión
* no sera nula, retornara la instancia
* @param driver
* @param url
* @param user
* @param password
* @return
*/
public static Connection getConnection(String driver, String url, String user, String password) {
if (con == null) {
new ConnectionManager(driver, url, user, password);
try {
Class.forName(ConnectionManager.driver);
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
con = DriverManager.getConnection(ConnectionManager.url, ConnectionManager.user, ConnectionManager.password);
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
return con;
}

public static void closeConnection() {
if (con != null) {
try {
con.close();
} catch (SQLException ex) {
Logger.getLogger(ConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}

Torre de Hanói

La torre de hanói o hanoi tower en inglés es un juego matématico inventado por Édouard Lucas, este consiste de 3 pilas y el objetivo es pasar todos los discos de la pila 1 a la pila 3 siguiendo las siguientes reglas:

1.- Solo se puede pasar un disco a la vez.
2.- No se puede colocar un disco grande sobre uno pequeño.
3.- Para ganar se debe ordenar los discos en la pila 3 tal y como se inicio el juego.

Para iniciar el juego seleccione el numero de discos, para agregar más discos mueva el control a la derecha.

Para mover un disco de una pila a otra, haga clic con el ratón y arrastre en el disco hacia la pila que desee.

Si desea ver la solución haga clic nuevamente en cargar y finalmente en Resolver, puede cambiar la velocidad de movimientos moviendo el control de velocidad.

Pase varios días de trabajo desarrollando esta primera versión pero aquí esta...

Licencia
Código Fuente Html
Descargar

Hola Mundo Applet!!! Parte 2

En esta segunda parte del tutorial Hola Mundo Applet!!!, vamos a invocar un applet desde una página web.

1.- Al compilar HelloApplet en la primera parte de este tutorial se genera un archivo jar HelloApplet.jar, este se encuentra la carpeta dist del proyecto. Lo vamos a copiar en el mismo directorio de la página web que vamos a crear.

2.- Creamos una página html HolaMundoApplet.html, la página tendrá la siguiente código.

<html>
<body>
<applet code="helloapplet/HelloApplet.class" archive="HelloApplet.jar" height="200" width="300">
</applet>
</html>
</body>

3.- Abrimos HolaMundoApplet.html en un navegador web... si vemos cargar un applet como el que mostramos abajo... ya tenemos nuestro applet incrustado en nuestra página.

Hola Mundo Applet!!!

En este tutorial vamos a crear un Applet, que es un aplicación Java ejecutándose en un navegador local.

1.- Iniciamos Netbeans 6.8, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.


2.- En Project Name colocamos "HelloApplet", la opción Create main Class la des chequeamos. hacemos clic en Finish.



3.- En el nodo principal del proyecto, hacemos clic derecho New > Others > Swing GUI Forms > JApplet Form



Esto creará un Applet vacío, para modificar nuestro Applet disponemos de 2 vistas la de Source y Design. En el modo Design que es para modificar la GUI de manera gráfica, arrastramos una JLabel de la paleta hacia el Applet. Hacemos doble clic sobre la etiqueta y colocamos "Hello Applet!!!".

4.- Ahora para ejecutar el Applet hacemos clic derecho en la clase y seleccionamos Run File.

Aquí podran ver el applet en acción en su navegador, en una segunda parte de este tutorial estudiaremos como llamar al Applet desde una página Web:

Ejecutando sentencias SQL JDBC!!! 3 Parte

En la segunda parte del tutorial Ejecutando sentencias SQL JDBC!!!, probamos con éxito la ejecución de una sentencia SELECT. Ahora vamos a actualizar un registro específico en la tabla persona.

package hellojdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;

/**
*
* @author carlos
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Creamos una sentencia SQL para actualizar el registro con id_persona = 1
String UPDATE_SQL = "update persona set nombre_persona = 'Luke Actualizado', apellido_persona = 'Sky Actualizado', fecha_nac_persona = '2010-03-25' where id_persona = 1";
// Ejecutamos la actualización del regist
st.executeUpdate(UPDATE_SQL);
ro

// Realizamos la consulta de la persona con el id_persona = 1
String SQL_SELECT = "select * from persona where id_persona = 1";
rs = st.executeQuery(SQL_SELECT);
while (rs.next()) {
System.out.println("Resultado del Select:");
System.out.println("id_persona: " + rs.getString("id_persona"));
System.out.println("nombre_persona: " + rs.getString("nombre_persona"));
System.out.println("apellido_persona: " + rs.getString("apellido_persona"));
System.out.println("fecha_nac_persona: " + rs.getString("fecha_nac_persona"));
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

La salida del programa debería ser como esta:

Resultado del Select:
id_persona: 1
nombre_persona: Luke Actualizado
apellido_persona: Sky Actualizado
fecha_nac_persona: 2010-03-25

Ejecutando sentencias SQL JDBC!!! 2 Parte

En la primera parte del tutorial Ejecutando sentencias SQL JDBC!!!, insertamos un registro con éxito. Al ejecutar por segunda vez el tutorial tenemos que nos dará el siguiente error:

com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry '1' for key 1

Este error dá porque la columna "id_persona" es la clave primaria de la tabla y está no acepta duplicados.

Lo que vamos hacer ahora es ejecutar una consulta en la tabla antes de insertar algun registro, a continuación agregamos las senténcias que ejecutará las acciones:

// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Se selecciona el máximo id de la persona
ResultSet rs = st.executeQuery("select max(id_persona) from persona");
int idPersona;
// Se comprueba que el ResultSet tenga resultados
if (rs.next()) {
// Se obtiene el unico y se incrmenta en 1 su valor
idPersona = rs.getInt(1);
idPersona++;
} else {
// si no hay resultado es el primer registro a insertar
idPersona = 1;
}

Luego en pstm.setInt(1, 1); del código anterior los sustituimos por: pstm.setInt(1, idPersona); para que cada vez que se ejecute el programa se genere un id_persona diferente.

Aqui anexo el código completo:

package hellojdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;

/**
*
* @author carlos
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Crear un Objeto Statement para ejecutar la consulta a la BD
Statement st = con.createStatement();
// Se selecciona el máximo id de la persona
ResultSet rs = st.executeQuery("select max(id_persona) from persona");
int idPersona;
// Se comprueba que el ResultSet tenga resultados
if (rs.next()) {
// Se obtiene el unico y se incrmenta en 1 su valor
idPersona = rs.getInt(1);
idPersona++;
} else {
// si no hay resultado es el primer registro a insertar
idPersona = 1;
}

String SQL = "insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)";
PreparedStatement pstm = con.prepareStatement(SQL);
// Ejecutar sentencia SQL para insertar datos
pstm.setInt(1, idPersona);
pstm.setString(2, "Luke " + idPersona);
pstm.setString(3, "Sky " + idPersona);
pstm.setDate(4, new Date(Calendar.getInstance().getTimeInMillis()));
pstm.executeUpdate();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

James Gosling en TheServerSide Java Symposium (TSS JS)

En marzo 17-19 en Las Vegas se celebró la conferencía TheServerSide Java Symposium (TSS JS), los ponentes fueron nada mas que James Gosling el padre de Java, Rod Jhonson creador del FrameWork Spring, Reza Rahman Autor de EJB in action, entre otros.

James Gosling se enfocó en las actualizaciones hechas en Java Enterprise Edition 6 (JEE 6) que en el la velocidad de construcción de las aplicaciones. Calificó en su discurso que con la compra de Sun por parte de Oracle la atención se centra en un nuevo lenguaje de programación, describio tambien de aspectos de la Java Community Process JCP tildanlo de una pesadilla política.

Otro punto importante fue el uso de plantilla OSGi en JEE6, Gosling Dijo "Una de las cosas fuera de esto es la manera mas simple de empaquetar aplicaciones Web. Esto tambien hace más facíl enlazarlo en sooftware de gestión".

Algunos de estos nuevos rasgos puede poner a JEE en una posición más favorable frente a FrameWorks alternativos emergentes, como Spring. De hecho, el despliegue de Enterprise Java Bean (EJB) se ha mejorado como parte de JEE 6. Al mismo tiempo, se ha prestado atención en la reducción de la codificación XML para la configuración. Para Gosling, como desarrollador, esto es bienvenido.

"Para gente como yo que, cuando abran un archivo XML, dicen 'Oh, por favor, Señor, no, esto es hermoso'", dijo. "Me gustaría nunca ver un XML de nuevo", criticó Gosling. "Somos el 99% del camino."

Más...

Ejecutando sentencias SQL JDBC!!!

En el tutorial Hola Mundo JDBC!!!, estudiamos como abrir una conexión a la base de datos y como ejecutar una sentencia SQL sencilla. Ahora utilizando el proyecto HelloJDBC de Hola Mundo JDBC!!! vamos a insertar registros en una Base de Datos.

Importante:

Para realizar el tutorial:

• Crear una Base de Datos en Mysql que llamada "Prueba" con el usuario "prueba" y clave "prueba".
• Crear tabla prueba con el siguiente script SQL.
  

1.- Modificamos la Clase Main con el siguiente código:

public static void main(String[] args) {
// Cargar controlador mysql de la base de datos
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
// Crear conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");

String SQL = "insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)"; PreparedStatement pstm = con.prepareStatement(SQL); // Ejecutar sentencia SQnombre_personaL para insertar datos pstm.setInt(1, 1); pstm.setString(2, "Luke"); pstm.setString(3, "Sky"); pstm.setDate(4, new java.sql.Date(Calendar.getInstance().getTimeInMillis())); pstm.executeUpdate();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

Importamos las referéncias con el menu Source > Fix imports o Ctrl+ Mayúscula+I

Tenemos la variable SQL que es la sentencia a ejecutar en la Base de Datos, los símbolos "?" son los datos a insertar que luego se rellenaran con datos. Para ejecutar la sencencia creamos un objeto PreparedStament con la siguiente línea de código:

PreparedStatement pstm = con.prepareStatement(SQL);

Para ingresar los valores a la sentencia SQL utilizamos los método setInt para los del tipo Integer y setString para los tipo String. Se setean los valores por el numero orden, el primer simbolo "?" representa el indice 0, Por ejemplo:

pstm.setString(2, "Luke");
insert into persona(id_persona,nombre_persona,apellido_persona,fecha_nac_persona) values(?,?,?,?)

El primer párametro 2 significa el lugar donde pondrá el valor, la segunda "?" de izquierda a derecha, el segundo párametro "Luke" es el valor que pondrá en la sentencia.

Para ingresar fechas estas tienen que ser del tipo java.sql.Date, pues es el valor que soporta. normalmente en Java se manejan fechas con el tipo java.util.Date ó java.util.Calendar. En este ejemplo hacemos la conversión de esta manera.

new java.sql.Date(Calendar.getInstance().getTimeInMillis())

Por último ejecutamos la sentencia SQL con pstm.executeUpdate();

2.- Ejecutar el proyecto F6 o ir al menu Run > Run Project.

3.- Consultar la tabla y verificar que los datos fueron registrados, para esto agregamos la conexión en Services > Databases, hacemos clic derecho y seleccionamos New Connection.

4.- Si aparecen los datos en la tabla hemos insertado los datos correctamente.

Hola Mundo JDBC!!!!

En el siguiente tutorial vamos a realizar un Hola Mundo con Java DataBase Connectivity, JDBC es un API de Java para acceder a Base de Datos Relacionales. Para efecto del tutorial nos conectaremos a una Base de Datos Mysql y ejecutaremos una simple sentencia SQL .

Importante:

Para realizar el tutorial, debe crear una Base de Datos en Mysql que llamada "Prueba" con el usuario "prueba" y clave "prueba".

1.- Iniciar Netbeans, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.


2.- En Project Name colocamos "HelloJDBC", la opción Create main Class la chequeamos para que cree una clase principal. hacemos clic en Finish.


4.- Debemos agregar al proyecto el driver para la conexión a Mysql, expandimos el Nodo de proyecto y hacemos clic derecho en Libraries > Add Library y seleccionamos MySQL JDBC Driver - mysql-connector-java-5.1.6.jar.

3.- Para conectarnos a nuestra Base de Datos Mysql, lo primero que debemos hacer es cargar la clase controladora. Así que en la Clase Main, en el método principal agregamos las siguientes sentencias:

try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}

4.- Ahora agregamos las sentencias para abrir una conexión e interactuar con la Base de Datos.

try {

// Abrir Conexión a la Base de Datos
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
// Ejecutar sentencia SQL
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
// Navegar resultados
rs.next();
System.out.println(rs.getObject(1));
} catch (SQLException ex) {
ex.printStackTrace();
}

Para abrir la conexión lo hacemos con la clase DriverManager.getConnection(url,usuario,clave)
que nos devuelve una conexión del tipo Connection que recibe los siguientes parametros:

String url : Es la cadena de conexión a la base de datos
String usuario: Nombre de usuario para conexión
String clave: Clave del usuario para conexión

Para enviar sentencias SQL al servidor de Base de Datos creamos una instancia de Statement en la siguiente sentencia del código:


Statement stm = con.createStatement();

Y ejecutamos la sentencia con el siguiente método

ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
rs.next(); // Avanzamos a la primera fila de resultados

Por último enviamos a la consola el único valor por medio de la siguiente sentencia:

System.out.println(rs.getObject(1));

5.- Código completo de la clase:

package hellojdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
*
* @author carlos
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
try {
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/Prueba", "prueba", "prueba");
Statement stm = con.createStatement();
ResultSet rs = stm.executeQuery("select 'Hola JDBC!!!!!'");
rs.next();
System.out.println(rs.getObject(1));
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}

6.- Si la salida es "Hola JDBC!!!!!" Listo hemos creado con éxito nuestro Hola Mundo JDBC!!!!

Historia del Lenguaje Java

El lenguaje de programación Java fue creado por un equipo de 13 personas y dirigido por James Gosling en Sun Microsystems a partir del año 1991 hasta 1995 que salio a luz pública, desde sus comienzo fue llamado proyecto Oak donde posteriormente fue renombrado a Java. El termino "Java" tiene varios posibles orígenes, desde las inciales de los creadores James Gosling, Arthur Van Hoff, y Andy Bechtolsheim a Just Another Vague Acronym ("sólo otro acrónimo") y la mas convincente de todas es que es una receta para preparar café de allí su símbolo de taza de café.

Java fue incialmente creado para la programación de decodificadores de TV por cable, donde su fuerte sea su portabilidad entre diferentes tipos de hardware. Posteriormente el equipo de desarrollo vio el potencial de ampliar su uso a PC de escritorio, servidores, dispositivos móviles, entre otras.

Manejo de Singleton en Java

Para variar y entrar en conceptos más avanzados en Programación Orientada a Objetos, vamos a estudiar el uso de singleton creación y manejo en un prático ejemplo.

1.- Iniciar Netbeans, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.


2.- En Project Name colocamos " Singleton", la opción Create main Class la des chequeamos para que cree una clase principal. hacemos clic en Finish.

3.- Creamos una Clase llamada Singleton, esta clase tendrá la siguiente estructura:

package singleton;

/**
*
* @author carlos
*/
public class Singleton {
private int valor = 5;
// donde se almacenará instancia del singlenton
public static Singleton singleton;
private Singleton() {
}
// método para recuperar singlenton
public static Singleton getSingleton() {
// si la instancia es null crea una
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}

public static void main(String[] args) {
System.out.println("El valor inicial del singlenton es: "+Singleton.getSingleton().getValor());
Singleton.getSingleton().setValor(Singleton.getSingleton().getValor()-2);
System.out.println("El valor inicial del singlenton es: "+Singleton.getSingleton().getValor());
}

/**
* @return the valor
*/
public int getValor() {
return valor;
}

/**
* @param valor the valor to set
*/
public void setValor(int valor) {
this.valor = valor;
}
}

4.- Estudiando el código podemos ver que la clase Singleton tiene una propiedad "valor" esta propiedad la utilizaremos para almacenar un número y cambiar su valor.

Ahora tambien tenemos una propiedad "singleton" que es del tipo static, que almacenará el singleton en sí. EL truco es el siguiente, crear un método "getSingleton" estático que comprobará si la propiedad "valor" es null esto quiere decir que la instancia del singleton no ha sido iniciada, le asignada un valor y devuelve su instancia.

En caso contrario que la instancia del singleton ya ha sido creada, solo la retornará.

Esto se comprueba en el método principal, al imprimir el valor inicial con el primer println podemos apreciar que imprime la variable valor = 5, luego le restamos 2 y el próximo valor es 3.

La salida del programa será como la siguiente:

El valor inicial del singleton es: 5
El valor inicial del singleton es: 3

Setter y Getter

Setter y Getter es una técnica de encapsulamiento para esconder un atributo o propiedad de un objeto volviendolo privado y solo accesible a tráves de sus métodos. Vamos a realizar un ejemplo, donde crearemos una clase llamada Transporte que contenga una propiedad encapsulada.

1.- En el proyecto ClaseBasica de la entrada anterior del blog, vamos a crear la clase Transporte, para crear una clase hacemos clic derecho en el nodo del proyecto y elegimos New > Java Class.




2.- La clase Transporte tendrá la siguiente estructura.

package micarro;

/**
*
* @author carlos
*/
public class Transporte {

String tipo;
}

3.- El atributo que encapsularemos será tipo. Sombreamos el atributo tipo y hacemos clic derecho Refactor > Encapsulate Fields

4.- Los métodos getter y setter se crean automáticamente:

/**
* @return the tipo
*/
public String getTipo() {
return tipo;
}

/**
* @param tipo the tipo to set
*/
public void setTipo(String tipo) {
this.tipo = tipo;
}

Tenemos que el primer método getTipo es de acceso public, esto quiere decir que el método es visible cuando se accesa de fuera de la clase que lo contiene. Tanto getter como setter son de acceso public.

5.- Agregamos un método principal como el que se muestra a continuación:

public static void main(String[] args) {
Transporte transporte = new Transporte();
transporte.setTipo("Terrestre");
System.out.println("El tipo de transporte es : " + transporte.getTipo());
}

En este método principal estamos creando un objeto Transporte con el operador new, se le asigna un tipo al transporte que sera "Terrestre" con el método setter y este será mostrado por consola para comprobar el funcionamiento del getter.

Si la salida es "El tipo de transporte es : Terrestre" hemos finalizado correctamente nuestro encapsulamiento.

Tutorial Básico de Clase y Objeto

Java es un lenguaje nátivo orientado a objetos, por lo tanto como objetivo de este tutorial es estudiar y comprender la creación de objetos con propiedades y comportamientos. Para crear un objeto es necesario diseñar una clase, una clase es una plantilla con la definición del objeto, esta se usa para definir los atributos con su tipo de datos así como el comportamiento a través de métodos.

Para empezar diseñaremos una clase llamada Carro, la cual comentaremos para explicar su estructura y funcionamiento.

Los comentarios en Java se realizan de 2 formas:

Comentarios en una línea

// Esto es un comentario para una línea

/**

* Esto es un comentario multi línea

*

**/

1.- Iniciar Netbeans, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.

2.- En Project Name colocamos "ClaseBasica", la opción Create main Class la des chequeamos para que cree una clase principal. hacemos clic en Finish.

3.- Vamos a crear la clase Carro, para crear una clase hacemos clic derecho en el nodo del proyecto y elegimos New > Java Class.

4.- Escriba el nombre de la clase Carro, escriba el nombre del paquete micarro, y haga clic en Finish.

5.- Carro.java se abrirá en el editor de código.

6.- Escriba o pegue el siguiente código:

package micarro;

/**
* Clase de ejemplo que representa un carro
*/

// 1.- Inicio del cuerpo de la clase

public class Carro {

// 2.- Propiedades o atributos de la clase

String modelo;
String marca;
String color;
String uso;
int puestos;

// 3.- Método principal

public static void main(String[] args) {

Carro miCarro = new Carro();
miCarro.modelo = "Corolla";
miCarro.marca = "Toyota";
miCarro.color = "Rojo";
miCarro.uso = "Particular";
miCarro.puestos = 5;
System.out.println("Me compre un carro: ");
System.out.println("Marca: " + miCarro.marca);
System.out.println("Modelo: " + miCarro.modelo);
System.out.println("Color: " + miCarro.color);
System.out.println("Uso: " + miCarro.uso);
System.out.println("Puestos: " + miCarro.puestos);

miCarro.rodar();
}

public void accionarEmbrague(){
System.out.println("Embrague accionado...");
}

public void engranarPrimera(){
System.out.println("Primera engranada!!!");
}

public void rodar(){
accionarEmbrague();
engranarPrimera();
System.out.println("Rodando...");
}
}

7.- Seleccione Run > Run Main Project ( F6 )

La salida deber ser la siguiente:

Me compre un carro:
Marca: Toyota
Modelo: Corolla
Color: Rojo
Uso: Particular
Puestos: 5
Embrague accionado...
Primera engranada!!!
Rodando...

8.- La clase Carro contiene elementos como modelo, marca, color, uso y puestos estas serian las propiedades o atributos del objeto. Tenemos también los métodos accionarEmbrague, engranarPrimera, rodar representarian el comportamiento de un objeto.

Hola Mundo!!! con Netbeans 6.8

En este tutorial vamos a realizar el famoso Hola Mundo!!! en Java para inciarnos en el desarrollo con este lenguaje y familiarizarnos con el uso de las herramientas. Para el desarrollo de este tutorial vamos a utilizar Netbeans 6.8 que sería como matar un mosquito con una basuca. Asi que Manos a la obra!!!

1.- Iniciar Netbeans, y ir a la opción de menu File --> New Project. Elegimos en Categories Java y en Projects Seleccionamos Java Application. Hacemos clic en Next.

2.- En Project Name colocamos "HolaMundo", dejamos la opción Create main Class chequeada para que cree una clase principal donde agregaremos nuestro código. hacemos clic en Finish.

3.- Ya tenemos nuestro proyecto HolaMundo con nuestra clase holamundo y nuestro método Main. Ahora agreguemos el codigo a la función Main como se muestra:

package holamundo;

/**
*
* @author carlos
*/

public class Main {
/**
* @param args the command line arguments
*/

public static void main(String[] args) {
System.out.println("Hola Mundo!!! Con Netbeans 6.8!!!");
}
}

4.- Presionamos F6 para ejecutar el proyecto, y listo ya tenemos nuestro primer hola mundo!!!! en Java y Netbeans 6.8.